MariaDB MCP Server mit streamable HTTP für Open-WebUI

Ein read-only MCP Server, der als Schnittstelle zwischen einer MariaDB Datenbank und Open-WebUI dient. Der Server erlaubt ausschließlich lesende Abfragen und blockiert alle Schreiboperationen wie INSERT, UPDATE, DELETE, CREATE, ALTER, DROP usw.

Hinweis: Der Server verwendet mysql-connector-python, der vollständig mit MariaDB kompatibel ist und keine externen Systembibliotheken benötigt. Der Server ist MCP-kompatibel und implementiert die notwendigen Endpunkte für Open-WebUI. Aktuellste Version verwendet Python 3.12 als Base Image.

:rocket: Schnellstart

Mit Docker (empfohlen)

# Klone das Repository
git clone https://github.com/AndiAtom/mariadb-mcp-strhttp.git
cd mariadb-mcp-strhttp

# Starte mit Docker Compose (enthält MariaDB + MCP Server)
docker-compose up -d

# Der Server ist jetzt unter http://localhost:8000 verfügbar

Ohne Docker

# Installiere Abhängigkeiten
pip install -r requirements.txt

# Starte den Server
python -m src.server

# Oder direkt
python src/server.py

Related MCP server: tusk-mcp

:gear: Konfiguration

Umgebungsvariablen

Der Server kann über Umgebungsvariablen oder eine config.json-Datei konfiguriert werden.

Datenbank-Konfiguration

Server-Konfiguration

API-Token-Authentifizierung

Rate Limiting

Konfigurationsdatei

Erstelle oder bearbeite config.json:

{
  "server": {
    "host": "0.0.0.0",
    "port": 8000,
    "log_level": "info"
  },
  "database": {
    "host": "localhost",
    "port": 3306,
    "user": "mcpuser",
    "password": "securepassword",
    "database": "mydatabase",
    "timeout": 30
  },
  "security": {
    "read_only": true,
    "block_write_operations": true,
    "validate_queries": true
  },
  "authentication": {
    "enabled": true,
    "type": "api_token",
    "tokens": ["token1", "token2"],
    "token_file": null,
    "header_name": "Authorization",
    "query_param_name": "api_key"
  },
  "rate_limiting": {
    "enabled": true,
    "requests_per_minute": 100,
    "burst_requests": 10,
    "whitelist": ["/health", "/", "/docs", "/openapi.json", "/redoc"]
  }
}

Hinweis: Die Konfiguration kann auch über Umgebungsvariablen überschrieben werden.

:key: API-Token-Authentifizierung

Der Server unterstützt optionale API-Token-Authentifizierung, um den Zugriff auf die API zu schützen.

Token-Generierung

Das Projekt enthält ein Skript generate_token.py zur Generierung sicherer API-Tokens:

# Einzelnen Token generieren
python generate_token.py

# Mehrere Tokens generieren
python generate_token.py --num 5

# Token mit bestimmter Länge generieren (Standard: 32 Zeichen)
python generate_token.py --length 64

# Token in Datei speichern
python generate_token.py --file tokens.json

# Tokens nur anzeigen (nicht speichern)
python generate_token.py --no-file

Authentifizierung aktivieren

Es gibt mehrere Möglichkeiten, die Authentifizierung zu konfigurieren:

1. Einzelner Token über Umgebungsvariable

# In docker-compose.yml oder beim Starten
API_TOKEN=your-secure-token-here

2. Mehrere Tokens über Umgebungsvariable (komma-separiert)

API_TOKENS=token1,token2,token3

3. Token aus Datei laden

Erstelle eine JSON-Datei tokens.json:

{
  "tokens": [
    "your-secure-token-1",
    "your-secure-token-2"
  ]
}

Oder eine einfache Textdatei (ein Token pro Zeile):

token1
token2
token3

Dann in docker-compose.yml:

environment:
  - API_TOKEN_FILE=/app/tokens.json
volumes:
  - ./tokens.json:/app/tokens.json:ro

4. Authentifizierung deaktivieren (Standard)

DISABLE_API_AUTH=true

Token verwenden

Es gibt drei Möglichkeiten, den Token zu übergeben:

1. Authorization Header (empfohlen)

curl -X POST http://localhost:8000/query \
  -H "Authorization: Bearer your-secure-token" \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10"}'

2. Query Parameter

curl -X POST http://localhost:8000/query?api_key=your-secure-token \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10"}'

3. Im Request Body

curl -X POST http://localhost:8000/query \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10", "api_key": "your-secure-token"}'

Öffentliche Endpunkte

Die folgenden Endpunkte benötigen keine Authentifizierung:

• GET / - Server-Informationen

• GET /health - Health-Check

• GET /docs - Swagger UI

• GET /openapi.json - OpenAPI-Spezifikation

• GET /redoc - ReDoc

Alle anderen Endpunkte erfordern einen gültigen API-Token, wenn die Authentifizierung aktiviert ist.

:desktop_computer: Open-WebUI Integration

MCP Server in Open-WebUI hinzufügen

1. Öffne Open-WebUI (z.B. http://localhost:8080)

2. Gehe zu Einstellungen --> MCP Server oder Externe Tool-Server

3. Klicke auf "Add MCP Server" oder "Neuer Server"

4. Füge folgende Konfiguration ein:

{
  "name": "MariaDB Read-Only",
  "type": "http",
  "url": "http://localhost:8000",
  "readOnly": true,
  "headers": {
    "Authorization": "Bearer your-api-token-here"
  },
  "capabilities": {
    "query": true,
    "stream": true,
    "validate": true,
    "list_resources": false,
    "read_resource": false
  },
  "timeout": 60
}

:bulb: Hinweis: Open-WebUI erkennt automatisch den MCP-kompatiblen Endpunkt. Die URL kann einfach http://localhost:8000 sein, der Server hat sowohl den Standard- als auch den /mcp-Endpunkt.

Verbindung testen

Frage Open-WebUI:

"Was sind die Tabellen in der Datenbank?"

Erwartete Antwort: Eine Liste aller Tabellen aus deiner MariaDB.

:shield: Sicherheitsfeatures

Read-Only Implementierung

Der Server implementiert zwei Ebenen von Read-Only-Schutz:

1. Session-Ebene: SET SESSION read_only=ON wird einmal beim Verbinden gesetzt

2. Abfrage-Ebene: Jede Abfrage wird vor der Ausführung auf Schreiboperationen geprüft

Hinweis: Selbst wenn die Abfrage-Validierung umgangen würde, blockiert MariaDB alle Schreiboperationen auf Session-Ebene. Die Kombination beider Mechanismen bietet maximalen Schutz.

Query Timeout Schutz

• Standard-Timeout: Alle Datenbankabfragen haben einen Standard-Timeout von 30 Sekunden

• Individueller Timeout: Kann pro Abfrage über den timeout-Parameter angepasst werden

• Streaming-Limit: Streaming-Abfragen sind auf 10.000 Zeilen begrenzt, um sehr große Resultsets zu verhindern

• Konfigurierbar: Timeout kann über die Umgebungsvariable DB_TIMEOUT oder in der Konfigurationsdatei angepasst werden

Blockierte Befehle

Der Server blockiert alle Schreiboperationen, einschließlich:

DDL (Data Definition Language)

• CREATE - Tabellen, Datenbanken, Indizes erstellen

• ALTER - Objekte ändern

• DROP - Objekte löschen

• TRUNCATE - Tabellen leeren

• RENAME - Objekte umbenennen

DML (Data Manipulation Language)

• INSERT - Daten einfügen

• UPDATE - Daten aktualisieren

• DELETE - Daten löschen

• REPLACE - Daten ersetzen

• LOAD - Daten laden

• MERGE - Daten zusammenführen

DCL (Data Control Language)

• GRANT - Berechtigungen erteilen

• REVOKE - Berechtigungen entziehen

• DENY - Berechtigungen verweigern

Transaktionssteuerung

• COMMIT - Transaktionen bestätigen

• ROLLBACK - Transaktionen zurücksetzen

• SAVEPOINT - Speicherpunkte erstellen

• RELEASE - Speicherpunkte freigeben

Administrative Befehle

• SHUTDOWN - Server herunterfahren

• KILL - Verbindungen beenden

• PURGE - Logs bereinigen

• RESET - Zurücksetzen

• FLUSH - Caches leeren

• SET PASSWORD - Passwort ändern

• SET GLOBAL - Globale Variablen setzen

• SET SESSION - Sitzungsvariablen setzen (außer read_only)

Replikation

• CHANGE MASTER - Master ändern

• START SLAVE - Slave starten

• STOP SLAVE - Slave stoppen

MariaDB/MySQL-spezifische Befehle

• OPTIMIZE TABLE - Tabellen defragmentieren (Schreiboperation)

• REPAIR TABLE - Tabellen reparieren (Schreiboperation)

• ANALYZE TABLE - Statistiken aktualisieren (Schreiboperation)

• CHECK TABLE - Tabellen prüfen (kann Reparaturen auslösen)

• CHECKSUM TABLE - Prüfsummen berechnen

Erlaubte Befehle

Nur folgende Befehle sind erlaubt:

Datenabfragen

• SELECT - Daten abfragen

• WITH / CTE - Common Table Expressions

Metadaten-Abfragen

• SHOW - Informationen anzeigen (TABLES, DATABASES, COLUMNS, INDEX, etc.)

• DESCRIBE / DESC - Tabellenstruktur anzeigen

• EXPLAIN - Ausführungsplan anzeigen

Informationsschema

• INFORMATION_SCHEMA - Metadaten abfragen

Transaktionssteuerung (nur lesend)

• START TRANSACTION READ ONLY - Read-Only Transaktion starten

• BEGIN READ ONLY - Read-Only Transaktion beginnen

• SET TRANSACTION READ ONLY - Transaktion als read-only setzen

Sonstige

• USE - Datenbank auswählen

• HELP - Hilfe anzeigen

:satellite: API Endpunkte

MCP Endpunkte (für Open-WebUI)

Standard API Endpunkte (für direkte Nutzung)

:computer: API Beispiele

Einfache Abfrage mit Authentifizierung

# Mit Authorization Header
curl -X POST http://localhost:8000/query \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10"}'

# Mit Query Parameter
curl -X POST http://localhost:8000/query?api_key=your-api-token \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10"}'

# Mit Token im Body
curl -X POST http://localhost:8000/query \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM customers LIMIT 10", "api_key": "your-api-token"}'

# Mit Datenbank-Angabe
curl -X POST http://localhost:8000/query \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{"query": "SELECT * FROM mails LIMIT 5", "database": "tanss"}'

MCP Endpunkt testen

# MCP Server Info abrufen (keine Authentifizierung nötig)
curl http://localhost:8000/mcp

# MCP Anfrage ausführen (mit Authentifizierung)
curl -X POST http://localhost:8000/mcp \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{"method": "execute_query", "params": {"query": "SELECT * FROM customers LIMIT 5"}}'

Streaming Abfrage

curl -H "Authorization: Bearer your-api-token" \
  http://localhost:8000/query/stream?query=SELECT%20*%20FROM%20large_table

Antwort (Server-Sent Events):

data: {"type": "metadata", "columns": ["id", "name"], "query": "SELECT * FROM large_table"}

data: {"type": "row", "data": {"id": 1, "name": "Row 1"}}

data: {"type": "row", "data": {"id": 2, "name": "Row 2"}}

data: {"type": "complete", "total_rows": 1000}

Abfrage validieren

curl -X POST http://localhost:8000/query/validate \
  -H "Authorization: Bearer your-api-token" \
  -H "Content-Type: application/json" \
  -d '{"query": "INSERT INTO users VALUES (1, \"test\")"}'

Antwort:

{
  "valid": false,
  "error": "Abfrage enthält Schreiboperationen. Nur lesende Abfragen sind erlaubt.",
  "blocked_keywords": ["INSERT"]
}

Tabellen auflisten

# Alle Tabellen in der aktuellen Datenbank
curl -H "Authorization: Bearer your-api-token" \
  http://localhost:8000/tables

# Tabellen in einer bestimmten Datenbank
curl -H "Authorization: Bearer your-api-token" \
  http://localhost:8000/tables?database=tanss

Schema einer Tabelle abrufen

curl -H "Authorization: Bearer your-api-token" \
  http://localhost:8000/schema/customers

:hourglass: Rate Limiting

Der Server implementiert Rate Limiting, um die API vor übermäßiger Nutzung zu schützen.

Standard-Konfiguration

• Aktiviert: Ja (standardmäßig)

• Anfragen pro Minute: 100

• Burst-Anfragen: 10

• Whitelist: /, /health, /docs, /openapi.json, /redoc

Rate Limit Header

Jede Antwort enthält folgende Header:

• X-RateLimit-Limit: Maximale Anfragen pro Minute

• X-RateLimit-Remaining: Verbleibende Anfragen

• X-RateLimit-Reset: Zeitstempel, wann das Limit zurückgesetzt wird

Fehlerbehandlung

Bei Überschreitung des Rate Limits:

• HTTP Status: 429 Too Many Requests

• Header: Retry-After: 60 (Sekunden bis zum nächsten Versuch)

• Body:

  {
    "error": "Too Many Requests",
    "detail": "Rate Limit überschritten. Maximale Anfragen: 100 pro Minute",
    "retry_after": 60
  }

:test_tube: Testen

Automatisierte Tests

# Installiere Test-Abhängigkeiten
pip install pytest httpx

# Führe Tests aus
pytest tests/

Manuelles Testen

1. Verbindung testen:

   curl http://localhost:8000/health

2. MCP Endpunkt testen:

   curl http://localhost:8000/mcp

3. Erlaubte Abfrage testen:

   curl -X POST http://localhost:8000/query \
     -H "Authorization: Bearer your-token" \
     -d '{"query": "SELECT 1"}'

4. Blockierte Abfrage testen:

   curl -X POST http://localhost:8000/query \
     -H "Authorization: Bearer your-token" \
     -d '{"query": "INSERT INTO test VALUES (1)"}'

   --> Sollte Fehler 403 zurückgeben

5. Authentifizierung testen:

   # Ohne Token (sollte 401 zurückgeben, wenn Auth aktiviert)
   curl -X POST http://localhost:8000/query \
     -d '{"query": "SELECT 1"}'
   
   # Mit falschem Token (sollte 401 zurückgeben)
   curl -X POST http://localhost:8000/query \
     -H "Authorization: Bearer wrong-token" \
     -d '{"query": "SELECT 1"}'
   
   # Mit richtigem Token (sollte funktionieren)
   curl -X POST http://localhost:8000/query \
     -H "Authorization: Bearer your-correct-token" \
     -d '{"query": "SELECT 1"}'

:wrench: Fehlerbehebung

Häufige Probleme und Lösungen

1. Open-WebUI erkennt den MCP Server nicht

• Ursache: Falsche URL oder Server nicht erreichbar

• Lösung:

  • URL in Open-WebUI auf http://localhost:8000 setzen

  • Server-Status prüfen: curl http://localhost:8000/health

  • MCP-Endpunkt testen: curl http://localhost:8000/mcp

2. "Leere Abfrage" Fehler

• Ursache: Open-WebUI sendet die Abfrage in einem anderen Format

• Lösung: Der Server unterstützt jetzt:

  • JSON Body: {"query": "SELECT ..."}

  • Formular-Daten: query=SELECT ...

  • Alternative Feldnamen: query, sql, q

  • Datenbank-Angabe: {"query": "...", "database": "tanss"}

3. Verbindung zur Datenbank scheitert

• Ursache: Falsche Credentials oder MariaDB nicht für Remote-Zugriff konfiguriert

• Lösung:

  • Prüfe DB_HOST, DB_USER, DB_PASSWORD in docker-compose.yml

  • MariaDB für Remote-Zugriff konfigurieren:

    # In /etc/mysql/mariadb.conf.d/50-server.cnf
    bind-address = 0.0.0.0

  • Benutzer berechtigen:

    GRANT SELECT ON *.* TO 'mcp_user'@'%';
    FLUSH PRIVILEGES;

  • network_mode: host in docker-compose.yml verwenden

4. Server nicht erreichbar

• Ursache: Port Konflikt oder Firewall

• Lösung:

  • Prüfe mit curl http://localhost:8000/health

  • Port 8000 freigeben: sudo ufw allow 8000

  • Andere Dienste auf Port 8000 beenden: sudo lsof -i :8000

5. Docker-Container startet nicht

• Ursache: Berechtigungsprobleme oder fehlende Abhängigkeiten

• Lösung:

  docker-compose down
  docker-compose up -d --build
  docker-compose logs mariadb-mcp-server

6. Abfragen werden blockiert

• Ursache: Abfrage enthält Schreiboperationen

• Lösung:

  • Validierung prüfen: curl -X POST http://localhost:8000/query/validate -d '{"query": "DEINE_ABFRAGE"}'

  • Nur lesende Abfragen verwenden (SELECT, SHOW, DESCRIBE, etc.)

7. 401 Unauthorized Fehler

• Ursache: API-Token-Authentifizierung aktiviert, aber kein oder falscher Token angegeben

• Lösung:

  • Token in Authorization Header angeben: -H "Authorization: Bearer your-token"

  • Token als Query Parameter angeben: ?api_key=your-token

  • Token im Request Body angeben: {"api_key": "your-token"}

  • Authentifizierung deaktivieren: DISABLE_API_AUTH=true

:package: Abhängigkeiten

Der Server verwendet folgende Python-Pakete:

:bulb: Hinweis: Wir verwenden mysql-connector-python statt mariadb, da dieser Connector keine externen Systembibliotheken benötigt und damit Docker-freundlicher ist. Er ist vollständig kompatibel mit MariaDB.

:bookmark: Versionshistorie

:busts_in_silhouette: Mitwirken

1. Fork das Repository

2. Erstelle einen Feature-Branch (git checkout -b feature/AmazingFeature)

3. Commit deine Änderungen (git commit -m 'Add some AmazingFeature')

4. Push zum Branch (git push origin feature/AmazingFeature)

5. Öffne einen Pull Request

:memo: Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert - siehe LICENSE für Details.

:email: Kontakt

• GitHub: AndiAtom/mariadb-mcp-strhttp

• Issues: GitHub Issues

Hinweis: Dieser Server ist ausschließlich für lesende Abfragen konzipiert. Alle Versuche, Schreiboperationen auszuführen, werden blockiert und führen zu einem Fehler.

Technischer Hinweis: Der Server verwendet mysql-connector-python, der vollständig mit MariaDB kompatibel ist und keine externen C-Bibliotheken benötigt, was die Docker-Installation deutlich vereinfacht. Der Server implementiert einen MCP-kompatiblen Endpunkt (/mcp) für nahtlose Integration mit Open-WebUI und unterstützt sowohl JSON- als auch Formular-Daten-Anfragen. Die Read-Only-Funktionalität wird auf Session-Ebene (SET SESSION read_only=ON) und auf Abfrage-Ebene (Validierung) sichergestellt. Die API-Token-Authentifizierung bietet eine zusätzliche Sicherheitsebene für den Zugriff auf die API.