Which integrations are available for this server?

Allows running Cypher queries and exploring graph data on a Neo4j database.

How do I use Neo4j MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Neo4j MCP Server show me the schema of the graph database" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Neo4j MCP Server

by st3v0rr

Overview Schema Related Servers Score Discussions

Python

Hybrid

🔍⁉️ Neo4j MCP Server

🌟 Overview

A Model Context Protocol (MCP) server implementation that provides database interaction and allows graph exploration capabilities through Neo4j. This server enables running Cypher graph queries, analyzing complex domain data, and automatically generating business insights that can be enhanced further with an application's analysis tools.

This MCP server facilitates Text2Cypher workflows like the one detailed below.

Blue steps are handled by the agent
Purple by the Cypher or another MCP server
Green by the user

A user question is input to the process and the output is an answer generated by the agent.

text2cypher-workflow

Related MCP server: Neo4j MCP Server

🧩 Components

🛠️ Tools

The server offers these core tools:

📊 Query Tools

read_neo4j_cypher
- Execute Cypher read queries to read data from the database
- Input:
  - query (string): The Cypher query to execute
  - params (dictionary, optional): Parameters to pass to the Cypher query
- Returns: Query results as JSON serialized array of objects
- Timeout: Read queries are subject to a configurable timeout (default: 30 seconds) to prevent long-running queries from disrupting conversational flow
write_neo4j_cypher
- Execute updating Cypher queries
- Input:
  - query (string): The Cypher update query
  - params (dictionary, optional): Parameters to pass to the Cypher query
- Returns: A JSON serialized result summary counter with { nodes_updated: number, relationships_created: number, ... }

🕸️ Schema Tools

get_neo4j_schema
- Get a list of all nodes types in the graph database, their attributes with name, type and relationships to other node types
- No input required
- Returns: JSON serialized list of node labels with two dictionaries: one for attributes and one for relationships

🏷️ Namespacing

The server supports namespacing to allow multiple Neo4j MCP servers to be used simultaneously. When a namespace is provided, all tool names are prefixed with the namespace followed by a hyphen (e.g., mydb-read_neo4j_cypher).

This is useful when you need to connect to multiple Neo4j databases or instances from the same session.

⚙️ Query Configuration

The server provides configuration options to optimize query performance and manage response sizes:

⏱️ Query Timeouts

Configure timeouts for read queries to prevent long-running queries from disrupting conversational flow:

Command Line:

mcp-neo4j-cypher --read-timeout 60  # 60 seconds

Environment Variable:

export NEO4J_READ_TIMEOUT=60

Docker:

docker run -e NEO4J_READ_TIMEOUT=60 mcp-neo4j-cypher:latest

Default: 30 seconds. Read queries that exceed this timeout will be automatically cancelled to maintain responsive interactions with AI models.

📏 Token Limits

Control the maximum size of query responses to prevent overwhelming the AI model:

Command Line:

mcp-neo4j-cypher --token-limit 4000

Environment Variable:

export NEO4J_RESPONSE_TOKEN_LIMIT=4000

Docker:

docker run -e NEO4J_RESPONSE_TOKEN_LIMIT=4000 mcp-neo4j-cypher:latest

When a response exceeds the token limit, it will be automatically truncated to fit within the specified limit using tiktoken. This ensures:

Consistent Performance: Responses stay within model context limits
Cost Control: Prevents excessive token usage in AI interactions
Reliability: Large datasets don't break the conversation flow

Note: Token limits only apply to read_neo4j_cypher responses. Schema queries and write operations return summary information and are not affected.

🏗️ Local Development & Deployment

🐳 Local Docker Development

Build and run locally for testing or remote deployment:

# Build the Docker image with a custom name from your local version of the server
docker build -t mcp-neo4j-cypher:latest .

# Run locally (uses http transport by default for Docker)
docker run -p 8000:8000 \
  -e NEO4J_URI="bolt://host.docker.internal:7687" \
  -e NEO4J_USERNAME="neo4j" \
  -e NEO4J_PASSWORD="your-password" \
  mcp-neo4j-cypher:latest

# Access the server at http://localhost:8000/api/mcp/

🚀 Transport Modes

The server supports different transport protocols depending on your deployment:

STDIO (for local development): Standard input/output for Claude Desktop and local tools
HTTP (for remote deployments): RESTful HTTP for web deployments and microservices
SSE: Server-Sent Events for legacy web-based deployments

Choose your transport based on use case:

Local development/Claude Desktop: Use stdio
Remote deployment: Use http
Legacy web clients: Use sse

🔒 Security Protection

The server includes comprehensive security protection with secure defaults that protect against common web-based attacks while preserving full MCP functionality when using HTTP transport.

🛡️ DNS Rebinding Protection

TrustedHost Middleware validates Host headers to prevent DNS rebinding attacks:

Secure by Default:

Only localhost and 127.0.0.1 hosts are allowed by default
Malicious websites cannot trick browsers into accessing your local server

Environment Variable:

export NEO4J_MCP_SERVER_ALLOWED_HOSTS="example.com,www.example.com"

🌐 CORS Protection

Cross-Origin Resource Sharing (CORS) protection blocks browser-based requests by default:

Environment Variable:

export NEO4J_MCP_SERVER_ALLOW_ORIGINS="https://example.com,https://example.com"

🔧 Complete Security Configuration

Development Setup:

mcp-neo4j-cypher --transport http \
  --allowed-hosts "localhost,127.0.0.1" \
  --allow-origins "http://localhost:3000"

Production Setup:

mcp-neo4j-cypher --transport http \
  --allowed-hosts "example.com,www.example.com" \
  --allow-origins "https://example.com,https://example.com"

🚨 Security Best Practices

For allow_origins:

Be specific: ["https://example.com", "https://example.com"]
Never use "*" in production with credentials
Use HTTPS origins in production

For allowed_hosts:

Include your actual domain: ["example.com", "www.example.com"]
Include localhost only for development
Never use "*" unless you understand the risks

🔧 Usage with Claude Desktop

Using DXT

Download the latest .dxt file from the releases page and install it with your MCP client.

💾 Released Package

Can be found on PyPi https://pypi.org/project/mcp-neo4j-cypher/

Add the server to your claude_desktop_config.json with the database connection configuration through environment variables. You may also specify the transport method, namespace and other config variables with cli arguments or environment variables.

{
  "mcpServers": {
    "neo4j-database": {
      "command": "uvx",
      "args": [ "mcp-neo4j-cypher@0.4.0", "--transport", "stdio"  ],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "<your-password>",
        "NEO4J_DATABASE": "neo4j"
      }
    }
  }
}

🌐 HTTP Transport Configuration

For custom HTTP configurations with security middleware:

# Complete HTTP configuration with security
mcp-neo4j-cypher --transport http \
  --server-host 127.0.0.1 \
  --server-port 8080 \
  --server-path /api/mcp/ \
  --allowed-hosts "localhost,127.0.0.1,example.com" \
  --allow-origins "https://yourapp.com"

# Using environment variables
export NEO4J_TRANSPORT=http
export NEO4J_MCP_SERVER_HOST=127.0.0.1
export NEO4J_MCP_SERVER_PORT=8080
export NEO4J_MCP_SERVER_PATH=/api/mcp/
export NEO4J_MCP_SERVER_ALLOWED_HOSTS="localhost,127.0.0.1,example.com"
export NEO4J_MCP_SERVER_ALLOW_ORIGINS="https://yourapp.com"
mcp-neo4j-cypher

Multiple Database Example

Here's an example of connecting to multiple Neo4j databases using namespaces:

{
  "mcpServers": {
    "movies-neo4j": {
      "command": "uvx",
      "args": ["mcp-neo4j-cypher@0.4.0", "--namespace", "movies"],
      "env": {
        "NEO4J_URI": "neo4j+s://demo.neo4jlabs.com",
        "NEO4J_USERNAME": "recommendations",
        "NEO4J_PASSWORD": "recommendations",
        "NEO4J_DATABASE": "recommendations"
      }
    },
    "local-neo4j": {
      "command": "uvx",
      "args": ["mcp-neo4j-cypher@0.4.0"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "password",
        "NEO4J_DATABASE": "neo4j",
        "NEO4J_NAMESPACE": "local"
      }
    }
  }
}

In this setup:

The movies database tools will be prefixed with movies- (e.g., movies-read_neo4j_cypher)
The local database tools will be prefixed with local- (e.g., local-get_neo4j_schema)

Syntax with --db-url, --username, --password, --read-timeout and other command line arguments is still supported but environment variables are preferred:

"mcpServers": {
  "neo4j": {
    "command": "uvx",
    "args": [
      "mcp-neo4j-cypher@0.4.0",
      "--db-url",
      "bolt://localhost",
      "--username",
      "neo4j",
      "--password",
      "<your-password>",
      "--namespace",
      "mydb",
      "--transport",
      "sse",
      "--server-host",
      "127.0.0.1",
      "--server-port",
      "8000"
      "--server-path",
      "/api/mcp/"
    ]
  }
}

🐳 Using with Docker

Here we use the Docker Hub hosted Cypher MCP server image with stdio transport for use with Claude Desktop.

Config details:

-i: Interactive mode - keeps STDIN open for stdio transport communication
--rm: Automatically remove container when it exits (cleanup)
-p 8000:8000: Port mapping - maps host port 8000 to container port 8000
NEO4J_TRANSPORT=stdio: Uses stdio transport for Claude Desktop compatibility
NEO4J_NAMESPACE=neo4j: Prefixes tools with "neo4j-" (e.g., neo4j-read_neo4j_cypher)
NEO4J_URI=bolt://host.docker.internal:7687: Allows Docker container to connect to Neo4j running on host machine

{
  "mcpServers": {
    "neo4j": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-p", 
        "8000:8000",
        "-e", "NEO4J_URI=bolt://host.docker.internal:7687",
        "-e", "NEO4J_USERNAME=neo4j",
        "-e", "NEO4J_PASSWORD=password",
        "-e", "NEO4J_NAMESPACE=neo4j",
        "-e", "NEO4J_TRANSPORT=stdio",
        "mcp/neo4j-cypher:latest"
      ]
    }
  }
}

🐳 Docker Deployment

The Neo4j MCP server can be deployed using Docker for remote deployments. Docker deployment should use HTTP transport for web accessibility. In order to integrate this deployment with applications like Claude Desktop, you will have to use a proxy in your MCP configuration such as mcp-remote.

📦 Using Your Built Image

After building locally with docker build -t mcp-neo4j-cypher:latest .:

# Run with http transport (default for Docker)
docker run --rm -p 8000:8000 \
  -e NEO4J_URI="bolt://host.docker.internal:7687" \
  -e NEO4J_USERNAME="neo4j" \
  -e NEO4J_PASSWORD="password" \
  -e NEO4J_DATABASE="neo4j" \
  -e NEO4J_TRANSPORT="http" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  -e NEO4J_MCP_SERVER_PATH="/mcp/" \
  mcp/neo4j-cypher:latest

# Run with security middleware for production
docker run --rm -p 8000:8000 \
  -e NEO4J_URI="bolt://host.docker.internal:7687" \
  -e NEO4J_USERNAME="neo4j" \
  -e NEO4J_PASSWORD="password" \
  -e NEO4J_DATABASE="neo4j" \
  -e NEO4J_TRANSPORT="http" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  -e NEO4J_MCP_SERVER_PATH="/mcp/" \
  -e NEO4J_MCP_SERVER_ALLOWED_HOSTS="example.com,www.example.com" \
  -e NEO4J_MCP_SERVER_ALLOW_ORIGINS="https://example.com" \
  mcp/neo4j-cypher:latest

🔧 Environment Variables

Variable	Default	Description
`NEO4J_URI`	`bolt://localhost:7687`	Neo4j connection URI
`NEO4J_USERNAME`	`neo4j`	Neo4j username
`NEO4J_PASSWORD`	`password`	Neo4j password
`NEO4J_DATABASE`	`neo4j`	Neo4j database name
`NEO4J_TRANSPORT`	`stdio` (local), `http` (remote)	Transport protocol (`stdio`, `http`, or `sse`)
`NEO4J_NAMESPACE`	(empty)	Tool namespace prefix
`NEO4J_MCP_SERVER_HOST`	`127.0.0.1` (local)	Host to bind to
`NEO4J_MCP_SERVER_PORT`	`8000`	Port for HTTP/SSE transport
`NEO4J_MCP_SERVER_PATH`	`/api/mcp/`	Path for accessing MCP server
`NEO4J_MCP_SERVER_ALLOW_ORIGINS`	(empty - secure by default)	Comma-separated list of allowed CORS origins
`NEO4J_MCP_SERVER_ALLOWED_HOSTS`	`localhost,127.0.0.1`	Comma-separated list of allowed hosts (DNS rebinding protection)
`NEO4J_RESPONSE_TOKEN_LIMIT`	(none)	Maximum tokens for read query responses
`NEO4J_READ_TIMEOUT`	`30`	Timeout in seconds for read queries

🌐 SSE Transport for Legacy Web Access

When using SSE transport (for legacy web clients), the server exposes an HTTP endpoint:

# Start the server with SSE transport
docker run -d -p 8000:8000 \
  -e NEO4J_URI="neo4j+s://demo.neo4jlabs.com" \
  -e NEO4J_USERNAME="recommendations" \
  -e NEO4J_PASSWORD="recommendations" \
  -e NEO4J_DATABASE="recommendations" \
  -e NEO4J_TRANSPORT="sse" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  --name neo4j-mcp-server \
  mcp-neo4j-cypher:latest

# Test the SSE endpoint
curl http://localhost:8000/sse

# Use with MCP Inspector
npx @modelcontextprotocol/inspector http://localhost:8000/sse

🐳 Docker Compose

For more complex deployments, you may use Docker Compose:

version: '3.8'

services:
  # Deploy Neo4j Database (optional)
  neo4j:
    image: neo4j:5.26.1 # or another version
    environment:
      - NEO4J_AUTH=neo4j/password
      - NEO4J_PLUGINS=["apoc"]
    ports:
      - '7474:7474' # HTTP
      - '7687:7687' # Bolt
    volumes:
      - neo4j_data:/data

  # Deploy Cypher MCP Server
  mcp-neo4j-cypher-server:
    image: mcp/neo4j-cypher:latest
    ports:
      - '8000:8000'
    environment:
      - NEO4J_URI=bolt://host.docker.internal:7687
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
      - NEO4J_DATABASE=neo4j
      - NEO4J_TRANSPORT=http
      - NEO4J_MCP_SERVER_HOST=0.0.0.0 # must be 0.0.0.0 for sse  or http transport in Docker
      - NEO4J_MCP_SERVER_PORT=8000
      - NEO4J_MCP_SERVER_PATH=/api/mcp/
      - NEO4J_NAMESPACE=local
    depends_on:
      - neo4j

volumes:
  neo4j_data:

Run with: docker-compose up -d

🔗 Claude Desktop Integration with Docker

For Claude Desktop integration with a Dockerized server using http transport:

{
  "mcpServers": {
    "neo4j-docker": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "http://localhost:8000/api/mcp/"]
    }
  }
}

Note: First start your Docker container with HTTP transport, then Claude Desktop can connect to it via the HTTP endpoint and proxy server like mcp-remote.

🚀 Development

📦 Prerequisites

Install uv:

# Using pip
pip install uv

# Using Homebrew on macOS
brew install uv

# Using cargo (Rust package manager)
cargo install uv

Clone the repository and set up development environment:

# Clone the repository
git clone https://github.com/neo4j-contrib/mcp-neo4j.git
cd mcp-neo4j-cypher

# Create and activate virtual environment using uv
uv venv
source .venv/bin/activate  # On Unix/macOS
.venv\Scripts\activate     # On Windows

# Install dependencies including dev dependencies
uv pip install -e ".[dev]"

Run Integration Tests

./tests.sh

🔧 Development Configuration

For development with Claude Desktop using the local source:

{
  "mcpServers": {
    "neo4j-dev": {
      "command": "uv",
      "args": ["--directory", "/path/to/mcp-neo4j-cypher", "run", "mcp-neo4j-cypher", "--transport", "stdio", "--namespace", "dev"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "<your-password>",
        "NEO4J_DATABASE": "neo4j"
      }
    }
  }
}

Replace /path/to/mcp-neo4j-cypher with your actual project directory path.

📄 License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

Available Tools

3 tools

get_neo4j_schemaGet Neo4j SchemaA

Read-onlyIdempotent

List all nodes, their attributes and their relationships to other nodes in the neo4j database. This requires that the APOC plugin is installed and enabled.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the 'List' verb is consistent with them. The description adds one genuinely useful behavioral fact beyond annotations: the APOC plugin dependency, which can cause runtime failure. However, it does not disclose what happens when APOC is missing or how the schema is returned.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with zero waste: the first states the action and scope, the second states the prerequisite. The main purpose is front-loaded and every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read-only tool with annotations covering the safety profile, the description covers the essentials: what is returned (nodes, attributes, relationships) and a critical prerequisite. Minor gaps include the absence of output format expectations and performance caveats for large schemas, but these are not blocking for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the description carries no burden for documenting parameter meaning. The baseline of 4 applies, and the absence of parameter-specific description is not a deficiency.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('List') with a clearly defined resource: nodes, attributes, and relationships in the Neo4j database. This conveys schema introspection as a distinct operation, though it does not explicitly differentiate itself from the sibling Cypher execution tools by name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to use this tool versus read_neo4j_cypher or write_neo4j_cypher. The APOC prerequisite is a dependency condition, not a selection directive, so the agent must infer the appropriate context on its own.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

read_neo4j_cypherRead Neo4j CypherB

Read-onlyIdempotent

Execute a read Cypher query on the neo4j database.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes	The Cypher query to execute.
`params`	No	The parameters to pass to the Cypher query.

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond restating 'read', which is already present in the annotations. It does not disclose any error behavior, result shape, or side-effect details, so it contributes no value beyond the structured metadata.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no redundant filler. It front-loads the core purpose and read-only nature. While it is minimal, it is not bloated and earns its place, though it could slightly benefit from mentioning the sibling distinction.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only Cypher execution tool with full parameter schema coverage and strong safety annotations, the description is mostly sufficient. However, it does not explain when to prefer this tool over get_neo4j_schema, nor does it mention potential limitations of read queries. Given the tool's technical complexity, a bit more context about acceptable query scope would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters: 'query' as the Cypher query to execute and 'params' as the parameters to pass. The description itself adds no additional semantic detail about parameter usage, formatting, or the relationship between query and params. Baseline 3 is appropriate because the schema carries the full burden.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description specifies a clear action ('Execute'), a clear resource ('a read Cypher query on the neo4j database'), and explicitly limits the operation to reads, distinguishing it from its write sibling. Even without opening the schema, an agent understands exactly what this tool does and that it is the read counterpart to write_neo4j_cypher.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies this tool is for read-only Cypher queries, which suggests it should not be used for mutations. However, it does not explicitly mention alternatives, exclusions, or conditions such as 'use write_neo4j_cypher for writes' or 'use get_neo4j_schema for schema introspection', so the guidance remains implicit rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

write_neo4j_cypherWrite Neo4j CypherA

Destructive

Execute a write Cypher query on the neo4j database.

ParametersJSON Schema

Name	Required	Description	Default
`query`	Yes	The Cypher query to execute.
`params`	No	The parameters to pass to the Cypher query.

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description merely repeats the write nature and adds no new behavioral context such as side effects, irreversibility, or required permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler or redundant elaboration. The core action and target are front-loaded, making it immediately scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is enough to choose and invoke the tool with query and params, but it lacks return-value expectations, side-effect warnings beyond annotations, and any usage boundary against read_neo4j_cypher. Given no output schema, a bit more context would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3. The description adds little beyond the schema's existing parameter descriptions: it names query and params but gives no extra detail about parameter syntax, injection risks, or expected format.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Execute') on a specific resource ('a write Cypher query on the neo4j database'). The 'write' qualifier clearly distinguishes this from sibling tools like read_neo4j_cypher and get_neo4j_schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The 'write' wording implies this tool is for mutating queries while read_neo4j_cypher handles reads, but there is no explicit when-to-use or when-not-to-use guidance. No alternatives are named directly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: write_neo4j_cypher for mutations, read_neo4j_cypher for queries, and get_neo4j_schema for metadata. There is no overlap or ambiguity between them.

Naming Consistency5/5

All tools follow a consistent verb_neo4j_noun pattern (write/read/get). The naming is predictable and the verb clearly indicates the operation type.

Tool Count5/5

With three tools, the server is well-scoped for its purpose: read, write, and schema introspection. Each tool covers an essential need without redundancy.

Completeness5/5

The surface covers the core operations for a Neo4j MCP server: fetching schema, executing read queries, and executing write queries. Since write Cypher can handle create, update, and delete, there are no major gaps.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

mcp COAuth
com.wix
A Model Context Protocol server for Wix AI tools
Developer Tools Content Management Systems App Automation
216
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
Grafbase
com.grafbase.api
The Grafbase MCP server sits in front of a GraphQL API and exposes an MCP protocol-compliant interface that allows AI agents and LLMs to explore and query GraphQL APIs using natural language. It provides tools to search schemas, introspect types and fields, and execute GraphQL queries while minimizing context bloat by returning only relevant schema subsets, with built-in support for authentication, authorization, and configurable access control.
API Testing Search Developer Tools
2
Cortex C
io.cortex.mcp
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
Developer Tools Monitoring Observability
312

Related MCP Servers

NebulaGraph MCP Server
Databases Knowledge & Memory Vector Databases
nebula-contrib
A
license
B
quality
C
maintenance
A Model Context Protocol server implementation that enables LLMs to interact with NebulaGraph database for graph exploration, supporting schema understanding, queries, and graph algorithms.
Updated a year ago (2025-03-17 16:04 UTC)
5
28
Apache 2.0
Neo4j MCP Server
Databases Agent Orchestration
Tobarrientos2
A
license
B
quality
D
maintenance
An implementation for managing Neo4j graph database operations through the Model Context Protocol, enabling users to execute Cypher queries against their Neo4j database via AI assistants like Cursor and Claude Desktop.
Updated a year ago (2025-03-12 02:07 UTC)
1
11
4
ISC
Memgraph MCP Serverofficial
Databases Vector Databases RAG Systems
memgraph
-
license
C
quality
Not graded
maintenance
A lightweight server implementation of the Model Context Protocol that connects Memgraph database with LLMs, allowing users to interact with graph databases through natural language.
Updated a year ago (2025-05-16 09:21 UTC)
1
25
Neo4j GraphRAG MCP Server
RAG Systems Databases Vector Databases
neo4j-field
A
license
A
quality
C
maintenance
An MCP server that enables LLMs to perform semantic and fulltext searches within Neo4j while executing complex, search-augmented Cypher queries for GraphRAG applications. It provides tools for database schema discovery and supports multi-provider embeddings to facilitate advanced graph traversals.
Updated 2 months ago (2026-07-17 09:29 UTC)
5
2
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/st3v0rr/mcp-neo4j-cypher'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

🔍⁉️ Neo4j MCP Server

🌟 Overview

🧩 Components

🛠️ Tools

📊 Query Tools

🕸️ Schema Tools

🏷️ Namespacing

⚙️ Query Configuration

⏱️ Query Timeouts

📏 Token Limits

🏗️ Local Development & Deployment

🐳 Local Docker Development

🚀 Transport Modes

🔒 Security Protection

🛡️ DNS Rebinding Protection

🌐 CORS Protection

🔧 Complete Security Configuration

🚨 Security Best Practices

🔧 Usage with Claude Desktop

Using DXT

💾 Released Package

🌐 HTTP Transport Configuration

Multiple Database Example

🐳 Using with Docker

🐳 Docker Deployment

📦 Using Your Built Image

🔧 Environment Variables

🌐 SSE Transport for Legacy Web Access

🐳 Docker Compose

🔗 Claude Desktop Integration with Docker

🚀 Development

📦 Prerequisites

🔧 Development Configuration

📄 License

Available Tools

TDQS

TDQS

TDQS

TDQS

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

NebulaGraph MCP Server

Neo4j MCP Server

Memgraph MCP Serverofficial

Neo4j GraphRAG MCP Server

Latest Blog Posts

MCP directory API