Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Teljes időjárás-ügynök

12. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Teljes időjárás-ügynök építése a nulláról
  2. Az ügynök architektúrája
  3. Függvényimplementáció
  4. Az ügynök fő ciklusa
  5. Az ügynök tesztelése
  6. Lehetséges fejlesztések
  7. Főbb megállapítások

Teljes időjárás-ügynök építése a nulláról

Ebben a leckében mindent összegezel, amit eddig tanultál, hogy felépíts egy teljes időjárás-ügynököt. Ez az ügynök bemutatja a függvényhívás teljes ciklusát: az eszközdefiníciót, a többmenetes kezelést, a hibakezelést és a természetes nyelvű válaszokat.

Az ügynök architektúrája

Az időjárás-ügynök három eszközzel rendelkezik:

  1. get_weather – lekéri egy város aktuális időjárását
  2. get_forecast – több napra szóló előrejelzéseket kér le
  3. get_alerts – ellenőrzi az aktív időjárási riasztásokat
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"]
            }
        }
    }
]

Függvényimplementáció

Éles környezetben ezek a függvények egy valódi időjárási API-t hívnának meg. Itt szimuláljuk a válaszokat:

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

Az ügynök fő ciklusa

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

Az ügynök tesztelése

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

A 3. teszt párhuzamos hívásokat indít el: a modell egyszerre hívja meg háromszor a get_weather függvényt. A 4. teszt a legérdekesebb – a modellnek meg kell hívnia a get_forecast ÉS a get_alerts függvényt Marseille-re vonatkozóan, majd a gyakorlati tanácsok érdekében szintetizálnia kell az eredményeket.

Lehetséges fejlesztések

Egy éles környezetre kész ügynökhez add hozzá a következőket:

  • Gyorsítótár (Cache): kerüld el, hogy ugyanazon város esetén 10 percen belül újra meghívd az időjárási API-t
  • Geokódolás: konvertáld a városneveket koordinátákká a nagyobb pontosság érdekében
  • Előzmények: mentsd el a felhasználói preferenciákat (mértékegységek, kedvenc városok)
  • Nemzetköziesítés: támogasd a városneveket minden nyelven

Főbb megállapítások

  • Egy teljes ügynök több, eltérő felelősségi körrel rendelkező eszközt kombinál
  • A rendszerprompt irányítja a modell viselkedését (rendszeres riasztásellenőrzés)
  • A max_iterations paraméterrel rendelkező többmenetes ciklus megakadályozza a végtelen ciklusokat
  • Az execute_function diszpécser központosítja a végrehajtást és a hibakezelést
  • Tesztelj változatos lekérdezésekkel: egyszerű, többvárosos, összetett
  • Éles környezetben adj hozzá gyorsítótárazást, geokódolást és felhasználói előzménykezelést