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

Herramientas disponibles

list_databases - Lista todas las conexiones de bases de datos configuradas
query_database - Ejecuta una consulta SQL en una base de datos específica
list_tables - Lista todas las tablas en un esquema de base de datos
describe_table - Obtiene información detallada del esquema de una tabla
list_schemas - Lista todos los esquemas en una base de datos
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)

Instale las dependencias:

pip install -r requirements.txt

Establezca la variable de entorno:

export DB_CONFIG_PATH=./databases.json

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

Multi-Database MCP Server