Wie man eine bestehende API für LLMs über MCP zugänglich macht: Ein umfassender Leitfaden

Die Integration von Large Language Models (LLMs) mit Ihrer bestehenden API kann eine Herausforderung sein. Traditionell benötigen Sie benutzerdefinierte Konnektoren oder plattformspezifische Plugins, um KI-Zugriff auf Ihren Dienst zu ermöglichen. Das Model Context Protocol (MCP) bietet einen besseren Weg.

Was ist das Model Context Protocol (MCP)?

MCP ist ein offener Standard von Anthropic (jetzt ein Open-Source-Projekt), der standardisiert, wie KI-Assistenten mit externen Daten und Tools verbunden werden. Betrachten Sie MCP als einen universellen Adapter—einen “USB-C-Anschluss” für KI-Anwendungen. Anstatt Einzelintegrationen für jedes Modell oder jede Plattform zu erstellen, stellen Sie Ihre API einmal über MCP bereit, und jedes MCP-fähige LLM kann sie nutzen.

Hauptvorteile von MCP

• Standardisierung: Ersetzen Sie fragmentierte Integrationen durch ein einziges, konsistentes Protokoll
• Wiederverwendbarkeit: Erstellen Sie Ihren API-Konnektor einmal als MCP-Server, und mehrere KI-Clients können ihn nutzen
• Kontrolle: Der MCP-Server läuft in Ihrer Umgebung, sodass Sie die Sicherheit durchsetzen und genau steuern können, worauf das Modell zugreifen kann

MCP fungiert als universelles Plugin-System für LLMs und bietet einen strukturierten Weg für eine KI, Funktionen aufzurufen oder Daten aus externen Quellen abzurufen.

MCP-Grundelemente verstehen

MCP verwendet drei Hauptkonzepte, um Funktionalität bereitzustellen:

1. Resources (Ressourcen): Diese sind wie schreibgeschützte Datenendpunkte. Eine Ressource wird durch einen URI identifiziert (z.B. todo://list) und stellt dem Modell Daten zur Verfügung. Ressourcen dienen dazu, Kontext in das Modell zu laden (wie das Abrufen eines Dokuments, Datenbankeintrags oder einer Aufgabenliste). Sie ähneln GET-Anfragen und ändern normalerweise keinen Zustand.
2. Tools (Werkzeuge): Dies sind Aktionen oder Operationen, die das Modell aufrufen kann – im Wesentlichen Funktionen mit Parametern und Rückgabewerten, die das LLM aufrufen kann. Tools können Nebeneffekte haben oder Berechnungen durchführen. Betrachten Sie Tools wie “Funktionen, die die KI aufrufen kann.”
3. Prompts (Aufforderungen): MCP ermöglicht die Definition wiederverwendbarer Gesprächsvorlagen oder Workflows. Prompts sind wie vordefinierte Gesprächsausschnitte, die der Server dem Client bereitstellen kann.

Zusammenfassend: Ressourcen laden Daten für das Modell, Tools führen Aktionen aus, und Prompts leiten Interaktionen.

Implementierung: Schritt-für-Schritt-Anleitung

Gehen wir durch die Bereitstellung einer einfachen REST-API für einen KI-Assistenten mittels MCP.

Schritt 1: Einrichten eines einfachen REST-API-Beispiels

Wir verwenden eine einfache To-Do-Listen-API als Beispiel. Hier ist eine minimale Implementierung mit Flask:

from flask import Flask, request, jsonify

app = Flask(__name__)
tasks = [ {"id": 1, "title": "Sample Task", "done": False} ]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    # Return the full list of tasks
    return jsonify(tasks)

@app.route('/tasks', methods=['POST'])
def create_task():
    # Add a new task from the JSON request body
    data = request.get_json()
    new_task = {
        "id": len(tasks) + 1,
        "title": data.get("title"),
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

# Run with: flask run

Diese API hat zwei Endpunkte:

• GET /tasks - Alle Aufgaben abrufen
• POST /tasks - Eine neue Aufgabe hinzufügen

In einem realen Szenario könnte dies eine beliebige bestehende API mit einer Datenbankanbindung sein.

Schritt 2: Erstellen eines MCP-Servers zur Einbindung der API

Jetzt erstellen wir einen MCP-Server in Python, der unsere To-Do-API für ein LLM zugänglich macht:

Zuerst installieren wir das MCP-Paket:

pip install "mcp[cli]"

Dann erstellen wir eine Datei namens todo_mcp_server.py:

from mcp.server.fastmcp import FastMCP
import requests  # we'll use requests to call our REST API

# Initialize an MCP server with a descriptive name
mcp = FastMCP("To-Do API MCP Server")

# Define a Resource for reading tasks (like a GET endpoint)
@mcp.resource("todo://list")
def list_tasks() -> list:
    """Fetch all to-do tasks from the API."""
    response = requests.get("http://localhost:5000/tasks")
    response.raise_for_status()
    return response.json()  # return the list of tasks

# Define a Tool for adding a new task (like a POST operation)
@mcp.tool()
def add_task(title: str) -> dict:
    """Add a new task via the API and return the created task."""
    payload = {"title": title}
    response = requests.post("http://localhost:5000/tasks", json=payload)
    response.raise_for_status()
    return response.json()  # return the new task data

if __name__ == "__main__":
    mcp.run(transport="stdio")

Lassen Sie uns aufschlüsseln, was hier passiert:

• Wir erstellen eine FastMCP-Instanz mit dem Namen "To-Do API MCP Server", die den Server einrichtet und unsere Tools/Ressourcen registriert.
• Wir verwenden @mcp.resource("todo://list"), um eine Ressource bereitzustellen, die die Liste der Aufgaben zurückgibt. Dies entspricht dem GET-Endpunkt unserer API.
• Wir verwenden @mcp.tool(), um ein Tool bereitzustellen, das eine neue Aufgabe hinzufügt. Dies entspricht dem POST-Endpunkt unserer API.
• Die Docstrings für jede Funktion sind wichtig - das LLM wird diese Beschreibungen sehen, wenn es entscheidet, wie es die Tools nutzen soll.
• Wir starten den Server mit mcp.run(transport="stdio"), der über Standard-I/O kommuniziert (gut für lokale Entwicklung).

An diesem Punkt haben wir einen MCP-Server mit zwei Fähigkeiten: eine Ressource todo://list (zum Abrufen von Aufgaben) und ein Tool add_task (zum Erstellen einer Aufgabe). Diese entsprechen den Funktionalitäten unserer API. Effektiv haben wir die REST-API mit MCP umhüllt.

Schritt 3: Ausführen und Testen des MCP-Servers lokal

Bevor Sie den MCP-Server starten, stellen Sie sicher, dass Ihre Flask-API läuft (z.B. mit flask run).

Starten Sie nun den MCP-Server im Entwicklungsmodus:

mcp dev ./todo_mcp_server.py

Der Befehl mcp dev startet ein interaktives Entwicklungs-Dashboard in Ihrem Browser. Dieses Dashboard ermöglicht Ihnen:

1. Den Namen Ihres MCP-Servers und die verfügbaren Tools/Ressourcen zu sehen
2. Die Ressource todo://list zu testen - sie sollte die aktuelle Liste der Aufgaben zurückgeben
3. Das Tool add_task zu testen - geben Sie einen Aufgabentitel ein und führen Sie es aus
4. Ergebnisse zu überprüfen und Logs im Verlaufsbereich zu sehen

Dieses Dashboard ist unbezahlbar für Entwicklung und Debugging. Es verwendet dasselbe MCP-Protokoll, das ein echter LLM-Client verwenden würde, aber mit einer GUI zum Testen.

Schritt 4: Verbinden des MCP-Servers mit einem LLM-Client

Jetzt verbinden wir ein Live-LLM mit unserem MCP-Server. Mehrere KI-Assistenten und Tools unterstützen MCP, darunter:

Verbindung mit Claude Desktop

Anthropics Claude Desktop-Anwendung hat integrierte Unterstützung für lokale MCP-Server. Zur Integration:

mcp install ./todo_mcp_server.py

Dies registriert Ihren Server bei Claude. In der Claude-Oberfläche sollten Sie Ihren “To-Do API MCP Server” verfügbar sehen. Wenn Sie jetzt ein Gespräch mit Claude führen, können Sie:

• Fragen: “Liste meine To-Do-Aufgaben auf” - Claude wird die Ressource todo://list verwenden
• Anfragen: “Füge eine To-Do-Aufgabe hinzu, um Milch zu kaufen” - Claude wird das Tool add_task verwenden

Claude übernimmt die Ausführung des MCP-Servers und das Routing von Anfragen, wenn die KI beschließt, ihn zu verwenden.

Verbindung mit Cursor IDE

Cursor ist ein Code-Editor mit einem KI-Assistenten, der MCP unterstützt. Zum Verbinden:

1. Gehen Sie zu den Cursor-Einstellungen unter “Model Context Protocol”
2. Fügen Sie Ihren MCP-Server hinzu, indem Sie den Pfad zu todo_mcp_server.py angeben
3. Geben Sie den Transport an (stdIo)

Nach der Verbindung erkennt Cursor die Tools und Ressourcen Ihres Servers. Sie können dann den Cursor-Assistenten Fragen stellen wie “Welche Aufgaben sind in meiner To-Do-Liste?” oder “Füge ‘Blogbeitrag schreiben’ zu meinen Aufgaben hinzu.”

Allgemeine Hinweise zu LLM-Clients

Die genauen Verbindungsschritte variieren je nach Client:

• Für Claude Desktop verwenden Sie mcp install oder die UI der App
• Für Cursor konfigurieren Sie den Server in den Einstellungen
• Andere Umgebungen können unterschiedliche Ansätze haben

Nach dem Verbinden testen Sie, indem Sie die KI auf eine Weise auffordern, die die Verwendung von Tools fördert. Viele MCP-Clients zeigen visuell an, wenn die KI ein Tool verwendet.

Sicherheitshinweis: Wenn Sie einen MCP-Server verbinden, hat das LLM Zugriff auf alles, was dieser Server bereitstellt. MCP-Server laufen typischerweise lokal oder innerhalb Ihrer Infrastruktur, was gut für die Sicherheit ist. Wenn Ihre API Authentifizierung erfordert, können Sie diese Anmeldedaten in Ihrem MCP-Server-Code einbinden.

Vergleich von MCP mit traditionellen Ansätzen

Vergleichen wir, wie sich die Bereitstellung einer API über MCP von anderen Integrationsmethoden unterscheidet:

Direkte LLM-API-Aufrufe (Ohne MCP)

Ohne MCP könnten Sie:

• Funktionsaufrufe oder Plugins verwenden, die plattformspezifisch sind (an OpenAI oder eine bestimmte Umgebung gebunden)
• API-Details in Prompts einbetten, was fehleranfällig ist - das Modell könnte Endpunkte halluzinieren oder falsche Formate senden

GraphQL oder andere Abfragesprachen

Mit GraphQL könnten Sie das LLM Abfragen konstruieren lassen, aber:

• Das Modell muss immer noch das Schema und die Abfragesyntax kennen
• Sie würden wahrscheinlich eine benutzerdefinierte Integrationsschicht benötigen, um die Abfragen des Modells zu überprüfen

Der MCP-Vorteil

Die Verwendung von MCP abstrahiert diese Details in eine standardisierte Schnittstelle:

• Das LLM muss keine HTTP-Methoden oder Abfragesyntax kennen
• Es fragt den MCP-Server nach verfügbaren Tools und Ressourcen ab, die menschenlesbare Namen und Beschreibungen haben
• Der Prozess konzentriert sich auf Fähigkeiten statt auf Low-Level-Aufrufe
• Derselbe MCP-Server funktioniert für jeden Client, der das Protokoll unterstützt

Hier ist ein detaillierter Vergleich:

Aspekt Traditionelle API-Integration Verwendung von MCP-Integration Standardisierung Kein einheitlicher Standard - jede Plattform hat ihre eigene Integrationsmethode oder Plugin-Format Ein offener Standard über Plattformen hinweg - einmal erstellen, überall verwenden Entdeckung von Aktionen Dem LLM muss mitgeteilt werden, welche Endpunkte/Abfragen verfügbar sind, oder sie sind fest codiert LLM-Clients können programmgesteuert verfügbare Tools/Ressourcen von einem MCP-Server auflisten Datenzugriff API-Antworten werden oft über Prompts gesendet, was Kontextlimits erreicht MCP-Ressourcen laden Daten direkt in den Kontext des LLM auf kontrollierte Weise Programmieraufwand Hoch - benutzerdefinierte HTTP-Aufrufe, Parsing und Fehlerbehandlung für jedes Modell Vereinfacht - das MCP-SDK behandelt Protokolldetails; Sie schreiben Python-Funktionen Sicherheit & Kontrolle Das Modell könnte beliebige HTTP-Aufrufe generieren, wenn es nicht eingeschränkt wird Der MCP-Server fungiert als Torwächter - Sie entscheiden genau, was bereitgestellt wird Flexibilität Schwer an neue LLMs oder Anwendungsfälle anzupassen Sehr flexibel - Modelle können mehrere MCP-Aufrufe orchestrieren; einfaches Hinzufügen neuer Tools

Kurz gesagt, MCP bietet eine KI-freundlichere Schicht über Ihrer API. Anstatt mit rohen HTTP-Aufrufen zu arbeiten, interagiert das Modell mit benannten Aktionen und Daten, die im Gespräch Sinn ergeben.

Fazit

Die Bereitstellung Ihrer bestehenden REST-API für LLMs über MCP kann die Integration erheblich vereinfachen. Anstatt Einzelverbindungen für jede KI-Plattform zu erstellen, implementieren Sie das Model Context Protocol einmal und erhalten Kompatibilität mit jedem unterstützenden Client.

MCP bietet einen standardisierten, sicheren und flexiblen Weg, um KI und Ihre Daten zu verbinden. Es verwandelt Ihre API in eine modulare Komponente, die jede fortschrittliche KI verantwortungsvoll und intelligent nutzen kann. Dies eröffnet neue Möglichkeiten: Ihr LLM-gesteuerter Assistent könnte Ihre API mit anderen MCP-Konnektoren kombinieren, alles innerhalb desselben einheitlichen Frameworks.

FAQs