Salt la conținutul principal
Română— Alege o limbă
Meniu

Agent météorologique complet

Lecția 12 din 14 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Construire un agent météorologique complet de zéro
  2. Architecture de l’agent
  3. Implémentation des fonctions
  4. Boucle principale de l’agent
  5. Tester l’agent
  6. Améliorations possibles
  7. Puncte cheie

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

Dans cette leçon, vous allez assembler tout ce que vous avez appris pour construire un agent météorologique complet. Cet agent illustre le cycle complet d’appel de fonctions : 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éorologique 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éorologiques 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éorologique. 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, [])}

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, ajoutez :

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

Puncte cheie

  • 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 répartiteur execute_function centralise l’exécution et la gestion des erreurs
  • Testez avec des requêtes variées : simples, multi-villes, complexes
  • En production, ajoutez la mise en cache, le géocodage et l’historique utilisateur