# recall vs Mem0

Mem0 runs an LLM over every message your code sends it and stores the facts in a vector database. recall indexes the chat files Claude Code, Codex and Cursor already write, with no model calls, and writes notes overnight with a model you choose.

Checked 17 Oct 2026 · recall 0.5.1 · [Mem0 on GitHub](https://github.com/mem0ai/mem0)

## At a glance

Mem0 is a memory layer: your application sends it messages, a model distils them into facts, and queries get the nearest facts back. recall is a reader: it opens the transcripts Claude Code, Codex and Cursor already keep, indexes them without a model, and writes a few markdown notes a night from them.

Both give an agent long-term memory. One is a service you integrate; the other is a tool you install.

| | recall | Mem0 |
| --- | --- | --- |
| Runs | On your machine | Your code calls it: library, Docker server or Mem0's cloud |
| Licence | MIT | Apache 2.0; graph, consolidation and dashboard are platform-only |
| Model calls to store a chat | **0** | **1 LLM call per `add()`**, plus an embedding |
| A search takes | **11 ms** local, 47 with embeddings | **~1 s** p50 on its platform |
| Price | **Free** | Free tier; $19 to $249 a month; Enterprise |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the extraction LLM and the vector store, or Mem0's cloud |
| Claude Code, Codex, Cursor | MCP, skill, session hook | Hosted MCP server, Claude Code plugin |

## Where both were measured

On SWE-ContextBench, the one benchmark both have run, the authors asked Mem0 for the past fix behind a new GitHub issue across 300 Claude Code sessions. It found it in its top three 39.4% of the time, after $0.24 of LLM calls to take the sessions in. recall 0.5.1 finds it 76.8% of the time with none. The paper does not define its metric, so read the gap loosely; it is not small.

On LongMemEval Mem0 is ahead, 94.4% to 88.4%, with a bigger model as both answerer and judge, from a platform run with optimisations its open-source SDK lacks. recall's retrieval alone, which no judge can move, finds an answering session in the top five 98.7% of the time. The cost of recall's way is context: it hands the model whole chats, ~44k tokens for ten, against Mem0's ~7k of facts.

**Fig 1. recall 0.5.1 and Mem0** The past fix on SWE-ContextBench; answers and context on the chat benchmarks each reports.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Past fix in the top 3 | recall 0.5.1 | 76.8% | hybrid search, no model calls |
| Past fix in the top 3 | Mem0 | 39.4% | the paper's run: $0.24 and 21 minutes of LLM calls to take in the sessions |
| Answers correct | Mem0 | 94.4% | platform run, GPT-5 answering and judging |
| Answers correct | recall 0.4.1 | 88.4% | Claude Haiku 5.5 answering and judging, reading the top 10 chats |
| Context a question | Mem0 | ~7k | its own figure, on LoCoMo: distilled facts |
| Context a question | recall 0.4.1 · top 10 | ~44k | ten whole chats, scoring 88.4% |
| Context a question | recall 0.4.1 · windows | ~17.5k | matched windows of the top 5, scoring 84.2% |

SWE-ContextBench Lite, 99 issues, 300 sessions · LongMemEval_S, each system's own run · Mem0's tokens are from LoCoMo Mem0's SWE-ContextBench figure is the paper's run of a metric it does not define. Its LongMemEval figure is a platform run with GPT-5 answering and judging; recall 0.4.1 used Claude Haiku 5.5 for both, on all 500 questions.

## Cost

Mem0 pays per message: an LLM call and an embedding on every `add()`, and metered adds and retrievals on the platform, from 10,000 free adds a month to $249 for Pro. A coding agent produces a lot of messages.

recall pays nothing to index or search. Its one model cost is the nightly notes on the day's new chats, with the model you chose: nothing through a local one, covered by a Claude or ChatGPT subscription, or batch prices on an API key.

| | recall | Mem0 |
| --- | --- | --- |
| Model calls to store a chat | **0** | **1 LLM call per `add()`**, plus an embedding |
| Price | **Free** | Free tier; $19 to $249 a month; Enterprise |
| To take in 300 sessions | **$0**, no model calls | **$0.24**, 21 min of LLM calls |
| Cost of memory | One nightly run, your model | Metered adds and retrievals |

## Latency

Mem0 reports a p50 of 0.88 to 1.09 seconds for a search on its platform, and each `add()` waits on an LLM unless you turn inference off.

recall's search is a local index with no model in the path: 11 ms on ~2,800 chats, 47 ms with the embedding model, the query's embedding included. Nothing waits at write time, because recall writes nothing: it reads chats the agents already saved.

| | recall | Mem0 |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | **~1 s** p50 on its platform |
| Wait at write time | **None**: reads saved chats | An LLM call, unless inference is off |

## Privacy

With Mem0 your messages go to the extraction LLM, the embedding model and the vector store, and on the platform to Mem0's cloud, which claims SOC 2 Type I, HIPAA readiness and GDPR, with private-cloud and air-gapped options on Enterprise. The hosted MCP server, the route for Claude Code and Cursor, needs a platform account.

recall reads your chats read-only on your machine, redacts secrets before indexing, sends no telemetry, and never pushes its git repository. Pick a local model and no chat text leaves at all; pick a hosted one and it receives redacted excerpts once a night.

| | recall | Mem0 |
| --- | --- | --- |
| Runs | On your machine | Your code calls it: library, Docker server or Mem0's cloud |
| Licence | MIT | Apache 2.0; graph, consolidation and dashboard are platform-only |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to the extraction LLM and the vector store, or Mem0's cloud |
| Compliance | Nothing to certify: no service | SOC 2 Type I, HIPAA-ready, GDPR |
| Telemetry | **None** | A platform account for the MCP server |

## How memory is built

Mem0 keeps facts: on each `add()` a model reads the new messages with the existing memories in its prompt and emits new ones. Since April 2026 nothing is rewritten or deleted; a time-aware ranking prefers the newer fact at read time.

recall keeps every chat in a full-text index and a few notes beside it: preferences, project facts, decisions, lessons and open threads, each with a quote from its chat, in markdown under git. A nightly run folds new chats in rule by rule, superseding what changed. Edit a note and your edit wins. Notes written by Claude Haiku 5.5 hold 91% of the conventions a mentor set on MemoryCode, and loaded at session start they lift an agent from 32% to 75% on long histories.

| | recall | Mem0 |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Your app sending messages |
| Memory is | Markdown notes in git, plus an index of every chat | Extracted facts as vectors, add-only |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | Semantic, re-scored by BM25 and entities |
| You can edit it | **Yes**, and the edit wins | Through the API or dashboard |

## Which to pick

**Pick Mem0 if**

- You are building a product and want its users' memories kept by an API, scoped per user, with a dashboard and a hosted graph.
- Your messages come from your own application, not from a coding agent's transcript on disk.
- You want a managed service with compliance paperwork, and the per-message LLM cost suits your volume.

**Pick recall if**

- You want Claude Code, Codex and Cursor to remember each other's chats, with nothing to call from your code.
- You want no model calls to index or search, and search in milliseconds on your laptop.
- You want your chats to stay on your machine, and memory you can read, edit and `git revert`.

## Questions

**Is recall a Mem0 alternative?**

For one job, yes: giving coding agents memory across sessions. Mem0 is a general memory API for applications you build; recall is for the chats you already have with Claude Code, Codex and Cursor, with no code of yours.

**Which is more accurate?**

On the coding benchmark both have run, recall finds the past fix in its top three 76.8% of the time against Mem0's 39.4%. On LongMemEval, a chat benchmark, Mem0 reports 94.4% with GPT-5 and recall measures 88.4% with Claude Haiku 5.5, different answer models and judges, so that ranking is loose.

**Does recall use a vector database?**

No. The index is SQLite full-text search, ranked five ways and fused. An embedding model is optional, local through Ollama or any OpenAI-compatible endpoint. Mem0 needs a vector store and an embedding model to run at all.

**Can I run Mem0 locally like recall?**

Partly. Mem0's library and Docker server run on your machine, but extraction still needs an LLM and an embedding model, and graph memory, consolidation and the dashboard are platform-only. recall's index and search never call a model, and the nightly notes can use a local one.

## Sources

- Mem0 on GitHub: benchmark figures and the platform-only note: https://github.com/mem0ai/mem0
- Mem0 docs: the add operation and inference: https://docs.mem0.ai/core-concepts/memory-operations/add
- Mem0 docs: platform against open source: https://docs.mem0.ai/platform/platform-vs-oss
- Mem0 pricing: https://mem0.ai/pricing
- Mem0 research: tokens and latency: https://mem0.ai/research
- SWE-ContextBench, Zhu et al.: https://arxiv.org/abs/2602.08316
- recall's benchmarks and method: https://github.com/alirng/recall/blob/main/docs/benchmarks.md
- recall's chat benchmark runs, with the other systems' figures: https://github.com/alirng/recall/blob/main/docs/research/retrieval-benchmarks.md