Memory and context

Best MCP memory server for a team: what to compare and which options exist

MCP memory servers compared for teams: the reference server, Mem0, Zep, Graphiti, Supermemory, Basic Memory and Glean, on sharing, permissions and hosting.

An MCP memory server gives any MCP client, such as Claude Code, Cursor, Codex or ChatGPT, tools to save and search memories in one shared store. For one developer, almost any option works. For a team, four things decide: whether several people can share one store, who may read and write what, whether you can see where a memory came from, and whether you can host it yourself. Of the options we checked, Zep’s Context MCP Server and Supermemory describe shared team spaces with sign-in; Mem0 offers a hosted server with eleven memory tools; Basic Memory has a Teams workspace and an open-source local version; Graphiti and the official reference server are useful to learn from but are not meant for production.

By Bombos. Published November 17, 2026. Sources checked November 17, 2026.

The short answer

  • MCP is “an open-source standard for connecting AI applications to external systems” (modelcontextprotocol.io). A memory server is one such system.
  • Reference Memory server: a local knowledge graph in a JSONL file. The repo says its servers are “not as production-ready solutions” (GitHub).
  • Mem0 MCP: hosted at https://mcp.mem0.ai/mcp, eleven tools, browser sign-in or API key (Mem0 docs).
  • Zep Context MCP Server: a personal graph per user plus shared Context Graphs that admins open per project or user group (Zep docs).
  • Graphiti MCP: open source, “experimental”; authentication is not documented (GitHub).
  • Supermemory MCP: OAuth sign-in and shared “spaces” for teams (Supermemory docs).
  • Basic Memory: Markdown files, AGPL-3.0, with a cloud version and a Teams workspace (GitHub).
  • Glean MCP: enterprise search over company apps, with user permissions enforced (Glean docs).

What is an MCP memory server?

The Model Context Protocol lets AI applications like Claude or ChatGPT connect to “data sources”, “tools” and “workflows”. The project compares it to “a USB-C port for AI applications” (modelcontextprotocol.io). Claude, ChatGPT, VS Code and Cursor are among the clients that support it.

A memory server is an MCP server whose tools are about remembering: add a memory, search memories, update or delete one. Because the client only sees the tools, the same server can sit behind Claude Code on one laptop, Cursor on another and ChatGPT in the browser. That makes MCP the most practical way today to give different AI tools one memory. For how agent memory works in general, see What is AI agent memory?.

Which MCP memory servers exist?

Aspect What it stores Hosting Sharing in a team Sign-in Status
Reference Memory server Entities, relations, observations in JSONL Local Local JSONL storage; concurrent team access is not documented here None described Reference implementation
Mem0 MCP Memories in your Mem0 account Hosted by Mem0 Not covered on the page we read Browser sign-in or API key Production service
Zep Context MCP Temporal context graphs Hosted by Zep Personal graph plus shared graphs, granted by admins Google Workspace; enterprise IdP on Enterprise Production service
Graphiti MCP Temporal knowledge graph Self-hosted, FalkorDB or Neo4j Namespaces via group_id Not documented in the README Experimental
Supermemory MCP Documents, memories, profile context Hosted Spaces with read or write access OAuth Production service
Basic Memory Markdown files plus SQLite index Local, or cloud Teams: one shared cloud workspace Cloud account Open source (AGPL-3.0) plus cloud
Glean MCP Search over company apps Glean Org-wide, per-user permissions Glean account Enterprise product

Sources: the pages linked below, read November 17, 2026.

The reference Memory server stores a knowledge graph of entities, relations and atomic observations in a JSONL file set by MEMORY_FILE_PATH, with tools such as create_entities, add_observations and search_nodes. It calls itself “A basic implementation of persistent memory using a local knowledge graph” (GitHub). The repository says its servers are “meant to serve as educational examples”. Good for learning the shape of the problem.

Mem0 MCP is hosted: “The server is hosted by Mem0, and your client connects to it over HTTPS.” It offers eleven tools, including add_memory, search_memories, update_memory and delete_all_memories, and lists Claude Desktop, Claude Code, Codex, Cursor, Windsurf, VS Code and OpenCode as clients (Mem0 docs). The page does not describe team or project features. Mem0’s earlier local server, OpenMemory, is not in its current documentation index, so check its status before you plan on it.

Zep Context MCP Server is the most explicit about teams. Each user reads their own graph, fixed by their sign-in, “so they cannot reach another user’s memory”. If the project allows it, users can list and search shared Context Graphs, and “Administrators can grant access project-wide or per user group”. Sign-in runs through Google Workspace, or an enterprise identity provider on the Enterprise plan, with OAuth 2.1 and short-lived tokens. The plugin installs in Claude, ChatGPT, Cursor, Claude Code and Codex CLI (Zep docs).

Graphiti MCP is the open-source route to a temporal graph you host yourself. The README calls it “an experimental Model Context Protocol (MCP) server implementation”, supports FalkorDB (default) and Neo4j, namespaces data with group_id,; the README does not document authentication, so keep it off untrusted networks (GitHub).

Supermemory MCP says it “gives every MCP-compatible assistant a shared memory layer”. You sign in with OAuth and choose which spaces the client can reach; teammates work “within the spaces they can read or write” (Supermemory docs). Its memory engine is not open source, as we noted in Mem0 alternatives for team memory.

Basic Memory keeps knowledge as “Markdown files that both you and your AI can read, write, and search”, locally with a SQLite index. It is AGPL-3.0. The cloud version is listed at $15 a month, and Teams offers “a single, shared cloud workspace” (GitHub). Readable files are a real advantage: you can review memory in a pull request or an editor.

Glean is not a memory server in the narrow sense. It is enterprise search with an MCP server, and “All queries enforce user permissions through the Knowledge Graph of Glean” (Glean docs). Its documented capabilities include search, agents and governed read/write tools. See Glean alternative for startups and small teams.

What should a team look for in an MCP memory server?

Most comparisons rank on benchmarks for one user. For a team, these six questions matter more:

  1. One shared store. Can ten people and their tools read the same memory, or does each person get their own? Check whether sharing is designed in or something you script around.
  2. Permissions. Who may read which memories, and who may write? A shared memory that anyone’s agent can overwrite will drift. Look for sign-in per person, scopes or spaces, and admin control.
  3. Provenance. When an agent acts on a memory, can you see where it came from: which person, which conversation, which document, when? Without this, nobody dares to delete anything and nobody trusts what stays.
  4. Changing facts. Prices, owners and deadlines change. Does the server keep history and mark what is current, or does the newest write simply win?
  5. Self-hosting and data location. Can it run on your own server, or at least in a region you accept? Hosted services are faster to start; self-hosted gives control but makes security your job.
  6. Clients and review. Does it work in every tool the team uses, coding and non-coding? Can a person read and correct memory without writing code?

A practical test: connect two people with two different tools to one server for a week. Let one correct the AI. Check whether the other’s AI applies it, and who taught it.

Which one fits which team?

  • Learning or prototyping: the reference Memory server or Graphiti on your own machine.
  • A small developer team that wants readable memory: Basic Memory, local or on Teams.
  • A team building on agents that needs changing facts and admin-granted sharing: Zep’s Context MCP Server.
  • A team that wants hosted memory with plugins for coding agents: Mem0 or Supermemory.
  • An enterprise that mainly needs search over company apps: Glean.

If your team mostly needs the same rules in Claude Code, Codex and Cursor, start with a shared AGENTS.md and a committed MCP config, as described in shared memory across coding agents.

Read also: serving one company context to ChatGPT, Claude and Copilot over MCP.

How does Bombos do this?

Bombos is the memory layer under the AI a team already uses: Claude, Claude Code, ChatGPT, Copilot, Codex, Cursor or your own agents. It is a plugin, not a new chat or model.

  • One shared memory that learns how the team works.
  • The source behind every answer. Every memory shows where it came from.
  • Your AI acts, Bombos remembers. Bombos does not take actions itself.
  • Cloud on servers in Europe, or standalone on your own server.

Where Bombos is not the answer: if you want an open-source server you run and change line by line, Graphiti or Basic Memory fit better.

Frequently asked questions

What is the official MCP memory server? The Model Context Protocol project publishes a Memory server as one of its reference servers. It stores a local knowledge graph and is meant as an educational example, not a production service.

Can several people share one MCP memory server? Yes, if the server supports it. Zep, Supermemory and Basic Memory Teams describe shared spaces or workspaces. The reference server stores memory in a local JSONL file; concurrent team access is not documented there.

Is there a self-hosted MCP memory server for a team? Graphiti and Basic Memory are open source and run on your own machine. Graphiti’s MCP server is experimental and its README does not document authentication, so put your own access control in front of it.

Book your half hour: together we map what your AI forgets. Free, and the plan is yours, with or without Bombos.

Which sources did we use?

All sources opened and read on November 17, 2026.

  1. Model Context Protocol, introduction: https://modelcontextprotocol.io/docs/getting-started/intro
  2. MCP reference servers on GitHub: https://github.com/modelcontextprotocol/servers
  3. MCP reference Memory server: https://github.com/modelcontextprotocol/servers/tree/main/src/memory
  4. Mem0 docs, Mem0 MCP server: https://docs.mem0.ai/platform/mem0-mcp
  5. Mem0 docs index: https://docs.mem0.ai/llms.txt
  6. Zep docs, Context MCP Server: https://help.getzep.com/context-mcp-server
  7. Graphiti MCP server on GitHub: https://github.com/getzep/graphiti/tree/main/mcp_server
  8. Supermemory docs, MCP: https://supermemory.ai/docs/supermemory-mcp/introduction
  9. Basic Memory on GitHub: https://github.com/basicmachines-co/basic-memory
  10. Glean docs, About the Glean MCP server: https://docs.glean.com/administration/platform/mcp/about
The first half hour · free

What does your AI forget?

  1. 01You tell us which AI you use and where it keeps starting over.
  2. 02We show what a shared memory changes there, on your own examples.
  3. 03You keep the plan, with or without Bombos.
Piet Baudoin
Piet BaudoinYou talk to Piet, from the Bombos teamDutch team from Utrecht and Nijmegen · data in Europe
We reply the same working day.