# MCP memory servers, compared honestly

Firekeep, Mem0, Zep and Graphiti, Letta, basic-memory, the MCP reference memory
server, and Claude Code and Codex built-in memory: what each self-hosts,
licenses and shares.

[HTML version](https://firekeep.ai/mcp-memory-server-comparison.html)

Published October 26, 2026 by the Firekeep team. Facts checked October 25, 2026.

We make Firekeep, so read this as a vendor's comparison. To keep it useful
anyway, every claim about another product links to that product's own page or
repository (see Sources). Several of these projects changed direction in 2026,
and the table reflects where they are now. If we got something wrong,
[tell us](https://github.com/kapella-hub/FirekeepHQ/issues/new/choose).

## The short answer

- **One person, one machine, one coding agent:** start with the memory your
  agent already has. Claude Code's auto memory is on by default; Codex has local
  memories you can turn on. Add a server when context has to cross machines,
  runtimes or people.
- **You want hosted memory and no infrastructure:** Mem0 Platform or Zep Cloud.
  Both offer an official hosted MCP server.
- **You want plain Markdown notes you can read and edit yourself:** basic-memory.
- **You want the smallest possible thing:** the MCP reference memory server, a
  knowledge graph in one local file.
- **You want one memory that several coding agents and several people share, on
  hardware you control:** that is the case Firekeep is built for, with a heavier
  footprint than anything else here.

## Side by side

| Option | Self-host | Hosted | License (self-hosted part) | MCP | Storage | Shared across machines |
|---|---|---|---|---|---|---|
| Firekeep | Yes, Docker Compose | No | BUSL-1.1, source-available; free for self-hosted internal use | Local stdio gateway on each machine, connected to your server | Vectors (Qdrant), graph (Neo4j), Redis; local embeddings via Ollama | Yes: one server for many machines, runtimes and people, with per-key auth |
| Mem0 | Yes, as a library or server | Yes, Mem0 Platform | Apache-2.0 | Official server is hosted only, over HTTP; the self-hosted OpenMemory MCP server was removed in 2026 | Semantic, BM25 keyword and entity matching | Through the hosted platform |
| Zep | No; Community Edition discontinued in April 2025 | Yes, Zep Cloud | Not applicable | Official hosted MCP server | Temporal knowledge graph | Through the hosted service |
| Graphiti | Yes | No | Apache-2.0 | Experimental server, HTTP or stdio, with no authentication | Bi-temporal graph on Neo4j, FalkorDB or Neptune | Only by sharing the database yourself |
| Letta | Docker server no longer maintained; local mode in the Letta app or CLI | Yes | Apache-2.0 | Letta is an MCP client: its agents call MCP tools | Memory blocks | Through Letta's hosted plans |
| basic-memory | Yes | Yes, Basic Memory Cloud | AGPL-3.0 | stdio by default, plus HTTP | Markdown files with a SQLite index and semantic search | Through its cloud workspace |
| MCP reference memory server | Yes | No | MIT (the repository is moving to Apache-2.0) | stdio | Knowledge graph in one local JSONL file | No |
| Claude Code built-in | Local | Not applicable | Not applicable | Not applicable | CLAUDE.md files you write; auto memory notes Claude writes | CLAUDE.md through git; auto memory is machine-local |
| Codex built-in | Local | Not applicable | Not applicable | Not applicable | AGENTS.md files; local memories, off by default | AGENTS.md through git; memories are per machine |

## What changed in 2026

Older comparisons, and model answers trained on them, still describe three of
these projects as they were in 2025.

- **Mem0 retired OpenMemory,** its self-hosted MCP server. It announced the
  sunset in April and removed the code from its repository in July. Mem0's
  documented MCP server is now hosted: "Nothing runs on your machine." The Mem0
  library itself is still open source.
- **Letta's Docker server is no longer maintained.** Letta's self-hosting guide
  says the image "is no longer an actively maintained or supported Letta product
  surface" and points local users to the Letta app or CLI.
- **Built-in memory grew up.** Claude Code now writes auto memory by default and
  can read `AGENTS.md` directly. Codex added local memories, off by default.
  Neither shares those notes across machines.

Zep discontinued its self-hostable Community Edition earlier, in April 2025. Its
open-source graph engine, Graphiti, is actively developed.

## Built-in memory is not the competition

Claude Code's auto memory and Codex's memories are good at what they are for:
one agent, on one machine, remembering your preferences and corrections. We
would not tell anyone to turn them off. Their limits are by design. Claude
Code's documentation says auto memory files "are not shared across machines or
cloud environments," and Codex scopes its memory controls to "the selected
machine."

Neither one reaches the other runtime. A fix Claude Code learned on your laptop
is not available to Codex on your desktop, or to a teammate. A server is for
that gap. Firekeep writes its own instructions into `CLAUDE.md` and
`AGENTS.md`, so the layers work together rather than competing. See
[AGENTS.md vs agent memory](https://firekeep.ai/agents-md-vs-memory.html).

## Benchmarks do not line up

Mem0, Zep and Letta each publish LoCoMo or LongMemEval scores. Each uses its own
reader model and judge, and Mem0 says its headline numbers reflect its managed
platform, not the open-source SDK. Those figures measure answer accuracy.

Firekeep's published figure measures something narrower:
[97.7% Evidence Recall@10 on LongMemEval-S](https://firekeep.ai/longmemeval-benchmark.html).
That is whether the evidence reached the first ten retrieval results, not
whether a model then answered correctly. It is a different metric, so we do not
put it in a column next to the others.

## What Firekeep does that the others do not

The table shows where Firekeep is unusual: a self-hosted server, with
authentication, that several machines, coding agents and people share. Memory
is one part of it. The rest:

- **Configured adapters** for Claude Code, Codex, Kiro, OpenCode, Pi and Claude
  Desktop, plus a generic configuration for any other MCP client. Lifecycle
  automation depends on the hooks each runtime exposes.
- **Session state** that survives context compaction and can be resumed in a
  later session.
- **Coordination between agents:** file leases, a task queue and direct
  messages.
- **Replay** of every memory read and write, so you can see why an agent knew
  something.
- **Skills, a document corpus and an encrypted vault** in the same store.

## When Firekeep is the wrong choice

- **You do not want to run infrastructure.** Firekeep has no hosted offering.
  The default stack is Neo4j, Qdrant, Redis and Ollama, with 16 GB of RAM
  recommended. Choose a hosted service.
- **You want notes you can open in an editor.** basic-memory keeps everything as
  Markdown files.
- **You need an OSI-approved open-source license today.** Firekeep is
  source-available under BUSL-1.1. Each version converts to Apache 2.0 four
  years after its first public release.
- **You are building your own agent application,** not connecting existing
  coding agents. A memory library such as Mem0, or Graphiti for temporal graphs,
  fits that better.

## Sources

All pages were read on October 25, 2026.

- Mem0: [MCP documentation](https://docs.mem0.ai/platform/mem0-mcp),
  [OpenMemory sunset announcement](https://github.com/mem0ai/mem0/issues/4923),
  [removal from the repository](https://github.com/mem0ai/mem0/pull/6530),
  [repository and license](https://github.com/mem0ai/mem0)
- Zep: [Community Edition announcement](https://www.getzep.com/blog/announcing-a-new-direction-for-zeps-open-source-strategy/),
  [MCP server](https://help.getzep.com/memory-mcp-server)
- Graphiti: [repository and license](https://github.com/getzep/graphiti),
  [MCP server README](https://github.com/getzep/graphiti/tree/main/mcp_server)
- Letta: [self-hosting guide](https://docs.letta.com/guides/selfhosting),
  [MCP guide](https://docs.letta.com/guides/mcp/overview),
  [repository and license](https://github.com/letta-ai/letta)
- basic-memory: [repository and license](https://github.com/basicmachines-co/basic-memory),
  [changelog](https://docs.basicmemory.com/whats-new/changelog)
- MCP reference memory server: [README](https://github.com/modelcontextprotocol/servers/tree/main/src/memory)
- Claude Code: [memory documentation](https://code.claude.com/docs/en/memory)
- Codex: [memories](https://learn.chatgpt.com/docs/customization/memories),
  [AGENTS.md](https://learn.chatgpt.com/docs/agent-configuration/agents-md)