Mem0 MCP: Which One to Install (2026)

You search for mem0 MCP because you want your agent to remember things between sessions. What comes back is four different install commands, and three of them are for something that has since changed name, changed shape, or stopped being maintained. The most-starred repository on GitHub is archived. The official blog post explaining the local version still tells you to clone a folder that is no longer in the repository.

None of this is bad faith. Mem0 moved quickly, consolidated three products into one, and the rest of the internet kept publishing the old instructions. The result is a search term where the top results actively disagree with each other.

So this post does the disambiguation first and the setup second. By the end you will know which one to install, what it costs, and whether you need it at all.

Why searching for mem0 MCP is so confusing

The Model Context Protocol, or MCP, is the open standard that lets an AI client call outside tools mid-conversation. Anthropic introduced it in late 2024 and it is now how most tools expose themselves to agents. A memory server is one of the obvious things to build with it, and Mem0 built one early.

Then it built three more. Over about eighteen months the company shipped a standalone MCP server, a local-first product called OpenMemory, a hosted platform endpoint, and a self-hosted server that replaced two of those. Along the way the name OpenMemory got reused for something else entirely.

Every one of those still has documentation, blog coverage and directory listings pointing at it. Search does not know which is current. It ranks the one with the most links, and the one with the most links is the dead one.

The four things called mem0 MCP

Here is the actual state of play, checked against the repositories and the docs rather than against other people’s tutorials.

Two of those four deserve a note, because they are the ones that waste people’s afternoons.

The archived repo: mem0ai/mem0-mcp opens with a caution block stating the project is no longer actively maintained and the repository is a public archive. It thanks its stargazers in the past tense. The matching npm package last shipped version 0.2.0 in April 2026. It is still the first GitHub result many people hit, and plenty of MCP directories still list its install command as the way in.

The recycled name: the repository at mem0ai/openmemory is no longer a memory server. It is now a CLI and terminal UI for porting coding sessions between Claude Code, Codex and OpenCode. Useful, but not remotely what you were looking for. If you followed a 2025 tutorial to that repo and came away baffled, that is why.

Which one to install

For almost everyone, the hosted server.

It is the path Mem0 itself points to from the archived repo’s own README, it is what the Claude Code integration docs document, and it is the only one where somebody else handles the database. Memory is a stateful service. Running a stateful service on your laptop to remember which linter you prefer is a poor trade unless you have a reason.

The reason, when it exists, is usually privacy. If the facts your agent stores cannot leave your machine, self-host. Otherwise take the hosted one.

Setting up the hosted Mem0 MCP

Three steps and about five minutes.

First, get an API key from your Mem0 dashboard. It starts with m0-. Export it so your client can read it.

export MEM0_API_KEY="m0-your-key-here"

Then add the server. Mem0 publishes a one-liner that works across clients.

npx mcp-add \
  --name mem0-mcp \
  --type http \
  --url "https://mcp.mem0.ai/mcp/" \
  --clients "claude code"

Swap claude code for claude, cursor, windsurf or vscode depending on what you use. There is also a plugin marketplace route for Claude Code, which installs lifecycle hooks and a skill alongside the server so memory capture happens automatically rather than only when you ask.

claude plugin marketplace add mem0ai/mem0
claude plugin install mem0@mem0-plugins

Restart the client. You should get nine tools, including add_memory, search_memories, get_memories, update_memory and delete_memory. If the list comes back empty, the key is almost certainly not in the environment your client launched from. The endpoint returns a 401 without it, and most clients report that as a generic connection failure rather than an auth problem, which sends people debugging the wrong thing.

Then test it properly. Tell the agent something real, close the session, open a new one and ask for it back. A memory layer that has not survived a restart has not been tested.

Running it yourself instead

If you want local, ignore every OpenMemory guide you find. The install steps in Mem0’s own OpenMemory announcement tell you to clone the repo and change into an openmemory directory. That directory is not in the repository any more. OpenMemory was deprecated and sunset in favor of the unified self-hosted server.

The current path lives in the server directory of the main repo. It is a FastAPI app with a Next.js dashboard, Postgres with pgvector for storage, and API key auth. Setup is a copied env file and one make target.

cd server
cp .env.example .env
# set POSTGRES_PASSWORD and OPENAI_API_KEY
make bootstrap

That brings the stack up, creates an admin account and prints your first API key. Save it, because the docs are explicit that the key cannot be recovered afterwards.

Two things people miss. You still need an OpenAI key, because the extraction step that turns a conversation into a stored fact is a model call and it does not run locally by default. And “self-hosted” here means Docker, a database and a dashboard to keep alive, which is a real amount of housekeeping for a personal memory store.

Do you actually need this?

Here is the part most setup guides skip, and it is the question worth asking first.

Since version 2.1.59 in February 2026, Claude Code ships Auto Memory turned on by default. It writes its own MEMORY.md as you work and loads it at the start of every session. It costs nothing and you have already got it.

For one person working in one repo, that is usually enough. Installing a memory service on top of a memory feature you already have is how people end up with two systems that half-remember different things.

Mem0 earns its place when you cross a boundary Auto Memory does not:

• You use more than one agent. Auto Memory does not follow you from Claude Code to Cursor or Codex. A shared memory server does.
• You work across several repos. Auto Memory is scoped per project, so context does not travel between them.
• You need semantic search over a lot of facts. The built-in file is capped and loaded whole. A vector store retrieves only what is relevant.
• You are building a product, not a workflow. If your app needs per-user memory, this is an API, and that is a different job entirely.

If none of those describe you, save yourself the afternoon. That is an odd thing to publish on a site that sells an MCP server, but recommending a tool to someone who does not need it is the fastest way to make them distrust everything else you say.

What it costs

Mem0’s published pricing splits the usage into two meters, which trips people up when they estimate.

Retrieval is the tighter meter, and retrieval is the one an agent burns through. Every time the assistant checks whether it knows something, that is a read. A thousand a month sounds generous until an agent with memory tools available starts checking on most turns.

Note also the gap between Starter and Pro. There is no middle tier, so a personal project that outgrows $19 lands on a $249 shelf. Mem0 says it will do usage-based pricing for teams that do not map to a tier, which is worth asking about before you assume the jump.

The honest limits

Memory quality depends on extraction. Something has to decide which parts of a conversation are worth keeping. That is a model call, it is imperfect, and it will sometimes store a passing remark as a durable preference. Read what it saved occasionally.

Stored facts go stale. An agent that confidently remembers a decision you reversed three months ago is worse than one that remembers nothing. The delete tools exist for a reason.

Hosted means hosted. Facts your agent stores sit on Mem0’s servers. That is fine for coding preferences and a bad idea for anything covered by a contract.

It remembers conversations, not sources. This is the limit people notice last. Mem0 stores what you told the agent. It has no idea about the article you read last week and decided was important, unless you retyped the gist of it into a chat.

Where ContextBolt fits

That last limit is the honest seam between the two things, so let me be straight about it rather than pretend at an integration that does not exist. ContextBolt does not connect to Mem0.

They hold different halves of the same problem. Mem0 remembers your conversations. ContextBolt holds the things you saved, the threads and posts and articles you kept from X, Reddit and LinkedIn because they seemed useful later. It tags and clusters them automatically, and Pro ships an MCP endpoint, so Claude can search that pile in the same conversation where it reads its Mem0 memories.

The distinction matters more than it sounds. Conversation memory is what you have said. Saved material is what you have read. An agent working from both is a genuinely different assistant to one working from either. That layering is the whole idea behind a personal context stack, and it is why AI agent memory is better understood as several types rather than one feature.

Pro is $6 a month and the free Basic tier gives you 150 bookmarks to test the idea on.

Worth doing?

If you move between agents or repos, yes, and the hosted setup is genuinely five minutes.

If you live in one repo in Claude Code, try the built-in memory for two weeks first. It is free, it is already running, and it will tell you whether the thing you actually want is better memory or just a tidier CLAUDE.md. There are nine ways to give Claude long-term memory and most people reach for the most complicated one before the simple ones have been ruled out.

The wider point is about picking any MCP server in 2026. This ecosystem is eighteen months old and already has archived repos ranking above live ones, deprecated products with better documentation than their replacements, and names recycled onto unrelated tools. Before you install anything, open the repository and look at the date of the last commit. Two seconds of checking would have saved most people who searched for mem0 MCP this month an afternoon.