```html
Die KI-Entwicklung entwickelt sich rasant, und die Integration externer Tools mit Sprachmodellen ist ein entscheidender Schritt nach vorn. OpenRouter bietet eine einheitliche API, um auf zahlreiche Sprachmodelle zuzugreifen, während MCP Servers (Model Context Protocol Servers) diesen Modellen ermöglichen, externe Tools auszuführen und auf Live-Daten zuzugreifen. Die Kombination beider schafft ein leistungsstarkes System für die Entwicklung fortschrittlicher KI-Anwendungen.
In diesem Beitrag führe ich Sie durch die Integration von MCP Servers mit OpenRouter. Sie lernen ihre Kernfunktionalitäten, den Integrationsprozess und praktische Beispiele kennen.
Verständnis von MCP Servers und OpenRouter
Um MCP Servers mit OpenRouter zu integrieren, müssen Sie zunächst verstehen, was jede Komponente tut.
OpenRouter: Einheitlicher Zugriff auf Sprachmodelle
OpenRouter ist eine Plattform, die die Interaktion mit großen Sprachmodellen (LLMs) von Anbietern wie OpenAI, Anthropic und xAI vereinfacht. Sie bietet einen einzigen API-Endpunkt https://openrouter.ai/api/v1/chat/completions, der mit der API-Struktur von OpenAI kompatibel ist. Zu den wichtigsten Funktionen gehören:
- Modellaggregation: Zugriff auf Hunderte von LLMs über eine einzige Schnittstelle.
- Kostenoptimierung: Leitet Anfragen an kostengünstige Modelle basierend auf Verfügbarkeit und Preisgestaltung weiter.
- Lastausgleich: Verteilt Anfragen, um eine Überlastung bei einem einzelnen Anbieter zu verhindern.
- Fallbacks: Wechselt zu alternativen Modellen, falls eines ausfällt.
Sie benötigen ein OpenRouter-Konto und einen API-Schlüssel, um fortzufahren. Holen Sie sich Ihren unter openrouter.ai.
MCP Servers: Erweiterung der Modellfähigkeiten
MCP Servers implementieren das Model Context Protocol, das es LLMs ermöglicht, externe Tools aufzurufen. Im Gegensatz zu eigenständigen Modellen, die auf ihre Trainingsdaten beschränkt sind, ermöglichen MCP Servers die Interaktion in Echtzeit mit Systemen wie Dateiverzeichnissen, Datenbanken oder APIs von Drittanbietern. Eine typische MCP-Tooldefinition umfasst:
- Name: Identifiziert das Tool (z. B.
list_files). - Beschreibung: Erklärt seinen Zweck.
- Parameter: Gibt Eingaben im JSON-Schema-Format an.
Beispielsweise könnte ein MCP-Tool zum Auflisten von Verzeichnisdateien so aussehen:
{
"name": "list_files",
"description": "Lists files in a specified directory",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Directory path"}
},
"required": ["path"]
}
}
Zusammen bietet OpenRouter das Modell und MCP Servers die Tools, wodurch ein robustes KI-Ökosystem entsteht.
Warum MCP Servers mit OpenRouter integrieren?
Die Kombination dieser Technologien bietet mehrere technische Vorteile:
- Modellflexibilität: Verwenden Sie jedes von OpenRouter unterstützte LLM mit Tool-Calling-Funktionen.
- Kostensenkung: Kombinieren Sie günstigere Modelle mit externen Tools, um komplexe Aufgaben auszulagern.
- Erweiterte Fähigkeiten: Ermöglichen Sie Modellen, Live-Daten abzurufen oder Aktionen auszuführen (z. B. Dateioperationen).
- Skalierbarkeit: Wechseln Sie Modelle oder Tools, ohne Ihre Kernlogik neu zu schreiben.
- Zukunftssicherheit: Passen Sie sich neuen LLMs und Tools an, sobald sie auftauchen.
Diese Integration ist ideal für Entwickler, die KI-Systeme entwickeln, die Interaktivität in der realen Welt benötigen.
Schritt-für-Schritt-Integrationsprozess
Kommen wir nun zur Technik. So integrieren Sie MCP Servers mit OpenRouter.
Voraussetzungen
Stellen Sie sicher, dass Sie Folgendes haben:
- OpenRouter-Konto und API-Schlüssel: Von openrouter.ai.
- MCP Server: Lokal (z. B. unter
http://localhost:8000) oder remote ausgeführt. Für diese Anleitung verwende ich einen Dateisystem-MCP-Server. - Python 3.8+: Mit der
requests-Bibliothek (pip install requests). - Apidog: Optional, aber für API-Tests empfohlen. Kostenlos herunterladen.
Schritt 1: MCP-Tools definieren und konvertieren
OpenRouter verwendet das Tool-Calling-Format von OpenAI, daher müssen Sie MCP-Tooldefinitionen konvertieren. Beginnen Sie mit der MCP-Definition:
{
"name": "list_files",
"description": "Lists files in a specified directory",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Directory path"}
},
"required": ["path"]
}
}
Konvertieren Sie es in das OpenAI-Format, indem Sie ein type-Feld hinzufügen und die Funktionsdetails verschachteln:
{
"type": "function",
"function": {
"name": "list_files",
"description": "Lists files in a specified directory",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Directory path"}
},
"required": ["path"]
}
}
}
Diese JSON-Struktur erwartet OpenRouter in seiner API-Nutzlast.
Schritt 2: Die API-Anfrage konfigurieren
Bereiten Sie eine API-Anfrage an OpenRouter vor. Definieren Sie Header mit Ihrem API-Schlüssel und eine Nutzlast mit dem Modell, den Nachrichten und den Tools. Hier ist ein Python-Beispiel:
import requests
import json
# Headers
headers = {
"Authorization": "Bearer your_openrouter_api_key",
"Content-Type": "application/json"
}
# Payload
payload = {
"model": "openai/gpt-4", # Replace with your preferred model
"messages": [
{"role": "user", "content": "List files in the current directory."}
],
"tools": [
{
"type": "function",
"function": {
"name": "list_files",
"description": "Lists files in a specified directory",
"parameters": {
"type": "object",
"properties": {
"path": {"type": "string", "description": "Directory path"}
},
"required": ["path"]
}
}
}
]
}
Ersetzen Sie your_openrouter_api_key durch Ihren tatsächlichen Schlüssel.
Schritt 3: Die erste API-Anfrage senden
Stellen Sie eine POST-Anfrage an den Endpunkt von OpenRouter:
response = requests.post(
"https://openrouter.ai/api/v1/chat/completions",
headers=headers,
json=payload
)
response_data = response.json()
Schritt 4: Tool-Aufrufe verarbeiten
Überprüfen Sie, ob die Antwort einen Tool-Aufruf enthält:
{
"choices": [
{
"message": {
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_123",
"type": "function",
"function": {
"name": "list_files",
"arguments": "{\"path\": \".\"}"
}
}
]
}
}
]
}
Extrahieren Sie die Tool-Aufrufdetails:
message = response_data["choices"][0]["message"]
if "tool_calls" in message:
tool_call = message["tool_calls"][0]
function_name = tool_call["function"]["name"]
arguments = json.loads(tool_call["function"]["arguments"])
Schritt 5: Den MCP Server aufrufen
Senden Sie die Tool-Anfrage an Ihren MCP Server:
mcp_response = requests.post(
"http://localhost:8000/call",
json={
"name": function_name,
"arguments": arguments
}
)
tool_result = mcp_response.json()["result"] # e.g., ["file1.txt", "file2.txt"]
Schritt 6: Tool-Ergebnis an OpenRouter zurückgeben
Fügen Sie den Tool-Aufruf und das Ergebnis des Assistenten zum Nachrichtenverlauf hinzu:
messages = payload["messages"] + [
{
"role": "assistant",
"content": null,
"tool_calls": [tool_call]
},
{
"role": "tool",
"tool_call_id": tool_call["id"],
"content": json.dumps(tool_result)
}
]
# Update payload
payload["messages"] = messages
# Send follow-up request
final_response = requests.post(
"https://openrouter.ai/api/v1/chat/completions",
headers=headers,
json=payload
)
final_output = final_response.json()["choices"][0]["message"]["content"]
print(final_output) # e.g., "Files: file1.txt, file2.txt"
Schritt 7: Mehrere Tool-Aufrufe verarbeiten
Wenn das Modell mehrere Tool-Aufrufe benötigt, durchlaufen Sie den Prozess in einer Schleife:
messages = payload["messages"]
while True:
response = requests.post(
"https://openrouter.ai/api/v1/chat/completions",
headers=headers,
json={"model": "openai/gpt-4", "messages": messages}
)
message = response.json()["choices"][0]["message"]
if "tool_calls" not in message:
print(message["content"])
break
for tool_call in message["tool_calls"]:
function_name = tool_call["function"]["name"]
arguments = json.loads(tool_call["function"]["arguments"])
mcp_response = requests.post(
"http://localhost:8000/call",
json={"name": function_name, "arguments": arguments}
)
tool_result = mcp_response.json()["result"]
messages.extend([
{"role": "assistant", "content": null, "tool_calls": [tool_call]},
{"role": "tool", "tool_call_id": tool_call["id"], "content": json.dumps(tool_result)}
])
Dadurch wird sichergestellt, dass alle Tool-Aufrufe verarbeitet werden.
Praxisbeispiel: Interaktion mit dem Dateisystem
Wenden wir dies auf ein praktisches Szenario an, in dem Dateien mit einem MCP Server aufgelistet werden.
- Tool-Definition: Verwenden Sie das Tool
list_filesvon zuvor. - MCP Server: Gehen Sie davon aus, dass er unter
http://localhost:8000ausgeführt wird. - API-Aufruf: Senden Sie „Dateien im aktuellen Verzeichnis auflisten“ an OpenRouter.
- Antwortverarbeitung: Das Modell ruft
list_filesmit{"path": "."}auf. - MCP-Ausführung: Der Server gibt
["file1.txt", "file2.txt"]zurück. - Endausgabe: Das Modell antwortet: „Gefundene Dateien: file1.txt, file2.txt.“
Hier ist der vollständige Code:
import requests
import json
headers = {"Authorization": "Bearer your_openrouter_api_key", "Content-Type": "application/json"}
payload = {
"model": "openai/gpt-4",
"messages": [{"role": "user", "content": "List files in the current directory."}],
"tools": [{
"type": "function",
"function": {
"name": "list_files",
"description": "Lists files in a specified directory",
"parameters": {
"type": "object",
"properties": {"path": {"type": "string", "description": "Directory path"}},
"required": ["path"]
}
}
}]
}
response = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json=payload)
message = response.json()["choices"][0]["message"]
if "tool_calls" in message:
tool_call = message["tool_calls"][0]
function_name = tool_call["function"]["name"]
arguments = json.loads(tool_call["function"]["arguments"])
mcp_response = requests.post("http://localhost:8000/call", json={"name": function_name, "arguments": arguments})
tool_result = mcp_response.json()["result"]
messages = payload["messages"] + [
{"role": "assistant", "content": null, "tool_calls": [tool_call]},
{"role": "tool", "tool_call_id": tool_call["id"], "content": json.dumps(tool_result)}
]
final_response = requests.post("https://openrouter.ai/api/v1/chat/completions", headers=headers, json={"model": "openai/gpt-4", "messages": messages})
print(final_response.json()["choices"][0]["message"]["content"])
Behebung häufiger Probleme
Hier sind Lösungen für häufige Probleme:
- Tool wird nicht aufgerufen: Überprüfen Sie die Syntax der Tooldefinition und die Klarheit der Eingabeaufforderung.
- Ungültige Argumente: Stellen Sie sicher, dass die Parameter mit dem JSON-Schema übereinstimmen.
- MCP Server-Fehler: Überprüfen Sie die Serverprotokolle und den Endpunkt (
http://localhost:8000/call). - API-Authentifizierung: Bestätigen Sie, dass Ihr OpenRouter-Schlüssel korrekt ist.
Verwenden Sie Apidog, um API-Anfragen und -Antworten effizient zu debuggen.
Erweiterung der Integration
Um mehr als 2000 Wörter zu erreichen und Tiefe hinzuzufügen, sollten Sie diese Erweiterungen in Betracht ziehen:
Datenbankabfrage-Beispiel
Definieren Sie ein MCP-Tool, um eine Datenbank abzufragen:
{
"type": "function",
"function": {
"name": "query_db",
"description": "Queries a database with SQL",
"parameters": {
"type": "object",
"properties": {"sql": {"type": "string", "description": "SQL query"}},
"required": ["sql"]
}
}
}
Senden Sie „Holen Sie alle Benutzer aus der Datenbank“ an OpenRouter, verarbeiten Sie den query_db-Aufruf und geben Sie Ergebnisse wie [{"id": 1, "name": "Alice"}] zurück.
Fehlerbehandlung
Fügen Sie eine robuste Fehlerbehandlung hinzu:
try:
mcp_response = requests.post("http://localhost:8000/call", json={"name": function_name, "arguments": arguments})
mcp_response.raise_for_status()
except requests.RequestException as e:
tool_result = f"Error: {str(e)}"
Dadurch wird sichergestellt, dass Ihre Anwendung stabil bleibt.
Fazit
Die Integration von MCP Servers mit OpenRouter ermöglicht es Ihrer KI, externe Tools über eine einzige API zu nutzen. Diese Anleitung behandelte Einrichtung, Tool-Konvertierung, API-Aufrufe und praktische Beispiele wie die Interaktion mit dem Dateisystem. Mit Vorteilen wie Kosteneinsparungen und erweiterter Funktionalität ist dieser Ansatz ein Muss für technische Entwickler.
Beginnen Sie jetzt mit dem Experimentieren, holen Sie sich Apidog hier kostenlos hier, um Ihre APIs zu testen. Lassen Sie mich wissen, wie es läuft!
```
