Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kompletní agent pro počasí

Lekce 12 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Vytvoření kompletního agenta pro počasí od nuly
  2. Architektura agenta
  3. Implementace funkcí
  4. Hlavní smyčka agenta
  5. Otestování agenta
  6. Možná vylepšení
  7. Klíčové poznatky

Vytvoření kompletního agenta pro počasí od nuly

V této lekci spojíš vše, co ses naučil, abys vybudoval kompletního agenta pro počasí. Tento agent ilustruje celý cyklus volání funkcí: definice nástrojů, zpracování více kol konverzace, ošetření chyb a odpovědi v přirozeném jazyce.

Architektura agenta

Agent pro počasí disponuje třemi nástroji:

  1. get_weather – získání aktuálního počasí pro město
  2. get_forecast – získání předpovědi na více dní
  3. get_alerts – kontrola aktivních meteorologických výstrah
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"]
            }
        }
    }
]

Implementace funkcí

V produkčním prostředí by tyto funkce volaly skutečné API pro počasí. Zde odpovědi simulujeme:

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

Hlavní smyčka agenta

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

Otestování agenta

# 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 spouští paralelní volání: model zavolá funkci get_weather třikrát současně. Test 4 je nejzajímavější – model by měl zavolat get_forecast A get_alerts pro Marseille a následně syntetizovat výsledky do praktických doporučení.

Možná vylepšení

Pro agenta připraveného do produkce přidej:

  • Mezipaměť (Cache): vyhnout se volání API pro počasí pro stejné město během 10 minut
  • Geokódování: převod názvů měst na souřadnice pro vyšší přesnost
  • Historie: ukládání uživatelských preferencí (jednotky, oblíbená města)
  • Internacionalizace: podpora názvů měst ve všech jazycích

Klíčové poznatky

  • Kompletní agent kombinuje více nástrojů s odlišnými odpovědnostmi
  • Systémový prompt řídí chování modelu (systematická kontrola výstrah)
  • Smyčka pro více kol s max_iterations zabraňuje nekonečným cyklům
  • Dispatcher execute_function centralizuje provádění a ošetření chyb
  • Testuj s různými dotazy: jednoduchými, pro více měst i komplexními
  • V produkci přidej mezipaměť, geokódování a historii uživatelů