9 Mem0 Alternatives for Agent Builders and AI Users

The best Mem0 alternative depends on why you came to Mem0. Developers adding memory to agents should look at Zep, Letta, Cognee, Supermemory, LangMem or MemOS; people who want their own AI tools to remember them need a finished product such as Unabyss, MemoryPlugin or Basic Memory.

The timing matters too: as of late October 2026, Mem0 no longer sells its Starter, Growth and Pro plans to new accounts. Below, nine options, with prices checked on each vendor's site in October 2026.

---

Why look for a Mem0 alternative?

People look for a Mem0 alternative because its pricing just changed, graph memory now needs a custom plan, the open-source version does less, or they were never building an agent.

• New pricing. New accounts now choose between a Free plan and a Custom contract. Existing Starter, Growth and Pro plans keep their price, but they're no longer sold and plan changes go through Mem0's team (Mem0 pricing FAQ).
• Bring your own key. After 30 days, the Free plan only adds memories through your own OpenAI, Anthropic, Azure or OpenRouter key, at a provider cost Mem0 puts at about $3.55 to$5.34 per 1,000 adds.
• Graph memory moved up. Graph memory, user profiles and Dream (background consolidation) are listed only on the Custom plan (Mem0 pricing).
• Open source lost features. Mem0's own comparison says the self-hosted version dropped its graph store integrations (Neo4j, Memgraph, Kuzu, Apache AGE) when the v3 pipeline landed, and doesn't support memory decay or temporal reasoning (Mem0 docs).
• You're a user, not a builder. Mem0 is a memory layer you call from code, which is more plumbing than you need if you just want Claude to know your projects.

---

How do the best Mem0 alternatives compare?

Six are memory layers for developers and three are finished tools for individuals. Prices come from each vendor's own pricing page (checked October 2026).

---

Which Mem0 alternatives suit developers building agents?

For agents, Zep is the strongest swap when time matters, Letta when memory should live inside the agent, Cognee when memory comes from a body of documents, and Supermemory when you'd rather buy connectors than build them. Longer write-ups are in 8 Supermemory Alternatives; below is what matters coming from Mem0.

Zep and Graphiti

Zep builds a Context Graph for each user, account or domain, and dates every fact so it's updated as your data changes (Zep). That's the gap Mem0 users hit most: knowing a customer's renewal moved, not just that both dates came up. Zep bills credits per episode you send (one credit per 350 bytes), while retrieval, storage and users cost nothing, with 10,000 free credits a month and Flex at $125.

The engine, Graphiti, is Apache 2.0 with about 31,900 GitHub stars, bi-temporal tracking with automatic fact invalidation, its own MCP server, and support for Neo4j, FalkorDB and Amazon Neptune (GitHub). If Mem0's open-source version losing graph memory is why you're leaving, Graphiti is the closest open-source answer.

Letta

Letta, formerly MemGPT, puts memory inside the agent: memory blocks are sections of the context window that persist across interactions, and the agent rewrites them with built-in memory tools (Letta docs). Its open-source agent, Letta Code, is Apache 2.0 and now tracks all of an agent's context, memory blocks included, in git (GitHub). The developer API plan is usage-based, at $0.10 per active agent a month plus tool execution and model calls (Letta pricing), and a hosted MCP server lets Claude Code or Cursor create and message your Letta agents (Letta docs). Pick Letta when you're designing the agent, not bolting memory onto one.

Cognee

Cognee turns documents, code and conversations into a knowledge graph your agents query (GitHub). It's Apache 2.0 with about 31,200 stars, ships an MCP server plus Claude Code and Codex plugins, and is free to self-host. Hosted, it's free up to 1 million tokens, then $1 per million plus$5 per extra workspace, with Slack, Notion, Linear and Google Drive integrations on the paid plan.

Supermemory

Supermemory is the closest commercial match to Mem0, a memory API whose MIT-licensed repo has about 31,400 stars, an MCP server at mcp.supermemory.ai/mcp, plugins for Claude Code, Cursor and Codex, and a self-hosted server (GitHub). Unlike Mem0, it still sells fixed monthly plans, from Pro at $19 a month to Scale at$399 with SOC 2 and a HIPAA BAA. Compared with Unabyss: Supermemory vs Unabyss.

LangMem

LangMem is LangChain's MIT-licensed memory library: tools an agent uses to record and search memories mid-conversation, plus a background manager that extracts and consolidates them, built into LangGraph's long-term memory store (LangMem docs). With no hosted service or MCP server, it suits teams already on LangGraph.

MemOS

MemOS, from MemTensor, is an Apache 2.0 "memory OS" with about 11,100 stars that you self-host with Neo4j and Qdrant, or use through MemOS Cloud (GitHub). The cloud free plan covers 50,000 adds and 20,000 searches a month, and its Starter and Pro tiers are listed at $0 on application, down from$19 and $286 (MemOS). It reports 88.83 on LoCoMo through its own OmniMemEval suite.

---

Mem0 vs Zep vs Letta: what's the difference?

Mem0 is a memory store you call, Zep is a context graph you query, and Letta is an agent runtime that manages its own memory. That one difference decides most of the rest.

• Mem0 extracts discrete memories from what you send, scoped by user, agent or run, and returns them through semantic search with entity-aware ranking. It's the easiest to add to an existing app.
• Zep ingests conversations and business data into a graph where every fact is dated, so the agent can tell what was true from what is true now. It's aimed at enterprise agents, and priced that way.
• Letta asks you to build on its runtime, where memory is part of the agent's context and the agent edits it.

On benchmarks, Mem0 reports 92.5 on LoCoMo and 94.4 on LongMemEval for its April 2026 algorithm, measured on its managed platform (GitHub); Zep reports 94.7% on LoCoMo and 90.2% on LongMemEval (Zep). Both are vendor-run on different setups, so choose by memory model, not by a two-point gap. Why even a strong memory layer misses who the user is: Agent Memory vs. Context.

---

What if you just want Claude, ChatGPT and Cursor to remember you?

Then skip the memory APIs: Unabyss, MemoryPlugin and Basic Memory give your own AI tools a shared memory without code. Mem0 serves this case too, as a listed connector in Claude's directory with 11 memory tools Claude calls when it decides something is worth saving (Claude), and its MCP docs cover Claude Code, Codex, Cursor, Windsurf, VS Code and OpenCode (Mem0 docs). But it only knows what your AI writes into it.

Unabyss

Unabyss is a personal context layer: shared memory for all your AI tools, built from your work apps. You connect at least two of its 26 apps, such as Gmail, Google Calendar, Notion, Slack, GitHub or Linear, and Unabyss extracts a structured picture of your role, projects, decisions and preferences, then keeps it current as those apps change. It serves that context over MCP to 13 clients, including Claude, ChatGPT, Cursor, Claude Code and Codex, and it's listed in Claude's connector directory. Access to your apps is read-only, your data is encrypted, and it's never used for training.

The difference from Mem0 is where memory starts: with Mem0 it exists once the model saves it, with Unabyss before your first prompt. In an August 2026 Unabyss benchmark, adding it to an assistant that already had the same tools connected cut cost by 36%, time by 38% and follow-up prompts by 60% (What Structured AI Context Is Worth). The trade-offs: no free plan, only a 7-day trial with no credit card before Pro at $15 a month ($13 billed annually), and no SDK for putting it inside your own product.

MemoryPlugin

MemoryPlugin carries one memory across what it counts as 21+ AI tools, through a Chrome and Safari extension, a hosted or local MCP server and a Custom GPT (MemoryPlugin). Memories come from what you save and imported chat history; Core is $89 a year and Pro$180, after a 7-day trial. The full breakdown is in MemoryPlugin Alternatives.

Basic Memory

Basic Memory keeps notes and decisions as plain Markdown files in a local knowledge graph and serves them over MCP. It's AGPL-3.0, free on your own machine, and cloud sync starts at $15 per seat per month with a 7-day trial (Basic Memory pricing). Setup for it, and for Mem0's MCP server, is in the best memory MCP servers for Claude. The wider field, built-in ChatGPT and Claude memory included, is in Best AI Memory Tools Across ChatGPT, Claude & Cursor.

---

Where is Mem0 still the better choice?

Mem0 is still the better choice when you want the simplest memory API with the biggest community behind it.

• You want add and search in a few lines. pip install mem0ai or npm install mem0ai, call Memory(), and you have memory, with a self-hosted Docker server when you outgrow the library (Mem0 docs).
• Community size matters to you. At 67,300 GitHub stars in October 2026, Mem0 has about twice the stars of Graphiti, Cognee or Supermemory.
• You can bring your own key. With one connected, the Free plan covers 50,000 adds and 10,000 retrievals a month at no charge from Mem0, more than most free tiers here.
• You want memory across Claude's apps today. The connector works in claude.ai, Claude Desktop and Cowork with no install (Mem0).

And if you're shipping a product, Unabyss is the wrong swap: it's built for the person using AI tools, not as memory inside someone else's app.

---

Is Mem0 free?

Yes: Mem0's Free plan covers 10,000 adds and 1,000 retrievals a month for the first 30 days with model calls paid by Mem0, then 50,000 adds and 10,000 retrievals once you connect your own LLM key. Without a key after 30 days, new adds return an error. Past the free limits you can turn on usage-based billing with a monthly cap; graph memory, SSO and on-prem need a Custom plan (Mem0 pricing). The open-source library is free too.

Is Mem0 open source?

Yes, Mem0 is Apache 2.0, and you can run it as a library or as a self-hosted server (GitHub). The open-source version does less than the platform, though: no queryable graph, no memory decay, no temporal reasoning and no Dream. Its README also says benchmark scores come from the managed platform, so self-hosters should expect similar, not identical, results.

What is the best open-source alternative to Mem0?

Graphiti is the best open-source alternative for most agent builders: it's Apache 2.0, self-hostable, and gives you back the graph Mem0's open-source version dropped, with time tracking built in. Choose Cognee for memory built from documents, Letta Code for agents that rewrite their own memory, LangMem if you're on LangGraph, and Basic Memory (AGPL-3.0) if the memory is for you rather than for an app.

If the memory is for you rather than an app, see how Unabyss works, or start a 7-day trial and connect two apps: your next Claude, ChatGPT or Cursor session starts with your context already loaded.

---

Related

• 8 Supermemory Alternatives for Developers and Individuals
• Agent Memory vs. Context: Why the Distinction Decides Whether Your Agent Works
• Best Memory MCP Servers for Claude: 6 Compared