Guide · Mem0 MCP

Mem0 MCP: Which One to Install (2026)

Install the hosted Mem0 server at https://mcp.mem0.ai/mcp/. It needs a Mem0 API key, and it’s the one Mem0 itself points people to now.

Search for mem0 MCP and you’ll find four different things, and three have changed name, changed shape or stopped being maintained. The most-starred repository on GitHub is archived, and the official blog post for the local version still tells you to clone a folder that is no longer in the repo. Mem0 consolidated three products into one, and the rest of the internet kept publishing the old instructions.

Quick answer
  • Install the hosted server. The endpoint is https://mcp.mem0.ai/mcp/ and it needs a Mem0 API key.
  • The mem0ai/mem0-mcp repo is archived. 659 stars, last push March 2026, and its README says so at the top.
  • OpenMemory MCP is deprecated, folded into the Mem0 self-hosted server that runs on Docker and Postgres.
  • The free Hobby tier covers 10,000 add requests and 1,000 retrievals a month.
  • Claude Code already has free memory built in. Check that before you install anything. Mem0 keeps what you told the agent. What you read and saved, on the web and on X, Reddit and LinkedIn, needs its own server, and that is ContextBolt, free up to 150 bookmarks.

Which mem0 MCP is which

What you will findWhat it isStatusUse it?
Hosted Platform MCPmcp.mem0.ai endpoint, OAuth or API keyCurrentYes
mem0ai/mem0-mcpStandalone Python server, 659 starsArchived March 2026No
OpenMemory MCPLocal Docker memory server, 4 toolsDeprecated, folded inNo
Mem0 self-hosted serverFastAPI, Postgres, pgvector, dashboardCurrentIf you want local

The archived repo: mem0ai/mem0-mcp opens with a caution block saying it’s no longer actively maintained and is a public archive. The matching npm package last shipped version 0.2.0 in April 2026. It’s still the first GitHub result many people hit, and plenty of MCP directories still list its install command.

The recycled name: the repository at mem0ai/openmemory is no longer a memory server. It’s now a CLI and terminal UI for porting coding sessions between Claude Code, Codex and OpenCode. If a 2025 tutorial sent you there and left you baffled, that’s why.

For almost everyone the hosted server is the right pick. It’s what the Claude Code integration docs describe, and somebody else runs the database. Self-host only if the facts your agent stores can’t leave your machine.

How to install the hosted Mem0 MCP server

  1. Get an API key. Sign up at mem0.ai and copy the key from your dashboard. It starts with m0-. The hosted server signs you in through the browser by default, so the key matters mainly for headless setups and the Claude Code plugin.
  2. Add the server. Mem0 publishes a one-liner that works across most clients:
npx mcp-add \
  --name mem0-mcp \
  --type http \
  --url "https://mcp.mem0.ai/mcp/" \
  --clients "claude code"
  1. Swap the client if you need to. Use cursor, windsurf, vscode or opencode in place of claude code. Claude Desktop rejects mcp-add, so add the URL there under Customize, then Connectors, then the + button, then Add custom connector.
  2. Sign in. Most clients open a browser window the first time your agent uses a Mem0 tool, and you approve access once. For headless setups like CI, send your API key as a bearer token instead. Where the key goes depends on the client, so follow Mem0’s client-specific setup.
  3. Restart the client and check the tools. You should see add_memory, search_memories, get_memories, update_memory and delete_memory. If the list is empty, the sign-in didn’t finish or the bearer key is wrong. Most clients report an auth failure as a generic connection problem, which sends people debugging the wrong thing.
  4. Test it. Tell the agent something real, like which database this project uses, then open a fresh session and ask it back. If it answers correctly, memory works. If it guesses, nothing was stored.

Claude Code also has a plugin marketplace route, claude plugin marketplace add mem0ai/mem0, followed by claude plugin install mem0@mem0-plugins --scope user with your API key passed as --config api_key=.... It installs lifecycle hooks and a skill alongside the server, so memory capture happens automatically instead of only when you ask.

Running it yourself

If you want local, ignore every OpenMemory guide. Mem0’s own OpenMemory announcement tells you to clone the repo and change into an openmemory directory, and that directory is gone. OpenMemory was deprecated and sunset in favor of the unified self-hosted server.

The current path is the server directory of the main repo: a FastAPI app with a Next.js dashboard, Postgres with pgvector for storage, and API key auth.

  1. Run cd server.
  2. Copy .env.example to .env and set POSTGRES_PASSWORD and OPENAI_API_KEY.
  3. Run 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 it can’t be recovered afterwards.

You still need an OpenAI key, because the extraction step that turns a conversation into a stored fact is a model call and doesn’t run locally by default. And self-hosted here means Docker, a database and a dashboard to keep alive, which is a lot of housekeeping for a personal memory store.

What does Mem0 cost?

Yes, it has a free tier. Mem0’s published pricing splits usage into two meters.

PlanPrice /moAdd requestsRetrieval requests
HobbyFree10,0001,000
Starter$1950,0005,000
Pro$249500,00050,000

Retrieval is the tighter meter. Every time the assistant checks whether it knows something, that’s a read, and an agent with memory tools available starts checking on most turns. There’s also 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 don’t map to a tier, which is worth asking about before you assume the jump.

Do you need Mem0 if you use Claude Code?

Probably not, if you work in one repo. 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, at no cost. Installing a memory service on top of it is how people end up with two systems that half-remember different things.

Mem0 earns its place when you cross a boundary Auto Memory doesn’t:

  • You use more than one agent. Auto Memory doesn’t 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.
  • You need semantic search over a lot of facts. The built-in file is capped and loaded whole. A vector store retrieves only what’s relevant.
  • You’re building a product. If your app needs per-user memory, this is an API, and that’s a different job.

If none of those describe you, try the built-in memory for two weeks first. There are nine ways to give Claude long-term memory, and the complicated ones tempt before the simple ones are ruled out.

Limits to know before you rely on it

Memory quality depends on extraction. A model decides which parts of a conversation are worth keeping, 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’s fine for coding preferences and a bad idea for anything covered by a contract.

It has no sources. Mem0 stores what you told the agent. It doesn’t know about the article you read last week unless you retyped the gist into a chat.

Before you install any MCP server, open the repository and look at the date of the last commit. Two seconds of checking saves an afternoon.

Where ContextBolt fits

Once Mem0 holds what you told the agent, the other half is what you read and kept. ContextBolt is a Chrome extension. Two clicks save any web page with its article text, and your X, Reddit and LinkedIn saves are captured as you make them, into one library that tags and clusters itself on arrival. It runs next to Mem0 in the same client, and the two don’t need wiring together.

Pro adds a personal MCP endpoint, so the same Claude Code session that reads its Mem0 memories can search your saves by meaning too. That layering is the idea behind a personal context stack, and it’s why AI agent memory is better understood as several types than one feature.

Basic is free, with no account and no card, and is capped at 150 bookmarks. Pro is $6 a month, removes the cap, and adds cloud sync and the MCP endpoint.

Where next

Frequently asked questions

Something else on your mind? Get in touch.

What is Mem0 MCP?

It is a server that gives an AI agent long-term memory through the Model Context Protocol. The agent can store facts, search them by meaning, and pull them back in later sessions. The maintained version is hosted by Mem0 at mcp.mem0.ai and needs an API key.

Is the mem0-mcp GitHub repo still maintained?

No. The mem0ai/mem0-mcp repository was archived, with its last push in March 2026. Its README now carries a caution banner pointing people to the hosted server instead. Plenty of directory sites and tutorials still link to it, so check the archive notice before following any guide.

What happened to OpenMemory MCP?

It was deprecated and folded into the unified Mem0 self-hosted server. The original install steps told you to clone the mem0 repo and enter an openmemory folder, but that folder no longer exists. Use the server directory in the same repo instead, which runs on Postgres with pgvector.

Is Mem0 free?

There is a free Hobby tier with 10,000 add requests and 1,000 retrieval requests per month, one project, and unlimited end users. Paid plans start at $19 a month for Starter. Self-hosting is free of Mem0 charges but you still pay for an OpenAI key to do the extraction.

Do I need Mem0 if I already use Claude Code?

Probably not, if you work in one repo. Claude Code ships Auto Memory turned on by default and it costs nothing. Mem0 earns its place when you cross a boundary, like sharing memory between Claude, Cursor and Codex, or across several repos.