Blog

The best MCP memory servers for Claude Code and teams (2026)

Published: November 4, 2026

We make Harbor, and it is first on this list. Every other entry was checked against its own docs, README or pricing page on 6 October 2026, and each one says what it does better than we do.

The short answer: if your team's decisions should reach every agent only through a gate you set, with a count per rule of how often it was served and how often an answer cited it, that is Harbor. For memory nobody has to write, captured from Claude Code, Codex and Cursor into one pool per repo, look at Supermemory or Mem0. For a knowledge base that people and agents both write as Markdown, Basic Memory, which you can host yourself, or Hjarni, which is hosted. For facts that change over time, Zep or its open-source core, Graphiti. For open-source memory you run on your own machine, Cognee.

What is an MCP memory server?

The Model Context Protocol lets an agent call tools on an external server. A memory server exposes tools like “add”, “search” and “delete”, and the agent decides when to call them. Because MCP is a shared protocol, the same server can sit behind Claude Code, Cursor, Codex and the Claude or ChatGPT apps.

That last point is why people reach for one. Built-in memory is tied to one tool: Claude Code auto memory is machine local, Codex memories live in ~/.codex, Copilot Memory stays inside Copilot. Our comparison of built-in agent memory has the details. An MCP server is the obvious way to get one memory across all of them.

What a team needs from one

Most memory servers began as one person's recall. Once a team shares one, these questions matter more than how well it searches:

Question	Why it matters for a team	What a good answer looks like
Who can write?	Every agent with the endpoint can teach every other agent.	Writes are attributed to a person, and you can limit who or what may write.
Is a write reviewed before it is served?	An inferred fact becomes team policy the moment another agent reads it.	You choose the gate: routine facts can go live on trial, and anything risky waits for a person.
What happens on a contradiction?	Two sessions will disagree. Silently keeping the latest is a coin toss.	A conflict it cannot settle is held next to the fact it contradicts; a clear reversal replaces the old fact, which can be restored.
When does a fact expire?	Code changes. A fact about a deleted handler keeps getting served.	Facts retire when the thing they describe is gone, and retired facts are archived, not lost.
Does it work across tools?	Your team runs Claude Code, Cursor and Codex, not one of them.	One store, reachable from every agent the team uses, with the same answer in each.
Can you see what gets used?	Without a count, dead facts pile up and nobody knows which to cut.	Per fact: how often it was served, and how often an answer cited it.
Where does knowledge come from?	Most decisions were made in Slack or a PR review, not in an agent chat.	It reads the places the team already decides, not only what agents write.

1. Harbor

Harbor's MCP server has four tools: harbor_get_knowledge, harbor_record_learning, harbor_revoke_learning and harbor_save_how_to. Behind them is what your team decided, learned from Slack, pull request reviews and docs, plus what agent sessions record. You set the gate: Manual holds everything for a person, Hybrid (the default) puts routine rules live on trial and holds the rest, and in every mode a secret, an install step or a clash Harbor cannot settle waits for a person.

Best for: engineering teams whose decisions live in threads and reviews, and who want every agent to start with them.
Team: one graph for the team. Hooks give Claude Code, Cursor, Codex and Copilot the rules that apply at the start of each session, and any MCP client can ask.
Where it is ahead: every rule shows how often it was served and how often an answer cited it, so you can delete the ones nobody uses (served vs cited). When a push deletes the file a rule is about, the rule is retired.
Watch out for: It is new: public sign-up opened on 31 October 2026, self-serve, with no card and no call. It wires four agents. The service is hosted only, and there is no SSO yet.
Price: Free costs nothing for up to 2 people, on one source. Pro is $24 per person a month billed yearly.

2. Supermemory

A hosted memory engine with an MCP server and plugins for Claude Code, Codex and Cursor. Its docs say the coding plugins share one tag per repository, so agents working on the same repo read and write the same memory.

Best for: memory nobody has to write. The plugins capture conversations and tool use on their own and recall before each turn.
Team: team spaces on the MCP server. Pro includes three seats; access per tag is on Scale.
What gets in: captured automatically. Facts the engine inferred are marked and count for less in search until someone approves or declines them.
When a fact changes: the newer fact replaces the old one in search, the history is kept, and memories can be forgotten on a schedule.
Licence and price: the main repo is MIT, but self-hosting is on Scale and Enterprise, and the self-hosted build has no MCP server. Free includes $5 of credits a month; Pro is $19 a month.

Its hosted Slack product, Company Brain, stopped in September 2026. See Supermemory Company Brain alternatives.

3. Basic Memory

Markdown files that people and agents both read and write, over a local MCP server or a hosted one, with a plugin for Claude Code. Basic Memory Teams adds shared projects, where, in its docs, “anything a teammate writes is immediately available to everyone else and to their agents.”

Best for: long-form team knowledge that people read and edit by hand, in plain files you own and can open in Obsidian or VS Code.
Team: shared projects with five roles, from Viewer to Owner.
What gets in: whatever a person or an agent writes. Cloud has optional suggested edits someone can accept or reject, but no approval step on writes.
When a fact changes: every save in Cloud is a new version, and local notes are plain files you can keep in git.
Licence and price: AGPL-3.0, free to run locally or host yourself. Cloud has a 7-day trial and no free tier; Team is $15 per seat a month.

4. Zep and Graphiti

Graphiti is an open-source temporal knowledge graph with an MCP server you host. Each fact has a validity window, and when information changes the old fact is invalidated rather than deleted, so you can ask what is true now or what was true then. Zep is the managed platform built on it, and its Context plugin installs in Claude Code, Codex CLI and Cursor.

Best for: facts that know when they stopped being true, and memory governed by your identity provider.
Team: Zep keeps one graph per person, plus shared graphs for a project, a team or the company.
What gets in: the assistant saves without waiting to be asked, and content policies drop anything that matches a rule you set. No review by a person is documented.
When a fact changes: the validity windows above, the strongest model of time on this list.
Licence and price: Graphiti is Apache-2.0 and self-hosted only. Zep is hosted, with your own cloud on Enterprise: free for 10,000 credits a month, then $125 a month.
Watch out for: the Zep plugin has no hooks, so nothing reaches the agent until it calls a tool.
Side by side: Harbor vs Zep.

5. Mem0

A hosted MCP server with eleven tools, and plugins for Claude Code, Codex and Cursor. The plugin captures messages, answers, changed files and test results, and Mem0 sorts each memory into shared project knowledge or a personal preference.

Best for: the quickest automatic memory in Claude Code or Codex. One install, and nobody writes anything down.
Team: one shared pool per repository. In Mem0's words, “Everyone on the repo reads and writes the same pool.”
What gets in: extracted automatically. No review step for memories is documented.
When a fact changes: on the hosted platform, a newer fact marks the older one as outdated, on every plan. The open-source version does not do this.
Licence and price: the library is Apache-2.0, but the coding plugin needs a Mem0 Platform key. Free covers 1,000 retrievals a month, with usage past that billed; Custom is priced to your volume.
Watch out for: the plugin adds up to five memories on the first prompt, then only when the agent searches, and in Cursor it adds nothing on its own. More in Mem0 alternatives for coding agents.
Side by side: Harbor vs Mem0.

6. Cognee

Open-source graph memory, with a Claude Code and Codex plugin that recalls on every prompt, an MCP server for Cursor, and a hosted MCP server for Cognee Cloud.

Best for: memory you run on your own machine. The Claude Code plugin starts a local Cognee by default.
Team: Cloud workspaces with access set per dataset, and unlimited users on the free plan.
What gets in: prompts, tool traces and answers, captured automatically. No review step is documented.
When a fact changes: an opt-in detector in the open-source version marks a contradiction without overwriting either fact.
Licence and price: Apache-2.0. Cloud is free up to 1M tokens, then $1 per million tokens plus $5 a workspace.
Side by side: Harbor vs Cognee.

7. Hjarni

A hosted Markdown notes app that ChatGPT, Claude and coding agents all reach over one remote MCP server. Hjarni Teams adds roles per folder.

Best for: runbooks and decision logs that people, engineers or not, edit by hand and every assistant can read.
Team: viewer, editor and admin roles per folder. An Enterprise tier adds SSO, SCIM and an audit log.
What gets in: whatever a person or an assistant saves. No approval step is documented; every edit is versioned and credited to whoever made it, and an assistant's edits are badged.
Licence and price: hosted only. Free up to 25 notes, Pro $12 a month, Teams $20 per seat a month.

Also asked about

claude-mem is automatic memory for one developer in Claude Code, kept locally, free and Apache-2.0. Its team version is “in development” as a pilot. See our claude-mem note.
Letta builds one long-lived agent that owns and versions its own memory. Its hosted MCP server lets another agent message Letta agents rather than store memory, and its Claude Code plugin is a demo “not intended to be used in production.”
ByteRover's main product is a skill, not an MCP server. Its company-brain plugin has an MCP tool whose saves stay “pending until someone reviews it”, but that brain is a pilot.
The reference Memory server keeps a local knowledge graph in one JSONL file, for one user. Its repo calls these servers “educational examples”, not production-ready.
Hindsight is open-source agent memory filled from sessions and git history. See Harbor vs Hindsight.
OpenViking is an open-source context database your agents fill from sessions. See Harbor vs OpenViking.
LangMem is a Python library for agents you build on LangGraph. It has no MCP server.

Side by side

	Team space	What gets in	When a fact changes	Host it yourself	Free, then
Harbor	One graph for the team	Learned from Slack, PRs and docs, plus sessions; a gate you set	A clash it cannot settle waits for a person; a rule is retired when its file is deleted	No	Free on one source; Pro $24 a person, yearly
Supermemory	Team spaces, 3 seats on Pro	Captured automatically; inferred facts approved or declined	Newer fact replaces the old in search; history kept	Scale and Enterprise, without MCP	$5 of credits a month; $19 a month
Basic Memory	Shared projects, 5 roles	Written by people and agents	Every save is a version	Yes, AGPL-3.0	Local is free; $15 a seat a month
Zep and Graphiti	Per person, plus shared graphs	Saved by the assistant; policies drop matches	Validity windows; old facts invalidated, not deleted	Graphiti only	10,000 credits a month; $125 a month
Mem0	One pool per repo	Extracted automatically	Newer fact supersedes the old, on the hosted platform	Library yes; the coding plugin needs the platform	1,000 retrievals a month; then usage or Custom
Cognee	Workspaces, access per dataset	Captured automatically	Opt-in contradiction marking	Yes, Apache-2.0	1M tokens; $1 per million
Hjarni	Roles per folder	Written by people or assistants	Every edit versioned and credited	No	25 notes; $20 a seat a month

Read the “What gets in” column. Most of these write automatically, and a few now review some writes: Supermemory for inferred facts, ByteRover in its pilot. What none of the others documents is a count, per fact, of how often it was served and how often an answer cited it. A cite is evidence a rule was used, not proof it was obeyed.

Can a team share one memory server?

Technically, yes. Point every engineer's agent at the same endpoint and they read and write one store. The question is what that store becomes after a month.

A personal memory is written by an agent on behalf of one person. If it records a wrong fact, one person sees one wrong answer and corrects it. A shared memory is written by every agent on behalf of everyone. If one session records that payment webhooks retry without dedupe, and nothing sits between the write and the read, every agent on the team is served it next. Nobody on the team decided it. An agent inferred it.

That is not a flaw in any one product. It is the difference between memory (what an agent noticed) and team knowledge (what people decided). The second needs a gate. The security version of the same problem has a name: see agent memory poisoning.

Do validity windows solve contradictions?

They solve half of it. Graphiti invalidates the old fact when information changes and keeps its history, so you can ask what is true now or what was true at any point. That is the right model for facts that change over time: a service moved, an owner changed.

The other half is deciding which statement is true when two arrive. If one session says the webhook handler dedupes and another says the queue consumer does, a timestamp tells you which was written last, not which is right. On a team, that call belongs to whoever owns the payments service.

How to choose

Your own recall across tools: claude-mem in Claude Code, or Basic Memory or Graphiti on your machine.
Memory captured for the whole repo, with nobody writing anything: Supermemory or Mem0.
A knowledge base that people write and agents read: Basic Memory to host it yourself, Hjarni hosted.
Facts that change over time, behind your identity provider: Zep. Self-hosted: Graphiti.
Open source on your own machine: Cognee.
Your team's decisions from Slack and reviews in every session, through a gate you set, with served and cited per rule: Harbor. Sign up, name your workspace, then run npx harborloop init.

For Harbor beside Mem0, Zep and others one at a time, read the comparisons. For tools that learn from where a team decides, not only from sessions, see the best company brain tools for coding agents. If a line here is out of date, tell us and we will fix it.

Questions

What is the best MCP memory server for Claude Code?

It depends on the job. For your own recall, claude-mem, Basic Memory or Graphiti on your machine. For memory captured automatically for a whole repo, Supermemory or Mem0. For facts that change over time, Zep or Graphiti. For open source you run yourself, Cognee. For a team's decisions served to every agent through a gate you set, with a count per rule of how often it was served and cited, Harbor.

Can a team share one MCP memory server?

Yes, by pointing every agent at the same endpoint. The risk is that any agent's write is served to every other agent. Without a review step, one wrong inference from one session becomes what the whole team's agents are told.

How is team knowledge different from agent memory?

Agent memory is what an agent noticed while working with one person. Team knowledge is what people decided, usually in Slack threads, PR reviews and design docs. It needs an approver, an owner and a way to retire facts when the code changes.

How do memory servers handle contradictions?

It varies. Graphiti gives each fact a validity window and invalidates the old fact when information changes, keeping its history. Supermemory replaces the old fact in search and keeps it for audit. Cognee can mark a contradiction without overwriting either fact. Deciding which of two conflicting statements is correct is still a judgment a team usually wants a person to make.

Which memory servers can I host myself?

Graphiti and Cognee (both Apache-2.0), Basic Memory (AGPL-3.0) and the reference Memory server. Mem0's library is open source, but its MCP server and coding plugin need its hosted platform. Supermemory self-hosts on its Scale and Enterprise plans, without its MCP server. Zep, Hjarni and Harbor are hosted.