Picking an llm memory database in 2026 means choosing between a handful of genuinely different architectures, not just different pricing pages for the same idea. This is a factual look at five of them: Mem0, Letta, Zep (via its Graphiti engine), Cognee, and Contextely, on dimensions that actually predict whether one will fit your team, rather than on benchmark numbers each vendor picked to flatter itself.
What these tools actually are
It helps to say plainly that these are not five versions of the same product.
Mem0 is a memory layer you add to an existing agent, open source under MIT, with a hosted API alongside the self-hosted option. Letta, a Berkeley AI Research Lab spinout, is a fuller agent runtime built around the idea that memory management is close to the whole problem of making an agent useful. Zep built its memory engine, Graphiti, as an open, MIT-licensed temporal knowledge graph, though Zep itself deprecated its self-hosted Community Edition in April 2025, meaning self-hosting that stack today means running Graphiti directly rather than the Zep product. Cognee frames itself around turning raw data into a structured memory layer for agents, with a smaller but active open source footprint. Contextely is a narrower thing again: not a general memory layer for any agent, but a context layer specifically for a company's own systems of record, with entitlement enforced inside the retrieval scoring function rather than layered on afterward.
"The most powerful characteristics of a useful AI agent, personalisation, self-improvement, tool use, reasoning and planning, are all fundamentally memory management problems."
Charles Packer, Letta CEO, quoted in the funding announcement for Letta's $10M seed round
That framing is a useful lens for the whole category: these tools exist because giving a model memory is mostly an engineering problem about what to keep, what to forget, and who gets to ask.
The comparison
| Tool | Self-hosting | Entitlement/permissions model | Licence | Funding | Primary use case |
|---|---|---|---|---|---|
| Mem0 | Yes, and a hosted API | Workspace-level, not per-asker retrieval scoring | MIT | $24.5M total | Drop-in memory for existing agents |
| Letta | Yes, free to self-host | No fine-grained retrieval permissions model | Open source (agent framework) | $10M seed, Sept 2024, led by Felicis Ventures, $70M post-money | Stateful agent runtime with persistent memory |
| Zep (Graphiti) | Community self-hosting via Graphiti directly; Zep's own Community Edition was deprecated April 2025 | Not a first-class feature of the graph engine itself | MIT (Graphiti) | Not publicly disclosed at the same granularity as the others | Temporal knowledge graph for agent memory |
| Cognee | Yes | Not positioned as a permissions layer | Open source | $7.5M seed | Structured memory pipeline from raw data |
| Contextely | Yes, via Docker, no feature gating | Retrieval-time entitlement scoring, unentitled objects score zero | Commercial with a free self-hosted option | Bootstrapped | Entitlement-aware context layer for company systems of record |
Table 1: hosting, permissions, licensing, funding and primary use case across five llm memory database options, current as of 2026.
A few things are worth reading past the table itself. Mem0's free tier covers 10,000 memories with paid tiers roughly $19, $79 and $249 a month, and the project reports roughly 186 million API calls a quarter, which is a genuinely large usage footprint for a memory layer. Cognee reports more than 70 production deployments and had passed 12,000 GitHub stars by May 2026. Graphiti had passed 20,000 GitHub stars in the same year. These are all real, actively-used projects, not experiments.
Vector database vs knowledge graph: which one does memory actually need?
Both, depending on the question being asked. A vector store answers "what's semantically similar to this" well. A knowledge graph answers "how are these two named things related, and when did that relationship hold" much better, which matters for agent memory specifically because a lot of useful memory is relational: who reports to whom, which deal replaced which, what changed between two versions of a fact. Graphiti leans hard into the graph side for exactly this reason. Mem0 and Cognee use a mix depending on configuration. None of this is a case for choosing one architecture outright; it's a case for checking which question your actual use case asks most often.
Is a mem0 alternative or a zep alternative actually worth switching to?
Sometimes, and the honest answer depends on what's missing rather than what's wrong. Teams switching away from Mem0 or Zep tend to cite one of two things: wanting a fuller agent runtime (which points towards Letta), or needing permissions enforced at the point of retrieval rather than trusting the calling application to filter (which none of the four general-purpose memory tools here are built around, and is the specific gap Contextely fills). Switching for a marginal accuracy improvement on a memory benchmark is rarely worth the migration cost; switching because a structural requirement, like retrieval-time entitlement, is genuinely missing usually is.
Where entitlement gets missed
None of Mem0, Letta, Zep or Cognee ship a retrieval-time entitlement model as a headline feature, and that is not really a criticism of any of them individually. They were built to solve "does the agent remember," which is a different, and arguably harder-to-notice-when-wrong, problem than "does the agent know who is asking." A team bolting permissions onto any of these after the fact usually ends up doing it at the application layer, filtering results before they reach the model, which works but puts the security boundary in application code that has to be gotten right every time, rather than inside the memory layer's own scoring.
Common pitfalls when choosing between these
- Comparing GitHub stars as a proxy for production readiness. Stars measure developer interest, not operational maturity. Check actual deployment counts and how long a project has run in production, not just its star count.
- Assuming "open source" means "self-hostable in practice." Zep's own Community Edition being deprecated is the clearest example in this list: the licence didn't change, but the supported self-hosting path did.
- Ignoring licence terms until after adoption. MIT gives you the fewest constraints. Read what you're actually agreeing to before a memory layer is wired into production, not after.
- Treating "memory" and "permissions" as the same problem. They are adjacent, not identical, and a tool that is excellent at one is not automatically competent at the other.
Picking between them
If you need a drop-in memory API for an agent you're already building and don't have a hard permissions requirement, Mem0 or Cognee are reasonable starting points. If you want a fuller stateful agent framework, Letta's design goes further in that direction. If temporal, relationship-heavy memory is your actual problem, Graphiti is purpose-built for it. If the requirement is a condensed, current, per-asker-permissioned memory of your own company's systems specifically, that is a narrower problem than general agent memory layer tooling solves, and it's the one Contextely is built around. See the security model for exactly how entitlement is scored, self-host it to try the mechanics yourself, or read the pricing page for how the free tier compares to the others listed here.