Konfigurieren eines Remote SSE-Servers
Auf dieser Seite
Update vom 2. November 2026 — Le Chat ist jetzt Vibe. Ab dem 28. Mai 2026 wurde Le Chat in Vibe umbenannt (immer noch 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 Deep Search 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önnen 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.
Update 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 werden inrun()oderstreamable_http_app()verschoben, 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.
Vom lokalen zum Remote-Server
Bisher hat Ihr MCP-Server auf Ihrem Gerät gelebt und über STDIO kommuniziert. Dieser Modus ist ideal für die Entwicklung, isoliert aber Ihre Arbeit: Niemand anderes kann ihn nutzen, und Mistrals Vibe kann niemals einen Prozess auf Ihrem lokalen Gerät starten. Um diese Grenze zu überschreiten, müssen Sie den Server über HTTP aussetzen.
Die Änderung ist geringer, als Sie vielleicht denken. Ein Remote-MCP-Server veröffentlicht seine Tools an einer URL; der Client – Vibe, ein SDK oder eine IDE – verbindet sich über das Netzwerk statt einen Prozess zu starten. Ihr Tool-Code selbst bleibt unverändert.
Der Server ändert sich kaum
MCPServer unterstützt den Streamable-HTTP-Transport nativ. Die Datei unten ist genau wie ein lokaler Server geschrieben: gleiche Dekoratoren, gleiche Docstrings, gleiche typisierte Signaturen.
# remote_server.py
"""Remote MCP server mit HTTP-Transport."""
from mcp.server.mcpserver import MCPServer
# Der Server ist derselbe wie lokal
app = MCPServer("Remote Demo Server")
@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
"""Text analysieren und Statistiken zurückgeben.
Args:
text: Der zu analysierende Text
language: Sprachcode (fr, en, es). Standard: fr
Returns:
Textstatistiken: Wortanzahl, Zeichenanzahl, Satzanzahl
"""
words = len(text.split())
chars = len(text)
sentences = text.count(".") + text.count("!") + text.count("?")
return (
f"Sprache: {language}\n"
f"Wörter: {words}\n"
f"Zeichen: {chars}\n"
f"Sätze: {sentences}"
)
@app.tool()
def summarize_key_points(text: str, max_points: int = 5) -> str:
"""Wesentliche Punkte aus Text extrahieren (vereinfachte Version).
Args:
text: Der Quelltext
max_points: Maximale Anzahl zu extrahierender Punkte (1-10)
Returns:
Liste der identifizierten wesentlichen Punkte
"""
sentences = [s.strip() for s in text.split(".") if len(s.strip()) > 20]
points = sentences[:max_points]
return "\n".join(f"- {p}" for p in points) if points else "Keine wesentlichen Punkte identifiziert."
Die einzige Änderung ist ein Startblock, der am Ende der Datei hinzugefügt wird: HTTP-Transport, Port und die Liste der Hostnamen, die der Server akzeptiert.
import os
from mcp.server.transport_security import TransportSecuritySettings
if __name__ == "__main__":
# Öffentlicher Hostname, z. B. der, den ngrok Ihnen zuweist (ohne https://)
public_host = os.environ.get("MCP_PUBLIC_HOST")
hosts = ["localhost:*", "127.0.0.1:*"]
if public_host:
hosts += [public_host, f"{public_host}:*"]
app.run(
transport="streamable-http",
port=8000,
transport_security=TransportSecuritySettings(allowed_hosts=hosts),
)
python remote_server.py
Ihr Server hört nun auf http://localhost:8000/mcp. Die Liste allowed_hosts ist kein Detail: Standardmäßig akzeptiert SDK v2 nur Anfragen, die an localhost oder 127.0.0.1 adressiert sind, als Schutz vor DNS-Rebinding. Hinter einem Tunnel oder einem echten Domänennamen erhält jede andere Anfrage einen Fehler 421 Invalid Host header, den der Client als allgemeinen Transportfehler anzeigt; nur das Serverprotokoll enthüllt den Grund.
Eine öffentliche URL mit ngrok erhalten
Um Ihren Server von Vibe aus zu testen, ohne eine vollständige Bereitstellung vorzunehmen, erstellt ngrok einen Tunnel zwischen einer öffentlichen URL und Ihrem lokalen Port. Dieses Werkzeug verkürzt den Entwicklungszyklus mehr als alles andere: Sie ändern ein Tool, starten neu, und der Remote-Verbinde sieht die neue Version sofort.
# Installieren Sie den ngrok-Agenten unter https://ngrok.com/download, und authentifizieren Sie sich (einmalig)
ngrok config add-authtoken YOUR_NGROK_TOKEN
# Port 8000 aussetzen
ngrok http 8000
ngrok weist Ihnen eine Adresse wie https://abc123.ngrok-free.app. zu. Starten Sie den Server neu, indem Sie diesen Hostnamen deklarieren (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Ihr MCP-Endpunkt wird dies, einfach indem Sie den Pfad /mcp anhängen:
https://abc123.ngrok-free.app/mcp
Fügen Sie diese URL so in Mistral Vibe als benutzerdefinierten Verbindungsassistenten hinzu. Denken Sie daran, dass sie vorübergehend ist und Ihr Gerät aussetzt: Lassen Sie keinen Tunnel offen auf einem Server, der echte Daten berührt.
Verbindung eines Python-Clients
Auf der Client-Seite bleibt die Code-Struktur dieselbe wie in der Lektion RunContext. Nur die Verbindungsklasse unterscheidet sich: MCPClientStreamableHTTP mit StreamableHTTPServerParams ersetzt das STDIO-Paar, und Sie geben eine URL statt eines Befehls an.
# remote_client.py
import asyncio
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
MCPClientStreamableHTTP,
StreamableHTTPServerParams,
)
async def main():
client = Mistral(api_key="YOUR_API_KEY")
agent = client.beta.agents.create(
model="mistral-medium-latest",
name="remote-assistant",
instructions="Sie verwenden Remote-Tools, um Text zu analysieren.",
)
# Verbindung zum Remote-Server
server_url = "https://abc123.ngrok-free.app/mcp"
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url=server_url,
timeout=100, # Timeout in Sekunden
)
)
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)
result = await client.beta.conversations.run_async(
run_ctx=run_ctx,
inputs="Analysieren Sie diesen Text: MCP ist ein offenes Protokoll.",
)
print(result.output_as_text)
asyncio.run(main())
Der Parameter timeout verdient einen Moment der Überlegung. Über STDIO waren Aufrufe nahezu sofort; über das Netzwerk kann ein Tool, das eine Drittanbieter-API abfragt oder ein großes Dokument verarbeitet, mehrere Zehntelsekunden dauern. Ein Timeout, der zu kurz ist, manifestiert sich als intermittierende, schwer reproduzierbare Fehler, meist bei den nützlichsten Anfragen.
Wenn der Server bestimmte Header erwartet – ein API-Token, ein Routing-Schlüssel, eine CORS-Beschränkung – geben Sie diese in headers an:
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url="https://my-server.example.com/mcp",
timeout=100,
headers={
"Authorization": "Bearer my_api_token",
"X-Custom-Header": "value",
},
)
)
Mehrere Server auf einem einzigen Host
Lektion 3 empfahl fokussierte Server statt eines Alleskönner-Katalogs. Diese Empfehlung verurteilt Sie nicht dazu, pro Server eine Maschine zu mieten: Mit FastAPI können Sie mehrere MCP-Server auf unterschiedlichen Routen desselben Hosts mounten.
# server.py — Mehrere MCP-Server auf einem einzigen Host
from contextlib import asynccontextmanager
from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings
# MCP-Server für Textanalyse
text_mcp = MCPServer("Text Analysis")
@text_mcp.tool()
def analyze(text: str) -> str:
"""Text analysieren."""
return f"Wörter: {len(text.split())}"
# MCP-Server für Berechnungen
math_mcp = MCPServer("Math Tools")
@math_mcp.tool()
def calculate(expression: str) -> str:
"""Bewerten Sie einen mathematischen Ausdruck."""
return str(eval(expression)) # Warnung: eval in der Produktion!
# Jeder MCP-Server erzeugt eine eigenständige ASGI-App,
# die den Hostnamen kennen muss, unter dem sie bereitgestellt wird
security = TransportSecuritySettings(allowed_hosts=["mon-serveur.com", "mon-serveur.com:*"])
text_app = text_mcp.streamable_http_app(transport_security=security)
math_app = math_mcp.streamable_http_app(transport_security=security)
# Kombinierte Lebensdauer: Jeder Server muss seinen Session-Manager starten
@asynccontextmanager
async def lifespan(app: FastAPI):
async with text_mcp.session_manager.run(), math_mcp.session_manager.run():
yield
api = FastAPI(lifespan=lifespan)
api.mount("/text", text_app)
api.mount("/math", math_app)
Sie erhalten zwei unabhängige Endpunkte, https://mon-serveur.com/text/mcp für Textanalyse-Tools und https://mon-serveur.com/math/mcp für Mathematik-Tools, die Sie separat in Vibe hinzufügen. Der kritische Punkt ist die lifespan: Jeder MCP-Server verfügt über einen Session-Manager, der explizit gestartet werden muss. Wenn Sie die Apps mounten, ohne diese lifespan an FastAPI zu übergeben, antwortet der Server, aber jeder Tool-Aufruf fehlschlägt mit einem Fehler einer nicht initialisierten Aufgabe. Ein Benutzer, der nur Berechnungen benötigt, wird seinen Kontext nicht mit Text-Tools belasten. Der Kommentar zu eval ist kein Scherz: Auf einem öffentlichen Endpunkt führt diese Zeile jeden Code aus, der vom Aufrufer gesendet wird – es ist ein didaktisches Beispiel, niemals ein Produktionsmuster.
Eine letzte Reflexion: Bevor Sie Ihre URL einem Chat hinzufügen, führen Sie sie erneut durch den Inspector. Ein Remote-Endpunkt fügt Fehlerquellen hinzu, die lokal ignoriert wurden – geschlossener Tunnel, fehlender Header, belegter Port – und es ist besser, sie außerhalb eines Gesprächs zu entdecken.
Kernaussagen
- Ein Remote-MCP-Server veröffentlicht seine Tools über HTTP an einem
/mcp-Endpunkt - ngrok ermöglicht es Ihnen, eine öffentliche URL für die Entwicklung zu erhalten
MCPClientStreamableHTTPmitStreamableHTTPServerParamsverbindet den Client mit dem Remote-Server (MCPClientSSEist jetzt nur noch für veraltete/sse-Endpunkte)- Der Parameter timeout ist für langsame Server wichtig
- Sie können mehrere MCP-Server auf demselben FastAPI-Host mounten, sofern Sie deren lifespan übergeben
- Testen Sie immer mit dem Inspector, bevor Sie in einen Chat integrieren