MnemoverseDocs

Appearance

Edward Izgorodin·Published Jul 11, 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, but its pinned MCP surface returns temporal fields rather than filtering on them.
  • Every surveyed surface lacks a first-class STOP or enough-information verb. Provenance appears only through adjacent trace or document calls, never inline with a normal read.

A graph database can traverse. That does not mean an agent-facing memory tool can ask for a useful traversal.

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 records the available surfaces as verified on 2026-07-11. 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.0.2, 9 tools · [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 — not a traversal or depth control, and available only on search_memory_facts.No first-class MCP path, expand, depth, or traversal parameter. The underlying library has breadth-first search, but the pinned MCP surface does not expose it as a memory verb.The survey’s only bi-temporal design: event or valid time plus ingestion time. At this pin, valid_at and invalid_at are returned fields, not query filters.get_entity_edge fetches a single edge by its UUID, and get_episodes lists recent episodes — adjacency lookups, not an episode-to-facts trace. Provenance is not returned inline with search results. No STOP or budget parameter.
Cognee — 14 tools per docs; 3 foregrounded in API mode, 2026-07-11 · [reported]Search modes return LLM-completed answers, chunks, summaries, or Cypher results. get_chunk_neighbors returns adjacent chunks from the same document, not graph-node neighbors.No first-class graph expansion. CYPHER is a raw-query escape hatch. get_chunk_neighbors is direct-mode only and drops from API mode.None.get_document is provenance-adjacent, but direct-mode only and absent from API mode. No inline provenance, STOP, or traversal budget.
Neo4j official mcp-neo4j-cypher — v1.5.3, 4 tools, 2026-06-11 · [verified-primary]Results from Cypher written by the model, 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, as of 2026-07 · [verified-primary]The Core profile has 6 tools; the Extended profile has 16 total. memory_search returns entities and facts. 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.None first-class.Reasoning-trace tools are provenance-adjacent but do not attach support to ordinary reads. No STOP verb. Experimental max_hops is the survey’s only budget-like traversal parameter.
Reference server-memory — archived-reference caveat; fetched 2026-07-09 · [reported]search_nodes performs substring keyword matching. open_nodes returns direct relations among named nodes. read_graph returns the whole graph.No neighbor expansion, subgraph retrieval, or multi-hop control.None.No provenance return, STOP verb, or budget parameter.

The tag next to each pin records confidence: [verified-primary] rows were re-fetched live on 2026-07-11 and passed an adversarial primary-source pass; [reported] rows reflect the published tool surface but were not adversarially re-verified.

Zep is folded into the Graphiti row because Zep’s official knowledge-graph MCP uses Graphiti as its engine. The zep_* tools found in third-party wrappers do not add a path or traversal verb.

The comparison also excludes surfaces that would duplicate another row or change the category. Memgraph MCP follows the raw-query shape represented by Neo4j official. FalkorDB agentic memory uses Graphiti with a FalkorDB backend, so it belongs with Graphiti. 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, at mcp-v1.0.2 Graphiti’s valid_at and invalid_at are return fields, not query filters, despite main-branch documentation that suggests date-range filtering. An agent sees the timestamps after retrieval; it cannot ask what was true between two dates. Second, several Cognee tools — get_chunk_neighbors, get_document, list_data, prune, and delete_dataset — are direct-mode only and drop in API mode, so any read-side capability that leans on them does not exist in the live API surface.

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 offers a CYPHER search mode. 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 wholly absent. Graphiti has get_entity_edge (single-edge lookup by UUID) and get_episodes; Cognee has direct-mode get_document; Neo4j Labs has reasoning-trace tools. The missing capability is provenance returned inline with a normal read, where an agent can inspect why a fact appeared without making a separate trace 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 facts already retrieved by search_memory_facts; 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 instead expose provenance-adjacent calls. 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 2026-07-11.

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 — grounding a level-of-detail verb that no server exposes.

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.0.2, Graphiti MCP has no first-class path, expand, or traversal verb. Its center_node_uuid parameter reranks retrieved facts 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 CYPHER mode, 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. At MCP tag mcp-v1.0.2, valid_at and invalid_at are returned fields rather than query filters.

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 2026-07-11. 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.

[^mem0]: mem0 is not included as a server row. Its MCP repository was archived 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-07-11