Komplettes Beispiel: Lokaler Server mit Agent
Auf dieser Seite
Aktualisiert am 2. November 2026 — MCP Python SDK v2. Dieser Kurs folgt nun Version 2 des
mcpSDKs (Stand 2.3.0 vom 2. Oktober 2026):MCPServerersetztFastMCP, Transport-Einstellungen werden inrun()oderstreamable_http_app()verlegt, 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 benötigt wird: Dasmistralai[agents]-Extra erfordertmcp>=2.2.0,<3.0. Quellen: Was ist neu in v2 · Migrationsanleitung · Bereitstellen & Skalieren. Ergänzung vom 3. November: Lesen Sie das Ergebnis einesrun_async-Aufrufs ausresult.output_as_text(dasmistralaiSDK 3.7.0 verfügt über keinoutput-Attribut), und im Streaming-Modus ist das letzte Ereignis einRunResult, identifiziert mittelsisinstance, wie im offiziellen SDK-Beispiel.
Zusammenbau der Bausteine
In den vorherigen Lektionen wurden die Bausteine einzeln dargestellt: der Server und seine Werkzeuge, der Client und sein RunContext. Nun werden Sie diese zu einem funktionierenden Projekt zusammenfügen – einem lokalen MCP-Server, der Wetterinformationen bereitstellt, angetrieben von einem Mistral-Agenten, der Fragen in natürlicher Sprache beantworten kann. Lesen Sie den Code, achten Sie aber besonders darauf, was jeder Teil entscheidet: Der Server entscheidet, was möglich ist, der Agent entscheidet, was relevant ist.
Der Server: weather_server.py
Dieser Server besteht aus drei Werkzeugen. Das erste gibt das Wetter für eine Stadt zurück, das zweite vergleicht zwei Städte, und das dritte listet auf, was die Datenbank enthält. Das letzte ist nicht nur dekorativ: Es gibt dem Modell einen Weg, den verfügbaren Umfang zu entdecken, statt Stadtname zu raten.
# weather_server.py
"""Lokaler MCP-Server, der Wetter-Werkzeuge bereitstellt."""
from mcp.server.mcpserver import MCPServer
import json
app = MCPServer("Weather Service")
# Simulierte Datenbank
WEATHER_DATA = {
"paris": {"temp": 18.5, "condition": "Cloudy", "humidity": 72},
"lyon": {"temp": 22.0, "condition": "Sunny", "humidity": 45},
"marseille": {"temp": 25.3, "condition": "Sunny", "humidity": 38},
"lille": {"temp": 14.2, "condition": "Rainy", "humidity": 88},
"bordeaux": {"temp": 20.1, "condition": "Partly cloudy", "humidity": 55},
}
@app.tool()
def get_weather(city: str) -> str:
"""Ruft das aktuelle Wetter für eine französische Stadt ab.
Args:
city: Stadtname in Kleinbuchstaben (paris, lyon, marseille, etc.)
Returns:
JSON mit Temperatur, Wetterlage und Luftfeuchtigkeit.
Gibt einen Fehler zurück, wenn die Stadt unbekannt ist.
"""
city_lower = city.lower().strip()
if city_lower in WEATHER_DATA:
data = WEATHER_DATA[city_lower]
return json.dumps({
"city": city.capitalize(),
"temperature_celsius": data["temp"],
"condition": data["condition"],
"humidity_percent": data["humidity"],
}, ensure_ascii=False)
return json.dumps({"error": f"City {city} not found. Available cities: {', '.join(WEATHER_DATA.keys())}"})
@app.tool()
def compare_weather(city_a: str, city_b: str) -> str:
"""Vergleicht das Wetter zwischen zwei französischen Städten.
Args:
city_a: Erste Stadt (Kleinbuchstaben)
city_b: Zweite Stadt (Kleinbuchstaben)
Returns:
Vergleich der Temperaturen und Wetterlagen für beide Städte
"""
a = WEATHER_DATA.get(city_a.lower().strip())
b = WEATHER_DATA.get(city_b.lower().strip())
if not a:
return f"Unknown city: {city_a}"
if not b:
return f"Unknown city: {city_b}"
diff = a["temp"] - b["temp"]
warmer = city_a if diff > 0 else city_b
return json.dumps({
"city_a": {"name": city_a.capitalize(), **a},
"city_b": {"name": city_b.capitalize(), **b},
"temperature_difference": abs(diff),
"warmer_city": warmer.capitalize(),
}, ensure_ascii=False)
@app.tool()
def list_cities() -> str:
"""Listet alle Städte auf, die in der Wetterdatenbank verfügbar sind.
Returns:
Liste der Städte mit ihrer aktuellen Temperatur
"""
cities = [
{"city": k.capitalize(), "temp": v["temp"], "condition": v["condition"]}
for k, v in WEATHER_DATA.items()
]
return json.dumps(cities, ensure_ascii=False)
Zwei Design-Details verdienen Aufmerksamkeit. Die Werkzeuge normalisieren die Eingabe mit .lower().strip(), da das Modell je nach Formulierung des Benutzers „Paris” oder „paris” schreiben könnte. Und wenn eine Stadt fehlt, wirft get_weather keine Ausnahme auf: Es gibt ein Fehler-JSON zurück, das die bekannten Städte auflistet und den Fehler in Informationen verwandelt, die das Modell nutzen kann.
Der Client: main.py
Der Client tut vier Dinge in der Reihenfolge: Er initialisiert Mistral, erstellt den Agenten, beschreibt, wie der Server gestartet wird, und öffnet den RunContext, um Gespräche zu verknüpfen.
# main.py
"""MCP-Client mit Mistral-Agent für Wetterabfragen."""
import asyncio
import os
from pathlib import Path
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mcp import StdioServerParameters
from pydantic import BaseModel
# Konfiguration
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
SERVER_PATH = Path(__file__).parent / "weather_server.py"
# Format für strukturierte Ausgabe (optional)
class WeatherResponse(BaseModel):
summary: str
details: dict | None = None
async def main():
# 1. Mistral-Client initialisieren
client = Mistral(api_key=MISTRAL_API_KEY)
# 2. Den Agenten erstellen
agent = client.beta.agents.create(
model="mistral-medium-latest",
name="weather-assistant",
instructions=(
"You are a weather assistant for France. "
"Use available tools to answer questions. "
"Always respond in French with metric units."
),
)
# 3. Lokalen MCP-Server konfigurieren
server_params = StdioServerParameters(
command="python",
args=[str(SERVER_PATH)],
env=None,
)
mcp_client = MCPClientSTDIO(stdio_params=server_params)
# 4. Kontext öffnen und MCP-Client registrieren
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)
# 5. Gespräche starten
questions = [
"What's the weather like in Paris?",
"Compare the weather between Marseille and Lille.",
"Which city is the warmest right now?",
]
for question in questions:
print(f"\n{'='*60}")
print(f"Question: {question}")
print(f"{'='*60}")
result = await client.beta.conversations.run_async(
run_ctx=run_ctx,
inputs=question,
)
print(f"Response: {result.output_as_text}")
# 6. Automatische Bereinigung beim Verlassen des Kontext-Managers
print("\nAgent and MCP server closed cleanly.")
if __name__ == "__main__":
asyncio.run(main())
Beachten Sie den Server-Pfad: Path(__file__).parent / "weather_server.py" lokalisiert die Datei relativ zum Skript, nicht zum aktuellen Verzeichnis. Dies ist der einzige Weg, um sicherzustellen, dass der Start funktioniert, egal wo Sie python main.py ausführen.
Ausführung des Projekts
# API-Schlüssel setzen
export MISTRAL_API_KEY="your_mistral_api_key"
# Client starten (er startet den Server automatisch)
python main.py
Sie starten nur einen Prozess. Der Client erstellt den Mistral-Agenten, der RunContext startet weather_server.py als STDIO-Prozess, entdeckt die drei Werkzeuge – get_weather, compare_weather und list_cities – und lässt das Modell dann, Frage für Frage, entscheiden, welche davon aufgerufen werden sollen, bevor es die Ergebnisse in seine Antwort integriert. Die dritte Frage im Beispiel ist die interessanteste zu beobachten: Um herauszufinden, welche Stadt am wärmsten ist, hat das Modell keine andere Wahl, als list_cities zu durchlaufen, auch wenn kein Wort in der Frage dies nahelegt.
Beobachten des Antwortaufbaus
Das Warten auf die vollständige Antwort funktioniert für ein Skript; gegenüber einem Benutzer bietet der Streaming-Modus ein viel besseres Erlebnis.
from mistralai.extra.run.result import RunResult
async with RunContext(agent_id=agent.id) as run_ctx:
await run_ctx.register_mcp_client(mcp_client=mcp_client)
events = await client.beta.conversations.run_stream_async(
run_ctx=run_ctx,
inputs="What's the weather like in Lyon?",
)
async for event in events:
if isinstance(event, RunResult):
# Letztes Ereignis: vollständiges Laufergebnis
print(event.output_as_text)
else:
# Zwischenereignisse (Werkzeugaufrufe, etc.)
print(f"[Event] {event}")
Der Ereignisstrom dient nicht nur der Anzeige: Er ist auch Ihr bestes Debugging-Tool, da er Werkzeugaufrufe und Argumente, die vom Modell in Echtzeit gewählt wurden, offenlegt.
Wenn ein Werkzeug fehlschlägt
Dank continue_on_fn_error=True bricht eine Anfrage außerhalb des Umfangs nichts. Wenn der Benutzer nach dem Wetter in Tokio fragt, gibt get_weather sein Fehler-JSON zurück, das Modell liest es und antwortet daraufhin, indem es die tatsächlich verfügbaren Städte vorschlägt.
# Wenn der Benutzer eine nicht existierende Stadt anfordert:
# → get_weather gibt {"error": "City tokyo not found..."} zurück
# → Das Modell liest den Fehler und formuliert seine Antwort neu
# → "I'm sorry, Tokyo is not in my database. Here are the available cities..."
Am Ende passt das Projekt in vier Dateien, von denen nur zwei Logik enthalten:
weather-mcp-project/
├── weather_server.py # MCP-Server (3 Werkzeuge)
├── main.py # Client mit Mistral-Agent
├── requirements.txt # mcp>=2.2,<3, mistralai[agents], pydantic
└── .env # MISTRAL_API_KEY=...
Kernaussagen
- Ein komplettes MCP-Projekt = Server (Werkzeuge) + Client (Agent + RunContext)
- Der Server definiert Werkzeuge mit
MCPServerund@app.tool()-Decoratoren - Der Client erstellt den Agenten, öffnet den RunContext und startet Gespräche
- Streaming-Modus ermöglicht schrittweise Anzeige
continue_on_fn_error=Truebehandelt Werkzeugfehler sanft- Alle Codes sind asynchron – verwenden Sie
asyncio.run()als Einstiegspunkt