Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Popoln vremenski agent

Lekcija 12 od 14 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Izdelava popolnega vremenskega agenta od začetka
  2. Arhitektura agenta
  3. Implementacija funkcij
  4. Glavna zanka agenta
  5. Preizkus agenta
  6. Možne izboljšave
  7. Ključne ugotovitve

Izdelava popolnega vremenskega agenta od začetka

V tej lekciji boš združil vse, kar si se naučil, da bi zgradil popoln vremenski agent. Ta agent ponazarja celoten cikel klicanja funkcij: definicija orodij, obravnava večkratnih izmenjav, ravnanje z napakami in odzivi v naravnem jeziku.

Arhitektura agenta

Vremenski agent ima tri orodja:

  1. get_weather – pridobi trenutno vreme za določeno mesto
  2. get_forecast – pridobi napovedi za več dni
  3. get_alerts – preveri aktivna vremenska opozorila
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"]
            }
        }
    }
]

Implementacija funkcij

V produkcijskem okolju bi te funkcije klicale pravi vremenski API. Tukaj simuliramo odzive:

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

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

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

Preizkus 3 sproži vzporedne klice: model trikrat hkrati pokliče get_weather. Preizkus 4 je najbolj zanimiv – model naj bi za Marseille poklical tako get_forecast kot get_alerts, nato pa rezultate sintetiziral v praktične nasvete.

Možne izboljšave

Z agenta, pripravljenega za produkcijo, dodaj:

  • Predpomnilnik: izogni se klicanju vremenskega API-ja za isto mesto v roku 10 minut
  • Geokodiranje: pretvori imena mest v koordinate za večjo natančnost
  • Zgodovina: shrani uporabniške nastavitve (enote, priljubljena mesta)
  • Internalizacija: podpora imenom mest v vseh jezikih

Ključne ugotovitve

  • Popoln agent združuje več orodij z različnimi odgovornostmi
  • Sistemski poziv usmerja vedenje modela (sistematično preverjanje opozoril)
  • Zanka z več izmenjavami in max_iterations preprečuje neskončne zanke
  • Usmerjevalnik execute_function centralizira izvajanje in obravnavo napak
  • Preizkušaj z različnimi poizvedbami: preproste, za več mest, kompleksne
  • V produkciji dodaj predpomnjenje, geokodiranje in zgodovino uporabnika