Memory MCP servers compared: thirteen 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, but search results conflate monorepo star counts, stale releases, and research frameworks with shipped products. Thirteen named, operational servers are compared here — one of them, flagged inline as a vendor entry, is built by the publisher of this site.
TL;DR
- Thirteen named memory MCP servers ship today, across four storage models: knowledge graph, vector, Markdown, and SQL. One of them is built by this site's publisher and is flagged as a vendor entry.
- Adoption and registry presence do not track each other. The largest project in this comparison, claude-mem, has ~90,100 stars and no registry entry, while some registry-listed servers have almost no users.
- The first filter is deployment, not features: local-first single-user versus hosted or shared multi-client. Supermemory, Mem0 and Mnemoverse (the vendor entry) are the hosted-first designs in this comparison.
- The official reference
server-memoryis 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 Memori (MemoriLabs, formerly GibsonAI), whose popular engine and 2-star MCP wrapper have to be judged separately.
- Mem0 removed OpenMemory from its monorepo in July 2026; its documented MCP entry point is now a hosted server, not a local Docker stack. Check whether a sub-project still ships before adopting it.
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 thirteen named products; it does not re-run the graph-traversal comparison in graph memory MCP tools.
Named memory MCP servers and what they store
Thirteen memory MCP servers ship functionality today. Each sits at a distinct point on the local-to-hosted spectrum and picks a distinct storage substrate.
The write-ups are grouped by the deployment split this article opens with — not by the tables' order. Within each group they run by the star count of the project's primary repository, descending, with the one project that has no star count of its own closing its group; the vendor entry opens the hosted group, where its disclosure belongs.
Local-first, single-user
claude-mem (thedotmack) is the largest project in this comparison by a wide margin, at roughly 90,100 stars. It is not a general memory store: it compresses coding-agent sessions — Claude Code first among them, with several other agents listed in its README — through hooks and a local worker, then exposes MCP search tools over what it captured. (Its README's own tool count is inconsistent — one line says four, the list under it names three, and the source defines more — so treat any tool number as approximate.) Storage is a local SQLite database with FTS5 plus a Chroma vector store for hybrid recall. The engine is Apache-2.0; the paid cloud tier, CMEM Pro, syncs memory across machines at $30 a month for solo developers, with Team at $333 per seat per month. One install trap the project documents itself: npm install -g claude-mem fetches the library only and does not register the hooks or the worker, so use their installer or the plugin command instead.
MemPalace stores text verbatim in a wings-rooms-drawers hierarchy rather than summarising it, and its main retrieval path needs no LLM at all, which means no third-party API key for ordinary use. The default store is a local ChromaDB, with sqlite_exact, Milvus, Qdrant, and pgvector backends as alternatives. MIT-licensed, roughly 58,200 stars, and there is no vendor cloud: the project is local-only and entirely free. Two things are worth knowing, both from the project's own pages. Its maintainers publish a page of retracted benchmark claims, having withdrawn earlier numbers of their own — unusual and, for a reader, a good sign. And they warn that impostor domains imitating the project (they name mempalace.tech) are not theirs and may distribute malware — install only from the repository they link.
agentmemory (rohitg00) runs one local server that every coding agent on the machine shares, with retrieval fusing BM25, vector search, and a knowledge graph through reciprocal-rank fusion; embeddings can run fully locally. Apache-2.0, roughly 26,800 stars, no hosted offering. By default it makes no LLM calls at all — configuring a provider is optional and switches on consolidation and compression. The caveat is architectural rather than commercial: it wraps a separate engine (iii), pinned by default to a specific version it installs for you, and its own docs warn that a machine already running a different version of that engine will conflict (the pin is overridable). Its Windows path is manual.
Engram (Gentleman-Programming) is the simplest thing here that still does real work: one Go binary, SQLite with FTS5 full-text search, no Node, Python, or Docker required for the core, and a setup command that can configure any of a dozen MCP clients (one chosen client per run). MIT, roughly 5,900 stars, entirely free. Sync between machines is git-based by default — compressed chunks over a repository you control, no server involved; an optional self-hosted "Cloud" sync server exists for teams (its documented deployment is Docker Compose, though the same binary can serve it directly), and none of it is a vendor service. Note their own documentation on scope: personal and project observations both travel during a project sync, because scope is a search filter, not a privacy boundary.
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 per seat per month) adds sync and mobile access. The AGPL-3.0 license carries strong copyleft obligations — a flag for commercial or hosted adopters. About 3,600 stars; installed with uv tool install basic-memory.
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. Its last tagged release is v0.3.9 from May 12, 2025, and the last commit to main landed on May 10, 2025 — fifteen months of silence, with only dependabot branches since. npm downloads sit around 127 a month. Earlier versions of this article hedged that a stale release date is only a maintenance signal; the commits have now been checked, and this one is abandoned. It is documented here because it still appears in search results, not as a starting point. MIT-licensed, 425 stars.
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. Licensing is mid-transition: new contributions land under Apache-2.0 while earlier code stays MIT. Install with npx -y @modelcontextprotocol/server-memory or the mcp/memory Docker image. It closes this group because it has no star count of its own — it lives inside the official monorepo. A sound starting point, not a production-hardened store.
Scaling to hosted or shared, multi-client
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 seven core tools (write, read, a newest-first recent feed, feedback, stats, and two delete operations), four beta Rooms tools, and a vault listing tool — twelve in total, and a hosted remote connector with OAuth sign-in (only the two delete tools stay local-only, so the remote connector exposes ten).
Because the store is hosted, one memory follows the user across any MCP client instead of living in a single tool's local file. Shared memory spaces across accounts ship as Rooms (beta), which let several agents — including agents 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. (Sharing exists elsewhere in this list — Memori through a common SQL database, Hindsight through per-bank HTTP endpoints; what differs here is the membership check and the self-service tooling across accounts.)
Storage is not a flat vector index: memory atoms carry association weights that strengthen with use and shift with outcome feedback (the Hebbian layer). The hyperbolic geometry the project is named for (THG, SLoD) is research-stage and not in the shipping engine, which its own technology pages state plainly (how it works). The server is listed in the official MCP registry — a self-service listing, not a vetting mark.
The weaknesses, in the same format as every other entry here: the client packages are open, but the engine is proprietary and cloud-only — there is no self-host path; the product is young, with one of the smallest adoption footprints in this table (the public package repo counts 17 stars — the lowest row-level count here — and about 1,200 npm downloads a month); and every capability description in this entry is a vendor claim — hold it to the same skepticism as any other vendor claim in this article.
Mem0 reaches MCP through a hosted server today, not a local one. The history matters because it is easy to install the wrong thing: the standalone mem0-mcp repository was archived in March 2026, and OpenMemory — the local Docker path that replaced it — was deleted from the monorepo on July 29, 2026 (commit ea2ee075, 208 files removed). The name now belongs to a different product in a separate repository: a CLI that syncs sessions between coding agents. What Mem0 documents as its MCP entry point is https://mcp.mem0.ai/mcp, hosted by Mem0 with OAuth sign-in, in their words with nothing running on your machine. The umbrella repository carries roughly 62,800 stars, a whole-project figure that never belonged to the sub-server. Apache-2.0 licensed.
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 deprecated v1 repo held about 1,700 stars, while the current supermemory monorepo — where MCP v2 now lives — carries roughly 28,800. The tables below rank it by the monorepo, since that is where the MCP server ships today.
Hindsight (Vectorize) is the most infrastructure-shaped entry: Postgres-backed, shipped as a Docker image with Helm charts, an MCP server enabled by default on the same port as its API, and a published preprint behind the approach (arXiv:2512.12818). Recall runs four retrieval strategies in parallel and merges them with reciprocal-rank fusion plus a cross-encoder reranker. MIT, roughly 19,300 stars. Self-hosting is free; the vendor cloud is priced per million tokens rather than per seat. Two operational notes: it needs an LLM key (any of several providers, including a fully local Ollama path), and its MCP endpoint ships unauthenticated by default — you enable auth explicitly, which matters the moment you expose it beyond localhost.
Memori (MemoriLabs; launched as GibsonAI Memori — the old domain now redirects to memorilabs.ai) and its wrapper memori-mcp 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 carries roughly 15,700 stars as of August 8, 2026; the MCP wrapper is far younger — created in March 2026 — and still carried 2 stars in August 2026. Different projects at very different maturity. The engine is Apache-2.0; only the thin MCP wrapper is MIT. GitHub's licence detector reports the engine as "Other" because its LICENSE file keeps the unfilled [2025] [Memori Team] placeholder, but the text itself is the Apache 2.0 licence verbatim.
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.7.0 shipped on August 5, 2026 under Apache-2.0. Old GitHub star counts for this project no longer mean anything — the Codeberg count started fresh, which is why it closes this group. Verify the current backend list on the new home before adopting.
Zep and Graphiti: one pointer, not a row
Zep's official knowledge-graph MCP server runs on Graphiti as its engine (29,700 stars as of August 2026; Zep's own blog post still cites the 20,000 it hit earlier). 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 three tables below map the thirteen servers: first storage and search, then deployment and maturity, then cost and fit. Shortlist from the first two; budget from the third.
The tables are ordered with our own entry first, deliberately. This site publishes one of these servers, and burying it mid-list would look neutral while still benefiting from the company it keeps; putting it at the top with the disclosure attached lets you discount it in one glance and read the other twelve on their own terms.
Everything after it is ordered by one rule: the star count of the project's primary repository, descending — the same number shown in the maturity column, checkable rather than chosen. Applied evenly, the rule has known distortions, flagged where they bite: Mem0's and Supermemory's counts are umbrella-repo counts (the monorepo where each MCP server lives today, not the server alone), and Memori's belongs to its engine rather than its 2-star MCP wrapper.
Two projects have no star count of their own and close the tables: mcp-memory-service moved to Codeberg, where its count started fresh, and server-memory lives inside the official monorepo (~89,400 stars for the whole curated set) — while being the most-downloaded MCP server package here, at roughly 390,000 npm downloads a month. (Engine libraries such as mem0ai on PyPI count far higher still, but they are engines, not MCP servers.)
Storage and search
| Server | Stores | Search | Persistence |
|---|---|---|---|
| Mnemoverse (vendor) | Memory atoms + association weights (spatial graph) | Semantic + association/outcome ranking | Hosted engine; local stdio + remote OAuth entry points |
| claude-mem | Session summaries + observations | FTS5 keyword + Chroma vector (hybrid) | Local SQLite; optional cloud mirror |
| Mem0 (hosted MCP) | Structured memories (vector) | Mem0 vector/hybrid | Hosted by Mem0 (the local OpenMemory path was removed from the monorepo in July 2026) |
| MemPalace | Verbatim text in a wings/rooms/drawers hierarchy | Semantic; no LLM needed on the main path | Local: ChromaDB by default (sqlite_exact, milvus, qdrant, pgvector) |
| Supermemory MCP | Memories, profiles, forgetting | Supermemory engine | Hosted (CF Workers/DO); optional self-host |
| agentmemory | Observations via the iii engine | BM25 + vector + KG (reciprocal-rank fusion) | Local (bundled iii engine) |
| Hindsight | Episodes and derived facts | 4 parallel retrieval strategies, RRF + cross-encoder rerank | Postgres (bundled or external) |
| Memori (MemoriLabs) | SQL-native structured state | SQL query/retrieval | SQL DB (SQLite default) |
| Engram (Gentleman) | Observations and sessions | SQLite FTS5 full-text | Local SQLite; git-based sync (optional self-hosted server) |
| basic-memory | Markdown + semantic graph | SQLite index + graph nav | Local Markdown + SQLite (optional cloud) |
| memento-mcp | KG + vectors (temporal, decay) | OpenAI embeddings, hybrid | Neo4j 5.13+ (external) |
| mcp-memory-service | Semantic + KG + consolidation | sentence-transformers | sqlite-vec / Milvus / Cloudflare |
Official server-memory | KG: entities/relations/observations | Substring/keyword | Local JSONL file |
Deployment and maturity
| Server | Multi-client? | Hosted vs local | In the official MCP Registry? | Maturity signal |
|---|---|---|---|---|
| Mnemoverse (vendor) | Yes (one memory, any MCP client) | Hosted (no self-host) | Yes, package and remote (v0.8.1) | Client packages open (MIT), engine proprietary; 17 stars, ~1.2k npm downloads/mo |
| claude-mem | Via optional cloud mirror | Local-first | No entry | Apache-2.0; ~90.1k stars; v13.14.0 (2026-08-08) |
| Mem0 (hosted MCP) | Yes (hosted, OAuth) | Hosted-first | Yes, remote only (v1.0.0) | Apache-2.0; active; umbrella repo ~62.8k stars, not the MCP server |
| MemPalace | Same palace path, any client | Local only, no vendor cloud | No entry | MIT; ~58.2k stars; v3.6.0 (2026-07-17) |
| Supermemory MCP | Yes (any client) | Hosted-first | No vendor entry (a third-party fork is listed) | MIT; monorepo ~28.8k stars (MCP v2 home); v1 repo deprecated (~1.7k) |
| agentmemory | Yes, one local server for all agents | Local only | No entry | Apache-2.0; ~26.8k stars; v0.9.28 (2026-07-19) |
| Hindsight | Yes, HTTP MCP with per-bank isolation | Self-host or vendor cloud | No entry | MIT; ~19.3k stars; v0.9.0 (2026-08-07) |
| Memori (MemoriLabs) | Via shared SQL DB | Local / cloud / VPC / on-prem | Yes, package only (v1.0.0) | Engine Apache-2.0 (~15.7k stars), MCP wrapper MIT (2 stars) |
| Engram (Gentleman) | Yes, all local agents share one DB | Local; git-based or self-hosted sync, no vendor cloud | No entry | MIT; ~5.9k stars; v1.20.0 (2026-07-20) |
| basic-memory | Many client apps (incl. Obsidian) | Local-first (optional paid cloud) | Yes, package only (v0.22.1) | AGPL-3.0 (copyleft); ~3,600 stars; active |
| memento-mcp | Via shared Neo4j | Local / self-host | No entry | MIT; 425 stars; abandoned — last commit 2025-05-10 |
| mcp-memory-service | Yes (Milvus/CF) | Local to distributed | No entry | Apache-2.0; v11.7.0 (2026-08-05); moved to Codeberg |
Official server-memory | No (single file) | Local, single-user | No entry | New code Apache-2.0, earlier MIT; "basic implementation"; ~390k npm downloads/mo |
Registry column checked against registry.modelcontextprotocol.io on 2026-08-09. Read it narrowly. Publishing there is self-service, not vetting — a listing means a maintainer filled in a form, not that anyone reviewed the server. And absence says nothing about adoption: the largest project here by stars, claude-mem (~90,100), has no entry at all, and neither does MemPalace (~58,200), while some of the smallest projects in the registry have almost no users. The column is useful for exactly one thing: MCP-aware clients that browse the registry can only find what is in it. Within that narrow frame, Mnemoverse is currently the only server in this comparison offering both a local stdio package and a hosted remote endpoint — a self-service listing fact, not a quality signal.
Cost and fit
| Server | Free tier | First paid tier | Best for |
|---|---|---|---|
| Mnemoverse (vendor) | Free: 10k atoms, 1,000 queries/day | $29/mo Pro | One memory following the user across MCP clients, plus shared Rooms; no self-host |
| claude-mem | Free engine, Apache-2.0 | $30/mo Pro (solo); Team $333/seat/mo | Claude Code users who want session history compressed and searchable |
| Mem0 (hosted MCP) | Hobby $0: 10k adds and 1k retrievals a month | $19/mo Starter | Product teams wanting a mature managed engine with a predictable ladder |
| MemPalace | Entirely free; there is no paid tier | None | Local-only memory with no vendor account anywhere in the loop |
| Supermemory MCP | Free with usage credit included | $19/mo Pro | One memory across LLM clients, billed by usage rather than seats |
| agentmemory | Free; no hosted offering found | None found | One local server shared by many coding agents on one machine |
| Hindsight | Self-host free; cloud has starting credits | Cloud is usage-priced (per million tokens) | Teams wanting a self-hostable engine with a documented cloud option |
| Memori (MemoriLabs) | OSS self-host free; cloud free tier | From $60k/year Team (contact sales; no self-serve step between) | Enterprises on existing SQL infrastructure, on annual contracts |
| Engram (Gentleman) | Entirely free, including sync | None | A single Go binary with no runtime dependencies |
| basic-memory | Free locally, forever (AGPL-3.0); 7-day cloud trial | $15/seat/mo Team ($13 from 10 seats, $12 from 20); Business $30/seat | Memory you can read and edit as plain Markdown, Obsidian included |
| memento-mcp | Free, but needs your own Neo4j and a paid OpenAI key | None | Teams already on Neo4j, prepared to fork and maintain abandoned code |
| mcp-memory-service | Free and fully self-hosted | None (the maintainer sells consulting) | The most complete self-host: local embeddings, OAuth, no cloud bill |
Official server-memory | Free, open source, no hosting | None | A first experiment on one machine; the reference, not the answer |
The pricing column exposes something a feature grid hides. Most of this field converges on roughly $15-30 a month for a hosted tier, and several projects have no paid tier at all. Memori is the outlier by two orders of magnitude: its first paid step is quoted from $60,000 a year, which is not a more expensive version of the same purchase but a different one entirely. Read the free tiers carefully too — free and self-hosted are not the same thing, and memento-mcp is "free" only until you add a Neo4j instance and a paid embeddings key.
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 — your branch if memory needs to stay on one developer's machine — covers claude-mem (local SQLite plus Chroma, with the cloud mirror as a paid option), MemPalace (a local vector store with no vendor cloud at all), agentmemory (one local server every agent on the machine talks to), Engram (a single Go binary over SQLite), basic-memory (Markdown plus SQLite), memento-mcp (external Neo4j), and server-memory (JSONL, no external dependencies). The primary store stays on hardware you control, and backups, versioning, and portability become the operator's responsibility — though the entries themselves flag the egress at the edges: memento-mcp sends text to OpenAI for embeddings, and claude-mem's optional cloud mirror syncs off-machine. 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 — your branch if several clients and users must share one store — covers mcp-memory-service on Cloudflare or Milvus, Supermemory MCP, Mem0's hosted MCP endpoint, Mnemoverse (this site's own — disclosed in its entry), Memori across a shared SQL database, the paid cloud tiers of basic-memory and claude-mem, and Hindsight, whose MCP server rides its HTTP API. Among them, Mem0, 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 the vendor's infrastructure: Supermemory's on Cloudflare, with an optional self-host path; Mem0's and Mnemoverse's on their own clouds, with no self-host escape. 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.
Two more disciplines 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's engine-versus-wrapper split and Mem0's umbrella count, both flagged above the tables, are the clearest cases. The second discipline: re-check that the sub-project you are citing still ships. An earlier version of this paragraph pointed at OpenMemory as Mem0's local MCP path; that path has since been removed from the monorepo.
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. A research codebase exists (the paper links bingreeky/GMemory), but it is Python experiment code: no MCP server, 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 Memori (MemoriLabs, formerly GibsonAI), 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. It is no longer maintained: the last commit to main was May 10, 2025, and npm downloads sit around 127 a month.
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 Memori from MemoriLabs (formerly GibsonAI), 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, Codex CLI, Cursor, VS Code, ChatGPT custom GPTs, and Obsidian. mcp-memory-service reaches multiple clients through its Cloudflare, hybrid, or Milvus backends, and Mem0, Supermemory and Mnemoverse (a vendor entry, built by the publisher of this comparison) 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, registries, and pricing pages re-verified 2026-08-08 against primary sources (GitHub and Codeberg APIs, npm and PyPI, the official MCP Registry, and each vendor's own pricing page).
- modelcontextprotocol/server-memory · npm package
- gannonh/memento-mcp
- doobidoo/mcp-memory-service (moved from GitHub to Codeberg)
- basicmachines-co/basic-memory
- mem0ai/mem0 · OpenMemory MCP announcement
- supermemoryai/supermemory-mcp · Supermemory MCP documentation
- MemoriLabs/Memori (engine, ex-GibsonAI) · MemoriLabs/memori-mcp · pricing
- thedotmack/claude-mem · pricing
- MemPalace/mempalace (its docs/HISTORY.md holds the benchmark retractions and the impostor-domain notice)
- rohitg00/agentmemory
- vectorize-io/hindsight · preprint (arXiv:2512.12818)
- Gentleman-Programming/engram
- Pricing pages: Mem0 · Supermemory · basic-memory · Mnemoverse
- G-Memory (arXiv:2506.07398)
- Zep: Graphiti hits 20k stars
Related
- Memory MCP: how they work and how to choose — the category explainer and five-question rubric this article applies
- Graph memory MCP tools compared — graph-backed servers, including traversal, temporal, and provenance surfaces
- AI agent memory: a practical framework — foundational concepts
- The agent memory interop gap — portability between backends, relevant to multi-client setups
- Knowledge-graph memory for agents — background on the KG storage model
- How Mnemoverse compares — the vendor's own head-to-head pages vs Mem0, Zep, Cognee, and Letta; vendor claims apply
Edward Izgorodin · Mnemoverse · last updated 2026-08-08
— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started