Multi-Datenbank MCP-Server

Ein MCP-Server (Model Context Protocol), der Tools für den gleichzeitigen Zugriff auf mehrere Datenbanken bereitstellt. Der Server läuft in Docker und unterstützt das parallele Abfragen mehrerer Datenbanken unterschiedlicher Typen. Dieser Server wurde durch den Bedarf inspiriert, Datenbanken zu vergleichen oder Migrationen zu unterstützen.

Funktionen

• Mehrere Datenbanktypen: Unterstützung für PostgreSQL, MySQL/MariaDB, SQL Server und SQLite

• Unterstützung mehrerer Datenbanken: Gleichzeitiges Verbinden und Abfragen mehrerer Datenbanken (auch unterschiedlicher Typen)

• Parallele Abfragen: Ausführen derselben Abfrage über mehrere Datenbanken hinweg gleichzeitig

• Schema-Erkundung: Auflisten von Datenbanken, Schemata, Tabellen und Beschreiben von Tabellenstrukturen

• Dockerisiert: Läuft in einem Docker-Container für einfache Bereitstellung

• Verbindungspooling: Effizientes Verbindungsmanagement für alle Datenbanktypen

• Flexible Konfiguration: Organisieren von Datenbanken nach Typ

Related MCP server: Universal SQL MCP Server

Verfügbare Tools

1. list_databases - Listet alle konfigurierten Datenbankverbindungen auf

2. query_database - Führt eine SQL-Abfrage auf einer bestimmten Datenbank aus

3. list_tables - Listet alle Tabellen in einem Datenbankschema auf

4. describe_table - Ruft detaillierte Schemainformationen für eine Tabelle ab

5. list_schemas - Listet alle Schemata in einer Datenbank auf

6. query_multiple_databases - Führt dieselbe Abfrage gleichzeitig auf mehreren Datenbanken aus

Einrichtung

1. Datenbankkonfiguration erstellen

Kopieren Sie die Beispielkonfigurationsdatei und bearbeiten Sie sie mit Ihren Datenbank-Anmeldedaten:

cp databases.json.example databases.json

Bearbeiten Sie databases.json mit Ihren Datenbankverbindungsdetails. Organisieren Sie Datenbanken nach Typ auf der Stammebene:

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

Unterstützte Datenbanktypen

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

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

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

• SQLite ("sqlite" oder "sqlite3")

• ClickHouse ("clickhouse" oder "ch")

2. Erstellen und Ausführen mit Docker Compose

docker-compose up --build

3. Erstellen und Ausführen mit 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. Tipps für Docker-Verbindungen

Beachten Sie beim Konfigurieren von Datenbankverbindungen innerhalb von Docker diese Tipps:

Netzwerkverbindungen (PostgreSQL, MySQL, SQL Server)

• Zugriff auf Datenbanken auf dem Host-Rechner: Verwenden Sie host.docker.internal als Hostname (Windows/Mac) oder 172.17.0.1 (Linux)

• Zugriff auf andere Container: Verwenden Sie den Containernamen oder Dienstnamen aus der docker-compose.yml

• Zugriff auf Remote-Datenbanken: Verwenden Sie den tatsächlichen Hostnamen oder die IP-Adresse

Beispiel für den Zugriff auf PostgreSQL auf dem Host-Rechner:

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

Beispiel für den Zugriff auf eine Datenbank in einem anderen Docker-Container:

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

Beispiel für den Zugriff auf SQL Server auf dem Host-Rechner:

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

Hinweis für SQL Server: Stellen Sie sicher, dass SQL Server für TCP/IP-Verbindungen konfiguriert ist und der SQL Server Browser-Dienst bei Verwendung benannter Instanzen ausgeführt wird. Der Standardport ist 1433.

Dateipfade (SQLite)

• SQLite-Datenbanken auf dem Host: Binden Sie das Verzeichnis, das die Datenbankdatei enthält, als Volume ein und verwenden Sie den Container-Pfad

• SQLite-Datenbanken im Container: Verwenden Sie absolute Pfade innerhalb des Containers

Beispiel für einen Docker-Run-Befehl mit SQLite-Volume:

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

Beispiel für eine SQLite-Konfiguration:

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

Hinweis: Der Pfad /app/data/mydatabase.db ist der Pfad innerhalb des Containers, der über das Volume-Mount auf ./data/mydatabase.db auf Ihrem Host-Rechner gemappt wird.

Verwendung

Der Server kommuniziert über stdio unter Verwendung des MCP-Protokolls. Verbinden Sie Ihren MCP-Client mit den stdio-Streams des Docker-Containers.

Beispiel für eine MCP-Client-Konfiguration

Wenn Sie einen MCP-Client verwenden, konfigurieren Sie ihn so, dass er eine Verbindung zum Docker-Container herstellt:

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

Tool-Beispiele

Alle Datenbanken auflisten

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

Eine einzelne Datenbank abfragen

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

Tabellen auflisten

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

Eine Tabelle beschreiben

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

Mehrere Datenbanken gleichzeitig abfragen

Sie können mehrere Datenbanken unterschiedlicher Typen gleichzeitig abfragen:

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

Hinweis: Stellen Sie beim Abfragen mehrerer Datenbanken unterschiedlicher Typen sicher, dass die SQL-Syntax über alle Datenbanktypen hinweg kompatibel ist, oder verwenden Sie datenbankspezifische Abfragen für jede Datenbank separat.

Entwicklung

Lokale Entwicklung (ohne Docker)

1. Abhängigkeiten installieren:

pip install -r requirements.txt

2. Umgebungsvariable setzen:

export DB_CONFIG_PATH=./databases.json

3. Server ausführen:

python server.py

Datenbankspezifische Hinweise

PostgreSQL

• Standardport: 5432

• Standardschema: public

• Verwendet asyncpg für asynchrone Operationen

MySQL/MariaDB

• Standardport: 3306

• Schema-Parameter ist optional (verwendet die aktuelle Datenbank)

• Verwendet aiomysql für asynchrone Operationen

SQL Server

• Standardport: 1433

• Standardschema: dbo

• Erfordert Microsoft ODBC Driver for SQL Server (v18 bevorzugt, v17 ebenfalls unterstützt; im Docker-Image installiert)

• Verwendet pyodbc mit asyncio-Wrapper

• Wichtig: SQL Server muss für TCP/IP-Verbindungen konfiguriert sein

• Stellen Sie bei benannten Instanzen sicher, dass der SQL Server Browser-Dienst ausgeführt wird

• Verwenden Sie host.docker.internal, um von Docker aus eine Verbindung zum SQL Server auf dem Host-Rechner herzustellen

SQLite

• Keine Netzwerkverbindung erforderlich

• Verwenden Sie das Feld database, um den Dateipfad anzugeben (oder :memory: für In-Memory)

• Standardschema: main

• Verwendet aiosqlite für asynchrone Operationen

Sicherheitshinweise

• databases.json niemals committen - Sie enthält sensible Anmeldedaten

• Verwenden Sie in der Produktion Umgebungsvariablen oder Secrets-Management

• Erwägen Sie die Verwendung von SSL/TLS-Verbindungen für Remote-Datenbanken

• Begrenzen Sie den Netzwerkzugriff auf den Docker-Container

• Stellen Sie bei SQLite sicher, dass Dateipfade sicher und zugänglich sind

Fehlerbehebung

Verbindungsprobleme

• Überprüfen Sie die Datenbank-Anmeldedaten in databases.json

• Stellen Sie sicher, dass die Datenbanken vom Docker-Container aus zugänglich sind

• Überprüfen Sie die Netzwerkkonnektivität (verwenden Sie docker network für die Kommunikation zwischen Containern)

Berechtigungsprobleme

• Stellen Sie sicher, dass die Datei databases.json über die richtigen Leseberechtigungen verfügt

• Überprüfen Sie, ob das Docker-Volume-Mount korrekt ist

Lizenz

MIT