Ir al contenido principal
Español— Elegir un idioma
Menú

Agente meteorológico completo

Lección 12 de 14 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Construye un agente meteorológico completo desde cero
  2. Arquitectura del agente
  3. Implementación de las funciones
  4. Bucle principal del agente
  5. Prueba del agente
  6. Posibles mejoras
  7. Puntos clave

Construye un agente meteorológico completo desde cero

En esta lección, reunirás todo lo que has aprendido para construir un agente meteorológico completo. Este agente ilustra el ciclo completo de llamada a funciones: definición de herramientas, gestión de múltiples turnos, manejo de errores y respuestas en lenguaje natural.

Arquitectura del agente

El agente meteorológico cuenta con tres herramientas:

  1. get_weather — obtiene el tiempo actual de una ciudad
  2. get_forecast — obtiene previsiones para varios días
  3. get_alerts — comprueba alertas meteorológicas activas
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"]
            }
        }
    }
]

Implementación de las funciones

En un entorno de producción, estas funciones llamarían a una API meteorológica real. Aquí simulamos las respuestas:

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

Bucle principal del 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."

Prueba del 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?"))

La prueba 3 desencadena llamadas paralelas: el modelo llama a get_weather tres veces simultáneamente. La prueba 4 es la más interesante: el modelo debería llamar a get_forecast Y a get_alerts para Marsella, y luego sintetizar los resultados en consejos prácticos.

Posibles mejoras

Para un agente listo para producción, añade:

  • Caché: evita llamar a la API meteorológica para la misma ciudad en un intervalo de 10 minutos
  • Geocodificación: convierte los nombres de las ciudades en coordenadas para mejorar la precisión
  • Historial: guarda las preferencias del usuario (unidades, ciudades favoritas)
  • Internacionalización: admite nombres de ciudades en todos los idiomas

Puntos clave

  • Un agente completo combina múltiples herramientas con responsabilidades distintas
  • El prompt del sistema guía el comportamiento del modelo (comprobar alertas sistemáticamente)
  • El bucle de múltiples turnos con max_iterations evita bucles infinitos
  • El despachador execute_function centraliza la ejecución y el manejo de errores
  • Realiza pruebas con consultas variadas: simples, multi-ciudad y complejas
  • En producción, añade caché, geocodificación e historial de usuario