Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Potpuni agent za vremensku prognozu

Lekcija 12 od 14 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Izgradi potpuni agent za vremensku prognozu od nule
  2. Arhitektura agenta
  3. Implementacija funkcija
  4. Glavna petlja agenta
  5. Testiraj agenta
  6. Moguća poboljšanja
  7. Ključne točke

Izgradi potpuni agent za vremensku prognozu od nule

U ovoj lekciji sastavit ćeš sve što si naučio kako bi izgradio potpuni agent za vremensku prognozu. Ovaj agent ilustrira cijeli ciklus pozivanja funkcija: definiciju alata, rukovanje višestrukim razmjenama poruka, obradu pogrešaka i odgovore na prirodnom jeziku.

Arhitektura agenta

Agent za vremensku prognozu koristi tri alata:

  1. get_weather — dohvaća trenutno vrijeme za grad
  2. get_forecast — dohvaća prognoze za više dana
  3. get_alerts — provjerava aktivna vremenska upozorenja
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 funkcija

U produkcijskom okruženju ove bi funkcije pozivale stvarni API za vremensku prognozu. Ovdje simuliramo odgovore:

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

Testiraj 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 pokreće paralelne pozive: model istovremeno tri puta poziva get_weather. Test 4 je najzanimljiviji — model bi trebao pozvati get_forecast I get_alerts za Marseille, a zatim sintetizirati rezultate u praktične savjete.

Moguća poboljšanja

Za agenta spremanog za produkciju dodaj:

  • Predmemorija (Cache): izbjegni pozivanje API-ja za vremensku prognozu za isti grad unutar 10 minuta
  • Geokodiranje: pretvori imena gradova u koordinate radi veće preciznosti
  • Povijest: spremi korisničke preferencije (jedinice, omiljeni gradovi)
  • Internacionalizacija: podrži imena gradova na svim jezicima

Ključne točke

  • Potpuni agent kombinira više alata s različitim odgovornostima
  • Sistemska uputa usmjerava ponašanje modela (sustavno provjeravanje upozorenja)
  • Petlja s višestrukim razmjenama poruka uz max_iterations sprječava beskonačne petlje
  • Dispatcher execute_function centralizira izvršavanje i obradu pogrešaka
  • Testiraj s različitim upitima: jednostavnim, za više gradova i složenim
  • U produkciji dodaj predmemoriju, geokodiranje i korisničku povijest