Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Komplettes Beispiel: Lokaler Server mit Agent

Lektion 6 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Zusammenbau der Bausteine
  2. Der Server: weather_server.py
  3. Der Client: main.py
  4. Ausführung des Projekts
  5. Beobachten des Antwortaufbaus
  6. Wenn ein Werkzeug fehlschlägt
  7. Kernaussagen

Aktualisiert am 2. November 2026 — MCP Python SDK v2. Dieser Kurs folgt nun Version 2 des mcp SDKs (Stand 2.3.0 vom 2. Oktober 2026): MCPServer ersetzt FastMCP, Transport-Einstellungen werden in run() oder streamable_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: Das mistralai[agents]-Extra erfordert mcp>=2.2.0,<3.0. Quellen: Was ist neu in v2 · Migrationsanleitung · Bereitstellen & Skalieren. Ergänzung vom 3. November: Lesen Sie das Ergebnis eines run_async-Aufrufs aus result.output_as_text (das mistralai SDK 3.7.0 verfügt über kein output-Attribut), und im Streaming-Modus ist das letzte Ereignis ein RunResult, identifiziert mittels isinstance, 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 MCPServer und @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=True behandelt Werkzeugfehler sanft
  • Alle Codes sind asynchron – verwenden Sie asyncio.run() als Einstiegspunkt