Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Ilmastikuagenti täielik loomine

Õppetund 12 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Ehitame nullist täieliku ilmastikuagenti
  2. Agendi arhitektuur
  3. Funktsioonide implementeerimine
  4. Agendi põhitsükkel
  5. Testi agenti
  6. Võimalikud täiustused
  7. Peamised punktid

Ehitame nullist täieliku ilmastikuagenti

Selles õppetükis paned kokku kõik senise teadmised, et ehitada täielik ilmastikuagent. See agent illustreerib funktsioonide kutsumise terviktsüklit: tööriista defineerimine, mitme vooru haldamine, veakäsitlus ja vastused loomulikus keeles.

Agendi arhitektuur

Ilmastikuagendil on kolm tööriista:

  1. get_weather – hangib linna praeguse ilmastiku
  2. get_forecast – hangib prognoosi mitmeks päevaks
  3. get_alerts – kontrollib aktiivseid ilmahoiatusi
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"]
            }
        }
    }
]

Funktsioonide implementeerimine

Tootmiskeskkonnas kutsuksid need funktsioonid tegelikku ilmastiku API-t. Siin simuleerime vastuseid:

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

Agendi põhitsükkel

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

Testi agenti

# 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 käivitab paralleelsed kutsed: mudel kutsub funktsiooni get_weather kolm korda samaaegselt. Test 4 on kõige huvitavam – mudel peaks kutsuma nii get_forecast kui ka get_alerts Marseille’i jaoks ja seejärel sünteesima tulemused praktilisteks soovitusteks.

Võimalikud täiustused

Tootmisvalmis agendi jaoks lisa:

  • Vahemälu: väldi sama linna ilmastiku API kutsumist 10 minuti jooksul uuesti
  • Geokodeerimine: teisenda linnanimed koordinaatideks suurema täpsuse saavutamiseks
  • Ajalugu: salvesta kasutaja eelistused (ühikud, lemmiklinnad)
  • Rahvusvahelistumine: toeta linnanimi kõigis keeltes

Peamised punktid

  • Täielik agent ühendab mitu erineva vastutusega tööriista
  • Süsteemne vihje suunab mudeli käitumist (kontrolli hoiatusi süstemaatiliselt)
  • Mitme vooru tsükkel koos max_iterations-ga hoiab ära lõpmatud tsüklid
  • execute_function dispatcher tsentraliseerib käivitamise ja veakäsitluse
  • Testi erinevate päringutega: lihtsad, mitme linna hõlmavad, keerulised
  • Tootmiskeskkonnas lisa vahemälu, geokodeerimine ja kasutajaajalugu