# MCP Memory Servers: SynaBun vs mem0 vs Letta vs Zep

> An honest comparison of four AI memory servers for MCP (SynaBun, Mem0, Letta and Zep): tools, storage, embeddings, license and when to pick each.

Source: https://synabun.ai/blog/mcp-memory-servers-comparison · By Danilo Khury · Published 2026-04-29 · Updated 2026-10-21

*Updated October 21, 2026: every fact about the four projects was rechecked against their repositories, documentation and pricing pages (sources at the end). OpenMemory has since been discontinued, Letta has moved to a new memory system, and the latency table of the first version is gone because those runs could not be reproduced.*

There are now half a dozen serious AI memory servers in the wild, and the marketing pages do not help you pick one. Each project highlights what it is good at and skips what it is not.

This post is the honest version. I built one of these (SynaBun), so I am biased — and I will flag that bias every time it shows up. If something in here is wrong, message me on [Discord](https://discord.gg/x6yWqE9GZP) and I will fix it. For the short version side by side, see [the comparison page](https://synabun.ai/compare); for the one-on-one detail, [SynaBun vs Mem0](https://synabun.ai/synabun-vs-mem0) and [SynaBun vs Letta](https://synabun.ai/synabun-vs-letta).

## The four servers

I am comparing four projects that share the same core job — give an AI agent persistent memory across sessions — but make wildly different architecture choices. All of them speak the [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) in some form.

- **SynaBun** — local-first, MCP-native, 158 tools (memory + assistant + browser + social + whiteboard + loops), Apache 2.0
- **Mem0** — open-source library plus the hosted Mem0 Platform, whose MCP server has 11 memory tools, Apache 2.0
- **Letta** (formerly MemGPT) — agent platform built around Letta Code, memory as Markdown files in git, Apache 2.0 + Letta Cloud
- **Zep** — hosted context platform built on Graphiti, an open-source temporal knowledge graph, Apache 2.0 (Graphiti) + Zep Cloud

There is also Memory Keeper, an MIT-licensed local MCP server with 38 tools for context and sessions, which overlaps with these. OpenMemory, Mem0's local variant, has been discontinued.

## Quick decision matrix

| You want… | Pick |
|--|--|
| One MCP install for everything (memory + browser + social + loops) | **SynaBun** |
| A managed memory service with a dashboard | **Mem0** |
| An agent platform where the agent maintains its own memory | **Letta** |
| Knowledge-graph reasoning over chat history | **Zep** (or Graphiti, self-hosted) |

The rest of this post is the long version.

## Feature matrix

As of October 21, 2026:

| Feature | SynaBun | Mem0 | Letta | Zep |
|--|--|--|--|--|
| **MCP tools** | 158 (141 on by default) | 11 (hosted MCP server) | 6 (hosted MCP server, for managing agents) | 13 (Graphiti MCP server) |
| **Memory architecture** | Hybrid (keyword + vector) + categories + importance | Facts extracted by an LLM, stored as vectors | MemFS: Markdown memory files in git | Temporal knowledge graph |
| **Default embedding** | all-MiniLM-L6-v2 (local) | OpenAI text-embedding-3-small | No vector index by default | OpenAI (Graphiti default) |
| **Storage** | SQLite | Local Qdrant + SQLite (library), Postgres + pgvector (server) | Files under `~/.letta`, or Letta Cloud | Neo4j, FalkorDB or Amazon Neptune (Graphiti), or Zep Cloud |
| **Local mode** | Yes (default) | Yes, with local models configured | Yes (local runtime) | Graphiti only; Zep itself is hosted |
| **Beyond memory** | Assistant with worker agents, browser automation, social tools, whiteboard, loops, Claude Code hooks | Memory only | Agent runtime and SDK | Context graph platform |
| **License** | Apache 2.0 | Apache 2.0 | Apache 2.0 | Apache 2.0 (Graphiti) + commercial Cloud |
| **Managed cloud** | No | Mem0 Platform | Letta Cloud | Zep Cloud |

## SynaBun

**Pitch:** the kitchen-sink MCP server. Memory is one of 158 tools, not the only one.

**Architecture:** Node MCP server + SQLite (FTS5 keyword search plus vectors stored as BLOBs) + local embeddings. Recall is hybrid by default since 2.0.0: keyword search and embeddings, fused by rank. Adds a 3D interface for browsing memory (the Neural Interface, in SynApp), a REST API, Claude Code hooks, and schedules for recurring loops. Browser tools wrap Playwright. [How the memory engine works](https://synabun.ai/docs#section-memory-v2).

**Embedding:** `all-MiniLM-L6-v2` (local, 384 dims, about 90 MB downloaded once). [Detailed reasoning here](https://synabun.ai/blog/all-minilm-l6-v2-mcp-vector-memory).

**Strengths:**
- One install gets you memory, a memory-aware assistant that dispatches worker agents, browser, social extraction, autonomous loops, Discord tools, Leonardo.ai image/video generation, and 30 Google Search Console tools (the browser-based ones need no API key).
- Local-first: memory, embeddings and recall run on your machine with no cloud account.
- First-class support for Claude Code, Codex, OpenCode and Gemini CLI.
- Categorical memory model (parent/child categories, project tags, importance scoring) maps cleanly to how developers actually organize knowledge.

**Weaknesses:**
- More surface area means more to learn. If you only want memory, this is overkill.
- The browser and social tools drive a real browser session, which adds setup on a headless server.
- No managed cloud option. You run it.

**Bias disclosure:** I built this. Every other server in this post is something I evaluated before deciding to write my own.

**When to pick:** you are a single developer who wants one MCP server that does everything, and you are happy to self-host.

## Mem0

**Pitch:** the most popular project of the four (about 67,600 GitHub stars in October 2026). Both a hosted platform and an open-source library.

**Architecture:** Python library + REST API + optional hosted platform. An LLM extracts facts from conversations and decides whether to add, update or delete memories. The library stores them in a local Qdrant collection with its history in SQLite; the self-hosted server runs on Postgres with pgvector.

**Embedding:** OpenAI `text-embedding-3-small` by default (its LLM is OpenAI by default too). Swappable via the config, including local models through Ollama.

**Strengths:**
- Largest community in the category. Lots of integrations, lots of documentation.
- "Intelligent" memory updates — if a new fact contradicts an old one, Mem0 tries to merge.
- The hosted platform means zero setup if you do not want to self-host.
- Documented integrations with LangGraph, LlamaIndex, AutoGen, CrewAI and more.

**Weaknesses:**
- The self-hosted server is a Docker Compose stack (API plus Postgres with pgvector). Not as plug-and-play as SQLite.
- Out of the box the library needs an OpenAI API key; going fully local means configuring local models.
- 11 MCP tools — a pure memory layer, no adjacent tooling.
- The "intelligent" memory dedupe sometimes erases context you wanted to keep. Tunable but takes work.

**When to pick:** you want a managed memory service with a polished dashboard and a large community.

## Letta (formerly MemGPT)

**Pitch:** memory the agent maintains itself, inside an agent platform. Letta grew out of the 2023 MemGPT research paper.

**Architecture:** Letta Code agents keep their memory in MemFS: Markdown files in a git repository. The files under `system/` are in the prompt on every turn, and the agent reads and edits the others when it needs them. The older three-tier model (core, archival and recall memory) belongs to the legacy V1 SDK.

**Embedding:** none by default for memory files — MemFS has no vector index. Searching past messages is full-text locally, and full-text, vector or hybrid on Letta Cloud.

**Strengths:**
- Memory as plain files is easy to read, diff and version.
- Runs locally (Letta Code keeps its state under `~/.letta`) or in Letta Cloud, with free and paid plans.
- Real research lineage: the MemGPT paper ("MemGPT: Towards LLMs as Operating Systems", UC Berkeley, 2023).
- An Agent SDK if you want to ship a product with agents of its own.

**Weaknesses:**
- Designed for running agents, not for "drop in a memory layer to my Claude Code session".
- Its agents use MCP servers as clients; Letta's own hosted MCP server (6 tools) manages agents, not memory.
- No vector index by default, so recalling by meaning needs extra work.

**When to pick:** you are building a product with its own agents, and you want an agent platform that manages their memory.

## Zep

**Pitch:** knowledge graph + vector memory. Tracks entities, relationships, and facts over time, not just unstructured text.

**Architecture:** Zep Cloud is built on Graphiti, Zep's open-source framework for temporal knowledge graphs. Graphiti turns conversations into a graph of entities and relationships and runs on Neo4j, FalkorDB or Amazon Neptune; recall combines graph traversal with search.

**Embedding:** OpenAI by default in Graphiti, configurable.

**Strengths:**
- The knowledge graph layer is genuinely powerful for use cases that involve tracking relationships over time (CRM-style assistants, customer support agents).
- Temporal awareness — can answer "what did the user say about X last month vs this week".
- Graphiti is open source (Apache 2.0) and ships its own MCP server with 13 tools; Zep Cloud adds a managed platform.

**Weaknesses:**
- The graph layer adds real complexity. For pure dev memory ("remember that we agreed to use TanStack Query"), it is overkill.
- Self-hosting means running Graphiti with a graph database such as Neo4j or FalkorDB.
- Zep itself is hosted only: the self-hosted Zep Community Edition was discontinued in April 2025.

**When to pick:** your AI agent needs to reason about relationships between entities over time. CRM, support, sales-copilot use cases.

## Latency

This is where the local vs cloud split matters most, and it is also where the first version of this post went too far: it had a table of p50 latencies for every server, from runs I cannot reproduce today, so that table is gone.

What I can stand behind is SynaBun's own benchmark, the one every change to its memory engine must pass (`benchmarks/memory-v2.mjs`, not yet in the public repository; run on September 6, 2026 on an Apple M4 with Node 24):

| Workload | p50 | p95 |
|--|--|--|
| 59 documents, 23 queries, hybrid recall | 1.6 ms | 2.4 ms |
| 10,000 documents, repeated queries | — | 5.8 ms |
| 10,000 documents, fresh queries (embedding included) | — | 10.5 ms |

The structural point stands without numbers for the others: SynaBun's recall happens in one local process with no network hop. A hosted memory API adds a network round trip to every call, and a self-hosted stack of separate services adds calls between them.

For interactive coding sessions, that is the difference between "memory feels invisible" and "memory feels like it has a loading state".

## License + commercial concerns

All four have an Apache 2.0 core. The differences:

- **SynaBun** — Apache 2.0 throughout. No hosted product.
- **Mem0** — Apache 2.0 library + the hosted Mem0 Platform (free plan, paid plans).
- **Letta** — Apache 2.0 + Letta Cloud (free plan, paid plans).
- **Zep** — Graphiti is Apache 2.0; Zep Cloud is commercial. The self-hosted Community Edition was discontinued in April 2025.

For the long tail, "fully open source with no hosted product" matters to some teams.

## What about OpenMemory?

OpenMemory was Mem0's local MCP memory server: 5 tools, Qdrant for vectors and SQLite for metadata. Mem0 announced its end in April 2026 and removed it from its repository in July 2026, so it is no longer an option. If you used it for local memory, SynaBun and Memory Keeper are the local MCP servers in this space.

## Picking by use case

**Solo developer using Claude Code daily:** SynaBun. Local recall in milliseconds, the extras (browser, loops, hooks) come for free, no cloud account.

**Team building a product with its own agents:** Letta. The agent platform, its SDK and Letta Cloud save you the wiring.

**Product team integrating with multiple LLM frameworks (LangGraph, LlamaIndex, AutoGen):** Mem0. The integration coverage is unmatched.

**CRM / support agent that needs entity reasoning over time:** Zep, or Graphiti if you self-host. The knowledge graph is the unique value.

## What none of these do well

The category has gaps. None of these handle well:

- **Cross-developer memory.** Sharing a memory store across a team without re-implementing access control yourself.
- **Memory search across documents + code.** Most are tuned for chat-style memories. Searching across a code corpus + chat memory in one query is still rough.

Two gaps from the first version of this post have narrowed in SynaBun since: it can rank forget candidates (duplicates, old memories nobody recalls) without deleting anything, and its recall can explain why a memory ranked where it did.

If any of the remaining gaps matter to your use case, you will end up writing custom code regardless of which server you pick.

## Closing

The "AI memory" category is going to keep fragmenting. Cloud-first products are going to get more polished. Local-first products are going to get faster and more capable. And a lot of teams will end up running both — local for dev memory, cloud for production memory.

For dev work specifically, the case for local is strong: lower latency, lower cost, full privacy. SynaBun is my answer to that case. The other three are good answers to different questions. The [SynaBun docs](https://synabun.ai/docs) cover installing it and connecting it to your tools.

## Sources

Checked on October 21, 2026:

- Mem0: [repository](https://github.com/mem0ai/mem0), [MCP server](https://docs.mem0.ai/platform/mem0-mcp), [integrations](https://docs.mem0.ai/integrations), [pricing](https://mem0.ai/pricing), and the [pull request that removed OpenMemory](https://github.com/mem0ai/mem0/pull/6530)
- Letta: [Letta Code](https://github.com/letta-ai/letta-code), [MemFS](https://docs.letta.com/concepts/memfs), [hosted MCP server](https://docs.letta.com/platform/hosted-mcp), [pricing](https://docs.letta.com/pricing), [the MemGPT paper](https://arxiv.org/abs/2310.08560)
- Zep: [Graphiti](https://github.com/getzep/graphiti), [the end of the Community Edition](https://www.getzep.com/blog/announcing-a-new-direction-for-zeps-open-source-strategy/), [pricing](https://www.getzep.com/pricing/)
- Memory Keeper: [repository](https://github.com/mkreyman/mcp-memory-keeper)
- SynaBun: [repository](https://github.com/danilokhury/Synabun)

Related reading:

- [Using all-MiniLM-L6-v2 for Local Vector Memory in MCP Servers](https://synabun.ai/blog/all-minilm-l6-v2-mcp-vector-memory)
- [Self-Hosted AI Memory: Why Local Beats Cloud](https://synabun.ai/blog/self-hosted-ai-memory-vs-cloud)
- [SynaBun vs Mem0 (full comparison page)](https://synabun.ai/synabun-vs-mem0)
- [SynaBun vs Letta (full comparison page)](https://synabun.ai/synabun-vs-letta)
- [Compare all AI memory tools](https://synabun.ai/compare)