Mem0 vs Zep: Which Agent Memory Architecture Fits?

Mem0 vs Zep is not a simple feature contest. Mem0 starts from compact, retrievable memories; Zep starts from a temporal knowledge graph. Both can make an agent remember across sessions, but they optimize for different questions, infrastructure, and failure modes.

There is also a third design worth considering. For decisions, runbooks, and project knowledge, your agent's memory can be files you can read, edit, diff, and self-host—not only records reconstructed through an API. Meshnote provides that model as a markdown wiki over MCP, independent of the agent using it.

The short answer

Choose Mem0 when you need a general-purpose memory layer for personalized agents, broad framework integration, compact retrieval, and straightforward self-hosting.
Choose Zep when changing relationships and time are central: who knew what, when a fact became invalid, or how entities connect across episodes.
Choose readable markdown memory when humans must review changes, edit the canonical wording, use Git-style history, or move knowledge among several MCP-compatible tools.

These can be combined. A support product might use Mem0 for per-user preferences, Zep for relationship-heavy account history, and markdown for approved policies. “One memory system” is often the wrong constraint.

Architecture: extracted memories versus temporal graph

Mem0 extracts useful facts from interactions and retrieves a small relevant set for later calls. Its current materials describe user, session, agent, and organization scopes, plus semantic, keyword, and entity signals. The open-source project can use configurable vector stores and graph components. This is a natural fit for facts such as “Ada prefers concise answers” or “this account uses SAML.”

Zep is graph-first. Its Graphiti engine turns episodes into entities and relationships, retaining temporal information so a relation can be valid for one period and superseded later. That matters for “Which vendor owned the integration before the acquisition?” and “What did the customer believe before the incident review?” Self-hosting now generally means operating Graphiti and a supported graph database; the old Zep Community Edition was deprecated.

A file-backed wiki takes a different route. A page is the durable artifact, links form an explicit graph, and search helps the agent find it. The system does not automatically infer every relationship or personalize at event-stream scale. In return, an engineer can open the exact memory, correct a sentence, inspect history, and back it up without decoding embeddings. See the deeper guide to self-hosted agent memory.

Mem0 vs Zep comparison

Decision factor	Mem0	Zep / Graphiti	Readable markdown over MCP
Primary abstraction	Extracted memory records with retrieval scopes	Episodes, entities, relations, and temporal edges	Human-readable pages and explicit links
Strongest workload	Personalization and compact cross-session recall	Temporal, relational, and multi-hop questions	Approved project knowledge, decisions, and runbooks
Human inspection	Via SDK, API, or product UI	Via API, graph tools, or cloud UI	Directly in markdown files
Self-hosting	Active open-source path; you operate dependencies	Graphiti is open source; you operate a graph stack	File-backed and self-hostable
Update model	Extract, add, update, or delete memories	New episodes can invalidate prior relationships	Edit the canonical page; preserve page history
Main trade-off	Extraction can omit or over-generalize facts	More graph infrastructure and schema reasoning	Less automatic personalization and graph inference

Native memory in ChatGPT or Claude offers the least integration work for a person using one product. It is useful for preferences and continuity, but it is not a shared, application-controlled memory service. Letta is different again: it treats memory as part of a stateful agent runtime, which is compelling when you want the agent itself to manage context blocks. The right comparison depends on whether you are buying an agent runtime, a retrieval layer, a temporal graph, or an owned knowledge base.

Do not crown a winner from benchmark numbers alone

Current vendor and third-party pages cite sharply different LoCoMo and LongMemEval results. Mem0's 2026 research reports 92.5 on LoCoMo and 94.4 on LongMemEval for its newer token-efficient algorithm, averaging under 7,000 retrieved tokens. Zep has publicly disputed earlier configurations and calculations; its corrected rebuttal reported 75.14% on its LoCoMo evaluation. Those numbers are not safely interchangeable: model choice, prompts, dataset treatment, system version, and scoring can differ.

Benchmarks are useful evidence, not a purchasing answer. They test conversational recall better than they test whether an on-call engineer can identify a memory's source, approve a policy change, or recover after a bad write. Run a workload-specific evaluation before committing.

An acceptance test the ranking comparisons miss

The leading Mem0 vs Zep pages explain architecture, pricing, benchmarks, and self-hosting; some provide a Mem0 SDK snippet. What they do not provide is an operational acceptance test for conflicts, deletion, provenance, and portability. Use this seven-case drill against every candidate with the same model and prompts:

Seed: store “Project Atlas deploys in us-east-1 on Fridays.” Confirm exact recall in a new session.
Paraphrase: ask “Where and when does Atlas ship?” This checks semantic retrieval rather than exact matching.
Conflict: add “Atlas moved to eu-west-1; Tuesday is now the deploy day.” Ask for the current rule and the previous rule.
Scope: create another user or project named Atlas. Confirm its facts cannot leak into the first scope.
Provenance: ask which interaction, episode, or page supports the answer. Decide whether an ID is enough or reviewers need readable source text.
Deletion: remove the new rule. Verify normal search, graph traversal, and regenerated summaries no longer surface it.
Portability: export everything required to rebuild the memory elsewhere, restore it in an empty environment, and repeat cases 1–6.

Score each case 0 for failure, 1 for partial/manual success, and 2 for deterministic success. Weight scope and deletion twice for multi-tenant products. Weight conflict and provenance twice for regulated or operational knowledge. This test exposes a key distinction: retrieval accuracy answers “can the agent find it?” while governability answers “can the team trust and repair it?”

A working readable-memory setup with Claude Code

If governability matters, you can test Meshnote through the same MCP client boundary used by other agent tools. Create an API key in Meshnote, then add this server to ~/.claude/settings.json:

{
  "mcpServers": {
    "meshnote": {
      "type": "url",
      "url": "https://meshnote.io/mcp",
      "headers": {
        "Authorization": "Bearer mnk_REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}

Restart Claude Code, ask it to list Meshnote projects, and create or select one. Then run the seven cases above using page writes and reads. For the conflict case, keep the current deploy rule in one canonical page and record the old rule in the page's history or project log. That makes “current” explicit rather than asking retrieval heuristics to reconcile two facts. The broader Claude Code persistent memory guide explains how this complements CLAUDE.md and native auto memory.

How to decide without overbuilding

List ten real queries. Include ordinary recall, updates, deletion, and one adversarial scope test.
Name the canonical source. Is it the conversation, an extracted fact, a graph edge, or a reviewed document?
Price the whole system. Count extraction-model calls, embedding or graph storage, operations, and review—not only the plan price.
Test failure recovery. Inject one incorrect memory and time how long a human takes to find, fix, and verify it.
Prefer the simplest passing architecture. Do not operate a temporal graph for static runbooks; do not force markdown to act like a high-volume personalization engine.

For a protocol-level view of connecting stores to agents, read the MCP memory server guide. If a readable shared wiki passes your acceptance test, start syncing — $8/mo. Teams that need their own deployment can choose self-hosted for teams from $10/seat/month, with a five-seat minimum.