数据库MCP连接服务器

┌──────────────┐      ┌─────────────────────────┐      ┌──────────────────┐
│              │      │                         │      │   PostgreSQL     │
│   Claude /   │◄────►│   mcp-database-server   │◄────►│   MySQL          │
│   Any LLM    │ MCP  │                         │      │   MongoDB        │
│              │      │   • Security Layer       │      │   Redis          │
│              │      │   • Rate Limiting        │      │   ... 18 more    │
└──────────────┘      │   • Audit Logging        │      └──────────────────┘
                      └─────────────────────────┘

npm install -g mcp-database-server

npm install -g pg

npm install -g mongodb

npm install -g pg mongodb redis

# Set your database details
export MCP_DB_ENGINE=postgresql
export MCP_DB_HOST=localhost
export MCP_DB_PORT=5432
export MCP_DB_DATABASE=myapp
export MCP_DB_USER=postgres
export MCP_DB_PASSWORD=mypassword

# Run the server
npx mcp-database-server

export MCP_DB_ENGINE=postgresql
export MCP_DB_URL="postgresql://postgres:mypassword@localhost:5432/myapp"

npx mcp-database-server

# Copy the example
cp config.example.json config.json

# Edit it with your details
nano config.json

# Run it
MCP_DB_CONFIG=./config.json npx mcp-database-server

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "postgresql",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "5432",
        "MCP_DB_DATABASE": "myapp",
        "MCP_DB_USER": "postgres",
        "MCP_DB_PASSWORD": "secret"
      }
    }
  }
}

# Simple: one database
claude mcp add database -- npx -y mcp-database-server

# With config file
claude mcp add database -- env MCP_DB_CONFIG=./config.json npx -y mcp-database-server

{
  "server": {
    "name": "my-databases",
    "logLevel": "info"
  },

  "connections": [
    {
      "id": "my-postgres",
      "engine": "postgresql",
      "host": "localhost",
      "port": 5432,
      "database": "myapp",
      "username": "postgres",
      "password": "secret",
      "readOnly": true
    }
  ],

  "security": {
    "sqlInjectionProtection": true,
    "allowDDL": false,
    "allowDML": true,
    "rateLimitPerMinute": 120,
    "auditLogging": true
  }
}

{
  "connections": [
    {
      "id": "app-db",
      "engine": "postgresql",
      "connectionString": "postgresql://user:pass@host:5432/myapp",
      "readOnly": true
    },
    {
      "id": "cache",
      "engine": "redis",
      "host": "localhost",
      "port": 6379
    },
    {
      "id": "analytics",
      "engine": "clickhouse",
      "host": "localhost",
      "port": 8123,
      "database": "analytics",
      "readOnly": true
    }
  ],
  "security": {
    "allowDDL": false,
    "rateLimitPerMinute": 60
  }
}

npm install -g pg

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "postgresql",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "5432",
        "MCP_DB_DATABASE": "myapp",
        "MCP_DB_USER": "postgres",
        "MCP_DB_PASSWORD": "secret",
        "MCP_DB_READ_ONLY": "true",
        "MCP_DB_SSL": "false"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "postgresql",
    "MCP_DB_URL": "postgresql://postgres:secret@localhost:5432/myapp?sslmode=require"
  }
}

{
  "connections": [{
    "id": "my-postgres",
    "engine": "postgresql",
    "host": "localhost",
    "port": 5432,
    "database": "myapp",
    "username": "postgres",
    "password": "secret",
    "readOnly": true,
    "ssl": { "enabled": false },
    "pool": { "min": 1, "max": 10 },
    "queryTimeout": 30000,
    "maxRows": 1000
  }]
}

SELECT * FROM users WHERE active = true ORDER BY created_at DESC LIMIT 10

sql:    "SELECT * FROM users WHERE age > $1 AND city = $2"
params: [25, "London"]

SELECT u.name, o.total, o.created_at
FROM users u
JOIN orders o ON o.user_id = u.id
WHERE o.total > 100
ORDER BY o.created_at DESC
LIMIT 20

SELECT
  DATE_TRUNC('month', created_at) AS month,
  COUNT(*) AS signups,
  AVG(age) AS avg_age
FROM users
GROUP BY month
ORDER BY month DESC

sql:    "INSERT INTO users (name, email, age) VALUES ($1, $2, $3)"
params: ["Alice", "alice@example.com", 30]

sql:    "UPDATE users SET active = false WHERE last_login < $1"
params: ["2024-01-01"]

npm install -g mysql2

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "mysql",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "3306",
        "MCP_DB_DATABASE": "myapp",
        "MCP_DB_USER": "root",
        "MCP_DB_PASSWORD": "secret",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "mysql",
    "MCP_DB_URL": "mysql://root:secret@localhost:3306/myapp"
  }
}

SELECT * FROM products WHERE price > 50 ORDER BY price DESC LIMIT 10

sql:    "SELECT * FROM users WHERE country = ? AND age >= ?"
params: ["India", 18]

SELECT category, COUNT(*) AS product_count, AVG(price) AS avg_price
FROM products
GROUP BY category
ORDER BY product_count DESC

npm install -g mysql2

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "mariadb",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "3306",
        "MCP_DB_DATABASE": "myapp",
        "MCP_DB_USER": "root",
        "MCP_DB_PASSWORD": "secret"
      }
    }
  }
}

sql:    "SELECT * FROM orders WHERE status = ? AND total > ?"
params: ["pending", 100]

npm install -g better-sqlite3

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "sqlite",
        "MCP_DB_DATABASE": "/path/to/your/database.db",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "sqlite",
    "MCP_DB_DATABASE": ":memory:"
  }
}

SELECT * FROM todos WHERE completed = 0 ORDER BY created_at DESC

sql:    "SELECT * FROM notes WHERE tag = ? AND archived = ?"
params: ["work", 0]

PRAGMA table_info('users')

npm install -g tedious

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "mssql",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "1433",
        "MCP_DB_DATABASE": "MyDatabase",
        "MCP_DB_USER": "sa",
        "MCP_DB_PASSWORD": "YourStrong!Passw0rd",
        "MCP_DB_SSL": "true"
      }
    }
  }
}

sql:    "SELECT TOP 10 * FROM Employees WHERE Department = @p0 AND Salary > @p1"
params: ["Engineering", 80000]

SELECT * FROM Products
ORDER BY ProductName
OFFSET 20 ROWS
FETCH NEXT 10 ROWS ONLY

npm install -g oracledb

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "oracle",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "1521",
        "MCP_DB_DATABASE": "ORCL",
        "MCP_DB_USER": "hr",
        "MCP_DB_PASSWORD": "secret"
      }
    }
  }
}

sql:    "SELECT * FROM employees WHERE department_id = :1 AND salary > :2"
params: [60, 5000]

npm install -g pg

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "cockroachdb",
        "MCP_DB_URL": "postgresql://user:pass@localhost:26257/defaultdb?sslmode=verify-full",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

sql:    "SELECT * FROM accounts WHERE balance > $1"
params: [1000]

npm install -g pg

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "neon",
        "MCP_DB_URL": "postgresql://user:pass@ep-cool-name-123456.us-east-2.aws.neon.tech/neondb?sslmode=require",
        "MCP_DB_SSL": "true",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

npm install -g pg

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "supabase",
        "MCP_DB_URL": "postgresql://postgres.xxxxxxxxxxxx:YOUR-PASSWORD@aws-0-us-east-1.pooler.supabase.com:6543/postgres",
        "MCP_DB_SSL": "true",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

npm install -g mysql2

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "planetscale",
        "MCP_DB_HOST": "aws.connect.psdb.cloud",
        "MCP_DB_USER": "xxxxxxxxxx",
        "MCP_DB_PASSWORD": "pscale_pw_xxxxxxxx",
        "MCP_DB_DATABASE": "mydb",
        "MCP_DB_SSL": "true",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

sql:    "SELECT * FROM orders WHERE status = ?"
params: ["shipped"]

npm install -g mysql2

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "tidb",
        "MCP_DB_HOST": "gateway01.us-east-1.prod.aws.tidbcloud.com",
        "MCP_DB_PORT": "4000",
        "MCP_DB_DATABASE": "mydb",
        "MCP_DB_USER": "root",
        "MCP_DB_PASSWORD": "secret",
        "MCP_DB_SSL": "true"
      }
    }
  }
}

npm install -g mysql2

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "singlestore",
        "MCP_DB_HOST": "svc-xxxxxxxxxx.svc.singlestore.com",
        "MCP_DB_PORT": "3306",
        "MCP_DB_DATABASE": "mydb",
        "MCP_DB_USER": "admin",
        "MCP_DB_PASSWORD": "secret",
        "MCP_DB_SSL": "true"
      }
    }
  }
}

npm install -g mongodb

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "mongodb",
        "MCP_DB_URL": "mongodb://localhost:27017/myapp",
        "MCP_DB_DATABASE": "myapp",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "mongodb",
    "MCP_DB_URL": "mongodb+srv://user:pass@cluster0.xxxxx.mongodb.net/myapp?retryWrites=true&w=majority",
    "MCP_DB_DATABASE": "myapp"
  }
}

{
  "collection": "name_of_collection",
  "operation": "find|findOne|aggregate|insertOne|...",
  "filter": {},
  "projection": {},
  "sort": {},
  "limit": 100
}

{
  "collection": "users",
  "operation": "find",
  "filter": {},
  "limit": 50
}

{
  "collection": "users",
  "operation": "find",
  "filter": { "age": { "$gt": 25 }, "city": "Mumbai" },
  "projection": { "name": 1, "email": 1 },
  "sort": { "name": 1 },
  "limit": 20
}

{
  "collection": "users",
  "operation": "findOne",
  "filter": { "email": "alice@example.com" }
}

{
  "collection": "orders",
  "operation": "countDocuments",
  "filter": { "status": "pending" }
}

{
  "collection": "orders",
  "operation": "aggregate",
  "pipeline": [
    { "$match": { "status": "completed" } },
    { "$group": { "_id": "$product", "total": { "$sum": "$amount" } } },
    { "$sort": { "total": -1 } },
    { "$limit": 10 }
  ]
}

{
  "collection": "users",
  "operation": "distinct",
  "field": "country"
}

{
  "collection": "users",
  "operation": "insertOne",
  "document": { "name": "Alice", "email": "alice@example.com", "age": 30 }
}

{
  "collection": "products",
  "operation": "insertMany",
  "documents": [
    { "name": "Widget A", "price": 9.99 },
    { "name": "Widget B", "price": 19.99 }
  ]
}

{
  "collection": "users",
  "operation": "updateOne",
  "filter": { "email": "alice@example.com" },
  "update": { "$set": { "age": 31, "updatedAt": "2024-06-01" } }
}

{
  "collection": "users",
  "operation": "updateMany",
  "filter": { "active": false },
  "update": { "$set": { "archived": true } }
}

{
  "collection": "users",
  "operation": "deleteOne",
  "filter": { "email": "bob@example.com" }
}

{
  "collection": "logs",
  "operation": "deleteMany",
  "filter": { "createdAt": { "$lt": "2024-01-01" } }
}

npm install -g redis

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "redis",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "6379"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "redis",
    "MCP_DB_URL": "rediss://default:your_password@redis-12345.c1.us-east-1-2.ec2.redns.redis-cloud.com:12345",
    "MCP_DB_SSL": "true"
  }
}

GET user:1001

SET user:1001 "Alice"

SET session:abc123 "token_data" EX 60

HGETALL user:1001

HSET user:1001 name "Alice" age "30" city "Mumbai"

KEYS user:*

DEL user:1001

LRANGE myqueue 0 -1

INCR page:views:homepage

TYPE user:1001

TTL session:abc123

{ "command": "HGETALL", "args": ["user:1001"] }

{ "command": "SET", "args": ["greeting", "hello world"] }

npm install -g cassandra-driver

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "cassandra",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "9042",
        "MCP_DB_DATABASE": "my_keyspace",
        "MCP_DB_USER": "cassandra",
        "MCP_DB_PASSWORD": "cassandra"
      }
    }
  }
}

{
  "connections": [{
    "id": "my-cassandra",
    "engine": "cassandra",
    "host": "node1.example.com,node2.example.com",
    "port": 9042,
    "database": "my_keyspace",
    "username": "admin",
    "password": "secret",
    "options": { "datacenter": "us-east-1" }
  }]
}

sql:    "SELECT * FROM users WHERE user_id = ? LIMIT 10"
params: ["user-abc-123"]

sql:    "SELECT * FROM events WHERE partition_key = ? AND event_time > ? ALLOW FILTERING"
params: ["sensor-01", "2024-06-01T00:00:00Z"]

npm install -g @clickhouse/client

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "clickhouse",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "8123",
        "MCP_DB_DATABASE": "analytics",
        "MCP_DB_USER": "default",
        "MCP_DB_PASSWORD": "",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "clickhouse",
    "MCP_DB_URL": "https://xxxx.clickhouse.cloud:8443",
    "MCP_DB_USER": "default",
    "MCP_DB_PASSWORD": "your-password",
    "MCP_DB_DATABASE": "default",
    "MCP_DB_SSL": "true"
  }
}

SELECT
  toDate(timestamp) AS day,
  count() AS events,
  uniq(user_id) AS unique_users
FROM events
WHERE timestamp >= now() - INTERVAL 7 DAY
GROUP BY day
ORDER BY day DESC

SELECT
  country,
  count() AS users,
  avg(session_duration) AS avg_duration
FROM user_sessions
GROUP BY country
ORDER BY users DESC
LIMIT 20

npm install -g neo4j-driver

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "neo4j",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "7687",
        "MCP_DB_DATABASE": "neo4j",
        "MCP_DB_USER": "neo4j",
        "MCP_DB_PASSWORD": "password"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "neo4j",
    "MCP_DB_URL": "neo4j+s://xxxx.databases.neo4j.io",
    "MCP_DB_USER": "neo4j",
    "MCP_DB_PASSWORD": "your-password",
    "MCP_DB_SSL": "true"
  }
}

MATCH (p:Person) RETURN p.name, p.age LIMIT 20

sql:    "MATCH (p:Person {name: $p0})-[:FRIENDS_WITH]->(friend) RETURN friend.name, friend.age"
params: ["Alice"]

sql:    "MATCH path = shortestPath((a:Person {name: $p0})-[:FRIENDS_WITH*]-(b:Person {name: $p1})) RETURN path"
params: ["Alice", "Bob"]

sql:    "MATCH (p:Person)-[:WORKS_AT]->(c:Company {name: $p0}) RETURN p.name, p.role, p.since ORDER BY p.since DESC"
params: ["Acme Corp"]

MATCH (p:Person)-[r]->(other)
RETURN type(r) AS relationship, count(r) AS count
ORDER BY count DESC

sql:    "MATCH (me:Person {name: $p0})-[:FRIENDS_WITH]->(friend)-[:FRIENDS_WITH]->(suggestion) WHERE NOT (me)-[:FRIENDS_WITH]->(suggestion) AND suggestion <> me RETURN suggestion.name, count(friend) AS mutual_friends ORDER BY mutual_friends DESC LIMIT 10"
params: ["Alice"]

npm install -g @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "dynamodb",
        "MCP_DB_REGION": "us-east-1",
        "MCP_DB_READ_ONLY": "true",
        "AWS_ACCESS_KEY_ID": "your-access-key",
        "AWS_SECRET_ACCESS_KEY": "your-secret-key"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "dynamodb",
    "MCP_DB_HOST": "localhost",
    "MCP_DB_PORT": "8000",
    "MCP_DB_REGION": "us-east-1",
    "MCP_DB_USER": "fakeAccessKey",
    "MCP_DB_PASSWORD": "fakeSecretKey"
  }
}

{
  "operation": "scan",
  "table": "Users",
  "limit": 50
}

{
  "operation": "scan",
  "table": "Users",
  "filter": "age > :minAge AND city = :city",
  "attributeValues": { ":minAge": 25, ":city": "London" },
  "limit": 50
}

{
  "operation": "query",
  "table": "Orders",
  "keyCondition": "userId = :uid",
  "attributeValues": { ":uid": "user-123" },
  "limit": 20
}

{
  "operation": "query",
  "table": "Events",
  "keyCondition": "deviceId = :did AND eventTime BETWEEN :start AND :end",
  "attributeValues": {
    ":did": "sensor-01",
    ":start": "2024-06-01T00:00:00Z",
    ":end": "2024-06-30T23:59:59Z"
  },
  "scanForward": false
}

{
  "operation": "getItem",
  "table": "Users",
  "key": { "userId": "user-123" }
}

{
  "operation": "putItem",
  "table": "Users",
  "item": {
    "userId": "user-456",
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30
  }
}

{
  "operation": "updateItem",
  "table": "Users",
  "key": { "userId": "user-123" },
  "updateExpression": "SET #n = :name, age = :age",
  "attributeNames": { "#n": "name" },
  "attributeValues": { ":name": "Alice Updated", ":age": 31 }
}

{
  "operation": "deleteItem",
  "table": "Users",
  "key": { "userId": "user-456" }
}

npm install -g @elastic/elasticsearch

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "elasticsearch",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "9200",
        "MCP_DB_USER": "elastic",
        "MCP_DB_PASSWORD": "changeme",
        "MCP_DB_READ_ONLY": "true"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "elasticsearch",
    "MCP_DB_URL": "https://my-deployment.es.us-east-1.aws.found.io:9243",
    "MCP_DB_USER": "elastic",
    "MCP_DB_PASSWORD": "your-password",
    "MCP_DB_SSL": "true"
  }
}

SELECT title, author, published_date FROM articles WHERE match(title, 'machine learning') LIMIT 10

SELECT category, COUNT(*) AS count FROM products GROUP BY category ORDER BY count DESC

{
  "operation": "search",
  "index": "articles",
  "body": {
    "query": { "match": { "title": "machine learning" } }
  },
  "size": 10
}

{
  "operation": "search",
  "index": "articles",
  "body": {
    "query": {
      "multi_match": {
        "query": "database performance",
        "fields": ["title", "body", "tags"]
      }
    }
  },
  "size": 20
}

{
  "operation": "search",
  "index": "products",
  "body": {
    "query": {
      "bool": {
        "must": { "match": { "name": "laptop" } },
        "filter": [
          { "range": { "price": { "gte": 500, "lte": 2000 } } },
          { "term": { "in_stock": true } }
        ]
      }
    }
  },
  "sort": [{ "price": "asc" }],
  "size": 20
}

{
  "operation": "aggregate",
  "index": "logs",
  "aggs": {
    "status_codes": {
      "terms": { "field": "status_code" }
    },
    "avg_response_time": {
      "avg": { "field": "response_time_ms" }
    }
  }
}

{
  "operation": "index",
  "index": "articles",
  "document": {
    "title": "Getting Started with MCP",
    "body": "This is a guide...",
    "tags": ["mcp", "ai", "databases"],
    "published": "2024-06-01"
  }
}

npm install -g nano

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "couchdb",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "5984",
        "MCP_DB_DATABASE": "mydb",
        "MCP_DB_USER": "admin",
        "MCP_DB_PASSWORD": "password"
      }
    }
  }
}

{
  "operation": "find",
  "selector": { "type": "article", "published": true },
  "fields": ["title", "author", "date"],
  "sort": [{ "date": "desc" }],
  "limit": 20
}

{
  "operation": "get",
  "id": "article-12345"
}

{
  "operation": "allDocs",
  "includeDocs": true,
  "limit": 50
}

{
  "operation": "insert",
  "document": {
    "type": "article",
    "title": "Hello World",
    "body": "This is my first post",
    "published": true
  }
}

{
  "operation": "delete",
  "id": "article-12345",
  "rev": "1-abc123"
}

{
  "operation": "view",
  "designDoc": "articles",
  "viewName": "by_date",
  "params": { "descending": true, "limit": 10 }
}

npm install -g @influxdata/influxdb-client

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "influxdb",
        "MCP_DB_HOST": "localhost",
        "MCP_DB_PORT": "8086",
        "MCP_DB_DATABASE": "my-bucket",
        "MCP_DB_USER": "my-org",
        "MCP_DB_PASSWORD": "your-influxdb-token"
      }
    }
  }
}

{
  "env": {
    "MCP_DB_ENGINE": "influxdb",
    "MCP_DB_URL": "https://us-east-1-1.aws.cloud2.influxdata.com",
    "MCP_DB_DATABASE": "my-bucket",
    "MCP_DB_USER": "my-org",
    "MCP_DB_PASSWORD": "your-api-token"
  }
}

from(bucket: "my-bucket")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "cpu")
  |> filter(fn: (r) => r._field == "usage_percent")

from(bucket: "my-bucket")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "cpu")
  |> filter(fn: (r) => r._field == "usage_percent")
  |> group(columns: ["host"])
  |> mean()

from(bucket: "iot-data")
  |> range(start: -7d)
  |> filter(fn: (r) => r._measurement == "temperature")
  |> group(columns: ["device_id"])
  |> max()
  |> sort(columns: ["_value"], desc: true)

from(bucket: "metrics")
  |> range(start: -30d)
  |> filter(fn: (r) => r._measurement == "memory")
  |> aggregateWindow(every: 1h, fn: mean)

npm install -g firebase-admin

{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "mcp-database-server"],
      "env": {
        "MCP_DB_ENGINE": "firestore",
        "MCP_DB_PROJECT_ID": "my-firebase-project",
        "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/service-account-key.json"
      }
    }
  }
}

{
  "connections": [{
    "id": "my-firestore",
    "engine": "firestore",
    "projectId": "my-firebase-project",
    "serviceAccountKeyPath": "/path/to/service-account-key.json"
  }]
}

{
  "operation": "list",
  "collection": "users",
  "limit": 50,
  "orderBy": "name"
}

{
  "operation": "get",
  "collection": "users",
  "id": "user-abc-123"
}

{
  "operation": "query",
  "collection": "users",
  "where": [
    { "field": "age", "op": ">=", "value": 18 },
    { "field": "active", "op": "==", "value": true }
  ],
  "orderBy": "name",
  "limit": 20
}

{
  "operation": "add",
  "collection": "users",
  "data": {
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30,
    "active": true
  }
}

{
  "operation": "set",
  "collection": "users",
  "id": "user-abc-123",
  "data": { "name": "Alice", "email": "alice@example.com" },
  "merge": true
}

{
  "operation": "update",
  "collection": "users",
  "id": "user-abc-123",
  "data": { "age": 31, "lastLogin": "2024-06-01" }
}

{
  "operation": "delete",
  "collection": "users",
  "id": "user-abc-123"
}

{
  "security": {
    "sqlInjectionProtection": true,
    "nosqlInjectionProtection": true,
    "maxQueryLength": 10000,
    "blockedKeywords": ["TRUNCATE", "DROP DATABASE", "DROP TABLE", "GRANT", "REVOKE"],
    "blockedSchemas": ["information_schema", "pg_catalog", "sys", "mysql", "performance_schema"],
    "allowDDL": false,
    "allowDML": false,
    "auditLogging": true,
    "rateLimitPerMinute": 30,
    "maxConnections": 5,
    "enforceParameterizedQueries": true
  }
}

MCP_DB_0_ENGINE=postgresql
MCP_DB_0_ID=app-db
MCP_DB_0_URL=postgresql://...

MCP_DB_1_ENGINE=redis
MCP_DB_1_ID=cache
MCP_DB_1_HOST=localhost
MCP_DB_1_PORT=6379

# Up to MCP_DB_19 (20 connections)

# Install the driver for your database globally
npm install -g pg          # for PostgreSQL
npm install -g mysql2      # for MySQL
npm install -g mongodb     # for MongoDB
# etc.

# BAD (will be blocked):
sql: "SELECT * FROM users WHERE name = 'Alice'; DROP TABLE users;--'"

# GOOD (use params):
sql:    "SELECT * FROM users WHERE name = $1"
params: ["Alice"]

# 1. Make sure you're logged in to npm
npm login

# 2. Update the "name" field in package.json to your preferred name
#    e.g., "name": "my-mcp-database-server"

# 3. Build the project
npm run build

# 4. Test it locally first
node dist/index.js

# 5. Publish!
npm publish --access public

# 6. If using a scope (e.g., @myorg/mcp-database-server)
npm publish --access public

src/
├── index.ts                    # Main entry — MCP server, all 12 tools
├── types/
│   ├── index.ts                # TypeScript types for everything
│   └── declarations.d.ts       # Module declarations for untyped drivers
├── adapters/
│   ├── base.ts                 # Abstract base class all adapters extend
│   ├── index.ts                # Factory + engine registry (22 engines)
│   ├── postgresql.ts           # PostgreSQL / CockroachDB / Neon / Supabase
│   ├── mysql.ts                # MySQL / MariaDB / PlanetScale / TiDB / SingleStore
│   ├── sqlite.ts               # SQLite (file-based)
│   ├── mongodb.ts              # MongoDB (document store)
│   ├── redis.ts                # Redis (key-value)
│   ├── mssql.ts                # Microsoft SQL Server
│   ├── oracle.ts               # Oracle Database
│   ├── cassandra.ts            # Cassandra / ScyllaDB
│   ├── clickhouse.ts           # ClickHouse (analytics)
│   ├── neo4j.ts                # Neo4j (graph)
│   ├── dynamodb.ts             # AWS DynamoDB
│   ├── elasticsearch.ts        # Elasticsearch / OpenSearch
│   ├── couchdb.ts              # Apache CouchDB
│   ├── influxdb.ts             # InfluxDB (time series)
│   └── firestore.ts            # Google Cloud Firestore
├── security/
│   └── index.ts                # SQL/NoSQL injection, rate limiter, audit logger
└── utils/
    └── config.ts               # Config loader (files, env vars, CLI args)