Mem0 MCP alternatives
Mem0 is the best-known memory layer for AI applications. Its MCP server is a hosted endpoint at mcp.mem0.ai: the agent sends text to add_memory, an LLM extracts discrete memories, and search_memories runs semantic search with filters. Every memory belongs to a user_id, agent_id, app_id or run_id, which is the right model for giving each end user of your product their own memory.
It is a less natural fit for a team of developers. Nothing is stored until the agent calls add_memory, memory is partitioned by the IDs the agent passes, and the self-run mem0-mcp package is archived, with OpenMemory sunset in July 2026. If you are here because you want memory that a whole team's agents share, Glen is the place to start; the rest of the field follows.
The 9 best alternatives
- GlenOur pick
Memory for your team's agents, not your app's users
Mem0 is built to give each user of your app their own memory, written when the agent calls add_memory. Glen is built for a team's coding agents: it records every session and tool on its own and shares one memory across the org.
Recorded automaticallyClaude CodeCodexCursorSlackGitHubLinearNotionCall transcriptsOne memory for your orgSourced, permissioned per fact, newer decisions winEvery teammate's agentClaude CodeCodexCursorGets one cited answer, injected into the session before it goes looking.29%fewer tokens across 100 replayed PRs21%faster, measured end to endParity+quality on withheld testsMem0GlenWho writes memoryThe agent, via add_memoryRecorded from every session and toolWho can read itKeyed to a user_id or agent_idYour whole org, permissions per factWhat the agent getsRanked memories to weighOne cited answer, injected in-sessionWhat you runHosted; self-run MCP archivedNothing: hosted, OAuth 2.1 The closest to Glen in mechanism: claude-mem records sessions through hooks in Claude Code, Codex, Cursor and others, compresses tool use into observations with an observer model, and injects context when a session starts. The difference is scope. Memory lives in SQLite on one machine, grouped by project, and TeamBrain, its sharing feature, was a pilot with no public pricing when we checked. It is good memory for one developer, and your teammates' agents never see any of it.
Set up claude-mem →MemPalace keeps conversations and files verbatim, without summarizing, and files each piece into wings and rooms so a search can be scoped to one person or project; ChromaDB with local embeddings does retrieval, and a SQLite graph tracks facts with validity windows. Hooks for Claude Code, Codex and Cursor save sessions automatically. A palace lives on one machine unless you run your own HTTP hub, search returns raw drawers for the agent to read rather than an answer, and its 47 tool definitions sit in every session's context window.
Set up MemPalace →Cognee runs an LLM pipeline over what it is given, extracting entities and relationships into a knowledge graph beside vector embeddings, and recall picks among graph, RAG, temporal and Cypher strategies. It runs locally on SQLite, LanceDB and an embedded graph and needs your own LLM key. Each MCP client writes to its own dataset by default, so Claude Code and Cursor on one machine don't share memory unless you change COGNEE_MCP_AGENT_SCOPED, and nothing is stored until the agent calls remember.
Set up Cognee →Graphiti, the open-source library under Zep's commercial product, is the most careful about time of anything on this list: facts are graph edges with validity timestamps, and a newer episode that contradicts an older fact invalidates it. You run it yourself on FalkorDB or Neo4j with your own LLM and embedding keys, and the README calls the MCP server a reference implementation with no authentication, so anyone who reaches the port can read or clear the whole graph. Episodes still arrive only when the agent calls add_memory.
Set up Zep Graphiti →Supermemory's hosted server turns content the agent saves into documents, extracts memories from them asynchronously, and returns matches with a similarity score and the source document's ID. Spaces partition memory per project or user, and clients with MCP Apps support get a space picker and an interactive memory graph. Through this server, memory enters when the agent or the user calls a save tool, so what a space holds is whatever someone remembered to store.
Set up Supermemory →ByteRover keeps project knowledge as topic files in a .brv/context-tree directory inside the repository, with git-style branches and merges and optional cloud sync for a team. Its MCP server is deliberately small: brv-query runs BM25 over the tree and brv-curate saves a topic the agent wrote. Knowledge enters only when an agent or a person curates it, so the tree holds what someone chose to document, which is the AGENTS.md problem with better tooling.
Set up ByteRover →LongMemory, the CaviraOSS project published until recently as OpenMemory and unrelated to Mem0's product of that name, sorts memories into five sectors that decay at different rates and links them through a waypoint graph. It is six tools over a local SQLite file, with a user_id on each call to keep users apart. It records only what the agent chooses to store, and the team-aware rewrite on its main branch was not on npm when we checked.
Set up LongMemory (formerly OpenMemory) →Basic Memory writes memory as plain Markdown in a folder you choose, parses observations and wiki-link relations into a graph, and indexes it in SQLite for hybrid search. The files open in Obsidian and diff cleanly in git, and Basic Memory Cloud serves the same 17 tools over OAuth with shared workspaces. A note exists only when the agent calls bm_write or bm_edit, so the memory is exactly as complete as the agent's judgment about what was worth writing down.
Set up Basic Memory →
How to choose
Keep Mem0 if you are building an application and need per-user memory behind an API; that is what it is designed for. If your goal is for a team's coding agents to share what they learn, Glen fits the job directly: memory recorded from every session and tool, one store for the organization with per-observation permissions, cited answers, and contradiction handling. Among the others, Supermemory is the closest hosted memory API to Mem0, claude-mem and MemPalace record sessions automatically on one machine, and Graphiti and Cognee are graph engines to self-host.
FAQ
- What is the best Mem0 alternative for coding agents?
- Glen, if more than one person's agents need the memory: it records Claude Code, Codex, Cursor and Pi sessions automatically and shares one memory across the organization. For a single developer on one machine, claude-mem records sessions locally.
- Is there still a self-hosted Mem0 MCP server?
- The mem0-mcp package is archived and OpenMemory was removed from the Mem0 repository in July 2026, with a read-only copy left in mem0ai/openmemory. The Mem0 library itself can still be self-hosted, but the maintained MCP route is the hosted endpoint.
- Can Mem0 share memory across a team?
- Memories are scoped to the user_id, agent_id, app_id or run_id the agent passes. Sharing across a team means choosing shared IDs and enforcing who reads what in your own code. Glen shares memory across the organization by default and checks permissions per observation.
- Does Glen use the same extraction approach as Mem0?
- Both turn raw text into smaller units of memory with an LLM. The differences are upstream and downstream: Glen records the text automatically from sessions and integrations instead of waiting for an add call, and returns a synthesized, cited answer instead of a list of matches.