### Run Neo4j MCP Server

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/gemini-extension/GEMINI.md

After installation and setting necessary environmental variables, run this command to start the Neo4j MCP server. This should make 4 Neo4j related tools available.

```bash
gemini
```

--------------------------------

### Install uv (Universal Virtualenv)

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Install the uv package manager, a fast Python virtual environment and package installer. Choose the installation method that best suits your system.

```bash
# Using pip
pip install uv

# Using Homebrew on macOS
brew install uv

# Using cargo (Rust package manager)
cargo install uv
```

--------------------------------

### Install uv Package Manager

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Instructions for installing the uv package manager using pip, Homebrew, or cargo.

```bash
# Using pip
pip install uv
```

```bash
# Using Homebrew on macOS
brew install uv
```

```bash
# Using cargo (Rust package manager)
cargo install uv
```

--------------------------------

### List Available Example Data Models

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Use this tool to list all available pre-built domain models. The response includes counts and descriptions for each example, aiding in selection.

```python
# Tool: list_example_data_models
# Input: (none)
# Response: dict of available examples with node/relationship counts and descriptions
# Available: patient_journey, supply_chain, software_dependency,
#            oil_gas_monitoring, customer_360, fraud_aml, health_insurance_fraud
```

--------------------------------

### Get Specific Example Data Model

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Retrieve a specific pre-built data model by its name. The response includes the data model structure and a Mermaid configuration for visualization.

```python
# Tool: get_example_data_model
{"example_name": "fraud_aml"}
# Response:
# {
#   "data_model": {
#     "nodes": [Customer, Transaction, Account, Alert, ...],
#     "relationships": [INITIATED, LINKED_TO, TRIGGERED, ...]
#   },
#   "mermaid_config": "erDiagram\n  Customer {\n    STRING customerId PK\n  } ..."
# }
```

--------------------------------

### Start Server with SSE Transport using Docker

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Use this command to start the server with SSE transport enabled, binding to all interfaces and exposing port 8000. This is useful for legacy web clients.

```bash
docker run -d -p 8000:8000 \
  -e NEO4J_TRANSPORT="sse" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  --name neo4j-data-modeling-mcp-server \
  mcp-neo4j-data-modeling:latest
```

--------------------------------

### Install Neo4j MCP Extension

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/gemini-extension/GEMINI.md

Use this command to install the Neo4j MCP server extension from its GitHub repository. Ensure you have the gemini CLI installed.

```bash
gemini extensions install https://github.com/neo4j-contrib/mcp-neo4j.git
```

--------------------------------

### Start Server with SSE Transport using Docker

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Use this command to start the Neo4j Memory MCP server with SSE transport enabled. Ensure the necessary environment variables for Neo4j connection and server configuration are set.

```bash
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="neo4j" \
  -e NEO4J_TRANSPORT="sse" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  --name neo4j-memory-mcp-server \
  mcp-neo4j-memory:latest
```

--------------------------------

### Clone Repository and Set Up Development Environment

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Follow these steps to clone the repository, create a virtual environment using uv, and install project dependencies, including development tools.

```bash
# Clone the repository
git clone https://github.com/yourusername/mcp-neo4j-memory.git
cd mcp-neo4j-memory

# 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]"
```

--------------------------------

### Clone Repository and Set Up Virtual Environment

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Clone the mcp-neo4j repository, navigate to the cypher directory, and set up a virtual environment using 'uv'. Activate the environment and install project dependencies.

```bash
# 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]"
```

--------------------------------

### Install mcp-neo4j-aura-manager

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Install the Neo4j Aura Database Manager MCP Server using pip. This command is used for local installation.

```bash
pip install mcp-neo4j-aura-manager
```

--------------------------------

### Example Data Model Tools

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Tools to access and retrieve pre-built example data models for various use cases.

```APIDOC
## list_example_data_models

### Description
List all available example data models with descriptions.

### Input
None

### Returns
Dictionary with example names, descriptions, node/relationship counts, and usage instructions
```

```APIDOC
## get_example_data_model

### Description
Get an example graph data model from the available templates.

### Input
- `example_name` (str): Name of the example to load ('patient_journey', 'supply_chain', 'software_dependency', 'oil_gas_monitoring', 'customer_360', 'fraud_aml', or 'health_insurance_fraud')

### Returns
ExampleDataModelResponse containing DataModel object and Mermaid visualization configuration
```

--------------------------------

### Run Docker Container

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Run the Docker container for the mcp-neo4j-data-modeling service. This will start the server with default configurations.

```bash
docker run mcp/neo4j-data-modeling:latest
```

--------------------------------

### Install mcp-neo4j-memory

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Install the Neo4j memory MCP server package using pip.

```bash
pip install mcp-neo4j-memory
```

--------------------------------

### Example Data Models

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Retrieve pre-defined example data models for various use cases.

```APIDOC
## GET resource://examples/patient_journey_model
### Description
Get a real-world Patient Journey healthcare data model in JSON format.
### Returns
JSON DataModel for tracking patient encounters, conditions, medications, and care plans
```

```APIDOC
## GET resource://examples/supply_chain_model
### Description
Get a real-world Supply Chain data model in JSON format.
### Returns
JSON DataModel for tracking products, orders, inventory, and locations
```

```APIDOC
## GET resource://examples/software_dependency_model
### Description
Get a real-world Software Dependency Graph data model in JSON format.
### Returns
JSON DataModel for software dependency tracking with security vulnerabilities, commits, and contributor analysis
```

```APIDOC
## GET resource://examples/oil_gas_monitoring_model
### Description
Get a real-world Oil and Gas Equipment Monitoring data model in JSON format.
### Returns
JSON DataModel for industrial monitoring of oil and gas equipment, sensors, alerts, and maintenance
```

```APIDOC
## GET resource://examples/customer_360_model
### Description
Get a real-world Customer 360 data model in JSON format.
### Returns
JSON DataModel for customer relationship management with accounts, contacts, orders, tickets, and surveys
```

```APIDOC
## GET resource://examples/fraud_aml_model
### Description
Get a real-world Fraud & AML data model in JSON format.
### Returns
JSON DataModel for financial fraud detection and anti-money laundering with customers, transactions, alerts, and compliance
```

```APIDOC
## GET resource://examples/health_insurance_fraud_model
### Description
Get a real-world Health Insurance Fraud Detection data model in JSON format.
### Returns
JSON DataModel for healthcare fraud detection tracking investigations, prescriptions, executions, and beneficiary relationships
```

--------------------------------

### Legacy Syntax for mcp-neo4j-cypher Configuration

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Example of using legacy command-line arguments for mcp-neo4j-cypher configuration, though environment variables are preferred.

```json
"mcpServers": {
  "neo4j": {
    "command": "uvx",
    "args": [
      "mcp-neo4j-cypher@0.6.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",
      "/mcp/"
    ]
  }
}
```

--------------------------------

### Start Neo4j Data Modeling Server in HTTP Mode

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Launch the server using HTTP transport. Default settings use host 127.0.0.1, port 8000, and path /mcp/. Custom configurations for host, port, and path are supported.

```bash
# Basic HTTP mode (defaults: host=127.0.0.1, port=8000, path=/mcp/)
mcp-neo4j-data-modeling --transport http

# Custom HTTP configuration
mcp-neo4j-data-modeling --transport http --host 127.0.0.1 --port 8080 --path /api/mcp/

# With namespace for multi-tenant deployment
mcp-neo4j-data-modeling --transport http --namespace myapp
```

--------------------------------

### Install Azure Container Apps Extension

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/README-Cloud.md

Install the Azure Container Apps extension for the Azure CLI. This extension provides commands for managing Container Apps.

```bash
az extension add --name containerapp
```

--------------------------------

### Docker Run Command for mcp-neo4j-memory

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Example of running the mcp-neo4j-memory server using Docker, setting Neo4j connection details and other configurations via environment variables.

```json
"mcpServers": {
  "neo4j": {
    "command": "docker",
    "args": [
      "run",
      "--rm",
      "-e", "NEO4J_URL=neo4j+s://xxxx.databases.neo4j.io",
      "-e", "NEO4J_USERNAME=<your-username>",
      "-e", "NEO4J_PASSWORD=<your-password>",
      "mcp/neo4j-memory:0.4.5"
    ]
  }
}
```

--------------------------------

### Example Scenarios for Schema Sampling

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Configure schema sampling using the `NEO4J_SCHEMA_SAMPLE_SIZE` environment variable for different scenarios, from fast inspection to full database scans. Choose values based on database size and desired accuracy.

```bash
# Fast schema inspection for large databases
export NEO4J_SCHEMA_SAMPLE_SIZE=100
```

```bash
# Balanced performance and accuracy (default)
export NEO4J_SCHEMA_SAMPLE_SIZE=1000
```

```bash
# Comprehensive schema analysis
export NEO4J_SCHEMA_SAMPLE_SIZE=5000
```

```bash
# Full database scan (use with caution on large databases)
export NEO4J_SCHEMA_SAMPLE_SIZE=-1
```

--------------------------------

### Build Docker Image for Azure Container Registry

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/README-Cloud.md

Builds a Docker image for an MCP Neo4j server and prepares it for pushing to Azure Container Registry. Assumes Azure CLI is installed and logged in.

```bash
# Navigate to your chosen server directory
cd servers/mcp-neo4j-memory  # or any other server

# Build the Docker image
docker build -t mcp-neo4j-server .

# Create Azure Container Registry (if not exists)
az acr create --resource-group myResourceGroup --name myacrregistry --sku Basic
```

--------------------------------

### Build and Run Neo4j Data Modeling MCP Server with Docker (HTTP)

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Build a local Docker image and run the Neo4j Data Modeling MCP server with HTTP transport. This example configures host, port, and path, and is suitable for remote deployments.

```bash
# Run with http transport (default for Docker)
docker run --rm -p 8000:8000 \
  -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-data-modeling:latest

# Run with security middleware for production
docker run --rm -p 8000:8000 \
  -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-data-modeling:latest
```

--------------------------------

### List and Get Instance Details for Aura Databases

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Browses database instances across all tenants. Retrieve detailed status for specific instances by their IDs.

```python
# Tool: list_instances
```

--------------------------------

### Configure mcp-neo4j-data-modeling Server

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Configuration for the mcp-neo4j-data-modeling server, specifying the command and arguments for its execution. This setup operates statelessly.

```json
// claude_desktop_config.json
{
  "mcpServers": {
    "neo4j-data-modeling": {
      "command": "uvx",
      "args": ["mcp-neo4j-data-modeling@0.8.2", "--transport", "stdio"]
    }
  }
}
```

--------------------------------

### Start mcp-neo4j-memory in HTTP Transport Mode

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Run the server with HTTP transport. Defaults to host `127.0.0.1` and port `8000` with path `/mcp/`. Custom configurations for host, port, and path are supported.

```bash
mcp-neo4j-memory --transport http
```

```bash
mcp-neo4j-memory --transport http --host 127.0.0.1 --port 8080 --path /mcp/
```

--------------------------------

### Docker Run Commands for Built Aura Manager Image

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

These commands demonstrate how to run a locally built Aura Manager Docker image. The first example uses HTTP transport, while the second includes security middleware configurations for production environments, such as allowed hosts and origins.

```bash
# Build the image
docker build -t mcp-neo4j-aura-manager:<version> .

# Run with http transport (default for Docker)
docker run --rm -p 8000:8000 \
  -e NEO4J_AURA_CLIENT_ID="your-client-id" \
  -e NEO4J_AURA_CLIENT_SECRET="your-client-secret" \
  -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-aura-manager:<version>

# Run with security middleware for production
docker run --rm -p 8000:8000 \
  -e NEO4J_AURA_CLIENT_ID="your-client-id" \
  -e NEO4J_AURA_CLIENT_SECRET="your-client-secret" \
  -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-aura-manager:<version>
```

--------------------------------

### Start mcp-neo4j-cypher with HTTP Transport and Security

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Configure the Cypher server for production with HTTP transport, DNS rebinding protection, and CORS middleware. This can be done via CLI arguments or environment variables.

```bash
# Start with full security configuration for production:
mcp-neo4j-cypher --transport http \
  --server-host 0.0.0.0 \
  --server-port 8080 \
  --server-path /mcp/ \
  --allowed-hosts "example.com,www.example.com" \
  --allow-origins "https://yourapp.com"

# Or using environment variables:
export NEO4J_URI=bolt://localhost:7687
export NEO4J_USERNAME=neo4j
export NEO4J_PASSWORD=password
export NEO4J_TRANSPORT=http
export NEO4J_MCP_SERVER_HOST=0.0.0.0
export NEO4J_MCP_SERVER_PORT=8080
export NEO4J_MCP_SERVER_PATH=/mcp/
export NEO4J_MCP_SERVER_ALLOWED_HOSTS="example.com,www.example.com"
export NEO4J_MCP_SERVER_ALLOW_ORIGINS="https://yourapp.com"
mcp-neo4j-cypher
```

--------------------------------

### Environment Variables for Namespacing

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Set environment variables for client ID, client secret, and namespace to configure the manager. This is useful for automated or non-interactive setups.

```bash
export NEO4J_AURA_CLIENT_ID=your_client_id
export NEO4J_AURA_CLIENT_SECRET=your_client_secret  
export NEO4J_NAMESPACE=myapp
mcp-neo4j-aura-manager
```

--------------------------------

### Prompts

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Tools for generating prompts to guide AI agents in creating new graph data models.

```APIDOC
## create_new_data_model

### Description
Provide a structured parameterized prompt for generating a new graph data model.

### Input
- `data_context` (str): Description of the data and any specific details to focus on
- `use_cases` (str): List of use cases for the data model to address
- `desired_nodes` (str, optional): Node labels to include in the data model
- `desired_relationships` (str, optional): Relationship types to include in the data model

### Returns
Structured prompt that guides the agent through a 3-step process: analysis of sample data and examples, generation of the data model with validation, and presentation of results with visualization
```

--------------------------------

### MCP Client Configuration for Cloud Deployment

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/README-Cloud.md

Example JSON configuration for MCP clients to connect to a cloud-deployed Neo4j MCP server. This uses `mcp-remote` to proxy the connection.

```json
{
  "mcpServers": {
    "neo4j-cloud": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://your-deployment-url/api/mcp/"]
    }
  }
}
```

--------------------------------

### List and Get Tenant Details for Aura Projects

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Manages Aura tenants (projects) by listing all available projects and retrieving detailed information for a specific tenant, including instance quotas and regions.

```python
# Tool: list_tenants
# Input: (none)
# Response: list of all tenants with id, name, instance counts, etc.
```

```python
# Tool: get_tenant_details
{"tenant_id": "abc123-tenant-id"}
```

```json
# Response:
# {
#   "id": "abc123-tenant-id",
#   "name": "My Production Project",
#   "instance_configurations": [
#     {"type": "enterprise-db", "memory": [4, 8, 16, 32], "region": "us-east-1"}
#   ]
# }
```

--------------------------------

### Configure Neo4j Aura Server with Docker

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Configure the Neo4j Aura server in Claude Desktop's config file for Docker deployment. This example uses environment variables to pass credentials to the Docker container.

```json
"mcpServers": {
  "neo4j-aura": {
    "command": "docker",
    "args": [
      "run",
      "--rm",
      "-e", "NEO4J_AURA_CLIENT_ID=${NEO4J_AURA_CLIENT_ID}",
      "-e", "NEO4J_AURA_CLIENT_SECRET=${NEO4J_AURA_CLIENT_SECRET}",
      "mcp-neo4j-aura-manager:0.4.8"
    ]
  }
}
```

--------------------------------

### Run Tests

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Execute the project's test suite using the provided test script. Ensure the development environment is set up and activated.

```bash
./test.sh
```

--------------------------------

### list_instances and get_instance_details

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

List all database instances across all tenants, or retrieve detailed status for one or more specific instances by ID.

```APIDOC
## list_instances and get_instance_details

### Description
List all database instances across all tenants, or retrieve detailed status for one or more specific instances by ID.

### Tool: list_instances
Input: (none)
```

--------------------------------

### Build and Run Docker Container

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Build the Docker image for the mcp-neo4j-memory project and run it as a container. Ensure to set the NEO4J_URL, NEO4J_USERNAME, and NEO4J_PASSWORD environment variables.

```bash
# Build the image
docker build -t mcp/neo4j-memory:latest .

# Run the container
docker run -e NEO4J_URL="neo4j+s://xxxx.databases.neo4j.io" \
          -e NEO4J_USERNAME="your-username" \
          -e NEO4J_PASSWORD="your-password" \
          mcp/neo4j-memory:latest
```

--------------------------------

### Build Docker Image

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Build the Docker image for the mcp-neo4j-data-modeling service. This command should be run from the root of the project directory.

```bash
docker build -t mcp/neo4j-data-modeling:latest .
```

--------------------------------

### Start MCP Neo4j Server with SSE Transport

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Start the MCP Neo4j server in detached mode using SSE transport for legacy web clients. This configuration is suitable for remote Neo4j instances.

```bash
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
```

--------------------------------

### Build and Run Local Docker Development

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Build the Docker image locally and run it for testing or remote deployment. Configure environment variables for Neo4j connection details and expose the server port.

```bash
# 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/mcp/
```

--------------------------------

### Test SSE Endpoint

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

After starting the server with SSE transport, you can test the endpoint using curl to verify it's running and accessible.

```bash
curl http://localhost:8000/sse
```

--------------------------------

### CLI Usage with Namespace

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Use the '--namespace' flag with the CLI to prefix tool names, such as 'myapp-list_instances'. Ensure client ID and secret are provided.

```bash
# With namespace
mcp-neo4j-aura-manager --client-id <id> --client-secret <secret> --namespace myapp

# Tools become: myapp-list_instances, myapp-create_instance, etc.
```

--------------------------------

### read_graph

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Returns every entity and relationship currently stored in the knowledge graph — useful for a complete audit or context refresh at the start of a session.

```APIDOC
## read_graph

### Description
Returns every entity and relationship currently stored in the knowledge graph — useful for a complete audit or context refresh at the start of a session.

### Input
(none)

### Expected response
```json
{
  "entities": [
    {"name": "Alice Johnson", "type": "person",  "observations": [...]},
    {"name": "Neo4j",         "type": "company", "observations": [...]},
    {"name": "Bob Smith",     "type": "person",  "observations": [...]}
  ],
  "relations": [
    {"source": "Alice Johnson", "target": "Neo4j",    "relationType": "WORKS_AT"},
    {"source": "Alice Johnson", "target": "Bob Smith", "relationType": "COLLABORATES_WITH"}
  ]
}
```
```

--------------------------------

### Configure Neo4j Server in Claude Desktop (Environment Variables)

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Add the Neo4j memory server to your Claude Desktop configuration using environment variables for database connection.

```json
"mcpServers": {
  "neo4j": {
    "command": "uvx",
    "args": [ "mcp-neo4j-memory@0.4.5" ],
    "env": {
      "NEO4J_URL": "neo4j+s://xxxx.databases.neo4j.io",
      "NEO4J_USERNAME": "<your-username>",
      "NEO4J_PASSWORD": "<your-password>"
    }
  }
}
```

--------------------------------

### Login to Azure Container Registry

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/README-Cloud.md

Log in to your Azure Container Registry (ACR) using the Azure CLI. Ensure you have the Azure CLI installed and are logged in to your Azure account.

```bash
az acr login --name myacrregistry
```

--------------------------------

### Configure Neo4j Server in Claude Desktop (Direct)

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Add the Neo4j memory server to your Claude Desktop configuration using direct database connection details.

```json
"mcpServers": {
  "neo4j": {
    "command": "uvx",
    "args": [
      "mcp-neo4j-memory@0.4.5",
      "--db-url",
      "neo4j+s://xxxx.databases.neo4j.io",
      "--username",
      "<your-username>",
      "--password",
      "<your-password>"
    ]
  }
}
```

--------------------------------

### Read Entire Knowledge Graph

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Returns every entity and relationship currently stored in the knowledge graph. Useful for a complete audit or context refresh at the start of a session.

```python
# Tool: read_graph
# Input: (none)
```

```json
# Expected response:
# {
#   "entities": [
#     {"name": "Alice Johnson", "type": "person",  "observations": [...]},
#     {"name": "Neo4j",         "type": "company", "observations": [...]},
#     {"name": "Bob Smith",     "type": "person",  "observations": [...]}
#   ],
#   "relations": [
#     {"source": "Alice Johnson", "target": "Neo4j",    "relationType": "WORKS_AT"},
#     {"source": "Alice Johnson", "target": "Bob Smith", "relationType": "COLLABORATES_WITH"}
#   ]
# }
```

--------------------------------

### Docker Compose Configuration for MCP Neo4j Server

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

A Docker Compose configuration for deploying the Neo4j database and the MCP Cypher server together. This setup is useful for more complex deployments.

```yaml
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=/mcp/
      - NEO4J_NAMESPACE=local
    depends_on:
      - neo4j

volumes:
  neo4j_data:
```

--------------------------------

### create_instance

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Provisions a new Neo4j Aura database instance with specified configurations including name, memory, region, version, and optional vector optimization.

```APIDOC
## create_instance

### Description
Provisions a new Neo4j Aura database instance with specified memory, region, version, and optional vector optimization.

### Method
Tool Call

### Parameters
#### Request Body
- **tenant_id** (string) - Required - The ID of the tenant.
- **name** (string) - Required - The name for the new instance.
- **memory** (integer) - Required - The memory allocation in GB.
- **region** (string) - Required - The cloud region for the instance.
- **version** (string) - Required - The Neo4j version.
- **type** (string) - Required - The instance type (e.g., "enterprise-db").
- **vector_optimized** (boolean) - Optional - Whether to enable vector optimization.

### Response
#### Success Response
- **instance object** - Contains id, name, status, connection_url, username, and password (only shown at creation time).
```

--------------------------------

### Complete Security Configuration for Production

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Configure HTTP transport with specific allowed hosts and origins for production environments. Uses domain names and HTTPS origins.

```bash
mcp-neo4j-memory --transport http \
  --allowed-hosts "example.com,www.example.com" \
  --allow-origins "https://example.com,https://app.example.com"
```

--------------------------------

### Docker Compose Deployment for mcp-neo4j-cypher and Neo4j

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Deploy the Cypher server and a Neo4j database together using Docker Compose. This setup is suitable for local development or cloud environments, ensuring both services are linked.

```yaml
# docker-compose.yml
version: '3.8'
services:
  neo4j:
    image: neo4j:5.26.1
    environment:
      - NEO4J_AUTH=neo4j/password
      - NEO4J_PLUGINS=["apoc"]
    ports:
      - '7474:7474'  # Browser UI
      - '7687:7687'  # Bolt
    volumes:
      - neo4j_data:/data

  mcp-neo4j-cypher:
    image: mcp/neo4j-cypher:latest
    ports:
      - '8000:8000'
    environment:
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password
      - NEO4J_DATABASE=neo4j
      - NEO4J_TRANSPORT=http
      - NEO4J_MCP_SERVER_HOST=0.0.0.0
      - NEO4J_MCP_SERVER_PORT=8000
      - NEO4J_MCP_SERVER_PATH=/mcp/
    depends_on:
      - neo4j

volumes:
  neo4j_data:

# Run: docker-compose up -d
# MCP endpoint: http://localhost:8000/mcp/
```

--------------------------------

### Docker Deployment with stdio Transport for Claude Desktop

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Configure the mcp-neo4j-cypher server using the Docker Hub image with stdio transport for Claude Desktop compatibility. Includes port mapping and environment variables for Neo4j connection.

```json
{
  "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"
      ]
    }
  }
}
```

--------------------------------

### Configure Claude Desktop with Neo4j Cypher Server (STDIO)

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Connect Claude Desktop to a local Neo4j instance using the mcp-neo4j-cypher server via STDIO transport. Ensure Neo4j connection details are correctly set in the environment variables.

```json
// claude_desktop_config.json — connect to a local Neo4j instance
{
  "mcpServers": {
    "neo4j-database": {
      "command": "uvx",
      "args": ["mcp-neo4j-cypher@0.6.0", "--transport", "stdio"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "your-password",
        "NEO4J_DATABASE": "neo4j"
      }
    }
  }
}
```

--------------------------------

### Namespacing Configuration for Multi-tenant Deployments

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Configure the 'mcpServers' object to define namespaces for different tenants. This prefixes tool names, enabling distinct deployments for each tenant.

```json
{
  "mcpServers": {
    "neo4j-aura-app1": {
      "command": "uvx",
      "args": [
        "mcp-neo4j-aura-manager@0.4.8",
        "--client-id", "<your-client-id>",
        "--client-secret", "<your-client-secret>",
        "--namespace", "app1"
      ]
    },
    "neo4j-aura-app2": {
      "command": "uvx", 
      "args": [
        "mcp-neo4j-aura-manager@0.4.8",
        "--client-id", "<your-client-id>",
        "--client-secret", "<your-client-secret>",
        "--namespace", "app2"
      ]
    }
  }
}
```

--------------------------------

### Complete Security Configuration for Development

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Configure HTTP transport with specific allowed hosts and origins for development environments. This balances security with the need for local testing.

```bash
mcp-neo4j-aura-manager --transport http \
  --allowed-hosts "localhost,127.0.0.1" \
  --allow-origins "http://localhost:3000"
```

--------------------------------

### Docker Run Command for SSE Transport

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

This command starts the Aura Manager MCP server in detached mode using SSE transport. It's intended for legacy web clients and requires your Aura API credentials. The server will be accessible at http://localhost:8000/sse.

```bash
# Start the server with SSE transport
docker run -d -p 8000:8000 \
  -e NEO4J_AURA_CLIENT_ID="your-client-id" \
  -e NEO4J_AURA_CLIENT_SECRET="your-client-secret" \
  -e NEO4J_TRANSPORT="sse" \
  -e NEO4J_MCP_SERVER_HOST="0.0.0.0" \
  -e NEO4J_MCP_SERVER_PORT="8000" \
  --name neo4j-aura-mcp-server \
  mcp-neo4j-aura-manager:latest

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

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

--------------------------------

### Configure Neo4j Data Modeling Server via Environment Variables

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Set environment variables to configure the HTTP transport, host, port, path, and namespace for the Neo4j Data Modeling server.

```bash
export MCP_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_NAMESPACE=myapp
mcp-neo4j-data-modeling
```

--------------------------------

### Claude Desktop Integration with Dockerized HTTP Server

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

This configuration allows Claude Desktop to connect to a Dockerized Aura Manager MCP server running with HTTP transport. Ensure the Docker container is started first, then Claude Desktop can connect via the specified HTTP endpoint and proxy.

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

--------------------------------

### Complete Security Configuration for Development

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Configure HTTP transport with specific allowed hosts and origins for development environments. Includes localhost and a development origin.

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

--------------------------------

### Run Integration Tests

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Execute the integration tests for the project using the provided test script.

```bash
./tests.sh
```

--------------------------------

### Docker Deployment with Namespacing

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

Run the manager in a Docker container, passing namespace and authentication details via environment variables. This simplifies deployment and isolation.

```bash
docker run -e NEO4J_AURA_CLIENT_ID=<id> \
           -e NEO4J_AURA_CLIENT_SECRET=<secret> \
           -e NEO4J_NAMESPACE=myapp \
           mcp-neo4j-aura-manager
```

--------------------------------

### Run MCP Neo4j Server with Security Middleware

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Run the MCP Neo4j server using Docker with essential environment variables for production security. Ensure all necessary Neo4j and MCP server configurations are set.

```bash
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
```

--------------------------------

### Configure Namespaced Neo4j Data Modeling Servers

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Set up multiple instances of the Neo4j Data Modeling server with distinct namespaces for independent operation. Tools will be prefixed with their respective namespaces.

```json
{
  "mcpServers": {
    "neo4j-data-modeling-app1": {
      "command": "uvx",
      "args": [ "mcp-neo4j-data-modeling@0.8.2", "--transport", "stdio", "--namespace", "app1" ]
    },
    "neo4j-data-modeling-app2": {
      "command": "uvx", 
      "args": [ "mcp-neo4j-data-modeling@0.8.2", "--transport", "stdio", "--namespace", "app2" ]
    }
  }
}
```

--------------------------------

### Configure HTTP Transport via Environment Variables

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Set environment variables to configure HTTP transport, including host, port, path, and namespace for the mcp-neo4j-memory server.

```bash
export NEO4J_TRANSPORT=http
export NEO4J_MCP_SERVER_HOST=127.0.0.1
export NEO4J_MCP_SERVER_PORT=8080
export NEO4J_MCP_SERVER_PATH=/mcp/
export NEO4J_NAMESPACE=myapp
mcp-neo4j-memory
```

--------------------------------

### Run mcp-neo4j-memory Docker Image with Security Middleware

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-memory/README.md

Run a custom-built Docker image of mcp-neo4j-memory with HTTP transport and security middleware enabled for production. Configures allowed hosts and origins.

```bash
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-memory:latest
```

--------------------------------

### Create Neo4j Aura Instance

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Provisions a new Neo4j Aura database instance with specified configurations like memory, region, and version. Use this to set up new database environments.

```python
# Tool: create_instance
{
  "tenant_id": "abc123-tenant-id",
  "name": "mcp-test-instance",
  "memory": 4,
  "region": "us-east-1",
  "version": "5",
  "type": "enterprise-db",
  "vector_optimized": false
}
```

--------------------------------

### Ingest Process Documentation

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Provides documentation on the recommended process for ingesting data into Neo4j.

```APIDOC
## GET resource://neo4j_data_ingest_process
### Description
Get a detailed explanation of the recommended process for ingesting data into Neo4j using the data model.
### Returns
Markdown document explaining the ingest process
```

--------------------------------

### Development Configuration for Claude Desktop

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Configure mcpServers for local development with Claude Desktop. Ensure to replace the placeholder path with your actual project directory.

```json
{
  "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"
      }
    }
  }
}
```

--------------------------------

### Create Container Apps Environment

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/README-Cloud.md

Create a Container Apps environment, which provides a dedicated and isolated environment for running your containerized applications.

```bash
az containerapp env create \
  --name myenvironment \
  --resource-group myResourceGroup \
  --location eastus
```

--------------------------------

### Configure Neo4j Aura Manager Server

Source: https://context7.com/neo4j-contrib/mcp-neo4j/llms.txt

Sets up the Aura Manager server with necessary API credentials obtained from the Neo4j Aura console. This is a prerequisite for managing Aura resources.

```json
// claude_desktop_config.json
{
  "mcpServers": {
    "neo4j-aura": {
      "command": "uvx",
      "args": ["mcp-neo4j-aura-manager@0.4.8"],
      "env": {
        "NEO4J_AURA_CLIENT_ID": "your-client-id",
        "NEO4J_AURA_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}
```

--------------------------------

### Tenant/Project Management Tools

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cloud-aura-api/README.md

These tools allow for the management of Neo4j Aura tenants/projects, including listing all tenants and retrieving details for a specific tenant.

```APIDOC
## list_tenants

### Description
List all Neo4j Aura tenants/projects.

### Input
No input required.

### Returns
List of all tenants with their details.
```

```APIDOC
## get_tenant_details

### Description
Get details for a specific tenant/project.

### Input
- **tenant_id** (string): ID of the tenant/project to retrieve.

### Returns
Detailed information about the tenant/project.
```

--------------------------------

### Connect to Multiple Neo4j Databases with Namespaces

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-cypher/README.md

Configure connections to multiple Neo4j databases by assigning distinct namespaces. This allows for prefixing tools with the namespace, e.g., 'movies-read_neo4j_cypher'.

```json
{
  "mcpServers": {
    "movies-neo4j": {
      "command": "uvx",
      "args": ["mcp-neo4j-cypher@0.6.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.6.0"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "password",
        "NEO4J_DATABASE": "neo4j",
        "NEO4J_NAMESPACE": "local"
      }
    }
  }
}
```

--------------------------------

### Add Neo4j Data Modeling Server to Claude Desktop Config

Source: https://github.com/neo4j-contrib/mcp-neo4j/blob/main/servers/mcp-neo4j-data-modeling/README.md

Configure the `claude_desktop_config.json` to include the Neo4j Data Modeling server using stdio transport.

```json
{
  "mcpServers": {
    "neo4j-data-modeling": {
      "command": "uvx",
      "args": [ "mcp-neo4j-data-modeling@0.8.2", "--transport", "stdio" ]
    }
  }
}
```