Mem0 alternatives: 11 agent memory layers compared
Updated 18 min read
The closest Mem0 alternatives are Zep, Supermemory and Hindsight: hosted memory APIs that, like Mem0, pull facts out of conversations and return the relevant ones for each user. Letta and LangMem build memory into an agent framework instead, Cognee turns documents into a knowledge graph, and Basic Memory and Dexio keep memory as markdown pages a person can read. We checked every product below on its pricing page, docs and GitHub repository on 20 November 2026. We have not benchmarked any of them.
What is Mem0 best at?
Mem0 is a memory layer for apps and agents. You send it messages; it extracts facts, preferences and decisions, stores them per user, and returns the relevant ones when you search. It comes three ways:
- As a library:
pip install mem0ai(ornpm install mem0ai), and memory runs inside your own process. Apache-2.0. - As a self-hosted server: a Docker Compose stack with a dashboard, per-user API keys and a request audit log, on Postgres with pgvector. Its default LLM is OpenAI’s gpt-5-mini.
- As the hosted Platform (pricing), which now has two plans. Free gives 10,000 adds and 1,000 retrievals a month for the first 30 days with model calls on Mem0, then 50,000 adds and 10,000 retrievals a month with your own LLM key, and bills usage past those limits up to a monthly cap you set. Custom plans add graph memory, SSO and on-prem deployment.
The mem0 repository has 69,282 stars, with a commit on 18 November 2026.
Stay with Mem0 if you are adding per-user memory to an app, want an Apache-2.0 library you can run in-process now and a hosted API later, and find search over extracted facts good enough.
Look elsewhere if you need graph memory without a custom contract, facts that change over time, an agent that manages its own memory, or memory your team can open and read. Each alternative below says which of these it answers.
Which Mem0 alternatives are there?
| Alternative | What it stores | Runs | Price | License |
|---|---|---|---|---|
| Mem0 (baseline) | Facts extracted per user | Library, self-hosted or hosted | Free plan; custom plans | Apache-2.0 |
| Zep / Graphiti | Knowledge graph whose facts carry time | Hosted; Graphiti self-hosted | 10,000 free credits a month; from $125 a month | Apache-2.0 (Graphiti) |
| Supermemory | Memory graph per user, plus documents | Hosted; self-hosted option on Scale | $5 of free credits a month; from $19 a month | MIT (repo, MCP server, plugins); memory engine closed source |
| Hindsight | Memory banks, observations, mental models | Docker or hosted | Free self-hosted; cloud billed on tokens | MIT |
| Honcho | Peers (users, agents, groups) and what it learns about them | Hosted; open-source core | From $0.001 a query | AGPL-3.0 |
| Memori | Agent and conversation memory in your database | Self-hosted or hosted | Free to self-host; production plans from $60K a year | Apache 2.0, per its README |
| MemOS | Memory with hybrid retrieval and skill reuse | Self-hosted or hosted | Free cloud tier | Apache-2.0 |
| Letta | Memory blocks in the agent’s context, plus archival memory | Local, self-hosted or hosted | Free with your own keys; from $20 a month | Apache-2.0 |
| LangMem | Memories in a LangGraph store | Inside your app | Free | MIT |
| Cognee | Knowledge graph and embeddings from your data | Local or hosted | 100 million tokens free; then $0.10 per million | Apache-2.0 |
| Basic Memory | Markdown files | Local or hosted | Free locally; cloud from $19 a month per workspace | AGPL-3.0 |
| Dexio | Linked markdown pages, with history | Hosted, or self-host | Free for one person; $10 or $20 a member a month | AGPL-3.0 |
Which hosted memory APIs are closest to Mem0?
1. Zep and Graphiti: facts that change over time
Zep stores memory as a knowledge graph in which facts carry time, so the graph records when something changed. Its engine, Graphiti, is Apache-2.0 (32,963 stars, v0.31.2) and you can run it yourself with a graph database and your own LLM key.
Zep’s free tier gives 10,000 credits a month. Flex is $125 a month for 50,000 credits (then $25 per 10,000), Flex Plus is $375 for 200,000 (then $75 per 40,000), and Enterprise is custom. You pay when you send data: an episode costs 1 credit per 350 bytes, and retrieval, storage and users cost nothing.
Zep beats Mem0 when facts change and you need to know what was true when, or when you want graph memory on a self-serve plan. Mem0 is better when you want to start bigger for free: with your own LLM key its free plan takes 50,000 adds a month, and Zep’s first paid plan is $125.
2. Supermemory: memory and document search in one API
Supermemory keeps a memory graph per user (its pricing page describes profiles and fact hierarchies) and also stores documents for search, so one service covers memory and RAG. Pricing is credits: Free includes $5 a month; Pro is $19 ($20 of credits, 3 team seats); Max is $100 ($130 of credits); Scale is $399 ($600 of credits, unlimited seats, a self-hosted option); Enterprise is custom. Memory costs $5 per million tokens, and repeats and unchanged content are not billed. It quotes a 187 ms median server time for search, a vendor-published number.
Its main GitHub repository, with the MCP server and plugins, is MIT (31,676 stars), and the TypeScript and Python SDKs are Apache 2.0. The memory engine is not open source. It runs in Supermemory’s cloud, as a free local binary for up to 10,000 stored documents, or in your own infrastructure on Scale and Enterprise.
Supermemory beats Mem0 when you want memory and document search from one API, or built-in connectors. Mem0 is better when you want fixed request limits rather than metered credits.
3. Hindsight: everything free to self-host
Hindsight comes from Vectorize. It has three operations: retain (store), recall (retrieve) and reflect (find patterns in what it has stored), and its docs describe the observations and mental models it builds from what it retains. The self-hosted version is MIT, runs with one Docker command and includes an MCP server. The repo has 62,236 stars and a release on 19 November 2026.
Hindsight Cloud has no monthly fee: retain costs $10 per million tokens, recall $0.75 per million and reflect $0.05 a call, and signing up with GitHub gives $5 of credit. Its site reports 94.6% on LongMemEval-S against 74.0% for the next best system it lists, a vendor-published benchmark.
Hindsight beats Mem0 when you want every feature self-hosted at no cost, or memory that reflects on past work as well as recalling it. Mem0 is better when you want a free plan with fixed limits.
4. Honcho: memory about people and agents
Honcho, from Plastic Labs, models peers (users, agents, game characters, groups) and the relationships between them. New messages trigger reasoning about each peer, and you ask questions with .chat() at five levels priced per query: Minimal $0.001, Low $0.01, Medium $0.05, High $0.10 and Max $0.50. Storing memory costs $2.00 per million tokens. New accounts start with $5 of credits, and startups that have raised under $5M can apply for extra credits. The core is AGPL-3.0 with 8,210 stars.
Honcho beats Mem0 when conversations have several participants (group chats, agents with subagents) or you want conclusions drawn about a user on top of the stored facts. Mem0 is better when you want a plain add and search API.
5. Memori and MemOS
Memori stores agent and conversation memory in a database you bring. The SDK is free to self-host (17,601 stars, Apache 2.0 per its README), and a hosted MCP server is at https://api.memorilabs.ai/mcp/. Production plans start at $60K a year (Team) and $150K (Business), with Enterprise in your VPC or on-prem, and every production plan includes immutable audit logging and SSO. It suits companies that need memory in their own database.
MemOS calls itself a memory OS for LLMs and agents, with hybrid retrieval and skill reuse across tasks. It is Apache-2.0 with 12,465 stars; its cloud free plan lists 50,000 adds and 20,000 searches a month.
Mem0 vs Zep vs Supermemory
These three are the hosted memory APIs most often weighed against each other. We read each one’s pricing, docs and benchmark pages on 20 November 2026.
| 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, TypeScript |
| MCP | Hosted, mcp.mem0.ai |
Hosted Context 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 on Enterprise | Free local binary up to 10,000 documents (closed source); own cloud on Scale and Enterprise |
| Free tier | 10,000 adds, 1,000 retrievals a month for 30 days; then 50,000 and 10,000 with your own LLM key | 10,000 credits a month | $5 of credits a month |
| First paid plan | Usage past the free limits, up to a cap you set; custom plans | $125 a month | $19 a month |
| Billed on | Add and retrieval requests | Bytes you send (retrieval free) | Tokens ingested and searches |
Their MCP servers differ in who signs in. Mem0’s takes your Mem0 account through a browser sign-in, or an API key as a bearer token for headless agents. Zep’s Context 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 only their own memory, so the agent you built on Zep and the Claude or Cursor they use share one graph. Supermemory’s signs in with OAuth, and you choose which spaces each client can read or write.
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 the free plan once you bring your own LLM key (in the first 30 days, retrievals past 1,000 are billed as usage). 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, more than the free $5 but inside Pro’s $20. Check each vendor’s calculator with your own traffic.
Their benchmarks disagree whenever one vendor scores another. Zep reports 94.7% on LoCoMo and 90.2% on LongMemEval for itself. Mem0’s comparison post (updated 3 September 2026) gives Zep 80.32% and 71.2%, and says the two teams have “an active methodology dispute” over LoCoMo. Mem0 reports 92.5 on LoCoMo for itself. Supermemory’s headline 97% on LongMemEval-S measures retrieval: whether the right memory is among the 20 it returns. Retrieval depth, answer model, judge and metric differ between these runs, so none of them settles the question.
Pick Mem0 for the largest free plan and an in-process library. Pick Zep when facts change and you need to know what was true when, when you want business data in the same graph, or when you need a Go SDK. Pick Supermemory for memory and document search from one API, with connectors.
Which alternatives build memory into the agent?
6. Letta: agents that keep their own memory
Letta (formerly MemGPT) is a platform for stateful agents, not a layer you call from another framework. Its memory blocks are, in the docs’ words, “structured sections of the agent’s context window that persist across all interactions”: always visible, with no retrieval step. Archival memory holds the rest. The letta-ai/letta repo (Apache-2.0, 25,505 stars) points to letta-code for current source:
npm install -g @letta-ai/letta-code
letta # terminal UI
letta server # App Server for local or self-hosted agents
Pricing: Free with your own API keys or an external coding plan, limited to 3 stateful agents; Pro is $20 a month with $20 of credits and up to 20 stateful agents; Teams Pro is $20 a seat a month.
Letta beats Mem0 when you are building the agent itself and want memory to be part of its context, managed by the agent. Mem0 is better when you already have an agent stack and only need a memory API beside it.
7. LangMem: memory for LangGraph apps
LangMem is a library from LangChain. It gives agents tools to save and search memory during a conversation (“in the hot path”), plus a background manager that extracts, consolidates and updates what the agent knows. Memories live in LangGraph’s long-term memory store.
pip install -U langmem
MIT, 1,779 stars, last commit 16 November 2026, no tagged releases on GitHub.
LangMem beats Mem0 when you already run LangGraph, since it adds no new service and no new bill. Mem0 is better when you are not on LangGraph, or want a hosted API with a dashboard.
Which alternative builds memory from documents?
8. Cognee
Cognee turns documents, code and conversations into a knowledge graph your agents can search. Apache-2.0, 33,431 stars, v1.6.10 on 18 November 2026. With no LLM key set, it extracts the graph with a local GLiNER model. From its README:
uv pip install "cognee[gliner]"
cognee-cli remember "Marie Curie was born in Warsaw." -d local_quickstart
cognee-cli recall "Where was Marie Curie born?" -d local_quickstart
The cloud Standard plan includes 100 million tokens with no card, then charges $0.10 per million tokens processed, with one workspace included and more at $5 a month each, plus Slack, Notion, Linear and Google Drive connectors. Premium is $99 a month plus token usage and adds an ontology learned from your data.
Cognee beats Mem0 when memory should come from a body of documents, or must run entirely on your own machines. Mem0 is better when memory is mostly what users said in chat.
Which alternatives keep memory a person can read?
Every product above stores memory you query through an API. If the question is “what do our agents actually know?”, you want memory you can open and read.
9. Basic Memory
Basic Memory writes memory as markdown files with wikilinks, by default in ~/basic-memory, which Obsidian can open as a vault. Local use is free under AGPL-3.0 (4,646 stars). The cloud charges per workspace with credits included, and members cost nothing up to each plan’s limit: Cloud is $19 a month (1,900 credits, 7-day trial), Pro $99 (9,900 credits, up to 5 members) and Business $249 (24,900 credits, up to 25 members). For Claude Code:
uv tool install basic-memory --prerelease=allow
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp
Basic Memory beats Mem0 when one person wants memory as notes they can edit. Mem0 is better when you need memory for the end users of an app.
10. Dexio: one wiki for all your agents
Dexio is ours. It is a hosted wiki that agents read and write over MCP at https://app.dexio.wiki/mcp. Memory is linked markdown pages, not extracted facts: agents search, read, write and edit pages, every change names the agent that made it, and people see what their agents know as a page graph. Claude Code, Codex, Cursor, Hermes Agent, OpenClaw, Claude and ChatGPT connect to the same wiki, so what one agent writes, the others can read. Pricing: free for one person (unlimited pages, 100 MB of storage); Team is $10 and Business $20 a member a month, with 1 GB and 10 GB of storage per member. Open source under AGPL-3.0. It has no per-end-user memory API for your app’s customers, so it does not replace Mem0 there; it fits when several agents, often on different machines, need one shared memory your team can read. Agents that run commands can set themselves up from dexio.wiki/agents.md.
Which MCP memory servers can stand in for Mem0?
An MCP memory server gives a coding agent tools to save things and look them up in later sessions, so Claude Code, Cursor, Codex and other clients can share one store. Memory files such as CLAUDE.md hold instructions you wrote; a memory server holds what the agent learns, and the agent decides when to call it.
Mem0’s own MCP server, and what happened to OpenMemory
Mem0’s MCP server is hosted at https://mcp.mem0.ai/mcp. In the docs’ words, “Nothing runs on your machine”, and memories live in your Mem0 account. Its tools are add_memory, search_memories, get_memories, get_memory, update_memory and delete_memory. The client opens a browser to sign in the first time a tool runs. Many older guides recommend OpenMemory, Mem0’s local MCP server. On 20 November 2026 the openmemory folder is missing from the mem0 repo (the GitHub API returns 404), and the last commit touching that path is dated 29 July 2026.
Memory, the reference server
The Memory server in modelcontextprotocol/servers is published by the MCP project. It keeps a knowledge graph of entities, relations between them and observations, which are short facts attached to an entity, with tools such as create_entities, create_relations, add_observations, read_graph, search_nodes and open_nodes. Everything lives in one JSONL file. Set MEMORY_FILE_PATH to an absolute path you own: the README warns that the default sits inside the server’s own directory, which under npx is a node_modules tree that a reinstall or a cleared cache can delete.
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"],
"env": { "MEMORY_FILE_PATH": "/path/to/your/memory.jsonl" }
}
}
}
claude-mem: automatic capture for coding agents
claude-mem is the most-starred memory project we checked, with 118,585 stars and a release on 19 November 2026. Hooks record what the agent does, a second agent takes notes as it works, and sessions, observations and summaries go into SQLite at ~/.claude-mem/claude-mem.db, with Chroma adding semantic search. The agent reads them back through search (a compact index), timeline and get_observations (full details only for the results it picks). It works with Claude Code, Codex, Cursor, OpenCode and other agents. Apache-2.0.
npx claude-mem install
The installer asks you to sign in, and its hosted observer starts with a 30-day free trial that asks for a payment method; passing an explicit --provider flag skips the sign-in.
Graphiti MCP, for a self-hosted temporal graph
Graphiti’s MCP server ships in its repo. docker compose up in the mcp_server folder starts FalkorDB and the server in one container (Neo4j is the alternative), with the endpoint at http://localhost:8000/mcp/. It needs an LLM key from OpenAI, Anthropic, Gemini, Groq or Azure OpenAI.
claude mcp add --transport http graphiti http://localhost:8000/mcp/
MCP Memory Service and Qdrant
MCP Memory Service is one self-hosted service with MCP, a REST API, OAuth, a CLI and a dashboard. It stores memories in SQLite, in Cloudflare to sync across devices, or in a hybrid of both, and serves Claude as well as LangGraph, CrewAI and AutoGen. Apache-2.0, v13.0.0 on 20 November 2026.
pip install "mcp-memory-service[sqlite]"
claude mcp add memory -- memory server
Qdrant’s MCP server has two tools, qdrant-store and qdrant-find, and runs with uvx mcp-server-qdrant against a Qdrant server (QDRANT_URL) or a local folder (QDRANT_LOCAL_PATH). It suits teams that already run Qdrant.
If your notes are already in Obsidian, a vault server turns them into agent memory; Obsidian MCP covers the three most used.
Which Mem0 alternatives are actively maintained?
From the GitHub API on 20 November 2026:
| Repository | Stars | Last commit | Latest release |
|---|---|---|---|
| thedotmack/claude-mem | 118,585 | 2026-11-20 | v16.0.1 (2026-11-19) |
| modelcontextprotocol/servers (memory folder) | 92,134 | 2026-11-18 | v2.5.0 (2026-11-18) |
| mem0ai/mem0 | 69,282 | 2026-11-18 | ts-v3.3.1 (2026-09-25) |
| vectorize-io/hindsight | 62,236 | 2026-11-20 | v1.2.3 (2026-11-19) |
| topoteretes/cognee | 33,431 | 2026-11-20 | v1.6.10 (2026-11-18) |
| getzep/graphiti | 32,963 | 2026-11-19 (MCP folder) | v0.31.2 (2026-10-20) |
| supermemoryai/supermemory | 31,676 | 2026-11-18 | server-v0.0.9 (2026-10-12) |
| letta-ai/letta | 25,505 | 2026-10-18 | 0.16.8 (2026-05-14) |
| MemoriLabs/Memori | 17,601 | 2026-09-18 | v3.3.6 (2026-05-28) |
| MemTensor/MemOS | 12,465 | 2026-11-09 | v2.0.36 (2026-11-09) |
| plastic-labs/honcho | 8,210 | 2026-11-20 | v3.6.1 (2026-11-11) |
| basicmachines-co/basic-memory | 4,646 | 2026-11-20 | v1.0.0 (2026-10-29) |
| doobidoo/mcp-memory-service | 2,138 | 2026-11-20 | v13.0.0 (2026-11-20) |
| langchain-ai/langmem | 1,779 | 2026-11-16 | none |
| qdrant/mcp-server-qdrant | 1,575 | 2026-11-20 | v0.8.1 (2025-12-10) |
Letta’s last release in that repo is from May because development moved to letta-code (v0.34.67 on 20 November 2026). MCP directories and older roundups still list servers that have stopped getting updates: simple-memory-mcp has 10 stars and no commit since 17 April 2026, and mcp-memory-libsql has 24 stars and no commit since 5 March 2025.
Should I trust memory benchmarks?
Read them as claims. Memory vendors publish scores on LoCoMo, LongMemEval and similar tests, each with its own setup, models and choice of rivals, and several of the comparison posts ranking for “mem0 alternatives” are written by a vendor that lists its own product first. This page has a vendor too, in section 10.
We ran part of LoCoMo ourselves on 1 October 2026, with each conversation session stored as a page in a wiki and Claude Sonnet answering from the top five pages that keyword search found. It answered 74.8% of 250 questions correctly. With the whole conversation pasted into the prompt instead, it got 80.8% while reading about six times as many words. Letting the model write up to three short queries per question helped retrieval more than adding embeddings did: the right session was in the top five for 91.0% of 1,536 questions, against 85.3% with the raw question and 89.6% with hybrid search. LoCoMo’s conversations run 8,000 to 16,000 words and fit in a current context window, so these scores say little about memory that outgrows one prompt. Test two or three candidates on your own conversations before you switch.
How do I choose a Mem0 alternative?
- Per-user memory in an app, cheapest start: Mem0 (50,000 free adds a month with your own LLM key) or Supermemory ($5 of free credits).
- Facts that change over time: Zep, or Graphiti self-hosted.
- Every feature self-hosted at no cost: Hindsight, Cognee, or Mem0’s own open-source server.
- Already on LangGraph: LangMem.
- An agent that manages its own memory: Letta.
- Conversations with several participants: Honcho.
- Memory built from documents: Cognee.
- Claude Code or another coding agent that records its own sessions: claude-mem.
- Notes one person can read and edit: Basic Memory.
- Several agents sharing one memory your team can see: a hosted wiki, as in section 10.
Our guide to agent memory covers the layers below these, from memory files to RAG, and the LLM wiki guide compares fact memory with pages an agent writes. If you only need one coding agent to remember a project, Claude Code memory may be enough.
FAQ
What is the best open-source alternative to Mem0? It depends on what you store: Graphiti for facts that change over time, Hindsight for a full MIT memory system you self-host, Cognee for documents. Mem0 itself is Apache-2.0 and can be self-hosted.
Does Mem0 include graph memory on the free plan? No. Its pricing page lists graph memory on custom plans only.
Is Zep cheaper than Mem0? Not at the start: Mem0’s free plan takes 50,000 adds a month with your own LLM key, and Zep’s paid plans begin at $125 a month. Zep does not charge for retrieval; Mem0 caps retrievals on its free plan.
Does Mem0 have an MCP server? Yes, a hosted one at https://mcp.mem0.ai/mcp. Its older local server, OpenMemory, is no longer in the mem0 repo; the MCP section above has the details.
Is there an official MCP memory server? The closest is the Memory server in the modelcontextprotocol/servers repository, published by the MCP project. The others here come from companies and individual developers.
Sources
- https://mem0.ai/pricing
- https://docs.mem0.ai/open-source/overview
- https://docs.mem0.ai/platform/mem0-mcp
- https://github.com/mem0ai/mem0
- https://www.getzep.com/pricing/
- https://github.com/getzep/graphiti
- https://github.com/getzep/graphiti/tree/main/mcp_server
- https://help.getzep.com/
- https://help.getzep.com/memory-mcp-server
- https://www.getzep.com/research/memory-benchmarks/
- https://supermemory.ai/pricing/
- https://github.com/supermemoryai/supermemory
- https://supermemory.ai/docs/supermemory-mcp/introduction
- https://supermemory.ai/research
- https://vectorize.io/pricing
- https://hindsight.vectorize.io/
- https://github.com/vectorize-io/hindsight
- https://honcho.dev/
- https://github.com/plastic-labs/honcho
- https://memorilabs.ai/pricing
- https://github.com/MemoriLabs/Memori
- https://memos.openmem.net/
- https://github.com/MemTensor/MemOS
- https://docs.letta.com/pricing
- https://docs.letta.com/v1-sdk/memory/memory-blocks
- https://github.com/letta-ai/letta
- https://langchain-ai.github.io/langmem/
- https://github.com/langchain-ai/langmem
- https://www.cognee.ai/pricing
- https://github.com/topoteretes/cognee
- https://basicmemory.com/pricing
- https://github.com/basicmachines-co/basic-memory
- https://github.com/modelcontextprotocol/servers/tree/main/src/memory
- https://github.com/thedotmack/claude-mem
- https://github.com/doobidoo/mcp-memory-service
- https://github.com/qdrant/mcp-server-qdrant
- https://github.com/chrisribe/simple-memory-mcp
- https://github.com/joleyline/mcp-memory-libsql
- https://mem0.ai/research
- https://mem0.ai/blog/zep-vs-mem0-which-ai-memory-layer-should-you-choose
- https://dexio.wiki/agents.md
- https://dexio.wiki/docs/
- https://dexio.wiki/pricing/
- https://github.com/dexio-wiki/dexio