← Articles MCP

MCP Memory Server: Exposing Knowledge Graphs as Resources

February 12, 2026 · Source: modelcontextprotocol/servers#3323

About the Contributor

RaidLZ is an MCP ecosystem contributor focused on memory and knowledge management implementations. This PR represents a shift in how the memory server exposes data — from imperative tool calls to declarative resource access.

What Happened

A new pull request proposes exposing the MCP memory server's internal knowledge graph as an MCP Resource. Currently, the memory server uses tools like create_entities, create_relations, and search_nodes to interact with the knowledge graph. This change would also expose the graph as a readable resource.

MCP distinguishes between Tools (actions the model can take) and Resources (data the model can read). Exposing the knowledge graph as a resource enables a fundamentally different interaction pattern.

Why This Matters

The distinction between tools and resources is subtle but architecturally significant:

Tool-based access (current):

Model must explicitly call search_nodes or read_graph
Each access requires a tool call turn
Knowledge retrieval is active and intentional

Resource-based access (proposed):

Graph can be included in context automatically
Enables "always available" memory semantics
Clients can prefetch and cache the resource
Reduces turn count for knowledge-dependent tasks

This isn't just an API change — it's a philosophical shift in how AI systems relate to their persistent memory. Tool-based memory is like asking someone a question. Resource-based memory is like having information already in working memory.

What Changed Technically

The PR adds a new resource endpoint that exposes the knowledge graph:

{
  "uri": "memory://knowledge-graph",
  "name": "Knowledge Graph",
  "mimeType": "application/json",
  "description": "The complete knowledge graph with entities and relations"
}

Clients can subscribe to this resource and receive updates when the graph changes. The resource includes:

All entities with their properties and observations
All relations between entities
Metadata about graph structure

Importantly, the existing tool-based interface remains — this is additive, not a replacement.

Implications

For MCP client developers: You can now choose between active (tool) and passive (resource) memory access patterns. For agents that need constant context awareness, resource subscriptions reduce latency.

For knowledge graph applications: This opens the door to treating MCP memory servers as real-time knowledge bases. Combined with resource subscriptions, you could build collaborative memory systems where multiple agents share a knowledge graph.

For the MCP ecosystem: This sets a precedent for other servers. SQLite, filesystem, and other data-heavy servers could expose queryable resources alongside their tool interfaces.

Context: Memory Growth Concerns

This PR arrives alongside #3321, which addresses unbounded memory growth in the sequential-thinking server. The two are related: as knowledge graphs grow, exposing them as resources requires careful consideration of size limits and pagination.

The memory growth fix implements a sliding window for thought history. Similar strategies may be needed for knowledge graph resources at scale.

What's Next

Watch for:

Size limits and pagination for large knowledge graphs
Selective resource exposure (e.g., expose only relevant subgraphs)
Other MCP servers adopting the resource pattern for data access
Client implementations that leverage resource subscriptions for real-time memory sync

The tool/resource dichotomy is one of MCP's underutilized features. This PR demonstrates what's possible when servers embrace both paradigms.