--- title: "XERJ vs Mem0: two ways to give an AI agent memory" canonical: "https://xerj.org/compare/xerj-vs-mem0" updated: "2026-10-30" source: "content/compare/xerj-vs-mem0.md" --- # XERJ vs Mem0: which memory fits your AI agent? **Short answer** (updated 2026-10-30): Should I use XERJ or Mem0 for agent memory? Pick Mem0 if you want a language model to read chats and keep a tidy list of facts for you. Pick XERJ if you want the agent to store exactly what it writes, find it with keyword, vector or hybrid search, and run it all on your own machine. **Key number:** Mem0's add() runs LLM fact extraction by default (infer=True); its default OpenAI model is gpt-5-mini and its default embedder is text-embedding-3-small. (as of 2026-10-30; source: [github.com/mem0ai/mem0](https://github.com/mem0ai/mem0)) **TL;DR** Mem0 and XERJ both give an agent memory that lasts across sessions. Mem0 asks a language model to turn chats into facts and keeps them up to date. XERJ stores what the agent writes, word for word, and finds it with keyword, vector or hybrid search on your machine. ## Agent prompt ```text Act as a coding agent. Read https://xerj.org/llms.txt, install XERJ, start a local node, store five facts about this project with POST /_memory/project, then recall each one twice, once with words from the fact and once in other words, and tell me which recalls missed and whether hybrid or semantic recall fixed them. ``` ## Commands ### Command 1 Note: Install the single XERJ binary. ```sh curl -fsSL https://xerj.org/get | sh ``` ### Command 2 Note: Store one memory. With dedup on, near duplicates at 0.95 similarity or above are skipped. ```sh curl -s -XPOST 'http://127.0.0.1:9200/_memory/project' -H 'content-type: application/json' -d '{"text":"User prefers pnpm over npm","dedup":true}' ``` ### Command 3 Note: Recall with BM25 and vectors fused by RRF. ```sh curl -s -XPOST 'http://127.0.0.1:9200/_memory/project/_recall' -H 'content-type: application/json' -d '{"query":"pnpm","hybrid":true,"k":5}' ``` *Figure: Mem0's add() runs a language model by default to turn messages into facts; pass infer=False to store raw messages instead. XERJ never calls a model on write: what you send is what gets stored, and an optional dedup check skips text at 0.95 similarity or above.* ## Side by side Checked on 2026-10-30 against the Mem0 repository and the XERJ source. | | Mem0 (open source) | XERJ | | --- | --- | --- | | What gets stored | Facts a model extracts, by default | The exact text the agent sends | | Model call on write | Yes by default; off with infer=False | Never | | Default models | gpt-5-mini, text-embedding-3-small (OpenAI) | None needed; optional local MiniLM | | Updates old facts | Yes, the model can update or delete | No; you overwrite by id or forget | | Search on recall | Vectors, plus BM25 and an entity boost when the store supports full-text search (Qdrant does) | BM25 by default; semantic or hybrid on request | | Storage | Vector store, Qdrant by default | One local index per namespace | | Scoping | user_id, agent_id, run_id | Namespace, plus metadata filters | | Ways to run | Python library, self-hosted server, cloud platform | One binary, HTTP API and MCP server | | License | Apache 2.0 | Apache 2.0 | ## Try the XERJ side This is XERJ's default recall: plain BM25 over three memories. Pick a recall and see what comes back. *Figure: Runs in your browser and sends nothing. A local XERJ v1.0.0-rc.97 node returned the same hits and scores for all four recalls on 2026-10-30. "which package manager" and "deploy day" come back empty because no stored word matches; "deploy" is not "Deploys". That gap is what semantic recall is for: start the node with --embed-mode neural and send semantic or hybrid set to true.* The empty results are the honest part. A word match cannot know that "package manager" means pnpm. You have three fixes: - Write memories with the words you will search for later, such as "package manager: pnpm". - Turn on `semantic` or `hybrid` recall with the neural embedder, which compares meaning. - Use a tool like Mem0 whose model rewrites memories into cleaner facts at write time. ## When to pick Mem0 - You want the memory layer to decide what is worth keeping. - Facts change, and you want old ones updated or removed for you. - You are happy to call a language model on every write, or to use the hosted platform. - You work in Python and want a library inside your app. ## When to pick XERJ - You want to know exactly what was stored, with no model rewriting it. - You want no model call and no cloud service on the write path. - You want memory in the same engine as the rest of your agent's search: logs, docs, code and past sessions. - Your agent speaks MCP. XERJ ships an MCP server with `xerj_memory_store` and `xerj_memory_recall`. ## Limits to know on the XERJ side - XERJ runs on one node. There is no replication or failover. - Namespaces isolate by name, not by credential. - Nothing ages out on its own. Your agent forgets with `DELETE /_memory/{ns}/{id}`. The [memory across sessions](/answers/coding-agent-memory-across-sessions) page shows a store, restart and recall run. The [agent memory tools comparison](/compare/xerj-vs-agent-memory-tools) also covers Zep, Letta and Cognee. ## How to try it with XERJ Use the Copy the prompt button and paste it into your coding agent. It installs XERJ, stores five facts and tests which recalls miss. Or run the three commands above by hand. ## Sources checked All checked on 2026-10-30. - Mem0: `mem0/memory/main.py` (infer defaults to True; BM25 scoring when the vector store supports it), `mem0/llms/openai.py` (gpt-5-mini), `mem0/embeddings/openai.py` (text-embedding-3-small) and `mem0/vector_stores/configs.py` (Qdrant) in [mem0ai/mem0](https://github.com/mem0ai/mem0). License Apache 2.0 from the repository. - XERJ memory API: `engine/crates/xerj-api/src/memory_api.rs`. MCP tools: `engine/crates/xerj-mcp/src/lib.rs`. - Recall results: a local XERJ v1.0.0-rc.97 node with the three memories shown. ## FAQ ### What is the main difference between XERJ and Mem0? Mem0 calls a language model on write to extract facts and update old ones. XERJ makes no model call on write. It stores the text the agent sends and finds it later with search. ### Does Mem0 need an OpenAI key? Its default setup uses OpenAI: gpt-5-mini for extraction and text-embedding-3-small for embeddings. You can configure other providers, and infer=False stores raw messages with no extraction step. ### Is XERJ a drop-in replacement for Mem0? No. The APIs differ, and XERJ does not extract or merge facts for you. If your agent relies on Mem0 updating old facts, you would write that logic yourself. ### Which one is better for a coding agent on my laptop? If you want no cloud service and no model on the write path, XERJ fits. If you want automatic fact cleanup and are fine with a model call per write, Mem0 fits. ### Does XERJ separate memories per user? Each namespace is its own index, so recall in one namespace never sees another. There is no per-namespace password, so do not use namespaces as a security boundary. ### Was a benchmark run between the two? No. We did not run a head-to-head, so this page compares design, not scores. ## Related - [XERJ vs agent memory tools: Mem0, Zep, Letta and Cognee](/compare/xerj-vs-agent-memory-tools) - [claude-mem vs MemPalace vs XERJ: which memory should Claude Code use?](/compare/xerj-vs-claude-mem-and-mempalace) - [How do people store user preferences so an agent can recall them next week?](/answers/coding-agent-memory-across-sessions) - [What is an MCP memory server?](/answers/what-is-an-mcp-memory-server) - [What is agentic memory?](/answers/what-is-agentic-memory) - [What is hybrid search?](/answers/what-is-hybrid-search) - [How do I give two agents private memory on one laptop?](/answers/private-agent-memory-namespaces) (same intent: agent memory) - [What's a simple way to give an agent long-term memory on my laptop without Qdrant?](/answers/agent-memory-without-postgres-qdrant) (same intent: agent memory) - [How does Claude Code memory work, and when do you need more?](/answers/claude-code-memory) (same intent: agent memory)