Komplettes Beispiel: Remote-Server mit Authentifizierung
Auf dieser Seite
Aktualisierung vom 2. November 2026 — Le Chat ist jetzt Vibe. Ab dem 28. Mai 2026 wurde Le Chat in Vibe umbenannt (nach wie vor unter chat.mistral.ai): ein einzelner Agent für Arbeit und Code, der Ihre Gespräche, Einstellungen und Abonnements übernimmt. Die klassische Le Chat-Erfahrung bleibt im Chat-Modus verfügbar; im Work-Modus sind Agenten nun Fähigkeiten (aufgerufen mit
@), Erinnerungen dienen als Wissensbasis und die tiefe Suche ist die Fähigkeit Deep Research. Pläne werden nun Mistral Free, Pro, Team und Enterprise genannt. Diese Lektion verwendet den Namen Vibe; einige hier beschriebene Menüs könnten andere Namen oder Standorte haben. Ergänzung vom 3. November: Ergebnisse vonrun_asyncwerden ausresult.output_as_textgelesen; dasmistralaiSDK 3.7.0 verfügt nicht über einoutput-Attribut.
Aktualisierung vom 2. November 2026 — MCP Python SDK v2. Dieser Kurs folgt nun Version 2 des
mcpSDKs (2.3.0 Stand 2. Oktober 2026):MCPServerersetztFastMCP, Transport-Einstellungen verlagern sich inrun()oderstreamable_http_app(), und eine App, die unter einem echten Hostnamen ausgesetzt ist, muss diesen Hostnamen deklarieren (transport_security). Dies ist auch die Version, die vom Mistral SDK erforderlich ist: Diemistralai[agents]-Zusatzfunktion erfordertmcp>=2.2.0,<3.0. Quellen: Was ist neu in v2 · Migrationsanleitung · Bereitstellen & Skalieren.
Szenario: Ein Aufgaben-Management-MCP-Server
In vorherigen Lektionen wurden die einzelnen Bausteine behandelt: HTTP-Transport, Middleware und Token-Authentifizierung. Nun werden Sie diese zu einem voll funktionsfähigen Projekt zusammenfügen. Der Server stellt vier Aufgaben-Management-Tools bereit – erstellen, auflisten, abschließen, löschen – und der Client verbindet sich remote, wobei er bei jeder Anfrage ein Bearer-Token vorlegt. Derselbe Server läuft dann in Vibe ohne eine einzige zusätzliche Zeile Code: das ist der gesamte Vorteil eines Remote-Servers gegenüber einem STDIO-Server.
Der Server: task_server.py
Drei Elemente koexistieren in dieser einzigen Datei. FastAPI übernimmt den HTTP-Transport und die Authentifizierungs-Middleware, MCPServer übernimmt das MCP-Protokoll und die Tools, und ein Python-Dictionary dient als Datenbank. Die Dateireihenfolge ist wichtig: deklarieren Sie zuerst den MCP-Server und seine Tools, erstellen Sie dann die FastAPI-App mit dem lifespan, der den Session-Manager startet, und montieren Sie den Server zuletzt. Beachten Sie, dass die Middleware den Pfad /tasks schützt, genau dort, wo der MCP-Server montiert ist: Diese beiden Werte müssen übereinstimmen, sonst landen Sie entweder mit einer offenen Tür oder einem abgeriegelten Pfad.
# task_server.py
"""Remote MCP server with token authentication."""
import json
import os
import uuid
from contextlib import asynccontextmanager
from datetime import datetime
from fastapi import FastAPI, Request, HTTPException
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings
# --- Konfiguration ---
API_TOKEN = "mcp-secret-token-2026"
# --- In-Memory-Datenbank ---
tasks_db: dict[str, dict] = {}
# --- MCP-Server ---
mcp = MCPServer("Task Manager")
@mcp.tool()
def create_task(title: str, description: str = "", priority: str = "medium") -> str:
"""Erstellt eine neue Aufgabe im Manager.
Args:
title: Aufgaben-Titel (erforderlich, maximal 200 Zeichen)
description: Detaillierte Beschreibung (optional)
priority: Prioritätsstufe: low, medium, high (Standard: medium)
Returns:
JSON mit der ID und den Details der erstellten Aufgabe
"""
task_id = str(uuid.uuid4())[:8]
task = {
"id": task_id,
"title": title[:200],
"description": description,
"priority": priority if priority in ("low", "medium", "high") else "medium",
"status": "open",
"created_at": datetime.now().isoformat(),
}
tasks_db[task_id] = task
return json.dumps({"success": True, "task": task}, ensure_ascii=False)
@mcp.tool()
def list_tasks(status: str = "all", priority: str = "all") -> str:
"""Listet Aufgaben mit optionalen Filtern auf.
Args:
status: Filter nach Status: all, open, completed (Standard: all)
priority: Filter nach Priorität: all, low, medium, high (Standard: all)
Returns:
JSON mit der Aufgabenliste und der Gesamtanzahl
"""
filtered = list(tasks_db.values())
if status != "all":
filtered = [t for t in filtered if t["status"] == status]
if priority != "all":
filtered = [t for t in filtered if t["priority"] == priority]
return json.dumps({
"total": len(filtered),
"tasks": filtered,
}, ensure_ascii=False)
@mcp.tool()
def complete_task(task_id: str) -> str:
"""Markiert eine Aufgabe als abgeschlossen.
Args:
task_id: Die eindeutige Kennung der Aufgabe
Returns:
Bestätigung der Aktualisierung oder eine Fehlermeldung
"""
if task_id not in tasks_db:
return json.dumps({"error": f"Task {task_id} not found"})
tasks_db[task_id]["status"] = "completed"
tasks_db[task_id]["completed_at"] = datetime.now().isoformat()
return json.dumps({"success": True, "task": tasks_db[task_id]}, ensure_ascii=False)
@mcp.tool()
def delete_task(task_id: str) -> str:
"""Löscht eine Aufgabe aus dem Manager.
Args:
task_id: Die eindeutige Kennung der zu löschenden Aufgabe
Returns:
Bestätigung der Löschung oder eine Fehlermeldung
"""
if task_id not in tasks_db:
return json.dumps({"error": f"Task {task_id} not found"})
deleted = tasks_db.pop(task_id)
return json.dumps({"success": True, "deleted_task": deleted["title"]}, ensure_ascii=False)
# --- MCP-Server in FastAPI einbinden ---
# streamable_http_app() erzeugt die ASGI-App für den MCP-Server.
# Der Session-Manager muss vom FastAPI-lifespan gestartet werden,
# sonst antwortet der Server, aber jeder Tool-Aufruf schlägt fehl.
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
api = FastAPI(title="Task Manager MCP", lifespan=lifespan)
# --- Authentifizierungs-Middleware ---
@api.middleware("http")
async def auth_middleware(request: Request, call_next):
"""Überprüft das Token für alle /tasks-Routen."""
if request.url.path.startswith("/tasks"):
auth = request.headers.get("Authorization", "")
if auth != f"Bearer {API_TOKEN}":
raise HTTPException(status_code=401, detail="Invalid token")
return await call_next(request)
# Öffentlicher Hostname (ngrok, Produktionsdomäne) wird dem MCP-Server mitgeteilt
PUBLIC_HOST = os.environ.get("MCP_PUBLIC_HOST", "localhost")
securite = TransportSecuritySettings(
allowed_hosts=[PUBLIC_HOST, f"{PUBLIC_HOST}:*", "localhost:*", "127.0.0.1:*"]
)
api.mount("/tasks", mcp.streamable_http_app(transport_security=securite))
if __name__ == "__main__":
import uvicorn
uvicorn.run(api, host="0.0.0.0", port=8000)
Zwei Implementierungsdetails verdienen Ihre Aufmerksamkeit. In create_task wird der Titel auf 200 Zeichen gekürzt und die Priorität standardmäßig auf medium gesetzt, wenn der empfangene Wert nicht in der erlaubten Liste steht: Das Modell schlägt manchmal plausible, aber vertragswidrige Werte vor, und das Tool muss robust bleiben, ohne zu versagen. In complete_task und delete_task führt eine unbekannte ID keine Ausnahme aus, sondern gibt eine JSON-Fehlermeldung zurück – das Modell kann dies lesen, seinen Fehler verstehen und neu formulieren, wohingegen ein Absturz dies verhindern würde.
Server starten und aussetzen
# In einem ersten Terminal das ngrok-Tunnel öffnen
ngrok http 8000
# Öffentliche URL: https://xyz789.ngrok-free.app
# In einem zweiten Terminal den Server starten und diesen Hostnamen deklarieren
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py
Der MCP-Endpunkt befindet sich dann unter https://xyz789.ngrok-free.app/tasks/mcp. Beachten Sie die Zusammensetzung dieser Adresse: die öffentliche URL von ngrok, gefolgt vom Mount-Pfad /tasks, dann das vom SDK hinzugefügte Suffix /mcp. Verwirrung über diese Verkettung ist die Hauptursache für Verbindungsfehler.
Der Client: client_tasks.py
Auf der Client-Seite ändert sich nichts im Vergleich zu einem lokalen Server außer dem MCP-Client-Typ und der Hinzufügung des Authentifizierungs-Headers. Der Agent erhält jedoch Anweisungen, die seine Rolle in natürlicher Sprache beschreiben – dies ermutigt ihn, jede Aktion zu bestätigen, anstatt Aufrufe stillschweigend zu verketteten.
# client_tasks.py
"""MCP client for the remote task server with authentication."""
import asyncio
import os
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
MCPClientStreamableHTTP,
StreamableHTTPServerParams,
)
API_TOKEN = "mcp-secret-token-2026"
SERVER_URL = "https://xyz789.ngrok-free.app/tasks/mcp"
async def main():
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Erstellen Sie den Agenten mit angepassten Anweisungen
agent = client.beta.agents.create(
model="mistral-medium-latest",
name="task-manager",
instructions=(
"You are an intelligent task manager. "
"Use the available tools to create, list, and manage "
"the user's tasks. Respond in English. "
"Confirm every action performed."
),
)
# Konfigurieren Sie den remote MCP-Client mit Authentifizierung
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url=SERVER_URL,
headers={"Authorization": f"Bearer {API_TOKEN}"},
timeout=30,
)
)
async with RunContext(
agent_id=agent.id,
continue_on_fn_error=True,
) as run_ctx:
await run_ctx.register_mcp_client(mcp_client=mcp_client)
# Gespräch mit dem Manager
conversations = [
"Create a high priority task: Prepare the MCP presentation",
"Create a medium priority task: Review the documentation",
"List all ongoing tasks",
"Mark the first task as completed",
"Show me the remaining tasks",
]
for msg in conversations:
print(f"\n> {msg}")
result = await client.beta.conversations.run_async(
run_ctx=run_ctx,
inputs=msg,
)
print(f"Agent: {result.output_as_text}")
asyncio.run(main())
Die Nachrichtenfolge ist absichtlich gewählt: Sie verkettet zwei Erstellungen, ein Lesen, ein Aktualisieren und ein erneutes Lesen. Dies ist das minimale Szenario, um zu überprüfen, dass der Zustand von einem Aufruf zum nächsten überdauert und dass das Modell die ID einer zuvor im Gespräch erstellten Aufgabe abrufen kann. Wenn die vierte Anweisung fehlschlägt, liegt Ihr Problem selten am Server: Es stammt meist daraus, dass die Antwort von list_tasks die IDs nicht ausreichend sichtbar macht.
Test in Mistral Vibe
Der gleiche Endpunkt kann direkt als benutzerdefinierter Connector hinzugefügt werden, was Ihnen eine Testoberfläche ohne Client-Schreiben bietet. Dies ist auch der beste Weg, um Ihre Docstrings zu validieren: Vibe zeigt sie während der Entdeckung so dar, wie sie sind, sodass Sie sofort sehen, was das Modell vor sich hat, um zu entscheiden, welches Tool es aufrufen soll.
- Gehen Sie zum Tab Connectors in Vibe
- Klicken Sie auf Add Custom Connector
- Geben Sie als Name
Task Managerein, URL alshttps://xyz789.ngrok-free.app/tasks/mcp, und wählen Sie dann Auth: Token und fügen Siemcp-secret-token-2026ein - Klicken Sie auf Connect
Vibe entdeckt dann automatisch die vier Tools, und Sie können in natürlicher Sprache mit Ihrem eigenen Server sprechen.
Projektorganisation und nächste Schritte
task-mcp-project/
├── task_server.py # MCP-Server + FastAPI + Auth
├── client_tasks.py # Python-Client mit Agent
├── requirements.txt # fastapi, uvicorn, mcp>=2.2,<3, mistralai[agents]
└── .env # MISTRAL_API_KEY, API_TOKEN
Dieses Gerüst funktioniert für Prototypen, aber zwei Dinge schließen es für die Produktion aus. Der Klartext-Token im Quellcode muss in .env verlagert werden, und die ngrok-URL ändert sich bei jedem Neustart, wodurch alle konfigurierten Connectors unterbrochen werden. ngrok bleibt das ideale Werkzeug, um eine Idee in Minuten zu validieren; permanente Hosting-Lösungen mit ihren Docker-, Cloud- und Hugging Face Spaces-Optionen sind Gegenstand von Lektion 12.
Kernaussagen
- Ein Remote-Server kombiniert FastAPI (HTTP) +
MCPServer(MCP) + Middleware (Auth), wobei der öffentliche Hostname intransport_securitydeklariert wird - Token-Authentifizierung wird über den Header
Authorization: Bearer ...gehandhabt - Der
MCPClientStreamableHTTP-Client akzeptiert benutzerdefinierte Header für Authentifizierung - Der gleiche Server ist sowohl vom Python SDK als auch von Mistral Vibe nutzbar
- ngrok ermöglicht schnelles Prototyping vor der Produktionsbereitstellung