Przejdź do głównej treści
Polski— Wybierz język
Menu

Kompletny agent pogodowy

Lekcja 12 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Budowa kompletnego agenta pogodowego od zera
  2. Architektura agenta
  3. Implementacja funkcji
  4. Główna pętla agenta
  5. Testowanie agenta
  6. Możliwe ulepszenia
  7. Kluczowe wnioski

Budowa kompletnego agenta pogodowego od zera

W tej lekcji połączysz wszystko, czego się nauczyłeś, aby zbudować kompletnego agenta pogodowego. Agent ten ilustruje pełny cykl wywoływania funkcji: definicję narzędzi, obsługę wielu tur rozmowy, zarządzanie błędami oraz generowanie odpowiedzi w języku naturalnym.

Architektura agenta

Agent pogodowy korzysta z trzech narzędzi:

  1. get_weather — pobiera aktualną pogodę dla danego miasta
  2. get_forecast — pobiera prognozy na wiele dni
  3. get_alerts — sprawdza aktywne ostrzeżenia pogodowe
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"]
            }
        }
    }
]

Implementacja funkcji

W środowisku produkcyjnym funkcje te wywoływałyby prawdziwe API pogodowe. Tutaj symulujemy odpowiedzi:

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

Główna pętla 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."

Testowanie 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 uruchamia wywołania równoległe: model wywołuje funkcję get_weather trzy razy jednocześnie. Test 4 jest najbardziej interesujący — model powinien wywołać zarówno get_forecast, jak i get_alerts dla Marsylii, a następnie syntezować wyniki w praktyczne porady.

Możliwe ulepszenia

Aby przygotować agenta do środowiska produkcyjnego, dodaj:

  • Pamięć podręczną (Cache): unikaj wywoływania API pogodowego dla tego samego miasta w ciągu 10 minut
  • Geokodowanie: konwertuj nazwy miast na współrzędne dla lepszej dokładności
  • Historię: zapisuj preferencje użytkownika (jednostki, ulubione miasta)
  • Internacjonalizację: obsługuj nazwy miast we wszystkich językach

Kluczowe wnioski

  • Kompletny agent łączy wiele narzędzi o odrębnych odpowiedzialnościach
  • Prompt systemowy kieruje zachowaniem modelu (systematyczne sprawdzanie ostrzeżeń)
  • Pętla wieloturowa z parametrem max_iterations zapobiega nieskończonym pętlom
  • Dispatcher execute_function centralizuje wykonywanie i obsługę błędów
  • Testuj agenta różnorodnymi zapytaniami: prostymi, wielomiejskimi i złożonymi
  • W środowisku produkcyjnym dodaj pamięć podręczną, geokodowanie i historię użytkownika