MCP for Aura: Hosted Model Context Protocol for Every Neo4j Graph Database | Graphs

Loading…

MCP for Aura: Hosted Model Context Protocol for Every Neo4j Graph Database | Graphs | graphwiz.ai

Teaser: Every Neo4j Aura instance now ships with a built-in MCP server — Cypher querying, schema discovery, graph traversal, and vector search exposed as standardised tools that any MCP-compatible agent can call. This article breaks down the architecture, the six core tools, and three practical patterns for connecting AI agents to knowledge graphs without custom connector code.

Introduction

In July 2026, Neo4j announced MCP for Aura — a hosted Model Context Protocol (MCP) server built directly into every Aura instance. The move is significant: it turns every Neo4j cloud database into an MCP endpoint that AI agents can discover, authenticate to, and query without custom connector code.

For teams building agentic AI systems, this closes a persistent gap. While MCP has gained traction as the open standard for connecting LLMs to tools and data sources, graph databases have largely been accessible only through bespoke integrations or REST API wrappers. MCP for Aura changes that by exposing Cypher query execution, schema introspection, and knowledge graph traversal as standard MCP tools.

This article examines the architecture of MCP for Aura, explores what it enables for AI agents, and walks through practical patterns for using knowledge graph MCP tools in production.

Why MCP Matters for Graph Databases

The Model Context Protocol, originally introduced by Anthropic in late 2024, defines a standardised interface between LLM hosts (clients) and external tools or data sources (servers). An MCP server exposes a set of tools — typed functions with descriptions and parameter schemas — that the LLM can invoke dynamically based on context.

Before MCP for Aura, connecting an AI agent to a Neo4j database required one of:

Approach	Drawback
Custom Cypher generator via LLM prompt	Hallucinated syntax, no schema awareness
REST API wrapper with LangChain/LlamaIndex	Framework lock-in, maintenance overhead
GraphRAG pipeline with pre-computed embeddings	Static, no ad-hoc traversal

MCP for Aura replaces all of these with a single, standardised endpoint. The agent negotiates capabilities at connection time, discovers available tools (query, schema, traversal), and invokes them with validated parameters. The MCP server handles authentication, rate-limiting, and error recovery.

Architecture: How MCP for Aura Works

MCP for Aura is not a separate service — it runs as a lightweight sidecar within each Aura instance's control plane. Every Aura database (both AuraDB Professional and AuraDB Enterprise) now includes an MCP server endpoint accessible at:

mcp://<instance-id>.aura-neo4j.io/mcp

The architecture follows a layered design:

┌─────────────────────────────────────────┐
│             AI Agent (Host)             │
│  ┌───────────────────────────────────┐  │
│  │  MCP Client (SDK)                │  │
│  │  • Tool discovery                │  │
│  │  • Tool invocation               │  │
│  │  • Context management            │  │
│  └──────────┬────────────────────────┘  │
└─────────────┼────────────────────────────┘
              │ MCP Protocol (JSON-RPC)
              │ over SSE or WebSocket
┌─────────────┼────────────────────────────┐
│  Aura MCP  │  Server Layer              │
│  ┌──────────┴────────────────────────┐  │
│  │  Tool Registry                   │  │
│  │  ┌─────────────────────────────┐  │  │
│  │  │ query_cypher                │  │  │
│  │  │ get_schema                  │  │  │
│  │  │ traverse_graph              │  │  │
│  │  │ run_graph_algorithm         │  │  │
│  │  │ vector_search               │  │  │
│  │  └─────────────────────────────┘  │  │
│  ├─── Authentication                 │  │
│  │   • OAuth 2.0 client credentials  │  │
│  │   • API key (AuraDB Pro)          │  │
│  ├─── Rate Limiting & Quotas         │  │
│  │   • Per-tool token budgets        │  │
│  │   • Query complexity scoring      │  │
│  └───────────────────────────────────┘  │
│                                         │
│   Neo4j Aura Control Plane              │
└─────────────────────────────────────────┘

Authentication

MCP for Aura supports two authentication modes:

OAuth 2.0 Client Credentials (AuraDB Enterprise) — integrates with existing identity providers
API Key (AuraDB Professional) — scoped to the instance, configurable via the Aura Console

The MCP server validates credentials at session startup and applies per-tool access controls mapped to the authenticated principal's database permissions.

Available Tools

The MCP for Aura server exposes six core tools:

Tool	Description	Parameters
`query_cypher`	Execute a Cypher query with parameter binding	`query: string`, `params: object`, `max_rows: int`
`get_schema`	Retrieve the graph schema (node labels, relationship types, property keys)	`include_indexes: boolean`
`traverse_graph`	BFS/DFS traversal from a starting node	`start_id: string`, `direction: "in"
`run_graph_algorithm`	Execute a GDS algorithm via MCP	`algorithm: string`, `config: object`
`vector_search`	Semantic search over node embeddings	`query_text: string`, `embedding_model: string`, `top_k: int`
`list_tools`	Discover available tools and their schemas	(none)

Each tool includes a full JSON Schema description of its parameters, enabling the LLM to construct valid invocations without prior knowledge of the database schema.

Practical Patterns: AI Agents + Knowledge Graphs via MCP

Pattern 1: Schema-Aware Cypher Generation

The most immediately useful pattern is schema-guided query generation. Instead of prompting an LLM to write Cypher from scratch (which produces hallucinated node labels and relationship types 30–40% of the time), the agent first calls get_schema to retrieve the actual graph structure:

sequenceDiagram
    Agent->>MCP Server: get_schema()
    MCP Server-->>Agent: Node labels: [Person, Company, Contract],<br/>Rels: [OWNS, EMPLOYS, SIGNS]
    Agent->>MCP Server: query_cypher("MATCH (p:Person)-[:EMPLOYS]->(c:Company) RETURN c.name, count(p)")
    MCP Server-->>Agent: [{"c.name": "Acme Corp", "count(p)": 42}]

This two-step pattern eliminates hallucinated labels and produces accurate queries on the first attempt.

Pattern 2: Multi-Hop Traversal for Entity Resolution

AI agents often need to answer questions that require walking the graph across multiple relationships. The traverse_graph tool handles this natively:

# Agent discovers: "What contracts does Alice have exposure to?"
traversal = mcp_client.call_tool("traverse_graph", {
    "start_id": "Person:alice-123",
    "direction": "out",
    "max_depth": 3,
    "relationship_types": ["EMPLOYS", "SIGNS", "OWNS"]
})

The agent can chain traversal results with query_cypher for filtering, or use run_graph_algorithm for path analysis.

Pattern 3: GraphRAG with Native Vector Search

Aura already supports vector indexes for embedding storage. MCP for Aura's vector_search tool lets agents perform semantic search directly against the knowledge graph:

results = mcp_client.call_tool("vector_search", {
    "query_text": "supply chain disruptions in semiconductor manufacturing",
    "embedding_model": "text-embedding-3-large",
    "top_k": 10
})

This turns graph-based RAG into a first-class MCP tool, eliminating the need for a separate vector database or embedding pipeline.

Comparison: MCP for Aura vs. Alternatives

Feature	MCP for Aura	Custom REST API	LangChain GraphCypherQAChain	Neo4j GraphRAG Python
Standard protocol	✅ MCP	❌ Proprietary	❌ LangChain-only	❌ Framework-only
Schema discovery	✅ Built-in	❌ Manual	✅ Auto (labelled)	✅ Auto
Auth	✅ OAuth 2.0 / API Key	❌ Custom	❌ Embedded credential	❌ Embedded credential
Vector search	✅ Native	❌	❌	✅
Graph algorithms	✅ via GDS	❌	❌	❌
Rate limiting	✅ Per-tool budgets	❌	❌	❌
Framework agnostic	✅	✅	❌ LangChain only	❌ Python only
Multi-agent support	✅ Concurrent sessions	❌	❌	❌

Getting Started

To use MCP for Aura, you need an Aura instance with the MCP feature enabled (currently in public preview, available on all AuraDB Professional and Enterprise instances created after July 15, 2026).

1. Obtain Credentials

From the Aura Console, navigate to Settings → MCP and generate an API key. The key is scoped to the instance and inherits the database permissions of the creating user.

2. Connect via MCP Client SDK

Using the official MCP client SDK (Python example):

from mcp import MCPClient

client = MCPClient(
    server_url="mcp://myinstance.aura-neo4j.io/mcp",
    api_key="aura-mcp-key-xxxx"
)

# Discover tools
tools = client.list_tools()
for tool in tools:
    print(f"{tool.name}: {tool.description}")

# Query the graph
result = client.call_tool("query_cypher", {
    "query": "MATCH (n) RETURN labels(n), count(*) AS count",
    "max_rows": 20
})

3. Connect via MCP Host (Claude Desktop, VS Code, etc.)

Many MCP hosts now support MCP for Aura natively. In Claude Desktop, add to your mcp_servers.json:

{
  "mcpServers": {
    "neo4j-aura": {
      "type": "sse",
      "url": "mcp://myinstance.aura-neo4j.io/mcp",
      "headers": {
        "X-API-Key": "${AURA_MCP_API_KEY}"
      }
    }
  }
}

For VS Code Copilot and Cline, the MCP for Aura server can be registered through their MCP configuration panels.

Limitations and Considerations

MCP for Aura is in public preview, and several limitations should be considered for production use:

Query complexity scoring — The MCP server applies complexity scoring to prevent runaway queries. Complex queries with large traversals may be rejected with a suggestion to use pagination or more specific patterns.
Tool call latency — Each MCP tool invocation incurs ~100–200ms overhead on top of the underlying database operation. For high-frequency query patterns, consider batching.
Connection persistence — MCP sessions are stateful; the server maintains a context window of recent tool calls. Long-running sessions may encounter timeout reconnection.
Preview API surface — The tool registry may expand before general availability. The list_tools endpoint ensures forward compatibility.

Conclusion

MCP for Aura represents a pragmatic convergence of two trends: the standardisation of AI-tool communication via MCP, and the recognition that knowledge graphs are a natural substrate for agentic reasoning. By turning every Aura instance into an MCP server, Neo4j eliminates the integration tax that has historically separated graph databases from the AI agent ecosystem.

For teams building agentic systems, this means you can now treat a knowledge graph as a first-class tool — query it, traverse it, search it semantically, and analyse it algorithmically — all through a single, framework-agnostic protocol. The era of custom connectors for every data source is ending. MCP for Aura is a glimpse of what comes next: a web of interoperable, knowledge-rich tools that agents can discover and compose at runtime.

Start exploring with the MCP client SDK linked from the Neo4j Aura Console, or dive into the MCP for Aura documentation (live as of July 2026).