---
title: "Mem0 vs Zep: Extraction or a Temporal Graph"
description: "Mem0 vs Zep in practice: extracted fact strings against a temporal knowledge graph, what each returns, pricing meters, and the Zep vs Graphiti split."
canonical: https://past.dev/blog/mem0-vs-zep
date: 2026-09-03
category: Research
authors: The past.dev team
---
# Mem0 vs Zep: Extraction or a Temporal Graph

Mem0 vs Zep is a choice between two definitions of agent memory. [Mem0](https://github.com/mem0ai/mem0) runs conversations through an LLM extraction step and stores what comes out: short fact strings scoped to a user, agent, or session, ranked at retrieval time ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). [Zep](https://www.getzep.com/) builds a [temporal knowledge graph](/glossary/temporal-knowledge-graph): entity nodes, fact edges with validity windows, and episodes that every fact traces back to ([concepts](https://help.getzep.com/concepts)). Mem0 fits per-user conversational personalization with an open-source library underneath; Zep fits teams whose questions carry dates and changes, with Graphiti as its open-source engine.

## The dimensions that matter

| Dimension | Mem0 | Zep | past.dev |
|---|---|---|---|
| Memory model | LLM-extracted fact strings, stored additively, plus a built-in entity graph ([docs](https://docs.mem0.ai/core-concepts/memory-operations)) | Temporal knowledge graph: entity nodes, fact edges, source episodes ([docs](https://help.getzep.com/concepts)) | Raw text ingested with its original timestamp; derived facts keep links to sources |
| Temporal handling | `timestamp` on add backdates `created_at`; optional `expiration_date` ([API](https://docs.mem0.ai/api-reference/memory/add-memories)) | `valid_at` and `invalid_at` on fact edges; contradicted facts are invalidated with the time recorded ([docs](https://help.getzep.com/concepts)) | Event time from the source timestamp, validity windows, supersession links |
| Entity handling | Schema-free entity web inferred from co-occurrence ([docs](https://docs.mem0.ai/open-source/features/graph-memory)) | Resolved entity nodes; typed entities via Pydantic in Graphiti ([repo](https://github.com/getzep/graphiti)) | Entity resolution at ingestion links references across email, transcripts, tickets, chat |
| A response contains | Memory strings with `score`, `created_at`, `updated_at`, `categories` ([API](https://docs.mem0.ai/api-reference/memory/v2-search-memories)) | A Context Block string assembling facts, entities, episodes, summaries; or raw `graph.search` results ([docs](https://help.getzep.com/concepts)) | Ranked, dated evidence with sources and one status: Supported, Conflicted, NoKnownSupport, UnknownBecauseDegraded |
| Deployment | Apache 2.0 library and self-hosted server, or managed platform ([repo](https://github.com/mem0ai/mem0)) | Managed cloud, BYOK, or BYOC; open-source self-hosting means Graphiti plus your own graph database ([pricing](https://www.getzep.com/pricing)) | Managed, or self-hosted in your own Postgres: docker compose, pinned images, same API |
| Pricing model | Meters adds and retrievals: free tier, then $19 and $249 tiers ([pricing](https://mem0.ai/pricing)) | Meters ingestion in 350-byte episode credits, retrieval unmetered: free tier, then $125 and $375 tiers ([pricing](https://www.getzep.com/pricing)) | Managed service, or self-hosted where infrastructure costs are yours |

## Mem0 vs Zep: pipeline against graph

Mem0's add call sends messages through an LLM that pulls out key facts, decisions, and preferences, stores new memories without overwriting old ones, and ranks the most relevant ones at search time ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations)). Since its April 2026 algorithm rework, ingestion is a single add-only pass with entity linking, and retrieval combines semantic, keyword, and entity signals ([README](https://github.com/mem0ai/mem0)). The entity graph is built in and schema-free: entities are proper nouns and key phrases, and connections are inferred from co-occurrence rather than declared ([graph memory docs](https://docs.mem0.ai/open-source/features/graph-memory)). Scoping runs on `user_id`, `agent_id`, `app_id`, and `run_id`.

Zep ingests chat through `thread.add_messages` and business data through `graph.add`, then builds what it calls a Context Graph: entity nodes, fact edges, and the episodes each fact traces back to ([concepts](https://help.getzep.com/concepts)). When new data contradicts a prior fact, the time the fact became invalid is stored on that fact's edge, so both states persist with dates. Retrieval offers `graph.search` for direct queries and `thread.get_user_context` for a Context Block, an assembled string of relevant facts, entities, episodes, and summaries.

The split: Mem0 optimizes for what the system knows about a user now. Zep also records when each fact became true and what replaced it, because the graph stores those transitions as data.

## Zep vs Graphiti

Graphiti is the Apache 2.0 project, around 30,000 GitHub stars as of September 2026, that Zep describes as the open-source framework for temporal knowledge graphs "at the core of Zep's context infrastructure" ([repo](https://github.com/getzep/graphiti)). It provides the bi-temporal model, episodes with provenance, entity resolution with optional typed entities, and hybrid retrieval across embeddings, BM25, and graph traversal. You supply and operate the database: Neo4j, FalkorDB, or Amazon Neptune.

The managed product adds what the repo leaves out. Zep Cloud runs on Konig, Zep's own graph database service, and layers on user and thread management, Context Block assembly, dashboards, SOC 2 Type II and HIPAA BAA compliance, and deployment as cloud, BYOK, or BYOC ([getzep.com](https://www.getzep.com/), [pricing](https://www.getzep.com/pricing)). Choose Graphiti to own the temporal graph design end to end and operate your own graph database. Choose Zep to consume the same design as a service.

## Two pricing meters that count different things

Mem0 meters both directions. The free tier includes 10,000 add and 1,000 retrieval requests a month; Starter at $19 raises that to 50,000 and 5,000, Pro at $249 to 500,000 and 50,000, with custom enterprise above ([mem0.ai/pricing](https://mem0.ai/pricing)). Zep meters ingestion only: an episode up to 350 bytes costs one credit and each further 350 bytes costs another, while retrieval, storage, and users go unmetered; free includes 10,000 credits, Flex at $125 includes 50,000, Flex Plus at $375 includes 200,000 ([getzep.com/pricing](https://www.getzep.com/pricing)). A read-heavy agent prices differently on the two meters, so model your own traffic first.

## The benchmark dispute, on the record

Zep published a post titled "Lies, Damn Lies, and Statistics" disputing Mem0's LoCoMo comparison, which had reported Mem0 ahead of Zep ([blog.getzep.com](https://blog.getzep.com/lies-damn-lies-statistics-is-mem0-really-sota-in-agent-memory/)). Zep documents three implementation errors in Mem0's setup of Zep: both speakers assigned the user role in a graph design meant for one user, timestamps appended to message text instead of the dedicated `created_at` field, and searches run sequentially instead of in parallel. With a corrected implementation, Zep reports 75.14% plus or minus 0.17 on LoCoMo. The post also carries Zep's own correction note: it erred in its first calculation of that score and updated the article. Zep further argues LoCoMo itself is a weak instrument, with transcripts small enough for a single context window and one category lacking usable ground truth.

Mem0's current self-published numbers postdate that exchange and the April 2026 rework: 92.5 on LoCoMo, 94.4 on LongMemEval, 64.1 on BEAM at 1M events, and 48.6 at 10M ([mem0.ai blog, September 2, 2026](https://mem0.ai/blog/ai-memory-benchmarks-in-2026)). Read both posts before trusting either vendor's numbers for the other vendor's product. This one exchange contains a vendor misconfiguring a competitor and a vendor miscalculating its own score.

BEAM allows a same-benchmark reading. On BEAM's complete splits, past.dev reports 91.50% at 100K events, 86.18% at 1M, and 82.61% at 10M ([/benchmarks](/benchmarks)). Mem0 self-publishes 64.1 at 1M and 48.6 at 10M at the link above. We found no self-published BEAM results from Zep as of September 2026. Scoring details are in the [methodology](/benchmarks/methodology).

## How to decide

Run the five tests from the [guide to choosing a memory system](/guides/choose-memory-system) on trials of both.

1. Change a fact, then request the old and new values with dates. Zep stores `valid_at` and `invalid_at` on the edge. Mem0 keeps both memory rows with record timestamps. Check what your prompt can reconstruct from each.
2. Backfill a year of history with original timestamps. Mem0's add accepts a `timestamp` that backdates `created_at` ([API](https://docs.mem0.ai/api-reference/memory/add-memories)); Zep takes message times in `created_at`. Verify out-of-order ingestion lands correctly in both.
3. Send three identifiers for one person: a name, an email address, a handle. Check whether they merge into one entity.
4. Ask a question the store has no basis to answer. Score abstention against confident nearest-neighbor matches.
5. Price your real traffic on both meters: request counts against 350-byte episode credits.

Expected behavior for facts with dates is written up in [facts that change over time](/guides/facts-that-change-over-time).

## Where past.dev sits in this comparison

past.dev is a memory API built around dated evidence rather than extracted summaries. `POST /api/v1/ingest` takes raw text with its original timestamp, entity resolution links references across email, transcripts, tickets, and chat at ingestion, and `POST /api/v1/recall` returns ranked, dated evidence with sources and one of four status values: Supported, Conflicted, NoKnownSupport, or UnknownBecauseDegraded. Facts carry event time, validity windows, and supersession links. Deleting a source erases what only that source supported. It runs managed or self-hosted in your own Postgres with the same API, holds SOC 2 Type II, ISO 27001, and ISO 27701, and data is exportable. Published results are at [/benchmarks](/benchmarks), including 88.7% on LoCoMo scored against corrected answer keys; corrected keys change the test, so that figure does not compare directly with either vendor's LoCoMo number. Setup is covered in the [quickstart](/docs/memory-api/quickstart).

Where the others genuinely fit: Graphiti is the pick for an open-source temporal graph engine you operate end to end. Mem0 is the pick for lightweight per-user personalization from an in-process library. past.dev fits when answers must arrive with dates, sources, and a status you can audit.

The deeper design walkthroughs live at [/vs/mem0](/vs/mem0) and [/vs/zep](/vs/zep), with alternative routes at [/mem0-alternative](/mem0-alternative) and [/zep-alternative](/zep-alternative).