Erstellen Sie einen MCP-Server in Python und verbinden Sie ihn mit Claude Desktop sowie SQLite.

Jeder, der Unternehmensagenten entwickelt, kennt die Herausforderungen beim Schreiben von Verbindungscode. Ein Wrapper für die Datenbank, eine weitere Integrationsschicht für Jira-Tickets, noch eine für Slack – multipliziert man das mit zehn Datenbanken und fünf LLM-Frameworks wie Claude, AutoGen und LangChain, bricht das Design unter seinem eigenen Gewicht zusammen. Das ist das N-mal-M-Integrationssproblem: Die KI muss die genaue Struktur jeder Datenquelle verstehen, mit der sie in Berührung kommt.

Das Model Context Protocol (MCP) ist ein offener Standard, der gezielt dieses Problem lösen soll. Stellen Sie sich ein universelles USB-C-Kabel für KI vor. Eine Datenbankverbindung wird einmal geschrieben und über einen einzigen standardisierten Server bereitgestellt, sodass jeder kompatible Client sich anschließen, die verfügbaren Tools entdecken und sie nutzen kann. Folgend wird ein lokaler MCP-Server in weniger als 50 Zeilen Python beschrieben, der mit Claude Desktop verbunden ist und von einer aktiven SQLite-Datenbank unterstützt wird.

Voraussetzungen

Das offizielle Python-Paket mcp übernimmt die schwierigen Aufgaben. Es versteckt die Details von JSON-RPC, sodass ein einziger Dekorator ausreicht, um ein Tool dem Modell zur Verfügung zu stellen. Installieren Sie es zunächst in Ihrer virtuellen Umgebung:

pip install mcp

Claude Desktop muss ebenfalls auf dem Rechner installiert werden.

Server schreiben

Erstellen Sie eine Datei mit dem Namen mcp_server.py, importieren Sie die notwendigen Bibliotheken und initialisieren Sie den Server. Ein wichtiger Punkt dabei ist, dass das os-Modul die SQLite-Datei im selben Verzeichnis wie das Skript platziert. Claude Desktop startet den Server im Hintergrund, und ohne feste Speicheradresse können Zugriffsfehler auftreten.

import sqlite3
import json
import os
import sys
from mcp.server.mcpserver import MCPServer

# Initialize the MCP server
mcp = MCPServer(name="Enterprise_SQL_Agent")

# Force the database to be created in the exact same folder as this script
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_PATH = os.path.join(BASE_DIR, "enterprise.db")

Danach wird eine temporäre Datenbank erstellt, damit das Modell etwas zum Abfragen hat. Die Einrichtung der Protokollierung erfolgt über den Standardfehlerstrom (sys.stderr). Der Standardausgang ist der Kanal, den MCP verwendet, um mit dem Client zu kommunizieren, und dort auftretende unerwünschte Ausgaben könnten diesen beschädigen.

def setup_dummy_db():
    """Create a sample employee database for the demo"""
    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()

        cursor.execute('''CREATE TABLE IF NOT EXISTS employees
                          (id INTEGER PRIMARY KEY, name TEXT, role TEXT, salary INTEGER)''')
        cursor.execute("DELETE FROM employees")

        employees = [
            ("Alice", "Data Scientist", 120000),
            ("Bob", "DevOps Engineer", 115000),
            ("Charlie", "AI Researcher", 135000)
        ]

        cursor.executemany("INSERT INTO employees (name, role, salary) VALUES (?, ?, ?)", employees)
        conn.commit()
        conn.close()
        print("Database initialized successfully.", file=sys.stderr)
    except Exception as e:
        print(f"Database setup error: {e}", file=sys.stderr)

Die Datenbank als Tool bereitstellen

Der zentrale Schritt besteht aus einer gewöhnlichen Python-Funktion, die eine SQL-Abfrage ausführt und die Ergebniszeilen zurückgibt. Fügen Sie den Dekorator @mcp.tool() hinzu, und der Server liest die Dokumentation sowie Typhinweise, um automatisch ein JSON-Schema für das Modell zu erstellen.

@mcp.tool()
def query_employee_database(sql_query: str) -> str:
    """
    Executes a SQL SELECT query against the enterprise.db database.

    The database contains an 'employees' table with columns:
    - id (INTEGER PRIMARY KEY)
    - name (TEXT)
    - role (TEXT)
    - salary (INTEGER)

    SECURITY: Only READ operations (SELECT) are permitted.
    """

    # Safety Check: Block destructive SQL commands
    dangerous_keywords = ["DROP", "DELETE", "UPDATE", "INSERT", "ALTER"]
    if any(keyword in sql_query.upper() for keyword in dangerous_keywords):
        return "Error: Only SELECT queries are authorized for this tool."

    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()
        cursor.execute(sql_query)
        results = cursor.fetchall()

        # Format the output as JSON so the LLM can read it cleanly
        column_names = [description[0] for description in cursor.description]
        formatted_results = [dict(zip(column_names, row)) for row in results]

        conn.close()
        return json.dumps(formatted_results, indent=2)

    except Exception as e:
        return f"Database error: {str(e)}"

Ein kurzer Startblock beendet die Datei:

if __name__ == "__main__":
    setup_dummy_db()
    mcp.run()

Verbindung von Claude Desktop herstellen

Dem Client muss mitgeteilt werden, wo der Server sich befindet. Unter Windows gehen Sie zum Ordner %APPDATA%\Claude, öffnen Sie claude_desktop_config.json in einem Editor und fügen Sie einen Eintrag mcpServers hinzu.

Ein Detail unter Windows, das viele Menschen verwirrt: Wenn Sie in einer virtuellen Umgebung wie Conda oder venv ausführen, geben Sie den absoluten Pfad zu python.exe dieser Umgebung anstelle des einfachen globalen Befehls python an, und schreiben Sie jeden Pfad mit doppelten Backslashes.

{
  "mcpServers": {
    "enterprise-sql": {
      "command": "C:\\Users\\YourName\\.conda\\envs\\your_env\\python.exe",
      "args": [
        "D:\\Your\\Project\\Path\\mcp_server.py"
      ]
    }
  }
}

Speichern Sie die Datei und starten Sie Claude Desktop vollständig neu.

Testen der Funktionalität

Öffnen Sie Claude Desktop und suchen Sie nach dem Hammer-Symbol (Tools) in der unteren rechten Ecke des Chat-Fensters. Das Tool query_employee_database sollte dort bereits registriert sein. Ein guter erster Test besteht darin, zu fragen, wer in der Mitarbeiterdatenbank am meisten verdient und welche Position diese Person innehat.

Das Modell liest die Beschreibung des Tools, schreibt den SQL-Code selbst (SELECT * FROM employees ORDER BY salary DESC LIMIT 1;), führt ihn über Ihren Server aus und wandelt das Ergebnis in eine Antwort in Alltagssprache um. Es wurde keine eigene API-Schicht entwickelt, und das Schema wurde dynamisch entdeckt.

Das gleiche Muster gilt für Slack, Jira, GitHub oder jede interne Unternehmens-API – und das ist es, was die Wirtschaftlichkeit beim Aufbau agiler Systeme in einem Unternehmen verändert: Jedes System wird nur einmal bereitgestellt, und jeder kompatible Assistent kann es nutzen.