Servidor MCP de bases de datos múltiples

Un servidor MCP (Model Context Protocol) que proporciona herramientas para acceder a múltiples bases de datos simultáneamente. El servidor se ejecuta en Docker y admite la consulta de múltiples bases de datos de diferentes tipos en paralelo. Este servidor se inspiró en la necesidad de comparar bases de datos o facilitar migraciones.

Características

• Múltiples tipos de bases de datos: Soporte para PostgreSQL, MySQL/MariaDB, SQL Server y SQLite

• Soporte para múltiples bases de datos: Conéctese y consulte múltiples bases de datos simultáneamente (incluso de diferentes tipos)

• Consultas en paralelo: Ejecute la misma consulta en varias bases de datos a la vez

• Exploración de esquemas: Liste bases de datos, esquemas, tablas y describa estructuras de tablas

• Dockerizado: Se ejecuta en un contenedor Docker para una fácil implementación

• Agrupación de conexiones (Connection Pooling): Gestión eficiente de conexiones para todos los tipos de bases de datos

• Configuración flexible: Organice las bases de datos por tipo

Related MCP server: Universal SQL MCP Server

Herramientas disponibles

1. list_databases - Lista todas las conexiones de bases de datos configuradas

2. query_database - Ejecuta una consulta SQL en una base de datos específica

3. list_tables - Lista todas las tablas en un esquema de base de datos

4. describe_table - Obtiene información detallada del esquema de una tabla

5. list_schemas - Lista todos los esquemas en una base de datos

6. query_multiple_databases - Ejecuta la misma consulta en múltiples bases de datos simultáneamente

Configuración

1. Crear la configuración de la base de datos

Copie el archivo de configuración de ejemplo y edítelo con sus credenciales de base de datos:

cp databases.json.example databases.json

Edite databases.json con los detalles de conexión de su base de datos. Organice las bases de datos por tipo en el nivel raíz:

{
  "postgresql": {
    "postgres_db": {
      "host": "localhost",
      "port": 5432,
      "user": "postgres",
      "password": "your_password",
      "database": "database1"
    },
    "another_postgres": {
      "host": "remote.example.com",
      "port": 5432,
      "user": "admin",
      "password": "secret",
      "database": "production"
    }
  },
  "mysql": {
    "mysql_db": {
      "host": "localhost",
      "port": 3306,
      "user": "root",
      "password": "your_password",
      "database": "mydatabase"
    }
  },
  "sqlserver": {
    "sqlserver_db": {
      "host": "localhost",
      "port": 1433,
      "user": "sa",
      "password": "your_password",
      "database": "MyDatabase"
    }
  },
  "sqlite": {
    "sqlite_db": {
      "database": "/path/to/database.db"
    }
  },
  "clickhouse": {
    "clickhouse_db": {
      "host": "localhost",
      "port": 8123,
      "user": "default",
      "password": "",
      "database": "default"
    }
  }
}

Tipos de bases de datos compatibles

• PostgreSQL ("postgresql", "postgres" o "pg")

• MySQL/MariaDB ("mysql" o "mariadb")

• SQL Server ("sqlserver", "mssql" o "sql server")

• SQLite ("sqlite" o "sqlite3")

• ClickHouse ("clickhouse" o "ch")

2. Construir y ejecutar con Docker Compose

docker-compose up --build

3. Construir y ejecutar con Docker

# Build the image
docker build -t multidb-mcp-server .

# Run the container
docker run -it \
  -v $(pwd)/databases.json:/app/databases.json:ro \
  multidb-mcp-server

4. Consejos de conexión en Docker

Al configurar conexiones de bases de datos desde dentro de Docker, tenga en cuenta estos consejos:

Conexiones de red (PostgreSQL, MySQL, SQL Server)

• Acceso a bases de datos en la máquina host: Use host.docker.internal como nombre de host (Windows/Mac) o 172.17.0.1 (Linux)

• Acceso a otros contenedores: Use el nombre del contenedor o el nombre del servicio desde docker-compose.yml

• Acceso a bases de datos remotas: Use el nombre de host real o la dirección IP

Ejemplo para acceder a PostgreSQL en la máquina host:

{
  "postgresql": {
    "local_db": {
      "host": "host.docker.internal",
      "port": 5432,
      "user": "postgres",
      "password": "password",
      "database": "mydb"
    }
  }
}

Ejemplo para acceder a una base de datos en otro contenedor Docker:

{
  "postgresql": {
    "container_db": {
      "host": "postgres-container",
      "port": 5432,
      "user": "postgres",
      "password": "password",
      "database": "mydb"
    }
  }
}

Ejemplo para acceder a SQL Server en la máquina host:

{
  "sqlserver": {
    "sqlserver_db": {
      "host": "host.docker.internal",
      "port": 1433,
      "user": "sa",
      "password": "password",
      "database": "MyDatabase"
    }
  }
}

Nota para SQL Server: Asegúrese de que SQL Server esté configurado para aceptar conexiones TCP/IP y que el servicio SQL Server Browser esté ejecutándose si utiliza instancias con nombre. El puerto predeterminado es 1433.

Rutas de archivo (SQLite)

• Bases de datos SQLite en el host: Monte el directorio que contiene el archivo de la base de datos como un volumen y use la ruta del contenedor

• Bases de datos SQLite en el contenedor: Use rutas absolutas dentro del contenedor

Ejemplo de comando de ejecución de Docker con volumen SQLite:

docker run -it \
  -v $(pwd)/databases.json:/app/databases.json:ro \
  -v $(pwd)/data:/app/data:ro \
  multidb-mcp-server

Ejemplo de configuración de SQLite:

{
  "sqlite": {
    "local_db": {
      "database": "/app/data/mydatabase.db"
    }
  }
}

Nota: La ruta /app/data/mydatabase.db es la ruta dentro del contenedor, que se asigna a ./data/mydatabase.db en su máquina host a través del montaje de volumen.

Uso

El servidor se comunica a través de stdio utilizando el protocolo MCP. Conecte su cliente MCP a los flujos stdio del contenedor Docker.

Ejemplo de configuración del cliente MCP

Si lo utiliza con un cliente MCP, configúrelo para conectarse al contenedor Docker:

{
  "mcpServers": {
    "multidb": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-v",
        "[YOUR/PATH]/databases.json:/app/databases.json:ro",
        "multidb-mcp-server"
      ]
    }
  }
}

Ejemplos de herramientas

Listar todas las bases de datos

{
  "tool": "list_databases",
  "arguments": {}
}

Consultar una sola base de datos

{
  "tool": "query_database",
  "arguments": {
    "database_name": "db1",
    "query": "SELECT * FROM users LIMIT 10"
  }
}

Listar tablas

{
  "tool": "list_tables",
  "arguments": {
    "database_name": "db1",
    "schema": "public"
  }
}

Describir una tabla

{
  "tool": "describe_table",
  "arguments": {
    "database_name": "db1",
    "table_name": "users",
    "schema": "public"
  }
}

Consultar múltiples bases de datos simultáneamente

Puede consultar múltiples bases de datos de diferentes tipos simultáneamente:

{
  "tool": "query_multiple_databases",
  "arguments": {
    "database_names": ["db1", "db2", "sqlserver_db"],
    "query": "SELECT COUNT(*) as total FROM users"
  }
}

Nota: Al consultar múltiples bases de datos de diferentes tipos, asegúrese de que la sintaxis SQL sea compatible en todos los tipos de bases de datos, o utilice consultas específicas para cada base de datos por separado.

Desarrollo

Desarrollo local (sin Docker)

1. Instale las dependencias:

pip install -r requirements.txt

2. Establezca la variable de entorno:

export DB_CONFIG_PATH=./databases.json

3. Ejecute el servidor:

python server.py

Notas específicas de la base de datos

PostgreSQL

• Puerto predeterminado: 5432

• Esquema predeterminado: public

• Utiliza asyncpg para operaciones asíncronas

MySQL/MariaDB

• Puerto predeterminado: 3306

• El parámetro de esquema es opcional (utiliza la base de datos actual)

• Utiliza aiomysql para operaciones asíncronas

SQL Server

• Puerto predeterminado: 1433

• Esquema predeterminado: dbo

• Requiere el controlador Microsoft ODBC para SQL Server (se prefiere v18, v17 también es compatible; instalado en la imagen de Docker)

• Utiliza pyodbc con envoltorio asyncio

• Importante: SQL Server debe estar configurado para aceptar conexiones TCP/IP

• Para instancias con nombre, asegúrese de que el servicio SQL Server Browser esté ejecutándose

• Use host.docker.internal para conectarse a SQL Server en la máquina host desde Docker

SQLite

• No requiere conexión de red

• Use el campo database para especificar la ruta del archivo (o :memory: para memoria)

• Esquema predeterminado: main

• Utiliza aiosqlite para operaciones asíncronas

Notas de seguridad

• Nunca suba databases.json al repositorio - Contiene credenciales confidenciales

• Utilice variables de entorno o gestión de secretos en producción

• Considere utilizar conexiones SSL/TLS para bases de datos remotas

• Limite el acceso a la red al contenedor Docker

• Para SQLite, asegúrese de que las rutas de los archivos sean seguras y accesibles

Solución de problemas

Problemas de conexión

• Verifique las credenciales de la base de datos en databases.json

• Asegúrese de que las bases de datos sean accesibles desde el contenedor Docker

• Verifique la conectividad de red (use docker network para la comunicación entre contenedores)

Problemas de permisos

• Asegúrese de que el archivo databases.json tenga los permisos de lectura adecuados

• Verifique que el montaje del volumen de Docker sea correcto

Licencia

MIT