Skip to main content
Glama
mcp-server-db

mcp-server-db

mcp-server-db

npm version license node types

mcp-server-db is a universal, production-grade Model Context Protocol (MCP) server that empowers AI assistants to interact with Postgres, Redis, Elasticsearch, MySQL, MongoDB, and LDAP through a unified suite of 113+ high-performance tools.

Built with resilience in mind, it features background lazy connection management, exponential backoff retries, circuit breaker patterns, strict read-only security enforcement, and on-demand dynamic driver loading.


Why mcp-server-db?

  • Multi-Database Support: Connect to Postgres, Redis, Elasticsearch (v7, v8 & v9), MySQL, MongoDB, and LDAP directories simultaneously.

  • On-Demand Light Drivers: Zero bloat. Drivers (pg, ioredis, mongodb, mysql2, @elastic/elasticsearch, ldapts) are dynamically loaded only when a connection to that database engine is initialized.

  • Ironclad Safety: Independent per-connection read-only mode with session-level enforcement for relational databases and query result truncation guards to prevent LLM context overflows.

  • Fault-Tolerant Architecture: Server starts instantly regardless of database availability. Dead or unreachable databases fail gracefully without crashing the MCP process or blocking other connections.

  • Multi-Connection Routing: Query multiple environments (e.g., production read-only replica + local scratch cache) in parallel within the same session.


Related MCP server: Legion Database MCP Server

Supported Database Engines

Database Engine

Default Driver

Supported Versions

Key Features & Guardrails

PostgreSQL

pg (optional)

10+

Table/Index stats, Health diagnostics, Session-level read_only, Statement timeouts

Redis

ioredis (optional)

5+

Key/String/Hash/Set/List operations, Automatic 1000-item result truncation cap

Elasticsearch

@elastic/elasticsearch / es7-client

7.x, 8.x, 9.x

Dual-API version facade (v7 legacy & v8/v9 modern), Cluster health, Query DSL

MySQL / MariaDB

mysql2 (optional)

5.7+, 8.0+

DDL extraction (SHOW CREATE), Processlist management, Indexes & Triggers, Session read-only

MongoDB

mongodb (optional)

4.4+

Aggregation pipelines, Distinct queries, Index management, Execution plan explain

LDAP

ldapts (optional)

v3 directories (OpenLDAP, AD, etc.)

Search/compare, Add/modify/delete entries, Bulk entry seeding


Quick Start

1. Installation & Optional Drivers

When installed globally (npm install -g mcp-server-db) or run via npx -y mcp-server-db, npm automatically includes all supported database drivers (pg, ioredis, @elastic/elasticsearch, mysql2, mongodb, ldapts) out of the box via optionalDependencies.

# Global installation (includes all drivers out of the box)
npm install -g mcp-server-db

# Local project installation
npm install mcp-server-db

If you install mcp-server-db locally using --no-optional to keep your node_modules lightweight, you can install only the specific drivers you need:

# PostgreSQL
npm install pg

# Redis
npm install ioredis

# Elasticsearch
npm install @elastic/elasticsearch   # For v8 & v9
npm install es7-client               # For v7 legacy

# MySQL / MariaDB
npm install mysql2

# MongoDB
npm install mongodb

# LDAP
npm install ldapts

2. Zero-Install Execution via NPX

Add mcp-server-db directly to your MCP client config file (e.g. Claude Desktop, Claude Code, Gemini CLI, Cursor):

{
  "mcpServers": {
    "mcp-server-db": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "mcp-server-db"],
      "env": {
        "POSTGRES_URL": "postgresql://user:password@localhost:5432/mydb",
        "REDIS_URL": "redis://localhost:6379",
        "MONGODB_URL": "mongodb://localhost:27017",
        "LDAP_URL": "ldap://localhost:389",
        "LDAP_BIND_DN": "cn=admin,dc=example,dc=com",
        "LDAP_BIND_PASSWORD": "admin-password"
      }
    }
  }
}

3. Fast Setup with Environment Variables

Define connection strings in env to start immediately without a configuration file:

POSTGRES_URL=postgresql://user:password@localhost:5432/mydb
REDIS_URL=redis://localhost:6379
ELASTICSEARCH_URL=http://localhost:9200
MYSQL_URL=mysql://user:password@localhost:3306/mydb
MONGODB_URL=mongodb://localhost:27017
LDAP_URL=ldap://localhost:389
LDAP_BIND_DN=cn=admin,dc=example,dc=com
LDAP_BIND_PASSWORD=admin-password
POSTGRES_READ_ONLY=true
REDIS_READ_ONLY=true
MYSQL_READ_ONLY=true
MONGODB_READ_ONLY=true
LDAP_READ_ONLY=true

Complete Tools Reference (113 Tools)

System & Management Tools (2)

  • db_status: Inspect connection states (idle, connecting, connected, retrying, failed, circuit_open), read-only mode, and error logs across all configured databases. Supports filtering by connectionId (or id) to check a single database, filtering by type (postgres/redis/etc.), and active live probing (probe: true) with round-trip latency measurement.

  • db_reload_config: Hot-reload databases.config.yml from disk and reconcile connections dynamically without interrupting active queries.

Postgres Tools (30)

  • pg_query: Execute read-only SELECT queries (enforces single-statement extended query protocol).

  • pg_execute_sql: Execute write SQL statements (INSERT, UPDATE, DELETE, DDL). Blocked in read-only mode.

  • pg_list_tables: List tables in a target schema.

  • pg_describe_table: Inspect column data types, ordinal position, and nullability.

  • pg_list_schemas: List all database schemas.

  • pg_list_views: List all views in a schema.

  • pg_list_indexes: List indexes and index definitions for a table.

  • pg_list_triggers: List triggers and action statements in a schema.

  • pg_table_stats: Get total size, table size, index size, and estimated row count.

  • pg_list_constraints: List primary keys, foreign keys, and check constraints.

  • pg_explain_query: Inspect query execution plans with EXPLAIN.

  • pg_active_queries: Retrieve running non-idle queries and durations from pg_stat_activity.

  • pg_list_functions: List user-defined functions, arguments, and return types.

  • pg_list_sequences: List sequence objects in a schema.

  • pg_database_info: Get database name, current user, PostgreSQL version, and database size.

  • pg_kill_query: Terminate a running backend process by PID. Blocked in read-only mode.

  • pg_vacuum_analyze: Run VACUUM ANALYZE to update statistics and reclaim dead tuples. Blocked in read-only mode.

  • pg_list_materialized_views: List materialized views in a schema.

  • pg_refresh_materialized_view: Refresh a materialized view (supports CONCURRENTLY). Blocked in read-only mode.

  • pg_index_usage: Inspect index scan counts and tuple fetch statistics.

  • pg_lock_info: Retrieve active database locks and query durations.

  • pg_get_top_queries: Get slow queries from pg_stat_statements.

  • pg_explain_hypothetical_index: Simulate hypothetical index performance using hypopg.

  • pg_database_health: Run health audit (connections utilization, buffer cache hit ratio, dead rows, replication lag).

  • pg_sizes_overview: Breakdown storage sizes for database, tables, and indexes.

  • pg_unused_indexes: Identify zero-scan candidate indexes to drop.

  • pg_duplicate_indexes: Find overlapping or redundant indexes.

  • pg_long_running_queries: Find queries exceeding a duration threshold.

  • pg_missing_indexes: Identify high-sequential-scan tables needing indexes.

  • pg_bloat_estimate: Estimate table bloat ratio based on dead tuple count.

Redis Tools (27)

  • redis_get: Get string value at key.

  • redis_set: Set key value. Blocked in read-only mode.

  • redis_mset: Set multiple key/value pairs in a single command (e.g. for seeding). Blocked in read-only mode.

  • redis_del: Delete key. Blocked in read-only mode.

  • redis_keys: List keys matching a glob pattern (capped at 1000 items).

  • redis_ttl: Get remaining TTL in seconds.

  • redis_hget: Get hash field value.

  • redis_hset: Set hash field value. Blocked in read-only mode.

  • redis_hdel: Delete hash fields. Blocked in read-only mode.

  • redis_hgetall: Get all hash fields and values.

  • redis_hexists: Check hash field existence.

  • redis_sadd: Add member to set. Blocked in read-only mode.

  • redis_srem: Remove member from set. Blocked in read-only mode.

  • redis_smembers: List set members (capped at 1000 items).

  • redis_sismember: Test set membership.

  • redis_lpush: Prepend element to list. Blocked in read-only mode.

  • redis_rpush: Append element to list. Blocked in read-only mode.

  • redis_lpop: Remove and return first list element. Blocked in read-only mode.

  • redis_rpop: Remove and return last list element. Blocked in read-only mode.

  • redis_lrange: Get range of list elements (capped at 1000 items).

  • redis_llen: Get list length.

  • redis_exists: Check key existence.

  • redis_expire: Set key expiration in seconds. Blocked in read-only mode.

  • redis_type: Retrieve data type of key.

  • redis_incr: Increment integer key. Blocked in read-only mode.

  • redis_decr: Decrement integer key. Blocked in read-only mode.

  • redis_flushdb: Clear current Redis database. Blocked in read-only mode.

Elasticsearch Tools (11)

  • es_cluster_health: Get status (green/yellow/red), node counts, and shard metrics.

  • es_list_indices: List indices, doc counts, store size, and status.

  • es_index_stats: Get detailed metrics for a specific index.

  • es_search: Execute search using Query DSL.

  • es_count: Count documents matching a query.

  • es_get_doc: Fetch document by ID.

  • es_index_doc: Index or overwrite document. Blocked in read-only mode.

  • es_bulk_index: Index multiple documents into one index in a single _bulk request, with per-document success/failure reporting (e.g. for seeding). Blocked in read-only mode.

  • es_update_doc: Partially update document fields. Blocked in read-only mode.

  • es_delete_doc: Delete document by ID. Blocked in read-only mode.

  • es_delete_by_query: Delete documents matching Query DSL. Blocked in read-only mode.

MySQL Tools (18)

  • mysql_query: Execute read-only SELECT/SHOW/EXPLAIN queries.

  • mysql_execute_sql: Execute write SQL (INSERT, UPDATE, DELETE, DDL). Blocked in read-only mode.

  • mysql_list_databases: List databases on server.

  • mysql_list_tables: List tables in database.

  • mysql_list_views: List views and security options.

  • mysql_describe_table: Show column definitions and metadata.

  • mysql_show_create_table: Extract raw CREATE TABLE DDL statement.

  • mysql_show_create_view: Extract raw CREATE VIEW DDL statement.

  • mysql_list_indexes: Show table indexes (SHOW INDEX).

  • mysql_list_triggers: List database triggers.

  • mysql_list_routines: List stored procedures and functions.

  • mysql_list_constraints: List foreign keys and constraints.

  • mysql_table_stats: Retrieve estimated rows, data length, and index size.

  • mysql_active_queries: Retrieve running threads (SHOW FULL PROCESSLIST).

  • mysql_kill_query: Kill running process by ID. Blocked in read-only mode.

  • mysql_explain_query: Analyze query execution plan (EXPLAIN).

  • mysql_global_status: Query server global status metrics.

  • mysql_analyze_table: Run ANALYZE TABLE to refresh statistics. Blocked in read-only mode.

MongoDB Tools (19)

  • mongo_list_databases: List databases on MongoDB cluster.

  • mongo_list_collections: List collections in database.

  • mongo_find: Query documents with filter, projection, sort, limit, and skip.

  • mongo_distinct: Get unique field values.

  • mongo_aggregate: Execute MongoDB aggregation pipeline.

  • mongo_count_documents: Count documents matching filter.

  • mongo_insert_one: Insert single document. Blocked in read-only mode.

  • mongo_insert_many: Insert array of documents. Blocked in read-only mode.

  • mongo_update_one: Update single document matching filter. Blocked in read-only mode.

  • mongo_update_many: Update multiple documents. Blocked in read-only mode.

  • mongo_delete_one: Delete single document. Blocked in read-only mode.

  • mongo_delete_many: Delete multiple documents. Blocked in read-only mode.

  • mongo_create_index: Create collection index. Blocked in read-only mode.

  • mongo_drop_index: Drop collection index by name. Blocked in read-only mode.

  • mongo_list_indexes: List all collection indexes.

  • mongo_db_stats: Get database storage statistics.

  • mongo_collection_stats: Get storage, index size, and object count for collection.

  • mongo_explain: Get query planner execution plan and index scan metrics.

  • mongo_server_status: Get cluster memory, connection, and operation stats.

LDAP Tools (6)

  • ldap_search: Search a directory by base DN, filter, and scope (capped at 500 entries).

  • ldap_compare: Compare an attribute/value pair against an entry.

  • ldap_add: Create a new entry. Blocked in read-only mode.

  • ldap_add_bulk: Create multiple entries in one call (e.g. for seeding), with per-entry success/failure reporting. Blocked in read-only mode.

  • ldap_modify: Add, replace, or delete an attribute's values on an entry. Blocked in read-only mode.

  • ldap_delete: Delete an entry. Blocked in read-only mode.


Multi-Connection YAML Configuration

For complex setups with multiple named databases, create config/databases.config.yml (copy config/databases.config.example.yml):

connections:
  - id: primary-pg
    type: postgres
    connectionString: ${POSTGRES_URL}
    defaultSchema: public
    statementTimeoutMs: 30000
    readOnly: true

  - id: app-cache
    type: redis
    connectionString: ${REDIS_URL}
    readOnly: false

  - id: search-logs
    type: elasticsearch
    connectionString: ${ELASTICSEARCH_URL}
    apiVersion: "9"
    readOnly: true

  - id: legacy-cluster
    type: elasticsearch
    connectionString: ${LEGACY_ELASTICSEARCH_URL}
    apiVersion: "7"
    readOnly: true

  - id: analytics-mysql
    type: mysql
    connectionString: ${MYSQL_URL}
    statementTimeoutMs: 30000
    readOnly: true

  - id: document-store
    type: mongodb
    connectionString: ${MONGODB_URL}
    defaultDatabase: production
    readOnly: true

  - id: directory
    type: ldap
    connectionString: ${LDAP_URL}
    bindDn: ${LDAP_BIND_DN}
    bindPassword: ${LDAP_BIND_PASSWORD}
    readOnly: false

Local Development & Custom Builds

1. Build and Run Locally

git clone https://github.com/Nam088/mcp-database-server-v2.git
cd mcp-database-server
npm install
npm run build    # Compiles TypeScript to dist/
npm test         # Runs Vitest test suite

2. Configure Local Build in MCP Clients

{
  "mcpServers": {
    "mcp-server-db": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/mcp-database-server/dist/index.js"],
      "env": {
        "DATABASES_CONFIG_PATH": "/absolute/path/to/mcp-database-server/config/databases.config.yml"
      }
    }
  }
}

3. Claude Code CLI

claude mcp add --scope user mcp-server-db node /absolute/path/to/mcp-database-server/dist/index.js --env DATABASES_CONFIG_PATH=/absolute/path/to/mcp-database-server/config/databases.config.yml

Client Config Paths

  • Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Claude Code (Global): ~/.claude.json

  • Gemini CLI / IDE: ~/.gemini/config/mcp_config.json

  • Cursor / Project Root: .mcp.json


License

Distributed under the MIT License. See LICENSE for details.

Available Tools

113 tools
db_reload_configA

Reload the databases.config.yml configuration file from disk, recreate connections, and reconnect.

Inputs: no named parameters.

db_statusA

List the live connection state of every configured database (postgres/redis/elasticsearch), including state, readOnly mode, last error, and next retry time.

Inputs: no named parameters.

es_bulk_indexA

Index (create or overwrite) multiple documents into one index in a single request via the Elasticsearch _bulk API (e.g. for seeding test/sample data) — far more efficient than one es_index_doc call per document. Reports per-document success/failure rather than aborting the whole batch on one bad document. Blocked when that connection's own readOnly mode is enabled.

Inputs: index (required), documents (required), connectionId.

es_cluster_healthA

Get Elasticsearch cluster health: status (green/yellow/red), node count, and shard counts.

Inputs: connectionId.

es_countA

Count documents in an index matching a query (or all documents if no query is given).

Inputs: index (required), query, connectionId.

es_delete_by_queryB

Delete all documents in an index matching a query. Blocked when that connection's own readOnly mode is enabled.

Inputs: index (required), query (required), connectionId.

es_delete_docC

Delete a document by id. Blocked when that connection's own readOnly mode is enabled.

Inputs: id (required), index (required), connectionId.

es_get_docB

Get a document by id from an index.

Inputs: id (required), index (required), connectionId.

es_index_docA

Index (create or overwrite) a document. Blocked when that connection's own readOnly mode is enabled.

Inputs: index (required), document (required), id, connectionId.

es_index_statsA

Get stats (doc count, store size, segments) for a specific index.

Inputs: index (required), connectionId.

es_list_indicesB

List all indices with document count, size, and health status.

Inputs: connectionId.

es_update_docB

Partially update a document by id. Blocked when that connection's own readOnly mode is enabled.

Inputs: id (required), doc (required), index (required), connectionId.

ldap_addB

Create a new LDAP entry. Blocked when that connection's own readOnly mode is enabled.

Inputs: dn (required), attributes (required), connectionId.

ldap_add_bulkA

Create multiple LDAP entries in one call (e.g. for seeding test/sample data). LDAP has no native multi-entry add operation, so this adds each entry sequentially and reports per-entry success/failure rather than aborting on the first error — a bad entry never blocks the rest of the batch. Blocked when that connection's own readOnly mode is enabled.

Inputs: entries (required), connectionId.

ldap_compareB

Compare an attribute/value pair against an LDAP entry. Returns true if they match.

Inputs: dn (required), value (required), attribute (required), connectionId.

ldap_deleteB

Delete an LDAP entry. Blocked when that connection's own readOnly mode is enabled.

Inputs: dn (required), connectionId.

ldap_modifyA

Add, replace, or delete a single attribute's values on an existing LDAP entry. Blocked when that connection's own readOnly mode is enabled.

Inputs: dn (required), attribute (required), operation (required), values, +1 more.

mongo_aggregateC

Run an aggregation pipeline on a MongoDB collection.

Inputs: pipeline (required), collection (required), database, connectionId.

mongo_collection_statsB

Get detailed storage, index size, and document count statistics for a MongoDB collection.

Inputs: collection (required), database, connectionId.

mongo_count_documentsB

Count documents matching a filter in a MongoDB collection.

Inputs: collection (required), filter, database, connectionId.

mongo_create_indexA

Create an index on a MongoDB collection. Blocked when readOnly mode is enabled.

Inputs: keys (required), collection (required), name, unique, +2 more.

mongo_db_statsC

Get statistics for a MongoDB database.

Inputs: database, connectionId.

mongo_delete_manyB

Delete multiple documents matching filter in MongoDB. Blocked when readOnly mode is enabled.

Inputs: filter (required), collection (required), database, connectionId.

mongo_delete_oneA

Delete a single document matching filter in MongoDB. Blocked when readOnly mode is enabled.

Inputs: filter (required), collection (required), database, connectionId.

mongo_distinctC

Find distinct values for a specified field in a MongoDB collection.

Inputs: field (required), collection (required), filter, database, +1 more.

mongo_drop_indexA

Drop an index by name on a MongoDB collection. Blocked when readOnly mode is enabled.

Inputs: indexName (required), collection (required), database, connectionId.

mongo_explainA

Get execution plan and index scan statistics for a MongoDB find query.

Inputs: collection (required), filter, database, verbosity, +1 more.

mongo_findC

Query documents from a MongoDB collection.

Inputs: collection (required), skip, sort, limit, +4 more.

mongo_insert_manyB

Insert multiple documents into a MongoDB collection. Blocked when readOnly mode is enabled.

Inputs: documents (required), collection (required), database, connectionId.

mongo_insert_oneA

Insert a single document into a MongoDB collection. Blocked when readOnly mode is enabled.

Inputs: document (required), collection (required), database, connectionId.

mongo_list_collectionsB

List all collections in a MongoDB database.

Inputs: database, connectionId.

mongo_list_databasesB

List all databases in MongoDB.

Inputs: connectionId.

mongo_list_indexesC

List all indexes on a MongoDB collection.

Inputs: collection (required), database, connectionId.

mongo_server_statusA

Get MongoDB server status (connections, memory, uptime, operations).

Inputs: connectionId.

mongo_update_manyC

Update multiple documents matching filter in MongoDB. Blocked when readOnly mode is enabled.

Inputs: filter (required), update (required), collection (required), upsert, +2 more.

mongo_update_oneC

Update a single document matching filter in MongoDB. Blocked when readOnly mode is enabled.

Inputs: filter (required), update (required), collection (required), upsert, +2 more.

mysql_active_queriesB

List currently running queries and processes in MySQL.

Inputs: connectionId.

mysql_analyze_tableB

Analyze key distribution for a MySQL table. Blocked when readOnly mode is enabled.

Inputs: table (required), database, connectionId.

mysql_describe_tableB

Show column definitions and metadata for a MySQL table.

Inputs: table (required), database, connectionId.

mysql_execute_sqlB

Run any SQL statement (INSERT/UPDATE/DELETE/DDL) against a configured MySQL connection. Blocked when readOnly mode is enabled.

Inputs: sql (required), connectionId.

mysql_explain_queryB

Get the execution plan for a MySQL query.

Inputs: sql (required), connectionId.

mysql_global_statusC

Show server status variables in MySQL.

Inputs: filter, connectionId.

mysql_kill_queryA

Kill a running query or connection thread by ID in MySQL. Blocked when readOnly mode is enabled.

Inputs: processId (required), connectionId.

mysql_list_constraintsA

List table constraints and foreign keys in a MySQL database.

Inputs: table, database, connectionId.

mysql_list_databasesA

List all databases on a MySQL connection.

Inputs: connectionId.

mysql_list_indexesB

Show all indexes for a specified MySQL table.

Inputs: table (required), database, connectionId.

mysql_list_routinesC

List stored procedures and functions in a MySQL database.

Inputs: database, connectionId.

mysql_list_tablesB

List tables in a MySQL database.

Inputs: database, connectionId.

mysql_list_triggersC

List triggers in a MySQL database.

Inputs: database, connectionId.

mysql_list_viewsC

List views in a MySQL database.

Inputs: database, connectionId.

mysql_queryA

Run a read-only SELECT/SHOW/EXPLAIN query against a configured MySQL connection.

Inputs: sql (required), connectionId.

mysql_show_create_tableB

Get the exact CREATE TABLE DDL statement for a MySQL table.

Inputs: table (required), database, connectionId.

mysql_show_create_viewC

Get the exact CREATE VIEW DDL statement for a MySQL view.

Inputs: view (required), database, connectionId.

mysql_table_statsC

Get size, row count estimates, and index sizes for tables in a MySQL database.

Inputs: database, connectionId.

pg_active_queriesB

Get active queries currently running on the server.

Inputs: connectionId.

pg_bloat_estimateA

Estimate table and index bloat using pg_stat_user_tables statistics (dead tuples vs live tuples ratio). Returns tables where dead tuple ratio exceeds a threshold.

Inputs: schema, connectionId, min_dead_ratio_pct.

pg_database_healthB

Get a comprehensive database health report (connections, buffer cache, invalid indexes, dead rows, and replication).

Inputs: connectionId.

pg_database_infoC

Get metadata and size information about the current database.

Inputs: connectionId.

pg_describe_tableA

Describe the columns of a table in the specified schema of a configured Postgres connection.

Inputs: table (required), schema, connectionId.

pg_duplicate_indexesA

Find redundant indexes where one index's leading columns are a subset of another, making the smaller one unnecessary.

Inputs: schema, connectionId.

pg_execute_sqlA

Run any SQL statement (INSERT/UPDATE/DELETE/DDL) against a configured Postgres connection. Blocked when that connection's own readOnly mode is enabled.

Inputs: sql (required), connectionId.

pg_explain_hypothetical_indexA

Explain a query's execution plan simulating hypothetical indexes using the hypopg extension (if installed).

Inputs: sql (required), indexes (required), connectionId.

pg_explain_queryA

Run EXPLAIN on a read-only SELECT query to analyze query performance.

Inputs: sql (required), connectionId.

pg_get_top_queriesA

Get the slowest SQL queries based on execution time from pg_stat_statements (if the extension is enabled).

Inputs: limit, connectionId.

pg_index_usageA

Retrieve index usage statistics for all user tables in the specified schema.

Inputs: schema, connectionId.

pg_kill_queryB

Terminate an active query by PID. Blocked when that connection's own readOnly mode is enabled.

Inputs: pid (required), connectionId.

pg_list_constraintsA

List constraints (foreign keys, primary keys, check constraints) on a table in the specified schema.

Inputs: table (required), schema, connectionId.

pg_list_functionsA

List all user-defined functions in the specified schema.

Inputs: schema, connectionId.

pg_list_indexesB

List all indexes for a given table in the specified schema.

Inputs: table (required), schema, connectionId.

pg_list_materialized_viewsA

List all materialized views in the specified schema.

Inputs: schema, connectionId.

pg_list_schemasB

List all database schemas.

Inputs: connectionId.

pg_list_sequencesA

List all sequences in the specified schema.

Inputs: schema, connectionId.

pg_list_tablesB

List all tables in the specified schema of a configured Postgres connection.

Inputs: schema, connectionId.

pg_list_triggersB

List all triggers in the specified schema.

Inputs: schema, connectionId.

pg_list_viewsB

List all views in the specified schema.

Inputs: schema, connectionId.

pg_lock_infoB

Get active lock information from the database catalog.

Inputs: connectionId.

pg_long_running_queriesC

Find queries that have been running longer than a given threshold in seconds.

Inputs: connectionId, min_duration_seconds.

pg_missing_indexesA

Find tables that have high sequential scan counts relative to index scans, suggesting they might benefit from new indexes.

Inputs: schema, connectionId, min_seq_scans.

pg_queryA

Run a read-only SELECT query against a configured Postgres connection.

Inputs: sql (required), connectionId.

pg_refresh_materialized_viewB

Refresh a materialized view. Blocked when that connection's own readOnly mode is enabled.

Inputs: view (required), schema, concurrently, connectionId.

pg_sizes_overviewB

Get size statistics for the database and all tables/indexes in a schema.

Inputs: schema, connectionId.

pg_table_statsA

Get statistics for a given table in the specified schema, including table size, index size, and estimated row count.

Inputs: table (required), schema, connectionId.

pg_unused_indexesA

Find indexes that have never been used (zero scans since last stats reset). Great for identifying candidates to DROP to save space and reduce write overhead.

Inputs: schema, connectionId.

pg_vacuum_analyzeA

Run VACUUM ANALYZE on a table to clean dead tuples and update database statistics. Blocked when that connection's own readOnly mode is enabled.

Inputs: table (required), schema, connectionId.

redis_decrB

Decrement the integer value of a key. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), connectionId.

redis_delC

Delete a Redis key. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), connectionId.

redis_existsC

Check key existence.

Inputs: key (required), connectionId.

redis_expireB

Set a key's time to live in seconds. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), seconds (required), connectionId.

redis_flushdbA

Delete all keys from the current database. Blocked when that connection's own readOnly mode is enabled.

Inputs: connectionId.

redis_getB

Get the value stored at a Redis key.

Inputs: key (required), connectionId.

redis_hdelB

Delete one or more hash fields. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), field (required), connectionId.

redis_hexistsC

Check if a hash field exists.

Inputs: key (required), field (required), connectionId.

redis_hgetC

Get the value of a hash field.

Inputs: key (required), field (required), connectionId.

redis_hgetallA

Get all fields and values of a hash.

Inputs: key (required), connectionId.

redis_hsetB

Set the value of a hash field. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), field (required), value (required), connectionId.

redis_incrA

Increment the integer value of a key. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), connectionId.

redis_keysA

List Redis keys matching a glob pattern (e.g. 'user:*'). Capped at 1000 keys; result is truncated=true with a total count if there are more.

Inputs: pattern (required), connectionId.

redis_llenB

Get the length of a list.

Inputs: key (required), connectionId.

redis_lpopC

Remove and return the first element of a list. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), connectionId.

redis_lpushA

Prepend a value to a list. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), value (required), connectionId.

redis_lrangeB

Get a range of elements from a list. Capped at 1000 elements; result is truncated=true with a total count if there are more.

Inputs: key (required), stop (required), start (required), connectionId.

redis_msetA

Set multiple string keys to their values in a single command (e.g. for seeding test/sample data) — far more efficient than one redis_set call per key. Blocked when that connection's own readOnly mode is enabled.

Inputs: entries (required), connectionId.

redis_rpopA

Remove and return the last element of a list. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), connectionId.

redis_rpushB

Append a value to a list. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), value (required), connectionId.

redis_saddA

Add a member to a set. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), member (required), connectionId.

redis_setB

Set a Redis key to a value. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), value (required), connectionId.

redis_sismemberA

Check if a value is a member of a set.

Inputs: key (required), member (required), connectionId.

redis_smembersA

Get all members of a set. Capped at 1000 members; result is truncated=true with a total count if there are more.

Inputs: key (required), connectionId.

redis_sremB

Remove a member from a set. Blocked when that connection's own readOnly mode is enabled.

Inputs: key (required), member (required), connectionId.

redis_ttlA

Get the remaining time to live (in seconds) of a Redis key, or -1 if it has none.

Inputs: key (required), connectionId.

redis_typeC

Retrieve the internal data type of a key.

Inputs: key (required), connectionId.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 113 tools

    Disambiguation4/5

    Engine prefixes and resource-specific predicates clearly separate tools, e.g., pg_list_tables vs redis_hgetall vs mongo_find. Minor overlap exists among PostgreSQL statistics and index analysis tools (pg_table_stats vs pg_sizes_overview vs pg_database_health), but descriptions generally differentiate them.

    Naming Consistency4/5

    The overwhelming majority follow a consistent engine_verb_noun snake_case pattern, such as pg_list_tables, redis_hset, mongo_insert_one, and es_delete_doc. Exceptions like db_status (no verb) and the variation between es_bulk_index and ldap_add_bulk are minor deviations from an otherwise strong convention.

    Tool Count2/5

    At 113 tools, the surface is far beyond the typical 3-15 tool scope and overwhelms agents even though the server spans multiple database engines. The sheer number exceeds the 'too many' threshold, and the breadth would be better split into dedicated per-engine MCP servers.

    Completeness4/5

    CRUD, schema inspection, query execution, and administrative operations are thoroughly covered for PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch, and LDAP. Notable gaps include Redis sorted-set operations, Elasticsearch index creation/deletion, and Mongo drop collection/database, but these are minor relative to the very broad surface.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A universal database gateway MCP server that enables AI assistants to connect to and query multiple databases (PostgreSQL, MySQL, MariaDB, SQL Server, SQLite) with support for schema exploration, SQL execution, and secure connections via SSH tunnels.
      17 npm
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      A unified MCP server for querying and managing multiple database types (PostgreSQL, MySQL, SQL Server, etc.) via natural language through AI assistants.
      GPL 3.0
    • A
      license
      A
      quality
      D
      maintenance
      A multi-database MCP server that enables LLMs to safely interact with MySQL, PostgreSQL, SQLite, and others through a unified tool interface, with permission modes and schema resources.
      10
      15 npm
      43
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Zero-config MCP server that empowers AI agents to safely query SQL and NoSQL databases like PostgreSQL, MySQL, SQLite, MongoDB, and Redis.
      5
      47 npm
      1
      MIT