← Blog

Mem0 vs Zep: Which AI Agent Memory Layer Fits?

November 19, 2026

AI Agents & ToolsAI CodingTool Comparisons

The Mem0 vs Zep choice comes down to one question: does your agent need to remember facts about a user, or does it need to know what was true, and when?

Mem0 is a memory layer. It pulls facts out of conversations, stores them, and hands the relevant ones back when your agent asks. Zep stores everything in a temporal context graph, where each fact carries the dates it was valid. Zep has also grown into a wider "enterprise context layer" that pulls in company data from tools like Slack and Google Drive.

Here's the short version:

  • Pick Mem0 if you want user-level memory you can drop into any agent, with an Apache-2.0 library you can self-host today.
  • Pick Zep if facts change over time and your agent must tell the old answer from the new one, or if you want conversations and company data in one governed graph.
  • Self-hosting is the big split. Mem0's Apache-2.0 package is a working memory service you can run yourself, minus a few Platform-only features. Zep's open-source path is Graphiti, a framework you assemble into your own service.

This guide sticks to what each vendor's own docs, GitHub repos and pricing pages say as of November 2026. It skips benchmark scores: vendor-published numbers favour the vendor, and Mem0's own README says its scores reflect the managed platform, not the open-source SDK.

Mem0 vs Zep: Quick Comparison

Mem0Zep
What it isMemory layer for AI agents and appsEnterprise context layer built on temporal context graphs
Core data modelExtracted memories, linked by shared entitiesGraph of entities and facts, each fact with validity dates
Handles changing factsNew memories are added, nothing is overwrittenOutdated facts are marked invalid, not deleted
Open sourceApache-2.0 library and self-hosted serverGraphiti framework (Apache-2.0); Zep itself is a managed service
Self-hostingLibrary or Docker Compose serverRun Graphiti on Neo4j, FalkorDB or Amazon Neptune yourself
Managed deploymentMem0 Platform, plus Kubernetes, private cloud or air-gappedZep Cloud, Cloud with your own keys (BYOK), or BYOC in your VPC
SDKsPython and Node.jsPython, TypeScript and Go
Company data connectorsNot the focusSlack, Google Drive, Notion, Snowflake, BigQuery and more
What gets billedAdd and retrieval requestsCredits per episode ingested, sized by bytes

How Each One Stores Memory

Mem0: extract, add, retrieve

Mem0 describes itself as "AI memory that persists across sessions and agents." You send it messages, it extracts memories about the user or task, and your agent searches those memories later.

The engine changed in 2026, and that matters if you read an older tutorial. The Mem0 GitHub README describes a new algorithm with single-pass, add-only extraction: one LLM call, no UPDATE or DELETE steps. Memories accumulate instead of being overwritten. Retrieval scores semantic search, BM25 keyword search and entity matching in parallel, then fuses the results.

Entities tie it together. Mem0's docs say people, places, organizations and concepts are pulled out of each memory, and memories that share an entity get linked. When a query mentions one of those entities, the connected memories get a ranking boost. On the managed platform this graph is built inside Mem0, with no separate graph database to run.

You scope memories to a user, an agent, an app or a single run, so one Mem0 project can serve many end users without mixing their data.

Zep: a graph where facts have dates

Zep calls itself "the enterprise context layer for reliable agents." Everything you send it, whether chat messages or business data, becomes episodes that Zep turns into entities and facts in a graph. Each user gets their own user graph, and conversations live in threads under that user.

At answer time, your agent asks Zep for context on the current thread. Zep's retrieval docs say it uses the thread's most recent messages as the query, searches the user's whole graph (other threads included), and returns a Context Block: a ready-to-paste bundle that can hold a user summary, facts, entities, episodes and thread summaries. One call per turn.

The bigger shift is scope. Zep's homepage now leads with a Context Lake that syncs selected Slack channels, Drive folders, Notion pages and warehouse tables into governed context graphs, with access policies, retention rules and audit logs on top. Agents reach it through MCP or the SDKs. If all you want is "remember that this user prefers short answers," that's more product than you need.

Changing Facts: The Real Difference

Say a customer tells your support agent in March that they use Adidas shoes, then in May says the shoes broke and they've switched to Puma. What should the agent remember?

Zep tracks time on every fact. The Zep facts docs list four timestamps on each fact: when Zep created it, when Zep infers it became valid (valid_at), when it stopped being valid (invalid_at), and when Zep marked it invalidated (expired_at). Zep works out the dates from the message content and its reference time, so "started at Acme one week ago" gets a start date a week back. When new data contradicts an old fact, Zep invalidates the old one instead of deleting it. The docs use almost exactly the shoe example: the "loves Adidas" fact gets invalidated, and new facts about the broken shoes and the Puma preference get added.

That gives you point-in-time questions for free: "what plan was this customer on in March?" still has an answer. Zep's docs add a fair warning: the dates describe what the content said, not proof that it was true.

Mem0 handles time differently. Its algorithm is add-only, so the Adidas memory and the Puma memory both stay. Mem0's temporal reasoning feature then boosts memories whose event dates match the time in a search, and you can pass a timestamp when importing old conversations or a reference_date to search as if it were a given day. Mem0's docs describe this as Platform-only; it isn't in the open-source SDK. What the docs don't describe is marking a fact as no longer true.

ScenarioMem0Zep
User changes a preferenceBoth memories kept, recency and dates inform rankingOld fact invalidated, new fact added, history kept
"What was true in March?"Search with a reference date (Platform)Facts carry valid and invalid dates
Importing old chat logsPass the original timestampEpisodes carry a reference time
Data model you can inspectList of memories plus entity linksGraph of entities and dated facts

If your agent mostly needs preferences and profile details, Mem0's approach is simpler and cheaper to reason about. If wrong-but-once-true facts would cause real damage, such as an old address, an old plan or an old medication, Zep's model was built for that problem.

Open Source and Self-Hosting

This is where the two diverge most, and where older comparisons are most out of date.

Mem0 open source: the same engine, two ways to run it

Mem0's library is Apache-2.0. Mem0's open-source docs describe two modes:

  • Library. Install the Python or Node.js SDK and create a memory instance in your app. Defaults are OpenAI models for extraction and embeddings, a local Qdrant instance for vectors and SQLite for history.
  • Self-hosted server. A Docker Compose stack with a dashboard, per-user API keys and a request audit log, using Postgres with pgvector by default.

One catch from the Mem0 v2 to v3 migration guide: graph memory is no longer in open source. The external graph store integrations (Neo4j, Memgraph, Kuzu, Apache AGE and Neptune) were removed from the OSS SDK, and the guide says they aren't being replaced with an open-source equivalent. Self-hosted users who relied on graph memory need the Platform. The same guide notes add-only extraction, new search defaults and renamed parameters, so test before upgrading.

Zep: Community Edition is gone, Graphiti is the path

Zep used to ship a self-hostable Community Edition. On April 2, 2025, Zep announced it would stop maintaining Community Edition. The repo stays public under Apache-2.0, but gets no updates or support. Zep's open-source work now goes into Graphiti.

Graphiti is Apache-2.0 and describes itself as "a framework for building and querying temporal context graphs for AI agents." It's the graph engine inside Zep, with the same bi-temporal tracking and automatic fact invalidation. You bring your own graph database: Neo4j, FalkorDB or Amazon Neptune.

Zep's own comparison page is clear that Graphiti is a framework, not a product. With Graphiti you build and run users and storage, developer tools, governance and compliance yourself. Zep adds managed users and threads, Context Block assembly, its own extraction and reranking models, a graph database service, dashboards and SOC 2 Type II and HIPAA coverage (Zep's own claims). Graphiti ships a reference MCP server, which its README says isn't a production deployment.

Mem0 self-hostedGraphiti
LicenseApache-2.0Apache-2.0
What you getA working memory service (library or server)A framework to build a memory service
Storage you runQdrant or Postgres with pgvector by defaultNeo4j, FalkorDB or Amazon Neptune
Graph featuresRemoved from OSS in v3Core of the framework
Ops effortLow to moderateModerate to high

Plain version: if self-hosting is a must and you want something that works this afternoon, Mem0 is easier. If self-hosting is a must and temporal facts are the point, Graphiti is the stronger engine, but you're building the service around it.

Compliance Claims

Mem0's homepage claims SOC 2 Type 1, HIPAA and GDPR compliance. Zep claims SOC 2 Type II and HIPAA BAAs. Both are the vendors' own statements, so check each trust center before you tell your security team either way.

Pricing: Requests vs Ingested Data

The bills are built differently, so model your own traffic rather than comparing headline numbers.

Mem0 meters requests. The Mem0 pricing page lists two plans, Free and Custom, and both meter add requests and retrieval requests each month. For the first 30 days, model calls run on Mem0. After that you bring your own LLM key, which also raises the monthly limits. Custom covers higher volume, SSO, audit logs, an SLA and on-prem deployment.

Zep meters ingestion. The Zep pricing page charges credits per episode you send, with larger episodes costing more credits by size. Retrieval, storage, threads, users and graph storage aren't metered. There's a Free tier for prototyping, self-serve monthly plans with credit top-ups and rollover, and an Enterprise plan that adds SSO, longer log retention and the BYOK and BYOC options.

What that means in practice:

Your trafficWatch out for
Chatty users, many messages per sessionZep's ingestion credits and Mem0's add requests both grow
Few writes, many reads per turnMem0's retrieval limits; Zep doesn't charge for retrieval
Large documents or business dataZep's per-byte episode sizing
Mostly self-hostedYour own servers and LLM calls, not either vendor's bill

Prices change. Check both pages before you budget.

Mem0 vs Zep: Which Should You Pick

Choose Mem0 if:

  • You want personalisation memory (preferences, profile facts, past decisions) in any agent framework.
  • You need to self-host now and want a working service, not a framework.
  • Your agent reads memory more than it rewrites it, and you'd rather pay per request.
  • You don't need facts to expire on a timeline.

Choose Zep if:

  • Facts change and your agent must know which version is current, and which was true before.
  • You want conversations and company data (Slack, Drive, warehouse tables) in one governed graph.
  • Retrieval should return a ready-made context block in one call per turn.
  • You want a Go SDK (Mem0's docs list Python and Node.js), or BYOC inside your own VPC.

Choose Graphiti over both if you want Zep's temporal graph model, must self-host, and have the engineers to run a graph database.

If neither fits, our Mem0 alternatives guide covers the wider field, and Letta alternatives covers agents that manage their own memory. For the concepts underneath all of these tools, start with how AI agent memory works.

Where Taku Fits

Picking a memory layer is a job for whoever is building the agent. If you'd rather run an AI tool someone has already built than wire memory into your own, that's where Taku comes in. Taku Apps and Sites, built by the best AI minds. Find one, run it, and keep it in your Mac Dock. Taku is in Beta, and the Mac app is available now.

Key Points

  • Mem0 extracts memories, links them by shared entities, and never overwrites them. Its library is Apache-2.0 and self-hosts easily.
  • Zep stores dated facts in a temporal graph and invalidates outdated facts instead of deleting them. It's now a broader enterprise context layer.
  • Zep Community Edition stopped receiving updates in April 2025. Graphiti, Apache-2.0, is Zep's open-source path.
  • Mem0 v3 removed graph memory from the open-source SDK. It lives on the managed platform.
  • Billing differs: Mem0 meters add and retrieval requests; Zep meters ingested episodes and doesn't charge for retrieval.

FAQ

What is the difference between Mem0 and Zep?

Mem0 extracts memories from conversations and retrieves them with semantic, keyword and entity search. Zep turns conversations and business data into a temporal graph where each fact carries the dates it was valid. Mem0 is the simpler memory layer. Zep is built for facts that change and for company-wide context.

Is Zep open source?

Zep itself is a managed service. Its Community Edition stopped receiving updates in April 2025. Graphiti, the temporal graph framework inside Zep, is open source under Apache-2.0.

Can you self-host Mem0?

Yes. Mem0's Apache-2.0 package runs as a library inside your app or as a self-hosted server with Docker Compose. Since v3, graph memory isn't part of the open-source SDK.

Does Mem0 have graph memory?

On the Mem0 Platform, yes. Entities are extracted and linked across memories, and linked memories get a retrieval boost, with no separate graph database. The open-source SDK dropped its external graph store integrations in v3.

Which is cheaper, Mem0 or Zep?

It depends on your traffic. Mem0 meters add and retrieval requests. Zep meters the data you ingest and doesn't charge for retrieval or storage. Agents that read memory many times per write tend to favour Zep's model, since retrieval isn't metered. Small apps with modest read and write volume can stay within Mem0's Free plan limits.

Is Graphiti the same as Zep?

No. Graphiti is the open-source framework that builds and queries temporal graphs. Zep is the managed service built on it, adding user and thread management, context assembly, dashboards, governance and compliance.