MnemoverseDocs

Appearance

Edward Izgorodin·Published Jul 11, 2026Updated Sep 19, 2026

Graph Memory MCP Servers: What Agents Actually Get ​

TL;DR

  • Graph-memory MCP servers expose sharply different read surfaces: ranked facts, completed answers, raw Cypher results, bounded entity neighborhoods, or substring matches.
  • No production server in this survey exposes agent-controlled multi-hop traversal as a first-class memory verb. Neo4j Labs Agent Memory is the experimental exception, with max_hops limited to 1–3 and no path-finding tool.
  • Graphiti is the only surveyed server with bi-temporal memory, and since MCP tag mcp-v1.1.0 (2026-09-01) an agent can filter a fact search by when facts became and stopped being true.
  • Every surveyed surface lacks a first-class STOP or enough-information verb. Provenance arrives at most as a pointer: Graphiti facts carry the IDs of their source episodes, and reading the evidence itself takes a separate call on every server that offers it.

A graph database can traverse. That does not mean an agent-facing memory tool can ask for a useful traversal. This article stays on the read-side verbs of graph-backed servers; for the wider field, including vector, Markdown and SQL stores, see thirteen memory MCP servers compared.

A graph-memory MCP server is an MCP tool surface that stores or retrieves agent memory through a graph-backed representation.

A read-side verb surface is the set of named retrieval operations an agent can call, including what each operation returns and how the agent can control scope, ranking, time, evidence, and stopping.

This distinction matters because tool names shape agent behavior. An agent given read-cypher must formulate a database query. An agent given path, why, or enough would be operating through a memory policy.

The latter verbs mostly do not exist. The table below was first verified on 2026-07-11 and re-verified against each vendor’s own source code or documentation on 2026-09-18. Tool sets change, so every row includes a tag, version, date, or documentation pin.

Graph memory MCP comparison: what each server returns ​

Server and pinWhat a read returnsMulti-hop or expandTemporal supportProvenance, STOP, and budget
Graphiti: tag mcp-v1.1.0, 13 tools, released 2026-09-01 · [verified-primary]search_memory_facts and search_nodes return ranked facts or nodes. center_node_uuid invokes a node-distance reranker that reorders already-retrieved candidates by hop-proximity to a center node. It is not a traversal or depth control, and since mcp-v1.1.0 it is available on both searches.No first-class MCP path, expand, depth, or traversal parameter. The underlying library has breadth-first search, but the MCP surface does not expose it as a memory verb.The survey’s only bi-temporal design: event or valid time plus ingestion time. Since mcp-v1.1.0, search_memory_facts accepts valid_at_after, valid_at_before, invalid_at_after, and invalid_at_before: range filters on each timestamp, not a single as-of parameter.Each fact returned by search_memory_facts carries the UUIDs of the episodes it came from (episodes), but not their content. get_episode_entities returns the entities and facts that given episodes produced, in a separate call. No STOP or budget parameter.
Cognee: 4 tools: remember, recall, forget, and cognify_status; checked 2026-09-18 · [verified-primary]recall auto-routes a natural-language query, or takes a search_type override, and returns LLM-completed answers, chunks, summaries, or Cypher results.No first-class graph expansion. recall with search_type=CYPHER is a raw-query escape hatch.No time-filter parameter. recall accepts search_type=TEMPORAL, which extracts a time range from the question and filters events, but only over data ingested with Cognee’s temporal cognify, which the MCP remember tool does not request.No inline provenance, STOP, or traversal budget. Earlier document- and chunk-level tools have been removed from MCP in every mode.
Neo4j official MCP server (neo4j/mcp): v1.6.0, 4 tools, 2026-09-10 · [verified-primary]Results from Cypher written by the model through read-cypher, with schema inspection available separately.Multi-hop is possible only when the model authors correct Cypher. There is no curated traversal verb.None unless the user models time in Cypher.No first-class provenance, STOP, or budget verb.
Neo4j Labs Agent Memory: experimental and community-supported, checked 2026-09-18 · [verified-primary]The Core profile has 6 tools; the Extended profile has 16 total. memory_search returns messages, entities, and preferences by default, and reasoning traces on request. Extended memory_get_entity can include neighbors.The named exception: memory_get_entity accepts max_hops from 1 through 3 and defaults to 1. This is capped neighbor expansion, not iterative path-finding. graph_query remains a read-only-Cypher escape hatch.Validity window on write only: memory_add_fact takes valid_from and valid_until, but no read tool filters on time.Reasoning-trace tools, and with a hosted NAMS backend memory_get_entity_provenance (source messages and extractors for an entity), give provenance as separate calls; ordinary reads do not attach it. No STOP verb. Experimental max_hops is the survey’s only budget-like traversal parameter.
Reference server-memory: maintained MCP reference server, src/memory on main, checked 2026-09-18 · [verified-primary]search_nodes performs substring keyword matching. open_nodes returns the named entities plus every relation that touches one of them; entities at the far end are returned only if they were named too. read_graph returns the whole graph.No hop or depth control: search_nodes and open_nodes return the matched entities plus the relations that touch them, and nothing further.None.No provenance return, STOP verb, or budget parameter.

The tag next to each pin records confidence: [verified-primary] means the row was re-read from the vendor’s own source code or documentation, with a control probe, most recently on 2026-09-18. All five rows carry it.

Zep is folded into the Graphiti row because Zep’s MCP offer is the Graphiti MCP server: its former knowledge-graph MCP page now redirects to Zep’s Graphiti platform page.

The comparison also excludes surfaces that would duplicate another row or change the category. Memgraph MCP, as of 2026-09-18, follows the raw-query shape represented by Neo4j official; its earlier get_node_neighborhood tool, with a max_distance parameter, was removed in July 2026. FalkorDB agentic memory uses Graphiti with a FalkorDB backend, so it belongs with Graphiti. Neo4j’s hosted NAMS MCP server (47 tools) is a separate product from the Labs server in the table and was not surveyed. Basic Memory is a local Markdown and Obsidian graph rather than the graph-backed memory-server category compared here. Letta and MemGPT use tiered memory blocks rather than graph-native retrieval.

Two precision traps are worth pinning. First, Graphiti’s MCP surface changed between tags: at mcp-v1.0.2, valid_at and invalid_at were returned fields only, and since mcp-v1.1.0 they are range filters on search_memory_facts. They are independent ranges on each timestamp, so an agent can bound when facts became and stopped being true, but there is no single as-of parameter. Second, Cognee MCP now exposes only its memory API (remember, recall, forget, and cognify_status). Document retrieval, chunk neighbors, listing, and pruning are not MCP tools in any mode, so no read-side capability leans on them.

Raw Cypher is an escape hatch, not a memory verb ​

The obvious objection is correct but incomplete: an agent can express multi-hop traversal in Cypher.

The Neo4j official MCP exposes read-cypher. Cognee’s recall accepts search_type=CYPHER. Neo4j Labs Agent Memory includes graph_query.

These tools prove that the underlying database can traverse. They do not provide an agent with a curated retrieval operation.

An escape hatch transfers query design to the model. The model must choose relationship types, direction, depth, filtering, projection, and output shape. The tool supplies no built-in ranking, level-of-detail policy, evidence contract, or stop semantics.

A first-class memory verb would package those choices behind a stable operation. For example, this article’s own framing uses observe, hop, path, summarize, as_of, why, and enough. This is a synthesis for comparing surfaces, not an external MCP standard. No shared graph-navigation verb standard appears across the surveyed implementations.

Provenance requires the same precision. It is not absent. Graphiti goes furthest: every fact returned by search_memory_facts carries the UUIDs of its source episodes, and since mcp-v1.1.0 get_episode_entities traces what given episodes produced. Neo4j Labs has reasoning-trace tools and, with a hosted NAMS backend, memory_get_entity_provenance. The missing capability is evidence returned with a normal read: the supporting text itself, so an agent can inspect why a fact appeared without a second call.

Three missing graph-memory MCP verbs ​

These gaps are ecosystem whitespace the whole field shares. The verb taxonomy used here — observe, hop, path, summarize, as_of, why, enough — is this article’s own synthesis. No published external MCP standard for graph-navigation verbs exists, and that absence — no shared verb standard across implementations — is itself the finding.

1. Curated multi-hop and path retrieval ​

No production graph-memory MCP server in the survey exposes agent-controlled multi-hop retrieval as a first-class verb.

The exception is explicit: experimental Neo4j Labs Agent Memory provides max_hops from 1 through 3, defaulting to 1, on memory_get_entity. It offers bounded expansion but no dedicated path-finding tool.

Elsewhere, traversal collapses into raw Cypher or disappears from the MCP layer. Even Graphiti’s center_node_uuid only reranks results already retrieved by search_memory_facts or search_nodes; it neither expands from the center nor sets traversal depth. A cheap local "observe" primitive that surveys the available relation types before deciding what to expand — distinct from Neo4j Labs’ bounded entity-neighborhood fetch — exists only in research code, such as Search-on-Graph’s Search operator and GraphWalk’s get_all_nearest_neighbors.

2. Provenance returned with the read ​

A useful why operation would return the supporting episode, document, edge, or derivation with the retrieved claim.

Current servers return at most a pointer, as Graphiti’s episode UUIDs do, and leave the evidence behind a separate call. Recent preprints continue to treat verified read paths as an open design problem: Eywa proposes deterministic multi-route retrieval without LLM calls during retrieval, while From Lossy to Verified focuses on verified memory. These are research proposals, not shared MCP verbs.

3. A sufficiency or STOP operation ​

No surveyed surface exposes a first-class enough or STOP verb as of the 2026-09-18 re-check.

Result limits and hop caps constrain individual calls. They do not let an agent state that the gathered evidence is sufficient. That leaves stopping inside the model’s prompt logic or orchestration code rather than the memory interface.

Traversal budgets are similarly thin. Neo4j Labs has its experimental hop cap, but production surfaces do not expose a navigation budget combining depth, width, token allowance, or stopping criteria. Think-on-Graph shows the research form of this control with beam width and maximum depth both set to 3 in its default setup.

Why graph-navigation verbs matter ​

Research systems report gains when they control navigation explicitly rather than dumping a graph into context. Except where marked peer-reviewed, the figures below are author-reported preprint results — claims by their authors, not settled benchmarks.

The authors of Search-on-Graph report that observe-then-navigate search — first observe the available relations, then make an informed one-hop step — uses at least 46.4% fewer LLM calls and 69.9% fewer output tokens than prior graph-reasoning methods. On WebQSP, they report 3.9 calls versus 8.4 for Think-on-Graph, a 53.6% reduction. Author-reported Hits@1 with GPT-4o: WebQSP 91.3, GrailQA 86.9, CWQ 75.1, SimpleQA 84.8.

GraphRunner separates route planning, schema validation, and execution. Its authors report 10–50% higher GPT4Score, 2.5–7.1× faster measured response time, and 3.0–12.9× lower estimated inference cost than the iterative GRAPH-CoT baseline on GRBench with GPT-4. The latency is measured wall-clock time. The cost figure is a token-count estimate using stated GPT-4 list prices, not a billed-cost measurement. Keep the two apart.

GDS-Agent illustrates another pattern: offload structural graph computation to tools rather than asking the model to simulate it. The research framework exposes roughly 46 graph-data-science algorithms. It is not a shipped memory MCP and has no place in the production table.

Two studies mark the ceiling. In GraphWalk, accuracy without navigation tools falls from about 49% at 100 nodes to about 4.2% at 500 nodes for o4-mini — which was never tested with tools, so this is a no-tools scaling curve, not a demonstration that tools failed. GraphArena (ICLR 2025, the one peer-reviewed result here) shows Claude-3.5-Sonnet’s NP-complete accuracy dropping from 47.8% to 7.2% as graphs grow, and GPT-4o’s diameter hallucination climbing from 16% to over 80%. Reach is bounded by graph size — an argument for a budget-and-stop policy, not a larger dump.

Level of detail is itself a navigation decision. KG-LLM-Bench finds serialization format alone worth up to 17.5 points, and GraphOmni measures up to a 40% gap from format choice for GPT-4o on diameter, which grounds a level-of-detail verb. The nearest shipped surface is Graphiti’s summarize_saga and build_communities (MCP mcp-v1.1.0), which build summaries but do not let a read choose its level of detail.

End-to-end, a navigable world-graph pays off on its own terms. On MuSiQue, AriGraph with GPT-4 reaches 45.0 EM / 57.0 F1 versus GraphReader with GPT-4 at 38.0 / 47.4.

Tool availability alone does not solve the policy problem. The authors of When the Tool Decides report that agents adopted a GNN tool’s label 97.6–99.2% of the time, made exactly one tool call on 83% of queries, and deferred more as capability rose across Qwen2.5 model sizes. That result argues for inspectable evidence and explicit stopping policies, not merely more tools.

The policy side — including navigation budgets and stopping decisions — is covered in Navigating Knowledge Graphs: Why Retrieval Needs a Policy.

Common questions ​

Does Graphiti MCP support multi-hop traversal? ​

At tag mcp-v1.1.0, released 2026-09-01, Graphiti MCP has no first-class path, expand, or traversal verb. Its center_node_uuid parameter reranks retrieved results by node distance; it does not control traversal depth.

Which graph-memory MCP server supports agent-controlled expansion? ​

Neo4j Labs Agent Memory is the survey’s experimental exception: memory_get_entity accepts max_hops from 1 through 3, defaults to 1, and performs bounded neighbor expansion rather than dedicated path-finding.

Can an agent perform multi-hop retrieval with raw Cypher? ​

Yes, if the agent writes a correct query through surfaces such as Neo4j read-cypher, Cognee recall with search_type=CYPHER, or Neo4j Labs graph_query. That is a database escape hatch, not a curated memory verb with ranking, level-of-detail, provenance, and stop semantics.

Which graph-memory MCP server supports bi-temporal memory? ​

Graphiti is the only bi-temporal server in this dated survey. Since MCP tag mcp-v1.1.0 (2026-09-01), search_memory_facts accepts range filters on valid_at and invalid_at; at the earlier pin mcp-v1.0.2 they were returned fields only.

Do graph-memory MCP servers expose a STOP or enough-information tool? ​

No surveyed surface exposes a first-class STOP or enough-information verb as of the 2026-09-18 re-check. Agents can receive result caps or an experimental hop cap, but they cannot explicitly report that retrieval is sufficient through a dedicated memory tool.

Why does the absence of a STOP verb matter? ​

Without an explicit sufficiency signal, an agent keeps retrieving until an external limit or a model decision ends the loop, which raises both token cost and latency. Because no server exposes a STOP verb, that control lives in orchestration code rather than the memory interface.

Sources ​

[^mem0]: mem0 is not included as a server row. Its MCP repository is archived, with its last push on 2026-03-24, while SDK v2.0.0, released 2026-04-16, removed graph memory in favor of entity linking. The fragmented and no-longer-graph-backed MCP surface illustrates why dated pins are necessary.

Edward Izgorodin · Mnemoverse · last updated 2026-09-19

— Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Plans and limits · Docs: Getting Started