Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pilnīgs laika ziņu aģents

Nodarbība 12 no 14 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Izveido pilnīgu laika ziņu aģentu no nulles
  2. Aģenta arhitektūra
  3. Funkciju implementācija
  4. Aģenta galvenais cikls
  5. Testē aģentu
  6. Iespējamie uzlabojumi
  7. Galvenās atziņas

Izveido pilnīgu laika ziņu aģentu no nulles

Šajā nodarbībā tu apvienosi visu, ko esi iemācījies, lai izveidotu pilnīgu laika ziņu aģentu. Šis aģents ilustrē pilnu funkciju izsaukšanas ciklu: rīku definēšanu, vairāku sarunu posmu apstrādi, kļūdu apstrādi un atbildes dabiskā valodā.

Aģenta arhitektūra

Laika ziņu aģentam ir trīs rīki:

  1. get_weather — iegūst pašreizējos laika apstākļus konkrētā pilsētā
  2. get_forecast — iegūst laika prognozes vairākām dienām
  3. get_alerts — pārbauda aktīvos laika brīdinājumus
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"]
            }
        }
    }
]

Funkciju implementācija

Reālā vidē šīs funkcijas izsauktu patiesu laika ziņu API. Šeit mēs simulējam atbildes:

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

Aģenta galvenais cikls

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

Testē aģentu

# 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?"))
  1. tests izraisa paralēlus izsaukumus: modelis vienlaicīgi trīs reizes izsauc get_weather. 4. tests ir visinteresantākais — modelim vajadzētu izsaukt gan get_forecast, gan get_alerts Marseļai un pēc tam apkopot rezultātus praktiskos ieteikumos.

Iespējamie uzlabojumi

Lai sagatavotu aģentu darbam reālā vidē, pievieno:

  • Kešatmiņu: izvairies no laika ziņu API izsaukšanas vienai un tai pašai pilsētai 10 minūšu laikā
  • Ģeokodēšanu: pārvērš pilsētu nosaukumus koordinātās, lai uzlabotu precizitāti
  • Vēsturi: saglabā lietotāja preferences (mērvienības, iecienītākās pilsētas)
  • Internacionalizāciju: atbalsti pilsētu nosaukumus visās valodās

Galvenās atziņas

  • Pilnīgs aģents apvieno vairākus rīkus ar atšķirīgām atbildībām
  • Sistēmas prompts virza modeļa uzvedību (sistemātiski pārbauda brīdinājumus)
  • Daudzposmu cikls ar max_iterations novērš bezgalīgas cilpas
  • execute_function dispečeris centralizē izpildi un kļūdu apstrādi
  • Testē ar dažādiem vaicājumiem: vienkāršiem, vairāku pilsētu, sarežģītiem
  • Reālā vidē pievieno kešatmiņu, ģeokodēšanu un lietotāja vēsturi