Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Agent météo complet

Lektion 12 av 14 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Construire un agent météo complet de zéro
  2. Architecture de l’agent
  3. Implémentation des fonctions
  4. La boucle principale de l’agent
  5. Tester l’agent
  6. Améliorations possibles
  7. Viktiga punkter

Construire un agent météo complet de zéro

Dans cette leçon, tu vas assembler tout ce que tu as appris pour construire un agent météo complet. Cet agent illustre le cycle complet d’appel de fonction : définition des outils, gestion des tours multiples, gestion des erreurs et réponses en langage naturel.

Architecture de l’agent

L’agent météo dispose de trois outils :

  1. get_weather — obtenir la météo actuelle d’une ville
  2. get_forecast — obtenir les prévisions sur plusieurs jours
  3. get_alerts — vérifier les alertes météo actives
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"]
            }
        }
    }
]

Implémentation des fonctions

En production, ces fonctions appelleraient une véritable API météo. Ici, nous simulons les réponses :

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, [])}

La boucle principale de l’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."

Tester l’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?"))

Le test 3 déclenche des appels parallèles : le modèle appelle get_weather trois fois simultanément. Le test 4 est le plus intéressant : le modèle doit appeler get_forecast ET get_alerts pour Marseille, puis synthétiser les résultats en conseils pratiques.

Améliorations possibles

Pour un agent prêt pour la production, ajoute :

  • Cache : évite d’appeler l’API météo pour la même ville dans un délai de 10 minutes
  • Géocodage : convertis les noms de villes en coordonnées pour plus de précision
  • Historique : sauvegarde les préférences utilisateur (unités, villes favorites)
  • Internationalisation : prends en charge les noms de villes dans toutes les langues

Viktiga punkter

  • Un agent complet combine plusieurs outils aux responsabilités distinctes
  • Le prompt système guide le comportement du modèle (vérifier systématiquement les alertes)
  • La boucle multi-tours avec max_iterations empêche les boucles infinies
  • Le distributeur execute_function centralise l’exécution et la gestion des erreurs
  • Teste avec des requêtes variées : simples, multi-villes, complexes
  • En production, ajoute la mise en cache, le géocodage et l’historique utilisateur