Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Visiškas oro sąlygų agentas

Paskaita 12 iš 14 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Sukurk visišką oro sąlygų agentą nuo nulio
  2. Agento architektūra
  3. Funkcijų implementacija
  4. Pagrindinis agento ciklas
  5. Ištestuok agentą
  6. Galimi patobulinimai
  7. Svarbiausi punktai

Sukurk visišką oro sąlygų agentą nuo nulio

Šioje pamokoje sujungsi viską, ko išmokai, kad sukurtum visišką oro sąlygų agentą. Šis agentas iliustruoja visą funkcijų kvietimo ciklą: įrankio apibrėžimą, daugiažingsnį valdymą, klaidų apdorojimą ir atsakymus natūralia kalba.

Agento architektūra

Oro sąlygų agentas turi tris įrankius:

  1. get_weather – gauna dabartines oro sąlygas miestui
  2. get_forecast – gauna prognozes kelioms dienoms
  3. get_alerts – tikrina aktyvius oro įspėjimus
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"]
            }
        }
    }
]

Funkcijų implementacija

Produkcinėje aplinkoje šios funkcijos kviestų tikrą oro sąlygų API. Čia mes imituojame atsakymus:

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

Pagrindinis agento ciklas

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

Ištestuok agentą

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

3-ias testas suaktyvina lygiagrečius kvietimus: modelis vienu metu tris kartus iškviečia get_weather. 4-as testas yra pats įdomiausias – modelis turėtų iškviesti get_forecast IR get_alerts Marselio miestui, o tada susintetinti rezultatus į praktinius patarimus.

Galimi patobulinimai

Kad agentas būtų paruoštas produkcijai, pridėk:

  • Podėlį (Cache): venk kviesti oro sąlygų API tam pačiam miestui per 10 minučių laikotarpį
  • Geokodavimą: konvertuok miestų pavadinimus į koordinates tikslesniems rezultatams
  • Istoriją: išsaugok naudotojo nuostatas (matavimo vienetus, mėgstamus miestus)
  • Internacionalizaciją: palaikyk miestų pavadinimus visomis kalbomis

Svarbiausi punktai

  • Visiškas agentas sujungia kelis įrankius su skirtingomis atsakomybėmis
  • Sistemos raginimas (system prompt) nukreipia modelio elgseną (sistemingai tikrina įspėjimus)
  • Daugiažingsnis ciklas su max_iterations neleidžia įstrigti begalinėse kilpose
  • execute_function dispečeris centralizuoja vykdymą ir klaidų apdorojimą
  • Testuok su įvairiomis užklausomis: paprastomis, kelių miestų, sudėtingomis
  • Produkcijoje pridėk podėlį, geokodavimą ir naudotojo istoriją