Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Volledige Weeragent

Les 12 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Bouw een Volledige Weeragent vanaf Nul
  2. Agent-architectuur
  3. Implementatie van de Functies
  4. De Hoofdlus van de Agent
  5. Test de Agent
  6. Mogelijke Verbeteringen
  7. Belangrijkste punten

Bouw een Volledige Weeragent vanaf Nul

In deze les combineert u alles wat u heeft geleerd om een volledige weeragent te bouwen. Deze agent illustreert de volledige cyclus van functieaanroepen: tool-definitie, afhandeling van meerdere gespreksbeurten, foutafhandeling en antwoorden in natuurlijke taal.

Agent-architectuur

De weeragent beschikt over drie tools:

  1. get_weather — haal het huidige weer voor een stad op
  2. get_forecast — haal voorspellingen voor meerdere dagen op
  3. get_alerts — controleer op actieve weerwaarschuwingen
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": "Get current weather for a city. "
                          "Returns temperature, humidity, wind, and conditions.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name (e.g., Paris, Lyon, Marseille)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_forecast",
            "description": "Get weather forecasts for multiple days. "
                          "Returns day-by-day conditions.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    },
                    "days": {
                        "type": "integer",
                        "description": "Number of forecast days (1-7)",
                        "default": 3
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_alerts",
            "description": "Check active weather alerts (storms, heatwaves, "
                          "floods) for a city or region.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City or region name"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

Implementatie van de Functies

In een productieomgeving zouden deze functies een echte weer-API aanroepen. Hier simuleren we de antwoorden:

def get_weather(city, unit="celsius"):
    # In production: call OpenWeatherMap, WeatherAPI, etc.
    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, [])}

De Hoofdlus van de Agent

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": "You are an expert weather assistant. "
                       "Use the available tools to provide "
                       "accurate weather information. Always "
                       "check alerts when asked about the "
                       "weather for a city."
        },
        {"role": "user", "content": user_message}
    ]

    for _ in range(5):  # Max 5 turns
        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"  → Calling: {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."

Test de Agent

# Test 1: simple question
print(weather_agent("What's the weather like in Paris?"))

# Test 2: forecast
print(weather_agent("Give me the forecast for Lyon for 5 days"))

# Test 3: multi-city (parallel calls)
print(weather_agent("Compare the weather between Paris, Lyon, and Marseille"))

# Test 4: complex question
print(weather_agent("I'm going to Marseille this weekend, what do you recommend?"))

Test 3 activeert parallelle aanroepen: het model roept get_weather drie keer gelijktijdig aan. Test 4 is het meest interessant: het model moet get_forecast EN get_alerts voor Marseille aanroepen en vervolgens de resultaten synthetiseren tot praktisch advies.

Mogelijke Verbeteringen

Voeg voor een productieklaar agent het volgende toe:

  • Cache: vermijd het aanroepen van de weer-API voor dezelfde stad binnen 10 minuten
  • Geocodering: converteer stadsnamen naar coördinaten voor betere nauwkeurigheid
  • Geschiedenis: sla gebruikersvoorkeuren op (eenheden, favoriete steden)
  • Internationalisering: ondersteun stadsnamen in alle talen

Belangrijkste punten

  • Een volledige agent combineert meerdere tools met verschillende verantwoordelijkheden
  • De systeemprompt stuurt het gedrag van het model (controleer waarschuwingen systematisch)
  • De lus met meerdere beurten en max_iterations voorkomt oneindige lussen
  • De execute_function-dispatcher centraliseert uitvoering en foutafhandeling
  • Test met gevarieerde query’s: eenvoudig, meerdere steden, complex
  • Voeg in productie caching, geocodering en gebruikersgeschiedenis toe