Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Agente Meteo Completo

Lezione 12 di 14 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Costruisci un Agente Meteo Completo da Zero
  2. Architettura dell’Agente
  3. Implementazione delle Funzioni
  4. Il Ciclo Principale dell’Agente
  5. Testa l’Agente
  6. Possibili Miglioramenti
  7. Punti chiave

Costruisci un Agente Meteo Completo da Zero

In questa lezione, assemblerai tutto ciò che hai imparato per costruire un agente meteo completo. Questo agente illustra l’intero ciclo di chiamata alle funzioni: definizione degli strumenti, gestione multi-turno, gestione degli errori e risposte in linguaggio naturale.

Architettura dell’Agente

L’agente meteo dispone di tre strumenti:

  1. get_weather — ottieni il meteo attuale per una città
  2. get_forecast — ottieni le previsioni per più giorni
  3. get_alerts — controlla gli avvisi meteo attivi
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"]
            }
        }
    }
]

Implementazione delle Funzioni

In produzione, queste funzioni chiamerebbero una vera API meteo. Qui simuliamo le risposte:

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

Il Ciclo Principale dell’Agente

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."

Testa l’Agente

# 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?"))

Il Test 3 attiva chiamate parallele: il modello chiama get_weather tre volte simultaneamente. Il Test 4 è il più interessante: il modello dovrebbe chiamare get_forecast E get_alerts per Marsiglia, per poi sintetizzare i risultati in consigli pratici.

Possibili Miglioramenti

Per un agente pronto per la produzione, aggiungi:

  • Cache: evita di chiamare l’API meteo per la stessa città entro 10 minuti
  • Geocodifica: converti i nomi delle città in coordinate per una maggiore precisione
  • Cronologia: salva le preferenze dell’utente (unità di misura, città preferite)
  • Internazionalizzazione: supporta i nomi delle città in tutte le lingue

Punti chiave

  • Un agente completo combina più strumenti con responsabilità distinte
  • Il prompt di sistema guida il comportamento del modello (controlla sistematicamente gli avvisi)
  • Il ciclo multi-turno con max_iterations previene i loop infiniti
  • Il dispatcher execute_function centralizza l’esecuzione e la gestione degli errori
  • Testa con query varie: semplici, multi-città, complesse
  • In produzione, aggiungi caching, geocodifica e cronologia utente