Data Nexus MCP

Eine modulare, sichere Plattform zur Verbindung mit SQL- und NoSQL-Datenbanken über REST-API, MCP (Model Context Protocol) und eine Vue.js-Web-UI.

Architektur

┌─────────────┐     ┌──────────────┐     ┌─────────────────┐
│   Web UI    │────▶│  REST API    │────▶│ core-db-command │
│  (Vue.js)   │     │  (FastAPI)   │     │  (Python lib)   │
└─────────────┘     └──────┬───────┘     └────────┬────────┘
                           │                       │
                    ┌──────▼───────┐               │
                    │  MCP Server  │───────────────┘
                    └──────┬───────┘
                           │
                    ┌──────▼───────┐
                    │  MCP Client  │──▶ AI Agents / LLMs
                    └──────────────┘

Module

Related MCP server: Database MCP Server

Unterstützte Datenbanktypen

Die Treiberregistrierung unterstützt über 50 Datenbanktypen in 13 Kategorien:

• Relational: PostgreSQL, MySQL, MSSQL, Oracle, CockroachDB, TiDB, YugabyteDB, TimescaleDB, pgvector

• Dokument: MongoDB, DocumentDB, Firestore, Couchbase (stub)

• Schlüssel-Wert: Redis, DynamoDB, Memcached/etcd/RocksDB (stub)

• Breitspalten: Cassandra, ScyllaDB, Bigtable/HBase (stub)

• Graph: Neo4j, Neptune/JanusGraph/ArangoDB (stub)

• Zeitreihen: InfluxDB, ClickHouse, Prometheus/QuestDB (stub)

• Vektor: Qdrant, Weaviate, Milvus, Pinecone

• Suche: Elasticsearch, OpenSearch, Splunk/Solr (stub)

• Data Warehouse: BigQuery, Snowflake, Redshift/Databricks (stub)

• Multi-Modell: Cosmos DB, OrientDB (stub)

• Eingebettet: SQLite, DuckDB, Realm/LMDB (stub)

• Ledger: QLDB/BigchainDB (stub)

• NewSQL: Spanner (stub)

Vollständig implementierte Treiber umfassen PostgreSQL, MySQL, MSSQL, Oracle, MongoDB, Redis, SQLite, DuckDB, Elasticsearch, ClickHouse, Neo4j, InfluxDB, Cassandra, DynamoDB, BigQuery, Snowflake, Qdrant, Weaviate, Milvus, Pinecone, Cosmos DB und Firestore. Stub-Treiber sind registriert und erweiterbar.

Schnellstart

Voraussetzungen

• Python 3.11+

• Node.js 20+ (für die Web-UI-Entwicklung)

• Docker & Docker Compose (optional)

1. Python-Abhängigkeiten installieren

cp .env.example .env
pip install -e ".[dev]"

2. Verbindungen konfigurieren

Bearbeiten Sie config/connections.yaml und setzen Sie Geheimnisse über Umgebungsvariablen:

connections:
  - name: postgres_prod
    type: postgresql
    host: localhost
    port: 5432
    database: mydb
    user: readonly_user
    password: ${PG_PASSWORD}

3. REST-API starten

db-rest-api
# or: uvicorn rest_api_command.app:app --reload

API-Dokumentation: http://localhost:8000/docs

4. Web-UI starten (Entwicklung)

cd web-ui
cp .env.example .env
npm install
npm run dev

Öffnen Sie http://localhost:5173 — Standard-Anmeldedaten: admin / changeme

5. Mit Docker Compose ausführen

docker compose up -d

Dienste:

• REST-API: http://localhost:8000

• Web-UI: http://localhost:5173

• PostgreSQL, MySQL, MongoDB, Redis, Elasticsearch

REST-API-Endpunkte

MCP-Server

Konfigurieren Sie in .env oder Cursor MCP env:

MCP_REST_API_URL=http://localhost:8000
# Option A: bearer token (when REST_API_AUTH_MODE=oauth2)
MCP_REST_API_TOKEN=<jwt-from-/api/auth/token>
# Option B: username/password (works with basic auth; auto-fetches JWT if oauth2)
MCP_REST_API_USER=admin
MCP_REST_API_PASSWORD=changeme

Ausführen:

db-mcp-server

Hinzufügen zur Cursor/Claude MCP-Konfiguration:

{
  "mcpServers": {
    "data-nexus-mcp": {
      "command": "db-mcp-server",
      "cwd": "/path/to/data_nexus_mcp",
      "env": {
        "MCP_REST_API_URL": "http://localhost:8000",
        "MCP_REST_API_USER": "admin",
        "MCP_REST_API_PASSWORD": "changeme"
      }
    }
  }
}

Hinweis: REST_API_*-Variablen gehören zum REST-API-Prozess (db-rest-api), nicht zur MCP-Server-Konfiguration.

MCP-Client

db-mcp-client                    # list available tools
db-mcp-client query local_sqlite "SELECT 1"

Authentifizierung

Setzen Sie REST_API_AUTH_MODE auf einen der folgenden Werte:

• basic — HTTP-Basisauthentifizierung (Standard für Entwicklung)

• oauth2 — JWT-Bearer-Tokens über /api/auth/token

• ldap — LDAP-Bindung (erfordert REST_API_LDAP_SERVER und REST_API_LDAP_BASE_DN)

Hinzufügen eines neuen Treibers

1. Erstellen Sie core_db_command/drivers/mydb.py

2. Erben Sie von BaseDriver und setzen Sie driver_type

3. Dekorieren Sie mit @DriverRegistry.register

4. Importieren Sie in core_db_command/drivers/registry_loader.py

from core_db_command.base import BaseDriver, DriverRegistry

@DriverRegistry.register
class MyDBDriver(BaseDriver):
    driver_type = "mydb"

    async def connect(self): ...
    async def disconnect(self): ...
    async def query(self, query, params=None): ...
    async def execute(self, command, params=None): ...
    async def list_tables(self, schema=None): ...
    async def describe_table(self, table, schema=None): ...

Testen

pytest tests/ -v

Sicherheitshinweise

• Anmeldedaten werden niemals von der REST-API oder dem MCP-Server zurückgegeben

• Geheimnisse müssen ${ENV_VAR}-Platzhalter in der YAML-Konfiguration verwenden

• Alle API-Endpunkte erfordern Authentifizierung

• Abfrageeingaben werden validiert und in der Länge begrenzt

Projektstruktur

data-nexus-mcp/
├── core_db_command/       # Core library + drivers
├── rest_api_command/      # FastAPI REST API
├── mcp_server/            # MCP server
├── mcp_client/            # MCP client
├── web-ui/                # Vue.js frontend
├── config/                # YAML connection config
├── tests/                 # Unit tests
├── docker-compose.yml
├── Dockerfile
└── pyproject.toml

Lizenz

MIT