Vollständiger Wetter-Agent — Function Calling mit Grok

Einen vollständigen Wetter-Agenten von Grund auf erstellen

In dieser Lektion stellen Sie alles zusammen, was Sie gelernt haben, um einen vollständigen Wetter-Agenten zu erstellen. Dieser Agent veranschaulicht den gesamten Funktionsaufruf-Zyklus: Tool-Definition, Mehrfach-Runden-Handling, Fehlerbehandlung und natürliche Sprachantworten.

Agenten-Architektur

Der Wetter-Agent verfügt über drei Tools:

get_weather — aktuelle Wetterdaten für eine Stadt abrufen
get_forecast — Vorhersagen für mehrere Tage abrufen
get_alerts — aktive Wetterwarnungen prüfen

import json
from openai import OpenAI

client = OpenAI(
    api_key="your-xai-key",
    base_url="https://api.x.ai/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Holen Sie sich das aktuelle Wetter für eine Stadt. "
                          "Gibt Temperatur, Luftfeuchtigkeit, Wind und Bedingungen zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Stadtname (z. B. Paris, Lyon, Marseille)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_forecast",
            "description": "Holen Sie sich Wettervorhersagen für mehrere Tage. "
                          "Gibt tagesbezogene Bedingungen zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Stadtname"
                    },
                    "days": {
                        "type": "integer",
                        "description": "Anzahl der Vorhersage-Tage (1-7)",
                        "default": 3
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_alerts",
            "description": "Prüfen Sie aktive Wetterwarnungen (Stürme, Hitzewellen, "
                          "Überschwemmungen) für eine Stadt oder Region.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Stadt- oder Regionsname"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

Funktionsimplementierung

In der Produktion würden diese Funktionen eine echte Wetter-API aufrufen. Hier simulieren wir die Antworten:

def get_weather(city, unit="celsius"):
    # In der Produktion: OpenWeatherMap, WeatherAPI etc. aufrufen
    data = {
        "Paris": {"temp": 18, "humidity": 65, "wind": 12, "conditions": "Cloudy"},
        "Lyon": {"temp": 21, "humidity": 55, "wind": 8, "conditions": "Sunny"},
        "Marseille": {"temp": 24, "humidity": 70, "wind": 15, "conditions": "Clear"},
    }
    result = data.get(city, {"error": f"City {city} not found"})
    if "error" not in result:
        result["city"] = city
        result["unit"] = unit
    return result

def get_forecast(city, days=3):
    return {
        "city": city,
        "forecast": [
            {"day": f"Day+{i+1}", "temp_max": 20+i, "temp_min": 12+i,
             "conditions": "Variable"}
            for i in range(days)
        ]
    }

def get_alerts(city):
    alerts = {
        "Marseille": [{"type": "Strong Wind", "severity": "orange",
                       "message": "Gusts up to 90 km/h expected"}],
    }
    return {"city": city, "alerts": alerts.get(city, [])}

Der Hauptzyklus des Agenten

def execute_function(name, args):
    functions = {
        "get_weather": get_weather,
        "get_forecast": get_forecast,
        "get_alerts": get_alerts,
    }
    fn = functions.get(name)
    if not fn:
        return {"error": f"Unknown function {name}"}
    try:
        return fn(**args)
    except Exception as e:
        return {"error": str(e)}

def weather_agent(user_message):
    messages = [
        {
            "role": "system",
            "content": "Sie sind ein erfahrener Wetter-Assistent. "
                       "Verwenden Sie die verfügbaren Tools, um "
                       "genaue Wetterinformationen bereitzustellen. Prüfen Sie "
                       "immer Warnungen, wenn nach dem Wetter einer Stadt gefragt wird."
        },
        {"role": "user", "content": user_message}
    ]

    for _ in range(5):  # Maximal 5 Runden
        response = client.chat.completions.create(
            model="grok-4.5",
            messages=messages,
            tools=tools
        )

        message = response.choices[0].message
        messages.append(message)

        if not message.tool_calls:
            return message.content

        for tc in message.tool_calls:
            args = json.loads(tc.function.arguments)
            print(f"  → Aufruf: {tc.function.name}({args})")
            result = execute_function(tc.function.name, args)
            messages.append({
                "role": "tool",
                "tool_call_id": tc.id,
                "content": json.dumps(result, ensure_ascii=False)
            })

    return "Sorry, too many turns required."

Den Agenten testen

# Test 1: einfache Frage
print(weather_agent("Wie ist das Wetter in Paris?"))

# Test 2: Vorhersage
print(weather_agent("Geben Sie mir die Vorhersage für Lyon für 5 Tage"))

# Test 3: mehrere Städte (parallele Aufrufe)
print(weather_agent("Vergleichen Sie das Wetter zwischen Paris, Lyon und Marseille"))

# Test 4: komplexe Frage
print(weather_agent("Ich fahre dieses Wochenende nach Marseille, was empfehlen Sie?"))

Test 3 löst parallele Aufrufe aus: das Modell ruft get_weather drei Mal gleichzeitig auf. Test 4 ist der interessanteste – das Modell sollte get_forecast UND get_alerts für Marseille aufrufen und die Ergebnisse dann in praktische Empfehlungen zusammenfassen.

Mögliche Verbesserungen

Für einen produktionsreifen Agenten fügen Sie hinzu:

Cache: Vermeiden Sie den Aufruf der Wetter-API für dieselbe Stadt innerhalb von 10 Minuten
Geocoding: Konvertieren Sie Stadtname in Koordinaten für eine bessere Genauigkeit
Verlauf: Speichern Sie Benutzerpräferenzen (Einheiten, Lieblingsstädte)
Internationalisierung: Unterstützen Sie Stadtname in allen Sprachen

Kernaussagen

Ein vollständiger Agent kombiniert mehrere Tools mit unterschiedlichen Verantwortlichkeiten
Der System-Prompt leitet das Modellverhalten (Warnungen systematisch prüfen)
Der Mehrfach-Runden-Zyklus mit max_iterations verhindert unendliche Schleifen
Der execute_function-Dispatcher zentralisiert die Ausführung und Fehlerbehandlung
Testen Sie mit unterschiedlichen Abfragen: einfach, mehrere Städte, komplex
Fügen Sie in der Produktion Caching, Geocoding und Benutzerhistorie hinzu