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

Architektura agenta: pętla rozumowanie-narzędzie

Lekcja 2 z 25 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Architektura agenta: pętla rozumowanie-narzędzie
  2. Cykl życia agenta
  3. Struktura wewnętrzna: elementy i wiadomości
  4. Wywołania równoległe a sekwencyjne
  5. Parametr max_turns
  6. Kluczowe wnioski

Zaktualizowano 3 listopada 2026: W funkcji rechercher_produit brakowało cudzysłowów wokół kluczy prix i stock, co powodowało błąd NameError przy pierwszym wywołaniu narzędzia.

Architektura agenta: pętla rozumowanie-narzędzie

Aby budować skutecznych agentów, musisz zrozumieć ich wewnętrzną architekturę. Agent OpenAI działa w oparciu o pętlę rozumowania: otrzymuje zadanie, myśli, używa narzędzia, obserwuje wynik, a następnie decyduje, czy zakończyć pracę, czy kontynuować. Wszystko, co zrobisz dalej – deklarowanie narzędzi, ustawianie zabezpieczeń, orkiestracja wielu agentów – opiera się na tej pętli.

Cykl życia agenta

Każde wykonanie składa się z sześciu kroków:

  1. Odebranie: Agent otrzymuje wiadomość od użytkownika i instrukcje systemowe.
  2. Rozumowanie: Model analizuje żądanie i decyduje o kolejnym działaniu.
  3. Wywołanie narzędzia: W razie potrzeby agent wywołuje jedno lub więcej narzędzi.
  4. Obserwacja: Agent otrzymuje wyniki działania narzędzi.
  5. Decyzja: Agent decyduje, czy kontynuować (powrót do kroku 2), czy udzielić odpowiedzi.
  6. Odpowiedź: Agent generuje swoją finalną odpowiedź.

Kluczowa jest pętla między krokami 2 a 5, która może uruchomić się wielokrotnie. Agent może połączyć w łańcuch 5, 10, a nawet 20 wywołań narzędzi przed udzieleniem finalnej odpowiedzi, bez konieczności pisania przez Ciebie ani jednej linii kodu orkiestracyjnego. Poniższy przykład to ilustruje: zadeklarowano dwa niezależne narzędzia, a model sam decyduje, jak je połączyć.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Searches for a product in the catalog."""
    # Simulation - in production, call your database
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} non trouvé"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Calculates the price after discount."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="You help customers find products and calculate discounts.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# The agent will: 1) find the product, 2) calculate the discount, 3) respond
result = Runner.run_sync(
    agent,
    "What is the price of the laptop-pro with a 15% discount?"
)
print(result.final_output)

Pytanie wymaga dwóch operacji, które nie są w kodzie jawnie powiązane. Agent automatycznie wykonuje dwa wywołania narzędzi sekwencyjnie: najpierw rechercher_produit, a następnie calculer_remise z pobraną ceną. To łączenie w łańcuch jest decyzją modelu, a nie Twoją instrukcją.

Struktura wewnętrzna: elementy i wiadomości

API Responses strukturyzuje każdą interakcję jako elementy (items). Ich analiza pokazuje, co Twój agent faktycznie zrobił. W rozmowie pojawiają się trzy typy:

  • message: wiadomość tekstowa (od użytkownika lub od agenta)
  • function_call: wywołanie narzędzia podjęte przez agenta
  • function_call_output: wynik zwrócony przez narzędzie
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspect the reasoning steps
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # You'll see: message input → function_call → function_call_output → message output

Wyrób sobie nawyk śledzenia tej pętli za każdym razem, gdy agent generuje zaskakującą odpowiedź. Dziewięć razy na dziesięć anomalia ujawnia się w function_call z nieoczekiwanymi argumentami.

Wywołania równoległe a sekwencyjne

Nie wszystkie kroki są od siebie zależne. Gdy dwa wywołania są niezależne, agent może zdecydować się na ich uruchomienie równolegle.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Gets the current weather for a city."""
    meteos = {"Paris": "18°C, sunny", "Lyon": "16°C, cloudy"}
    return meteos.get(ville, "Data unavailable")

agent = Agent(
    name="Travel Agent",
    instructions="You help plan trips.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# The agent will call obtenir_meteo("Paris") and obtenir_meteo("Lyon") in parallel
result = Runner.run_sync(
    agent,
    "What's the weather in Paris and Lyon?"
)

Pogoda w Lyonie nie zależy od pogody w Paryżu: SDK obsługuje równoległość automatycznie i uruchamia oba wywołania jednocześnie, redukując opóźnienia. Porównaj to z wcześniejszym przykładem sprzedażowym, gdzie obliczenie rabatu musiało poczekać na cenę: tam sekwencja narzuca się sama.

Parametr max_turns

Autonomiczna pętla może w najgorszym przypadku nigdy się nie zakończyć: agent wywołuje narzędzie, wynik skłania go do wywołania kolejnego i tak dalej. Zabezpieczeniem jest pojedynczy parametr.

result = Runner.run_sync(
    agent,
    "Full catalog analysis",
    max_turns=10  # Maximum 10 loop iterations
)

Jeśli agent osiągnie limit, zatrzymuje się z wynikami uzyskanymi do tego momentu. W środowisku produkcyjnym jest to niezbędne zabezpieczenie: ogranicza zarówno czas odpowiedzi, jak i koszty.

Kluczowe wnioski

  • Agent działa w pętli: rozumowanie → narzędzie → obserwacja → decyzja
  • Pętla ta może wykonać się wielokrotnie przed wygenerowaniem odpowiedzi
  • Model automatycznie decyduje, które narzędzia wywołać i w jakiej kolejności
  • Niezależne wywołania narzędzi działają równolegle
  • max_turns ogranicza liczbę iteracji ze względów bezpieczeństwa