Mem0 vs Zep vs Supermemory: memory APIs compared

Updated 10 min read

Mem0, Zep and Supermemory are all hosted memory APIs for AI apps: you send conversations, they extract what matters per user, and they return it when your agent asks. Mem0 is the cheapest place to start ($19 a month) and the easiest to run yourself as an Apache-2.0 library. Zep keeps a knowledge graph whose facts carry dates, which matters when facts change, and starts at $125 a month. Supermemory combines memory with document search and connectors, bills in credits from $19 a month, and has a local binary that is free for individual developers.

We read each vendor’s pricing, docs and benchmark pages on 1 October 2026; every benchmark number below is published by the vendor named next to it, and we have run none of them.

Mem0 vs Zep vs Supermemory at a glance

Mem0 Zep Supermemory
Memory model Facts extracted per user, agent or run Temporal graph per user, account or domain Memory graph and profile per user, plus documents
SDKs Python, Node; CLI; REST Python, TypeScript, Go Python, JavaScript
MCP Hosted, mcp.mem0.ai Hosted Memory MCP Server; Graphiti MCP to self-host Hosted, mcp.supermemory.ai
Self-host Apache-2.0 library or Docker server Graphiti (Apache-2.0); Zep itself only in your VPC on Enterprise Local binary, free within a license limit (closed source); supported self-host on Scale and Enterprise
Free tier 10,000 adds, 1,000 retrievals a month 10,000 credits a month $5 of credits a month
First paid plan $19 a month $125 a month $19 a month
Billed on Add and retrieval requests Bytes you send (retrieval free) Tokens ingested, queries, operations

For the wider field, including Hindsight, Letta, Cognee and others, see Mem0 alternatives.

How does each one model memory?

Mem0 extracts facts, preferences and decisions from the messages you send and stores them as separate memories, scoped by user_id, agent_id and run_id (the Platform adds app_id). Its research page describes the current algorithm: one LLM call that only adds memories and never overwrites or deletes them, then retrieval that scores semantic, keyword and entity matches together. Graph memory (entity linking) and Dream (background memory consolidation) are listed on the Pro and Enterprise plans.

Zep builds a Context Graph for each user, customer, account or domain. You send Episodes (a chat message, a JSON payload or a block of text), and Zep extracts entities and facts. Every fact carries timestamps for when it became valid and when it stopped being valid, so you can ask what was true at a point in time. You can define your own entity and edge types. The open-source engine underneath is Graphiti; the managed service adds Observations, its own extraction and reranking models, and a graph database service called Konig. Zep now pitches itself as a context layer covering business data and documents as well as conversations.

Supermemory keeps “a memory graph per user: profiles and fact hierarchies”, built by its own model, learner-1, which its homepage says updates, merges, infers and forgets memories. Memories are partitioned by container tags (one per user, project or any scope you choose), and a profile endpoint returns static and dynamic facts about a user in one call. It also stores documents (PDFs, images, audio, video) for retrieval, so one API covers memory and RAG, and paid plans add connectors such as Gmail, S3 and a web crawler.

Which SDKs and APIs do they have?

# Mem0
pip install mem0ai          # or: npm install mem0ai
pip install mem0-cli        # or: npm install -g @mem0/cli

# Zep
pip install zep-cloud       # or: npm install @getzep/zep-cloud
go get github.com/getzep/zep-go/v3

# Supermemory
pip install supermemory     # or: npm install supermemory

Mem0’s package has two clients: MemoryClient talks to the hosted Platform, Memory runs everything in your process. The core calls (add, search, get, get_all, update, delete, history) are the same on both, according to its Platform vs Open Source page. Zep is the only one of the three with a Go SDK. Supermemory’s SDKs also work against its local server if you pass base_url="http://localhost:6767", and it has integrations for the Vercel AI SDK and the OpenAI Agents SDK.

Do Mem0, Zep and Supermemory have MCP servers?

All three do, and all three are hosted. They differ in who signs in.

  • Mem0: https://mcp.mem0.ai/mcp, with your Mem0 account or an API key. Tools include add_memory and search_memories. Its older local server, OpenMemory, is gone from the main branch; details in our MCP memory servers roundup.
  • Zep: the Memory MCP Server at https://api.getzep.com/mcp is built for your app’s end users. Each person signs in through Google Workspace or your company’s identity provider and reaches their own memory, so the agent you built on Zep and the Claude or Cursor they use share one graph. Seats are per plan: 1 on Free, 5 on Flex, 15 on Flex Plus. To self-host, Graphiti ships its own MCP server.
  • Supermemory: https://mcp.supermemory.ai/mcp, signed in with OAuth (no API key), and you choose which spaces each client can read or write. Tools include search_memory, get_profile and add_memory.

To add any of them to Claude Code, see our Claude Code MCP guide.

Can I self-host Mem0, Zep or Supermemory?

Mem0 can be self-hosted in full. The library is Apache-2.0 and runs in your process with your own vector store, LLM and embedder. There is also a self-hosted bundle: a REST server and web dashboard started with Docker Compose, with an admin account, API keys and an audit log, on ports 8888 and 3000. You need an OpenAI key or another provider’s. Some features (app_id, webhooks, advanced retrieval) are documented as Platform-only. Enterprise adds on-prem deployment of the Platform.

With Zep you can self-host the engine, and the service only on Enterprise. Graphiti is Apache-2.0 and runs on Neo4j, FalkorDB or Amazon Neptune with your own LLM key. What you do not get is the managed layer: Observations, Zep’s own extraction, reranking and embedding models, and its managed graph database. Zep itself runs in your VPC only on an Enterprise contract (BYOC), or on Zep’s cloud with your own encryption keys (BYOK).

Supermemory can be self-hosted by one developer for free; production needs a contract. Supermemory local is one binary with no Docker and no database to provision:

curl -fsSL https://supermemory.ai/install | bash
# or
npx supermemory local

It embeds the graph engine, uses local embeddings by default (bge-base-en-v1.5), and works with any OpenAI-compatible model, including Ollama, so text memory can run offline after the first embedding-model download. The docs describe it as free within a lite license limit and “built for individual developers”: one API key, one machine, no connectors, no team access. The server is built from a non-public codebase; the SDKs and plugins in Supermemory’s GitHub repository are open source. The pricing page lists a supported self-hosted deployment on Scale ($399 a month) and Enterprise, and air-gapped deployment on Enterprise.

How much do Mem0, Zep and Supermemory cost?

Plan Mem0 Zep Supermemory
Free 10,000 adds, 1,000 retrievals a month, 1 project 10,000 credits a month, 2 projects, no rollover $5 of credits a month
Entry Starter $19: 50,000 adds, 5,000 retrievals Flex $125: 50,000 credits, then $25 per 10,000 Pro $19: $20 of credits, 3 seats
Middle Pro $249: 500,000 adds, 50,000 retrievals, graph memory, Dream Flex Plus $375: 200,000 credits, then $75 per 40,000; Observations, webhooks Max $100: $130 of credits, Gmail connector
Upper Scale $399: $600 of credits, unlimited seats, self-hosted option
Enterprise Custom: on-prem, SSO, audit logs Custom: BYOC, HIPAA BAA, 1-year logs Custom: air-gapped, SSO

The three meter different things:

  • Mem0 counts requests. Every plan allows unlimited end users, and it offers usage-based pricing on request.
  • Zep counts what you send: an Episode uses 1 credit per 350 bytes (a 700-byte message is 2 credits). Retrieval, storage and users cost nothing. Annual billing saves 17%.
  • Supermemory draws dollars from a monthly balance: memory costs $5 per million tokens of plain text ($10 for rich content), document indexing $1 to $2 per million, search $5 per million queries. Content it has already seen is not billed again.

A rough example of ours, not a vendor’s: an app that stores 10,000 messages of about 700 bytes a month and runs 5,000 searches. On Mem0 that fits Starter ($19; the free plan allows only 1,000 retrievals). On Zep it is 20,000 credits, over the free 10,000, so Flex at $125. On Supermemory, at our assumption of about 4 bytes per token, it is roughly 1.75 million tokens, about $9 of memory credits plus a few cents of search, which is more than the free $5 but well inside Pro’s $20. Check each vendor’s calculator with your own traffic before you decide.

What benchmarks do Mem0, Zep and Supermemory publish?

Each vendor publishes scores for itself, and two of them publish scores for rivals. None of these were run by us or by an independent party.

Number Published by Source page
Mem0: 92.5% on LoCoMo, 94.4% on LongMemEval (top 200 retrieval; 91.8% and 94.8% at top 50) Mem0 Research page, memory-benchmarks repo
Mem0: BEAM 64.1 at 1M tokens, 48.6 at 10M Mem0 Zep vs Mem0 blog post
Mem0: about 6,900 tokens per retrieval call Mem0 Research page
Zep: 94.7% on LoCoMo (1,459 of 1,540), 90.2% on LongMemEval (451 of 500) Zep Research page
Zep: p50/p95 retrieval 87/155 ms (LoCoMo), 104/162 ms (LongMemEval); 5,760 and 4,408 tokens of context Zep Research page
Supermemory: 97% on LongMemEval-S, “Recall@20 with aggregation”, judged by gpt-4o Supermemory Research page (May 2026 report)
Supermemory: 187 ms median search (server), 356 ms end to end Supermemory Homepage

Where they score each other, the numbers do not agree:

  • Zep on Mem0: its Mem0-alternative page puts Mem0 at 91.6% on LoCoMo with 3,060 ms retrieval, and 90.4% on LongMemEval at top 50, citing Mem0’s own benchmark repo. That repo shows 94.8% at top 50 today.
  • Mem0 on Zep: its comparison post (updated 3 September 2026) gives Zep 71.2% on LongMemEval and 80.32% on LoCoMo, and says the two teams have “an active methodology dispute” over LoCoMo. Zep’s own page today says 90.2% and 94.7%.
  • Supermemory on Zep: its LongMemEval-S table also lists Zep at 71.2%, against 97% for itself and 60.2% for full context.

Retrieval depth, answer model, judge and metric (answer accuracy or retrieval recall) differ between these runs. Treat every row as a claim, and test two of these on your own conversations before you commit.

Which should I pick: Mem0, Zep or Supermemory?

  • Per-user memory in an app, cheapest start: Mem0. $19 a month, an Apache-2.0 library you can run in-process today and move to the hosted API later.
  • Facts that change, and you need to know what was true when: Zep, or Graphiti if you will run the graph database yourself.
  • Business data as well as chat: Zep, which ingests JSON and documents into the same graph and adds access policies and audit logs.
  • End users who want their own Claude or Cursor to see the memory your app built: Zep’s Memory MCP Server, signed in through your identity provider.
  • Memory plus document search from one API, with connectors: Supermemory.
  • Try it on a laptop, offline: the Mem0 library, or Supermemory local for text memory.
  • Go SDK: Zep.

What about page-based memory?

All three store memory as extracted facts behind an API: good for remembering thousands of end users, hard for a person to open and read. A different approach keeps memory as pages: agents write and edit markdown pages, link them, and people read the same pages. That suits knowledge your team and its agents share (decisions, how a system works, what was tried), not per-customer recall inside your app. Our guide to agent memory covers both layers, and LLM wiki vs RAG covers when pages beat retrieval.

Dexio is ours and takes the page approach. It is a hosted wiki that agents read and write over MCP at https://app.dexio.wiki/mcp: Claude Code, Codex, Cursor, Hermes Agent, OpenClaw, Claude and ChatGPT connect to one shared wiki, every change keeps the agent and person behind it, and people see what their agents know as a page graph. It is free for one person with unlimited pages and agents; Team is $10 and Business $20 a member a month, with no usage charges. It is open source under AGPL-3.0. It is not a replacement for Mem0, Zep or Supermemory in a customer-facing app, and the two kinds of memory can run side by side. The idea behind it is the LLM wiki.

FAQ

Is Zep better than Mem0? For facts that change over time and for business data, Zep’s dated graph is the stronger model. For a cheap start and full self-hosting, Mem0 wins: $19 against $125, and the whole library is Apache-2.0. Each publishes benchmarks showing itself ahead.

Is Supermemory open source? Partly. Its GitHub repository (SDKs, plugins and the MCP server) is MIT, but the memory server, including the Supermemory local binary, is built from a non-public codebase. The local binary is free within a license limit; the hosted platform and the supported production self-host (Scale and Enterprise) are commercial.

Does Zep have a free plan? Yes: 10,000 credits a month, 2 projects and 1 Memory MCP Server seat, with lower-priority processing and no rollover.

Can I use them from Claude Code? Yes, all three have hosted MCP servers. If one coding agent only needs to remember a project, start with Claude Code memory.

Sources

Ask a question

Ask anything about Dexio.

About
We reply by email.