MnemoverseDocs

Appearance

Edward Izgorodin·Published Jul 21, 2026

Memory MCP servers compared: eight real options — one of them ours ​

A memory MCP server is an MCP-compatible service that gives an AI agent persistent storage for facts, entities, decisions, and relationships across sessions, so the agent does not start cold on every invocation. The category is real and growing, but search results conflate monorepo star counts, stale releases, and research frameworks with shipped products. Eight named, operational servers exist today — one of them, flagged inline as a vendor entry, is built by the publisher of this site.

TL;DR

  • Eight named memory MCP servers ship today, across four storage models: knowledge graph, vector, Markdown, and SQL. One of the eight is built by this site's publisher and is flagged as a vendor entry.
  • The first filter is deployment, not features: local-first single-user versus hosted or shared multi-client. Only Supermemory MCP is hosted-first.
  • The official reference server-memory is a deliberately basic implementation — actively maintained, substring-search only, and a starting point rather than the production answer.
  • "gmemory" is a research paper (G-Memory), not a shipped server. The nearest SQL-native product is GibsonAI Memori, whose popular engine and 2-star MCP wrapper have to be judged separately.

The first useful split is not a feature list. It is operational: local-first memory keeps its primary store on a machine you control, while hosted or shared memory puts one remote store in front of several clients, users, or agent processes. Storage type still matters — knowledge graphs hold explicit relationships, vectors support semantic recall, Markdown favors inspection, and SQL favors structured queries — but deployment sets the trust boundary and operating burden before those differences apply. This article applies the five-question rubric from the memory MCP category guide to eight named products; it does not re-run the graph-traversal comparison in graph memory MCP tools.

Named memory MCP servers and what they store ​

Eight memory MCP servers ship functionality today. Each sits at a distinct point on the local-to-hosted spectrum and picks a distinct storage substrate.

Local-first, single-user ​

Official server-memory (@modelcontextprotocol/server-memory) stores a knowledge graph — typed entity nodes, directed relations with active-voice labels, and observations as atomic string facts — in a single local JSONL file. Search is substring and keyword matching; there are no embeddings. Its README calls it, plainly, "a basic implementation." It stayed in the active curated set through the 2025 archiving that moved most first-party servers to servers-archived. The license is MIT today, with the monorepo openly mid-transition to Apache-2.0 for new contributions; install with npx -y @modelcontextprotocol/server-memory or the mcp/memory Docker image. A sound starting point, not a production-hardened store.

memento-mcp (gannonh) layers vector embeddings and temporal metadata onto a knowledge graph. Relations carry strength, confidence, and decay; the system versions facts over time. Persistence needs an external Neo4j 5.13+ database, and search runs OpenAI embeddings (text-embedding-3-small or -large) in a hybrid semantic-plus-keyword mode, so it also needs an OpenAI API key. As of the July 21, 2026 scout date, the last tagged release was v0.3.9 on May 12, 2025 — roughly 14 months earlier. That date is a maintenance signal, not proof that the software is unusable; check commits and open issues before adopting it. MIT-licensed, 425 stars on that date.

basic-memory (basicmachines-co) treats plain Markdown files on disk as the source of truth and extracts a semantic graph — entities, observations, relations — into a local SQLite index (Postgres optional). The result is user-owned, Obsidian-compatible memory that an agent reads as both text and graph. It connects to many client apps: Claude Desktop, Claude Code, Codex CLI, Cursor, VS Code, ChatGPT custom GPTs, and Obsidian. A paid cloud tier (listed at $15/month) adds sync and mobile access. The AGPL-3.0 license carries strong copyleft obligations — a flag for commercial or hosted adopters. About 3,500 stars on the scout date; installed with uv tool install basic-memory.

OpenMemory MCP (Mem0) is the local, self-hosted Docker path for the Mem0 memory engine. It exposes four operations — add, search, list, and delete memories — over a vector database running entirely on the developer's machine. Mem0 launched it on May 13, 2025 as a companion to the managed Mem0 Platform (app.mem0.ai); the two are distinct. The standalone mem0-mcp repository was archived on March 24, 2026, which leaves OpenMemory as the current local MCP entry point. It needs Docker and an OpenAI API key. Mem0's umbrella repository carries roughly 61,000 stars — a whole-project figure that does not belong to the OpenMemory sub-server alone. Apache-2.0 licensed.

Scaling to hosted or shared, multi-client ​

mcp-memory-service (doobidoo) provides semantic memory, a knowledge graph, and autonomous consolidation through a REST API, aimed at agent pipelines built with LangGraph, CrewAI, or AutoGen. Its backend is the sliding scale: sqlite-vec remains the single-file local default, and current releases pair it with Milvus and Cloudflare (Workers plus Vectorize) paths for shared and distributed deployments — earlier versions shipped ChromaDB for team access. Search uses sentence-transformers for semantic recall. Note the project's own migration: the long-cited GitHub repository now returns 404, and development moved to Codeberg, where v11.5.2 shipped on July 15, 2026 under Apache-2.0. Old GitHub star counts for this project no longer mean anything — the Codeberg count started fresh. Verify the current backend list on the new home before adopting.

Supermemory MCP (supermemoryai) is hosted-first, built on Cloudflare Workers and Durable Objects, with an optional self-host path behind an API key. It extracts facts, builds automatic user profiles, resolves contradictions, and supports selective forgetting. Authentication uses bearer tokens or OAuth, and projects are scoped through an x-sm-project header. The v1 repository carries a deprecation notice, so confirm the canonical install path before publishing a snippet. MIT-licensed; the v1 repo held about 1,700 stars on the scout date, while the current supermemory monorepo — where MCP v2 now lives — carries roughly 28,500 (different repo, different scope).

Mnemoverse — disclosure up front: this is the server this site's publisher builds, so read the entry as a vendor's self-description held to the article's own format. It is hosted-first with two entry points into one engine: a local stdio package, @mnemoverse/mcp-memory-server, exposing six core tools (write, read, feedback, stats, and two delete operations) plus three beta Rooms tools, and a hosted remote connector with one-click OAuth sign-in (the delete tools stay local-only). Because the store is hosted, one memory follows the user across any MCP client instead of living in a single tool's local file. It is also the only entry in this list with shared memory spaces across accounts: Rooms (beta) let several agents — even under different API keys — write to and read from one membership-checked shared pool, with self-service create, invite, and join tools in both the local server and the remote connector. Storage is not a flat vector index: memory atoms carry association weights that strengthen with use and shift with outcome feedback (the Hebbian layer) over a spatial, hyperbolic-graph representation (how it works). The server is listed in the official MCP registry. The weaknesses, in the same format as the seven other entries: the client packages are open, but the engine is proprietary and cloud-only — there is no self-host path; the product is young with a small user base; and every capability description in this paragraph is a vendor claim — hold it to the same skepticism as any other vendor claim in this article.

GibsonAI Memori and its wrapper memori-mcp (MemoriLabs) take the SQL-native route: facts, decisions, outcomes, agent execution traces, preferences, and summaries all live in a standard SQL database — SQLite by default, with managed-cloud, single-tenant, VPC, and on-premises options. No vector database is required, and there is no semantic-vector recall by default; retrieval is SQL query-based. The engine launched publicly on September 8, 2025 and carried roughly 15,600 stars as of July 21, 2026 (the project now lives under the MemoriLabs organization); the MCP wrapper is far younger — created in March 2026 — and carried 2 stars on the same date. Different projects at very different maturity. MIT-licensed.

Zep and Graphiti: one pointer, not a row ​

Zep's official knowledge-graph MCP server runs on Graphiti as its engine (about 20,000 stars per Zep's blog). It is graph-backed, and its read surface — traversal, temporal queries, provenance — is dissected in the graph memory MCP tools comparison. It is not a row in the table below because that article already covers it in full.

Memory MCP server comparison ​

Each choice fixes the operations that remain fast later. The two tables below map the eight servers: first storage and search, then deployment and maturity.

Storage and search

ServerStoresSearchPersistence
Official server-memoryKG: entities/relations/observationsSubstring/keywordLocal JSONL file
memento-mcpKG + vectors (temporal, decay)OpenAI embeddings, hybridNeo4j 5.13+ (external)
mcp-memory-serviceSemantic + KG + consolidationsentence-transformerssqlite-vec / Milvus / Cloudflare
basic-memoryMarkdown + semantic graphSQLite index + graph navLocal Markdown + SQLite (optional cloud)
OpenMemory MCP (Mem0)Structured memories (vector)Mem0 vector/hybridLocal Docker + vector DB
Supermemory MCPMemories, profiles, forgettingSupermemory engineHosted (CF Workers/DO); optional self-host
Mnemoverse (vendor)Memory atoms + association weights (spatial graph)Semantic + association/outcome rankingHosted engine; local stdio + remote OAuth entry points
GibsonAI Memori (+ memori-mcp)SQL-native structured stateSQL query/retrievalSQL DB (SQLite default)

Deployment and maturity

ServerMulti-client?Hosted vs localMaturity signal
Official server-memoryNo (single file)Local, single-userMIT (repo transitioning to Apache-2.0); "basic implementation"
memento-mcpVia shared Neo4jLocal / self-hostMIT; 425 stars; last release v0.3.9, 2025-05-12
mcp-memory-serviceYes (Milvus/CF)Local to distributedApache-2.0; v11.5.2 (2026-07-15); moved to Codeberg
basic-memoryMany client apps (incl. Obsidian)Local-first (optional paid cloud)AGPL-3.0 (copyleft); ~3,500 stars; active
OpenMemory MCP (Mem0)Shared local layerLocal-first (Mem0 Platform separate)Apache-2.0; active; umbrella repo ~61k stars, not sub-server
Supermemory MCPYes (any client)Hosted-firstMIT; ~1,700 stars; v1 repo deprecated
Mnemoverse (vendor)Yes (one memory, any MCP client)Hosted (no self-host)Client packages open, engine proprietary; MCP-registry-listed
GibsonAI Memori (+ memori-mcp)Via shared SQL DBLocal / cloud / VPC / on-premMIT; engine ~15.6k stars, wrapper 2 (2026-07-21)

Local-first vs hosted: the decision that filters the field ​

Feature checklists obscure the choice that actually narrows the field. Ask it first: does memory need to stay on one developer's machine, or must several clients and users share one store?

Local-first, single-user covers server-memory (JSONL, no external dependencies), memento-mcp (external Neo4j), basic-memory (Markdown plus SQLite), and OpenMemory (local Docker). Data never leaves the machine, and backups, versioning, and portability become the operator's responsibility. The reference server is the simplest and the most limited of these, by design. basic-memory gives the most user-owned artifact — plain Markdown you can read and edit outside the system — though its AGPL-3.0 license may gate commercial integration.

One caution belongs here. basic-memory connects to many client apps, yet it still serves one user's files. "Works with many clients" is not the same as "isolates many users."

Hosted or shared, multi-client covers mcp-memory-service on Milvus or Cloudflare, Supermemory MCP, Mnemoverse (this site's own — disclosed in its entry), Memori across a shared SQL database, and the paid cloud tier of basic-memory. Among them, Supermemory and Mnemoverse are the hosted-first designs: sign up, get an endpoint, connect any MCP client. The tradeoff is data locality — the agent's memory lives on Cloudflare infrastructure unless you configure the self-host path. And sharing a backend is not the same as separating tenants: in all multi-client cases, tenant isolation is a deployment concern, not an automatic guarantee. Portability between backends is a related problem, covered in the agent memory interop gap.

One more discipline before you compare adoption. Repository popularity can mislead. Check whether a star count belongs to the MCP server, its underlying engine, or an umbrella project. Memori is the clearest case: the engine's roughly 15,600 stars and the wrapper's 2 measure different things, and the two numbers must be kept separate. Mem0's ~61,000 stars belong to the umbrella project, not to OpenMemory. And the managed Mem0 Platform (app.mem0.ai) is hosted, while its MCP entry point is the separate local OpenMemory Docker path — one umbrella, two products, evaluated as such.

Is "gmemory" a memory MCP server? ​

Search for "gmemory MCP" and the results blur together. The most specific, verifiable match is G-Memory, a multi-agent memory research framework published on arXiv (paper 2506.07398) — a research contribution, not a shipped MCP server. There is no repository to clone, no endpoint to call, no npx command to run.

The nearest shipped option that answers the same intent — persistent structured state for agents without a vector-database requirement — is GibsonAI Memori, an open-source, SQL-native engine deployable on any SQL database. It is a separate project, not an implementation of G-Memory, and its MCP wrapper is early-stage. If you arrived looking for a product literally named "gmemory," the honest answer is that none exists.

Common questions ​

What is the best memory MCP server? ​

No single server wins across all use cases. The first decision is whether you need local-first single-user persistence or a hosted multi-client service, which filters the field immediately. After that, storage model — knowledge graph, vector, Markdown, or SQL — and operational maturity determine fit.

What is memento-mcp and what does it need to run? ​

memento-mcp is a knowledge-graph memory MCP server that adds vector embeddings and temporal metadata over Neo4j 5.13+. It needs an external Neo4j instance and an OpenAI API key for embeddings. Its last tagged release, v0.3.9, dates to May 12, 2025, so check recent commits before adopting it.

What is mcp-memory-service (doobidoo)? ​

mcp-memory-service provides semantic memory, a knowledge graph, and autonomous consolidation through a REST API. Backends range from sqlite-vec for single-file local use to Milvus and Cloudflare for shared and distributed deployments (earlier releases shipped ChromaDB), with sentence-transformers search. The project now lives on Codeberg, not GitHub.

Is 'gmemory' a memory MCP server? ​

No. The term most often points to G-Memory, a multi-agent memory research framework on arXiv (paper 2506.07398), which is not a shipped MCP server. The nearest shipped, SQL-native, open-source option is GibsonAI Memori, a separate project with a popular engine and a very new MCP wrapper.

What is the difference between a local memory MCP server and a hosted one? ​

A local memory MCP server keeps its primary store on infrastructure you control — a JSONL file, a SQLite database, or a local Docker container — and suits single-user work with full data control. A hosted or shared server exposes one remote store to several clients, which eases multi-client access but adds authentication, data-boundary, and trust decisions.

Which memory MCP server works across multiple AI clients? ​

basic-memory connects to Claude Desktop, Claude Code, Cursor, VS Code, ChatGPT custom GPTs, and Obsidian. mcp-memory-service reaches multiple clients through its Milvus or Cloudflare backends, OpenMemory exposes a shared local Docker layer, and Supermemory and Mnemoverse (this site's own server, disclosed in its entry) are hosted-first. In all multi-client cases, tenant isolation is a deployment concern, not an automatic guarantee.

Is the official Anthropic memory MCP server production-ready? ​

The official @modelcontextprotocol/server-memory calls itself, in its own README, "a basic implementation." It stores a knowledge graph in a single local JSONL file with substring-only search. It is actively maintained and a sound starting point; for production, pair it with or move to a server that adds vector search, multi-user scoping, or distributed persistence.

Sources ​

All repositories and pages accessed 2026-07-21.

Edward Izgorodin · Mnemoverse · last updated 2026-07-21