Knowledge graph / GraphRAG

Encodes conversation turns as hierarchically structured facts — world facts and experience facts consolidate into observations that merge into mental models, with automatic deduplication and evidence-tracking across updates. TEMPR retrieval runs four strategies in parallel (semantic, keyword/BM25, entity-graph, temporal) and merges results before returning them to the agent. Reflect reasons over retained memories using configurable mission, directives, and disposition settings per memory bank. Iris Extract provides a separate LLM-mediated structured-extraction pass for document ingestion. Memory banks are isolated namespaces; 40+ official framework adapters plus a first-party MCP server expose all operations.

Best for: Apps where recall accuracy is the priority (strong LongMemEval scores) · Persistent memory for coding agents (Claude Code / Cursor / Continue.dev / OpenCode / Roo Code) · Teams needing enterprise-grade memory: bank isolation, audit logs, webhooks, SSO, RBAC, and a managed cloud option

Context Engineering Platform (Zep v3) built on Graphiti — a bi-temporal knowledge graph that models facts as triplets (entity-relationship-entity) with temporal metadata on every edge. Contradictions are resolved via temporal edge invalidation, not LLM judgment: when a fact changes, the old edge is superseded and a new one is created, preserving the full historical timeline. Ingestion uses discrete episodes (text or structured JSON) that maintain data provenance and enable incremental extraction. Zep Cloud delivers enterprise-grade managed hosting (SOC 2 Type II, HIPAA BAA, BYOC); Graphiti is the Apache-2.0 OSS engine underneath.

Best for: Agents tracking facts that change over time — customer profiles, evolving relationships, product details that must stay current without losing history · Enterprise multi-agent deployments needing SOC 2 / HIPAA compliance, BYOC deployment, and sub-200ms retrieval SLAs · Workflows requiring point-in-time historical queries ("what did the agent know about X on date Y?")

Three-stage ECL pipeline: Extract ingests 30+ multimodal formats (PDF, Slack, Notion, images, audio) via dedicated connectors with auto-OCR and transcription; Cognify runs LLM-powered entity/relationship extraction into subject-predicate-object triples with RDF/OWL ontology alignment and URI-based coreference resolution (unifying name variants across documents into canonical identifiers); Load dual-writes to a pluggable graph store (Postgres native, Neo4j, Kuzu) and vector store (pgvector, Qdrant, LanceDB). Retrieval combines graph BFS traversal, vector similarity, temporal filtering, and auto-routing query optimization; hot context is cached in session memory with transparent fallback to the persistent knowledge graph across sessions.

Best for: Cross-document multi-hop reasoning where entity identity must be preserved across ingestion runs (legal, finance, research evidence graphs) · LangGraph or CrewAI agents needing first-party persistent memory without building a custom graph layer · Enterprise knowledge-graph workflows over large mixed-format corpora where ontology-backed deduplication matters

A neurobiologically inspired long-term memory framework that builds a knowledge graph over documents and retrieves with Personalized PageRank, enabling continual integration of knowledge. HippoRAG 2 improves multi-hop associativity and sense-making.

Best for: Multi-hop retrieval and knowledge integration over large document corpora

Open-source memory layer for autonomous agents built around a `ChatAgent` class that wires three components: a ReAct-based routing agent, a knowledge graph (Neo4j or FalkorDB) for entity storage, and dual memory modules (Memory Stream for breadth, Entity Knowledge Store for depth). Every agent response is parsed into typed entities and written back to the graph; at query time a recursive subgraph retrieval extracts relevant context and injects it alongside ranked top-entities and a condensed chat history into the LLM prompt. A Streamlit dashboard lets developers inspect and replay the evolving memory state.

Best for: Research and prototype agents that need an inspectable, queryable knowledge-graph audit trail of their actions · Multi-agent systems requiring isolated per-agent memory spaces via FalkorDB multi-graph, where a Neo4j/FalkorDB backend is already available · Teams prepared to fork and maintain the library, given upstream is inactive since late 2024

An end-to-end agentic memory framework built around CogniGraph, a lightweight hierarchical graph that uses entities and relations as semantic indexing layers. Targets efficient long-term reasoning: keep the memory graph small and the retrieval cheap while preserving multi-session recall. Published as an arXiv 2025 paper with public code.

Best for: Researchers comparing graph-based agentic memory under a controlled, efficiency-focused evaluation

Next-generation AI memory system inspired by hippocampal memory encoding and neocortical knowledge consolidation. Spans the full knowledge lifecycle: perception → extraction → association → forgetting. LLM-driven extraction converts conversations into structured entity-relationship triples stored in a Neo4j knowledge graph, while a parallel vector store enables hybrid semantic+keyword retrieval. A biologically-motivated forgetting engine (dormancy → decay → clearance) prunes low-value knowledge automatically.

Best for: AI assistants and agents that need rich relational knowledge management — especially where entity relationships, temporal tracing, and automated forgetting matter more than pure vector recall speed

A self-hosted cognitive memory engine that stores memories across five sectors (episodic, semantic, procedural, emotional, reflective) rather than flat chunks. It layers a temporal knowledge graph with valid_from/valid_to facts and point-in-time queries, plus an associative 'waypoint' graph of traversable links, on top of embeddings — with a decay and reinforcement engine in place of TTLs. Recall returns an explainable trace showing which nodes fired. Ships as a Python or Node SDK against local SQLite, or as a multi-user server with REST API, dashboard, and MCP.

Best for: Self-hosted local-first agent memory that needs time-aware facts and point-in-time truth · Teams wanting a free, no-lock-in alternative to Mem0, Zep, or Supermemory with a documented migration path · VS Code, Claude Code, and Cursor users wanting an MCP-native memory tool

Splits memory into three tiers: working (in-session, ephemeral), episodic (graph-based conversational history in Neo4j), and profile (long-term user facts in Postgres). Agents interact through a REST API, Python or TypeScript SDKs, or a native MCP server. An optional retrieval agent layer (split-query and chain-of-query strategies) orchestrates multi-tool retrieval for complex questions rather than issuing a single lookup. LLM-agnostic across OpenAI, Anthropic, Bedrock, and Ollama, and ships an in-repo evaluation harness covering LoCoMo, WikiMultiHop, and HotpotQA.

Best for: Teams that want separate working, episodic, and profile tiers and are comfortable operating Postgres plus Neo4j · Multi-framework shops wanting one memory backend wired into LangChain, CrewAI, LlamaIndex, or n8n via first-party adapters · Applications where multi-hop reasoning over conversation history matters more than single-shot recall

Rejects background auto-extraction on principle — the project's position is that with proxy memory 'the AI doesn't know what it remembers and has no say in what gets recorded.' Instead the agent itself authors, classifies, and writes its own recall trigger for every memory through seven first-person MCP tools. A Python/FastAPI backend stores memories as a node–memory–edge–path graph addressed by human-readable URIs (core://agent/identity), with an automatic version-chain snapshot on every AI write and a React dashboard offering diff and rollback.

Best for: Solo users wanting a persistent, portable, human-auditable identity layer that follows them across any MCP-capable model or client · Developers who want full local control on a single SQLite file with zero external services · Anyone who wants the agent to explicitly decide and disclose what it remembers rather than have it extracted in the background

A Flask REST API backed by two storage layers: FalkorDB holds memories as graph nodes connected by eleven authorable typed relationships plus three system-added edge types, while Qdrant holds a 1024-dimension embedding per memory. Recall blends semantic similarity, graph traversal, temporal alignment, tag overlap, and importance into a nine-component score, with multi-hop bridge discovery that surfaces the memory connecting two seed results rather than just the seeds themselves. Background enrichment and biologically-inspired consolidation cycles (daily decay, weekly creative linking, monthly clustering, optional forgetting) run continuously.

Best for: Solo developers and small teams wanting one shared memory across several coding-agent tools via MCP · Users who specifically want typed-relationship reasoning rather than similarity search alone · Teams comfortable running Docker or Railway infrastructure who value an honestly-benchmarked self-hosted backend

Three memory tiers: short-term (per-session conversation history with vector and text search), long-term (a POLE+O knowledge graph of People, Objects, Locations, Events, and Observations with entity resolution and deduplication), and reasoning (traces of agent tool use and decisions, retrievable for similar-task lookup). Multi-stage entity extraction via spaCy, GLiNER, or an LLM, plus relationship extraction with GLiREL and optional background enrichment from Wikipedia or Diffbot. Two independently versioned SDKs share one memory model and talk either directly to a self-hosted Neo4j over Bolt or to Neo4j's hosted memory service over REST, with cross-SDK behaviour enforced by a companion conformance suite.

Best for: Teams that want an actual queryable knowledge graph rather than vector recall as agent long-term memory · Multi-framework agent stacks needing one shared memory backend across LangChain, CrewAI, ADK, and others · Organizations already running Neo4j who want to reuse that operational expertise