Graphiti vs Mem0: Temporal Graph or Agent Memory Layer?

Graphiti vs Mem0 is a choice between two different memory shapes. Graphiti builds a temporal knowledge graph from episodes, entities, and relationships. Mem0 extracts reusable facts and retrieves them with semantic, keyword, entity, and temporal signals. Neither is simply “the better database.” The right choice depends on the questions your agent must answer and the infrastructure you are prepared to own.

There is a third boundary worth making explicit: canonical project knowledge does not have to live only inside an extracted graph or memory API. Decisions, runbooks, and verified facts can remain files that people and agents can read, edit, diff, and self-host. Meshnote exposes that kind of markdown wiki through MCP, independently of the agent using it.

The short answer

Choose Graphiti when relationship history is the product requirement: “Who reported to whom on 1 March?”, “What was true before the migration?”, or “How are these entities connected?”
Choose Mem0 when you need to add durable conversational facts to an existing agent and retrieve a compact, relevant set with familiar application scopes.
Choose readable markdown memory when humans must approve the canonical wording, inspect every change, restore a prior version, or share knowledge across several MCP clients.

A hybrid is often more accurate than forcing one store to do everything. Keep user preferences in Mem0, changing relationship history in Graphiti, and approved operating procedures in readable files. The vector memory versus readable memory guide explains why the source of truth and its retrieval index should be separate decisions.

What the leading Graphiti vs Mem0 pages cover

The current leading results agree on the architectural fork. A DEV Community benchmark tests five probes and reports Graphiti winning four, attributing the difference to entity summaries and temporal context. Vectorize compares Mem0 with Zep/Graphiti across architecture, temporal modeling, hosting, pricing, and LongMemEval results. Cognilium focuses on stable facts versus facts that evolve, then adds write-time extraction cost and graph-database operations.

Those are useful perspectives, but benchmark claims are not automatically portable. Models, prompts, retrieval budgets, hosted features, and open-source packages can differ. Mem0's 2026 documentation, for example, describes an ADD-only, multi-signal managed pipeline and clearly distinguishes Platform Graph Memory from OSS behavior. This article adds what those three pages do not: a decision-replay test that checks whether a system can show not just the current answer, but the evidence, correction path, and reconstructable state your team will need during an incident.

Architecture: timeline of relationships versus ranked facts

Graphiti ingests text or JSON as episodes. It extracts entity nodes and relationship edges, keeps links back to episodes for provenance, and models time on facts. Its documentation describes bi-temporal behavior: when something was true in the world and when the system learned it. New contradictory information can invalidate an earlier edge without erasing history. Search combines semantic similarity, BM25 full-text retrieval, and graph-aware ranking.

Mem0 sits between an application and its model. Applications call add after useful interactions and search before a model response. The current pipeline extracts durable facts, scopes them by identifiers such as user, agent, and run, and retrieves candidates using multiple signals. Its managed Platform includes built-in entity linking and temporal scoring; OSS capabilities depend on the configured stores and rerankers. That Platform-versus-OSS distinction matters more than old comparison tables imply.

Graphiti's graph answers relationship and point-in-time questions naturally, but you operate a graph backend when self-hosting and pay extraction cost on writes. Mem0 is usually the shorter path for personalization and application memory, but a ranked result is not the same thing as an editable canonical document. If the remembered object is a deployment procedure rather than a conversational preference, use a knowledge artifact designed for review.

Honest comparison

Question	Graphiti	Mem0	Readable markdown over MCP
Primary unit	Episodes, entities, temporal relationship edges	Extracted memories with metadata and retrieval signals	Pages, links, sources, and revision history
Best fit	Evolving relationships and multi-hop, point-in-time questions	Personalization and durable facts inside an existing agent app	Approved project knowledge, runbooks, and cross-tool memory
Retrieval	Semantic, keyword, and graph-aware search	Semantic plus configurable keyword, entity, temporal, and reranking signals	Explicit pages, links, full-text search, and agent-selected reads
Human correction	Usually through an API or graph tooling	Through SDK/API and platform tools	Edit the source page directly; diff and restore it
Self-hosting burden	Framework plus graph database and model dependencies	SDK plus selected vector/database/model dependencies	File-backed wiki and MCP service
Weakest fit	Simple stable preferences where graph operations add little	Deep typed relationship traversal or canonical long-form procedures	High-volume fuzzy recall without a derived search index

Letta represents another legitimate design: a stateful agent runtime where context and memory are managed as part of a long-lived agent. Native ChatGPT or Claude memory can be convenient for personal continuity. They are less suitable when several agent products must share one governed project brain. For that distinction, see Mem0 vs Letta and the cross-tool memory architecture.

A decision-replay test the feature table cannot answer

Run this test against the exact version and hosting mode you would deploy. Use a disposable tenant called memory-eval-01; do not rely on a vendor demo.

Record state A: “Mara leads Project Atlas. The deployment region is eu-west-1.” Attach source ticket-101 and timestamp 09:00.
Introduce a relationship: “Project Atlas depends on Billing API.” Attach adr-12 at 10:00.
Correct the state: “From 15 August, Ivo leads Project Atlas; Mara remains the security reviewer.” Attach ticket-144.
Ask four questions: Who leads Atlas now? Who led it before 15 August? What service does Atlas depend on? Which source established the current lead?
Apply a human correction: Change eu-west-1 to eu-central-1 without replaying the entire conversation.
Export and rebuild: Start an empty instance, import the export, repeat all four questions, and inspect whether the original sources and superseded fact survived.

Score each answer as correct / wrong / unsupported, then record p50 retrieval latency, prompt tokens returned, write-time model calls, and operator minutes required for correction and rebuild. Graphiti should earn its complexity on historical and relational answers. Mem0 should prove that the deployed retrieval path returns the right compact facts. A readable store should prove that a human can find and repair the canonical statement quickly. If a system cannot reconstruct why the agent believes the current answer, it is a cache of conclusions—not yet an operational memory system.

How to choose without benchmark theatre

Published 2025–2026 benchmarks such as LoCoMo, LongMemEval, and BEAM are useful, but they test different horizons and capabilities. Mem0 currently reports strong managed-platform results and explicitly notes that OSS users should expect directionally similar rather than identical numbers. A 2026 distributed-agent study comparing Mem0 and Graphiti on one LoCoMo conversation found Mem0 more efficient while accuracy differences were not statistically significant. That is evidence for testing cost and deployment shape, not proof that either architecture wins every workload.

Start with your failure cost. If a stale employment relationship creates a compliance error, temporal invalidation is valuable. If forgotten preferences merely cause a repetitive conversation, a lighter extracted-memory layer may be enough. If an agent can alter a production runbook, the reviewed file should remain canonical regardless of which index helps retrieve it.

For teams that want the canonical layer to be inspectable and agent-agnostic, Meshnote keeps memory in markdown and exposes it over MCP. Start syncing — $8/mo, or use self-hosted for teams from $10/seat/month. Pair it with Graphiti or Mem0 when temporal traversal or large-scale semantic recall genuinely improves your measured workload.