Mem0 vs Graphiti vs Letta vs Cognee

At a glance

Star counts and versions below are as of late October 2026, read from each project's own repository.

Four different things called memory

Mem0 — extracted facts, retrieved by similarity

Mem0's model is the simplest to reason about and the cheapest to adopt: you hand it conversation turns, an LLM extracts short standalone facts, and those facts go into a vector store to be retrieved by similarity at prompt time. The install is pip install mem0ai or the npm SDK, the defaults are OpenAI's gpt-5-mini for extraction and text-embedding-3-small for embedding, and a Docker Compose server with a dashboard is in the repo.

What you give up is anything that depends on relations between facts. "What did we decide about pricing?" retrieves well. "Which of those decisions superseded which" does not, because supersession is a relation and the store holds points. Mem0's own numbers are also the clearest case of the gap this post is about: the README's table reports 92.5 on LoCoMo, 94.4 on LongMemEval and 64.1 on BEAM-1M, then states that these are platform scores and open-source users should expect "directionally similar gains but not identical numbers." That is an unusually honest footnote, and it means the comparison you actually want — library against library — has not been published by anybody.

Graphiti — a graph that knows when a fact stopped being true

Graphiti is the open-source framework underneath Zep, and it is the only one of the four whose data model directly answers the question most agent memory gets wrong. Facts carry validity windows; when a new episode contradicts an old one, the old edge is invalidated rather than deleted, and every entity and edge traces back to the source episode it came from. Retrieval combines semantic search, BM25 and graph traversal. If your agent needs to say "as of last week this was the owner, it changed on Tuesday," this is the model that can.

Two costs. First, infrastructure: Graphiti needs a graph database — Neo4j 5.26, FalkorDB 1.1.2, Amazon Neptune with OpenSearch Serverless for full-text, or Kuzu 0.11.2, which the project now marks deprecated and warns about at import. That is a real operational commitment next to Mem0's vector store. Second, the Zep relationship: the Community Edition of Zep itself is deprecated, its code moved to a legacy/ folder, and the getzep/zep repository states plainly that it "is not Zep's product or service" — it holds examples and integrations for Zep Cloud. The "sub-200ms at scale" figure belongs to the commercial product, not to the framework. Graphiti is genuinely complete as a library; Zep is a hosted service that happens to share a lineage with it.

Letta — memory the agent edits itself

Letta, formerly MemGPT, inverts the question. Instead of a store the harness queries on the agent's behalf, the agent owns editable memory blocks that live in its context and that it rewrites with tools as it learns. That is the right shape for a long-lived assistant whose self-description and working notes should change, and the wrong shape for a corpus: there is no document ingestion story here, because the unit is the agent's own state rather than your data.

Letta is also the project whose centre of gravity has moved furthest. The 25.3k-star letta repository has retired its V1 API server to an archive branch; active development is in letta-code (3.7k stars), an agent harness that tracks all context, memory blocks included, in git, and whose default backend on first launch is Letta Cloud. Running locally is offered and some features — remote machines, secrets — require signing in. If you are choosing Letta for the self-hosted stateful server you read about in 2025, check which repository and which branch that server is now in before you plan around it.

Cognee — a graph you build from documents, with tenancy on by default

Cognee is the one to read first if your memory is mostly content rather than conversation. Its four verbs are remember, recall, improve and forget; remember and recall take a dataset name, so scoping is a first-class argument rather than a filter you remember to pass. Since v1.0 the whole layer can sit on one Postgres instance covering relational metadata, PGVector and graph state, and v1.6.1 (24 September 2026) runs the default local path keyless, with a local GLiNER extractor and local embeddings — the only one of the four that needs no model provider to try.

It is also the only one that defaults to requiring an authenticated user: every /api/v1 call is multi-tenant unless you set ENABLE_BACKEND_ACCESS_CONTROL=false. And it is the most careful about its own evaluation. The README reports BEAM scores of 0.79 at 100K tokens and 0.67 at 10M, labels the second exploratory, and warns that the two settings use different conversations, ingestion models and retrieval-selection procedures so the scores are not directly comparable — while noting an open reproduction gap on the distributed 10M ingestion. The catch is in the storage story: Postgres as the graph store is described as a demo feature, with the production version a licensed product.

Cross-cutting comparison

Every number you would compare them on is self-reported

LoCoMo, LongMemEval and BEAM are the three benchmarks in play, and across all four projects there is no independent replication of any score. Mem0 publishes the most numbers and attributes them to its platform; Cognee publishes fewer and attaches the caveats itself; Graphiti publishes none, offering only a latency comparison against GraphRAG with no methodology; Letta publishes none. Worse, the sample sizes at the interesting end are small enough to swallow the differences: BEAM's 10M bucket is roughly 200 questions, so a reported 48.6% carries a 95% interval of about ±6.9 points on binomial counting error alone. A 3-point gap between two vendors at that scale is noise. A 15-point drop from 1M to 10M, which Mem0 reports, is not — and that drop is the finding worth taking from the whole leaderboard: all of these degrade sharply as the corpus grows, and contradiction resolution scores worst of the sub-skills.

Scope is an argument the caller passes, not a principal

In Mem0 the scope is user_id, passed to add and to search filters. In Graphiti it is group_id. In Cognee it is a dataset name, with sessions layered on top. In Letta it is the agent itself. In three of the four, nothing in the library checks that the caller was entitled to the scope it named — which is a design choice, not a bug, as long as something above it does. Graphiti is explicit about the consequence: its reference MCP and REST servers have no authentication and no prompt-injection protection, callers can access any group_id, and the project says they are not meant for untrusted networks. Cognee is the exception, defaulting to an authenticated user per call. If you are deploying any of these for more than one human, see memory scopes and tenancy — the failure is silent, because an embedding does not carry who wrote it.

The exit cost is the real differentiator

Ask what you keep if you stop paying, or if the project pivots. Graphiti gives you a graph in a database you already run, with provenance edges back to source episodes — the most portable artifact of the four. Cognee gives you Postgres rows, with the caveat that the production graph path is licensed. Mem0 gives you extracted fact strings plus embeddings, portable but lossy: the extraction decisions are gone. Letta gives you memory blocks tracked in git, portable in form but meaningless outside the Letta harness that interprets them. Two of the four have already moved their own centre of gravity once this year, which is the best available evidence about how durable any of these choices is.

When to pick which

And one case for none of them: if your agent's memory requirement is "remember the five things the user told me earlier this session," a table with a user id and a LIMIT 5 is the right answer, and the write path is the part worth designing rather than the store.

Further reading

On this wiki:

• Memory stores: vector, KV, graph & eviction — matching the backend to the memory kind.
• Memory scopes & tenancy — why user_id is not an authorisation decision.
• Forgetting & supersession — the mutation that only Graphiti's model represents natively.
• Migrating off a memory provider — the exit cost, in detail.
• Memory poisoning defenses — what a shared scope lets an attacker write.

Project sources:

• mem0ai/mem0
• getzep/graphiti and getzep/zep
• letta-ai/letta and letta-ai/letta-code
• topoteretes/cognee