Mem0 alternatives: Zep, Letta, MCP memory and Space

What Mem0 is, in its own documentation

Mem0 describes itself as long-term memory for AI agents that persists across sessions, tools and runs. It comes in two forms that share the same core loop: the hosted Mem0 Platform and an open-source library you run on your own infrastructure. In both, an application calls add to store memories extracted from messages, then search, get, update and delete to use them, and every memory is scoped by user_id, agent_id and run_id.

The differences matter once you compare alternatives. The Platform runs the vector store, language model and embedder for you, adds a web dashboard and organizations with projects and member roles, and keeps a set of ranking features to itself: graph memory over extracted entities, memory decay, temporal reasoning, and Dream, a background job that merges duplicates and supersedes outdated facts. The open-source version leaves you to provision and pay for each component. Mem0's own comparison page states that its earlier integration with external graph stores such as Neo4j was dropped when the v3 pipeline landed, so self-hosted Mem0 still uses entities to rank results but has no queryable graph.

Mem0 also publishes setup guides for coding agents, starting with Claude Code and covering Cursor, Codex and others, next to integrations for frameworks such as LangChain, CrewAI and the Vercel AI SDK. Its core shape is still a memory layer that a developer calls from code.

Sources: Mem0, Platform vs Open Source; Mem0, Build with Mem0 (documentation home)

What Mem0 costs

Mem0's pricing page, read on 30 October 2026, lists four Platform plans. Hobby is free, with 10,000 add requests and 1,000 retrieval requests a month and one project. Starter is $19 a month for 50,000 adds and 5,000 retrievals, still with one project. Pro is $249 a month for 500,000 adds and 50,000 retrievals, unlimited projects, advanced analytics, private Slack support, graph memory and Dream. Enterprise is priced on request and adds unlimited requests, on-premises deployment, audit logs, custom integrations and SSO.

Two details shape the bill. On every self-serve plan the retrieval allowance is one tenth of the add allowance, so an agent that searches memory on every turn reaches the retrieval limit long before the add limit. And the step from Starter to Pro is also the step from one project to many. The open-source library has no license fee; you pay instead for the model, embeddings and vector database it runs on.

Sources: Mem0, Pricing; Mem0, Platform vs Open Source

Why people look for a Mem0 alternative

Most searches for a Mem0 alternative start from one of four situations. Each one points to a different kind of tool, which is why a single ranked list of alternatives is less useful than it looks.

• Facts change and you need to know what was true when. Mem0 supersedes outdated facts through Dream, which its pricing page lists from the Pro plan. If you need to ask what was true at a given date, a temporal graph such as Zep's Graphiti is built around that question.
• You want the agent to curate its own memory. Letta keeps editable memory blocks inside the agent's context window and lets the agent rewrite them, which is a different design from retrieving extracted facts.
• You want to self-host with the full feature set. Open-source Mem0 has no graph, decay, temporal reasoning or Dream, so compare it with other self-hosted options on the features you actually use.
• You are not building an app at all. If the goal is for Claude Code, Codex, Cursor or ChatGPT to remember your project and follow your team's way of working, an SDK you call from code is the wrong layer. You need something those tools already connect to, which today usually means an MCP server or files they read.

Sources: Mem0, Platform vs Open Source; Mem0, Pricing; Zep, Graphiti README; Letta, Memory blocks (core memory); Model Context Protocol, Architecture overview

Mem0 alternatives compared

The table groups the options by the job each one is built for. Every row comes from the project's own documentation. This site has not benchmarked them against each other, so the table compares design, not accuracy.

Read the last column first. The limits are what you will live with every day, and they differ far more between rows than the headline features do.

Sources: Mem0, Pricing; Mem0, Platform vs Open Source; Zep, Graphiti README; Letta, Memory blocks (core memory); Model Context Protocol, Knowledge Graph Memory Server (@modelcontextprotocol/server-memory); Cline, Memory Bank; Anthropic, How Claude remembers your project (Claude Code); AGENTS.md open format; Space, Agent connections

Zep and Letta, the two most common answers

Graphiti builds a context graph of entities, relationships and episodes. Each fact carries a validity window, so when information changes the old fact is invalidated rather than deleted, and you can ask what is true now or what was true before. Every derived fact traces back to the episode, the raw data that produced it, and retrieval combines semantic embeddings, keyword search and graph traversal. Graphiti is Apache 2.0 licensed, and you supply the graph database (its README names Neo4j, FalkorDB and Amazon Neptune), the model and the embedder. Zep is the managed service built on Graphiti, with users, threads, ingestion and a dashboard. The README itself says neither is an agent memory product: Graphiti is a framework for building graphs, and Zep serves an enterprise's context.

Letta takes the opposite approach to retrieval. Memory blocks are labelled sections of the agent's context window, each with a description and a size limit in characters, prepended to the prompt on every turn, and the agent reads and rewrites them with built-in memory tools. A block can be attached to several agents, so one update is visible to all of them, and it can be made read-only, which Letta suggests for shared information such as company policies that the agent should not change. The trade is that a block's contents are always in context, and how well the agent uses a block depends on how well its description is written.

Sources: Zep, Graphiti README; Letta, Memory blocks (core memory)

The question that decides it: your app, or the agents you already use?

Mem0, Zep and Letta are built for developers. Their unit is the end user of your product, identified by an ID, and their interface is an SDK or an API you call from your own code. If you are shipping a support bot or a companion app that has to remember thousands of customers, that is the right layer, and the comparison comes down to price, hosting and how facts change over time.

Many people who search for a Mem0 alternative are in a different position. They use Claude Code, Codex, Cursor, ChatGPT or Claude every day and want those tools to stop forgetting the project, the decisions and the way their team works. For that job, ask four questions before you compare features:

• Can the tools you already use connect to it without code? An MCP server or a file the tool reads qualifies; an SDK does not, unless you write the bridge yourself.
• Can a person read and correct what was saved? A memory nobody can inspect is hard to trust with project decisions.
• Does a saved fact say where it came from? When a decision changes, the source is how you find the stale copies.
• Does it hold instructions as well as facts? A team's way of doing a task, such as a review checklist or a report template, is a playbook rather than a memory, and it needs an owner who can change it.

An option that passes all four for your setup is worth a trial. The next section shows how to run one.

Sources: Mem0, Platform vs Open Source; Model Context Protocol, What is MCP; Agent Skills, Specification

A test to run on any two options

A feature table cannot tell you whether a memory returns the right thing. Run the same short test on two candidates, with your own agent and a real project:

• Save a decision in one session, for example the database you chose and why, then ask for it in a fresh session and, if the option claims to work across clients, in a second tool.
• Change the decision at its source, then ask again. The answer should reflect the change, or at least show that the stored fact is out of date.
• Ask about something you never saved. A good store says it does not know instead of inventing an answer.
• Ask where an answer came from, then delete one memory and confirm that it no longer comes back.

The MCP memory server guide on this site describes the full 30 minute version of this test and what to record. Run it before you move real project context into any store, Space included.

Sources: Space, MCP memory server: what it is and how to evaluate one

Where Space fits, and where it does not

Space is the workspace this site documents, so it gets the same treatment. It keeps a team's playbooks and knowledge in one place and serves them over MCP to the AI tools its people connect: skills, documents, tasks, databases and memory. Claude Code, Codex, Hermes, Cursor, Claude, ChatGPT, Gemini and Cline have each been tested with Space. When someone asks for work that a skill covers, Space instructs the agent to offer the skill and to apply it only once the person agrees, and only the Space's owner can change a skill.

Against the four questions: agents connect over MCP from the Agents page of a Space; saved memories are claims a person can inspect and forget; a claim can keep the source revision it came from; and skills hold the instructions. The limits are just as specific. Extraction may be asynchronous, and it may be wrong. Stored text is encrypted while search embeddings and hashes remain readable, so Space does not claim end-to-end encryption. Connecting an agent does not import earlier conversations, so the first useful memory is one someone saves on purpose. Space has not published a benchmark against Mem0, Zep or Letta.

If you are building an app that needs memory for each of your own users, Mem0, Zep and Letta are designed for that job, and Space is not the comparison to make. If you want the AI tools your team already uses to share one source of context and one way of working, create an account at app.getspace.sh, or book a call to start a pilot on one deliverable.

Sources: Space, Agent connections; Space, Memories, claims, and sources