Graphiti vs Mem0: Which Memory Layer Fits Your AI Agents

Graphiti and Mem0 both give AI agents a memory, but they answer different questions. Graphiti keeps a temporal knowledge graph: every fact is an edge with a validity window, and a newer fact closes the older one. Mem0 extracts memories from conversations into a vector store, and since its April 2026 algorithm it only adds: nothing is overwritten, and retrieval ranks the right dated memory at query time.

The short version: pick Graphiti when facts about customers, projects and systems change and someone will ask since when, and who said so. Pick Mem0 when you want user-level conversational memory with little infrastructure. The rest of this page is the detail behind that line, as of September 2026.

At a glance

How each one handles a changed fact

Take the case from the temporal knowledge graph guide: Acme’s contact for the rollout was Jana Keller in March, and is Tom Berger since 3 June.

Graphiti extracts “Tom Berger is Acme’s contact for the rollout” from the June ticket, sees that it contradicts the March fact, and closes the March edge by setting its invalid_at to 3 June. Both edges stay in the graph with their source episodes. A search for the current contact returns Tom, a question about 1 May can be answered from the validity windows, and the closure itself is a stored, auditable change: which episode closed which fact, and when.

Mem0 adds a new memory from the June message and keeps the March one. Its April 2026 algorithm drops the old update and delete steps on purpose (“Memories accumulate; nothing is overwritten”) and relies on time-aware retrieval that ranks the right dated memory for questions about the current state, past events and plans. For a chat assistant that remembers a user’s preferences, that is simpler and often enough. For a company’s shared record the difference matters: in Mem0 the supersession is a ranking decision made at read time, in Graphiti it is a fact you can inspect.

What “graph” means in each

Graphiti is a graph all the way down. Entities and facts live in Neo4j, FalkorDB or Neptune, you can query them with Cypher, and search combines embeddings, BM25 keyword search and graph traversal.

Mem0’s open-source SDK no longer ships graph stores. The rewrite that brought the April 2026 algorithm removed the Neo4j, Memgraph, Kuzu, Apache AGE and Neptune integrations from the Python and TypeScript SDKs and replaced them with entity linking at write time and entity boosting at search time. Graph memory remains a feature of the paid Mem0 Platform, where it runs without a graph database for you to operate. Many comparisons still describe Mem0 with a Neo4j graph store; that describes the earlier release.

Self-hosting and operations

Graphiti needs a graph database and a model that reliably returns structured output. FalkorDB is a single container under the SSPL license; Neo4j Community is GPLv3, with clustering and role-based access in the Enterprise edition. Ingestion is the cost driver: several model calls per episode, with resolution context that grows with the graph. Telemetry is on by default and switches off with GRAPHITI_TELEMETRY_ENABLED=false. The details are in Graphiti in production.

Mem0 needs a vector store, a model and an embedder, and runs on infrastructure many teams already have. Its README is candid that the headline scores come from the managed platform, “which includes proprietary optimizations not available in the open-source SDK”, so plan your evaluation on the version you will actually run.

The benchmark fight, briefly

Both vendors publish strong numbers, and both dispute the other’s.

• Zep’s paper (arXiv 2501.13956, January 2025) reports 94.8 percent on the Deep Memory Retrieval benchmark against 93.4 percent for MemGPT, and on LongMemEval up to 18.5 percent higher accuracy with 90 percent lower latency than baseline implementations.
• Mem0’s paper (arXiv 2504.19413, April 2025) reports a 26 percent relative improvement over OpenAI’s memory on LoCoMo, with 91 percent lower p95 latency than a full-context approach.
• On LoCoMo, Mem0 recomputed Zep’s result at 58.44 percent. Zep’s own recalculation puts Zep at 75.14 percent and Mem0’s graph variant at about 66 percent. Each side names flaws in the other’s harness, and Zep argues that LoCoMo’s conversations now fit into a model’s context window, which lets a plain full-context baseline compete.
• Mem0’s README reports 92.5 on LoCoMo and 94.4 on LongMemEval for its April 2026 algorithm, measured on the managed platform.

Read these as claims about harnesses as much as about memory. Thirty questions from your own data, with answers you already know, will tell you more than any of them.

Which one to pick

Graphiti fits when:

• the facts are about customers, projects, systems and decisions, and they change
• answers need a source and a date, and someone will ask what was true last quarter
• several people and agents share the memory, so writes need an owner
• you can operate a graph database, or already do

Mem0 fits when:

• the memory is per user: preferences, history, context for a chat product
• a vector store you already run is the only infrastructure you want
• the managed platform is acceptable for the features you need

Neither fits static documents, where plain retrieval is simpler, or numbers and aggregates, where a warehouse answers better.

Other alternatives

• Microsoft GraphRAG builds entities and community summaries over a document collection in a batch pipeline, for questions about the collection as a whole.
• LightRAG is a lighter graph and vector retrieval approach, built to cut GraphRAG’s indexing and update cost.
• Cognee is an open-source memory pipeline that lands data in a combined graph, vector and relational store.
• Letta, formerly MemGPT, runs stateful agents that manage their own context window, as a server with its own API.

How I use Graphiti

For companies I build the context layer for AI agents on Graphiti, because a company’s shared memory needs the two things this comparison turns on: facts that know when they stopped being true, and a write path with an owner. The MCP servers from both vendors hand the agent destructive tools: Graphiti’s can delete episodes and clear a group, and OpenMemory can delete all memories. So agents read through Graphiti Local, whose MCP tools cannot write at all, and every write waits for a person.

Graphiti Local is an independent community project built on Graphiti. It is not affiliated with or endorsed by Zep. Versions, stars and prices as of 11 September 2026.