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

Agent wieloetapowy z pętlą rozumowania

Lekcja 15 z 25 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Agent wieloetapowy z pętlą rozumowania
  2. Wzorzec planuj-wykonaj
  3. Agent samokorygujący
  4. Wzorzec: łańcuch wyspecjalizowanych agentów
  5. Kontrolowanie głębokości rozumowania
  6. Kluczowe wnioski

Agent wieloetapowy z pętlą rozumowania

Najpotężniejsze agenty nie kończą działania po jednym wywołaniu narzędzia. Łączą wiele kroków rozumowania, dostosowują swoją strategię w zależności od wyników i iterują, aż osiągną cel. W tej lekcji nauczysz się budować takie agenty wieloetapowe. Przykłady wykorzystują rodzinę modeli GPT-5.6: tam, gdzie poprzednia generacja wymagała przełączania modeli, aby włączyć rozumowanie, teraz kontrolujesz to zachowanie za pomocą ustawienia effort dla wybranego modelu.

Wzorzec planuj-wykonaj

Agent wieloetapowy zaczyna od stworzenia planu, a następnie wykonuje każdy jego krok. Ten podział jest celowy: planista nie ma dostępu do narzędzi i produkuje typowaną strukturę, podczas gdy wykonawca otrzymuje ten plan jako mapę drogową i po prostu go realizuje. Niejasne żądanie, takie jak „przygotuj kwartalne podsumowanie dla kluczowych klientów“, zamienia się w konkretną sekwencję działań – zapytanie do CRM, wygenerowanie raportu, wysłanie e-maila – zanim zostanie podjęta jakakolwiek akcja.

from agents import Agent, Runner, function_tool
from pydantic import BaseModel
import json

class PlanAction(BaseModel):
    steps: list[str]
    objective: str

planner_agent = Agent(
    name="Planner",
    instructions="""Otrzymujesz złożone zadanie. Rozbij je na proste, uporządkowane kroki.
    Każdy krok musi być konkretnym, możliwym do wykonania elementem.""",
    model="gpt-5.6-sol",  # Zaawansowane rozumowanie do planowania
    output_type=PlanAction,
)

@function_tool
def search_crm(query: str) -> str:
    """Wyszukuje informacje o klientach w systemie CRM."""
    return json.dumps({"customers": [
        {"name": "Acme Corp", "revenue": 500000, "contract": "Enterprise"},
        {"name": "TechStart", "revenue": 50000, "contract": "Starter"},
    ]})

@function_tool
def generate_report(title: str, content: str) -> str:
    """Generuje sformatowany raport."""
    return f"Raport '{title}' wygenerowany pomyślnie ({len(content)} znaków)"

@function_tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """Wysyła e-mail."""
    return f"E-mail wysłany do {recipient}: {subject}"

executor_agent = Agent(
    name="Executor",
    instructions="""Wykonujesz zadania krok po kroku.
    Używaj dostępnych narzędzi do realizacji każdego kroku.
    Jeśli krok się nie powiedzie, spróbuj alternatywnego podejścia.""",
    tools=[search_crm, generate_report, send_email],
    model="gpt-5.6-terra",
)

async def process_complex_task(task: str):
    # Krok 1: Planowanie
    plan = await Runner.run(planner_agent, task)
    print(f"Plan: {plan.final_output.steps}")

    # Krok 2: Wykonanie z planem jako kontekstem
    execution_instructions = f"""Wykonaj następujące kroki w kolejności:
    {chr(10).join(f'{i+1}. {e}' for i, e in enumerate(plan.final_output.steps))}
    Cel: {plan.final_output.objective}"""

    result = await Runner.run(executor_agent, execution_instructions)
    return result.final_output

Agent samokorygujący

Samo planowanie nie wystarczy: w rzeczywistym świecie narzędzia zawiodzą. Druga forma pętli pozwala agentowi wykryć własne błędy i je naprawić. Wszystko zależy od szczegółu, który często umyka uwadze – narzędzie nie zgłasza wyjątku, lecz zwraca czytelny komunikat o błędzie. Agent odczytuje go, orientuje się, że zapomniał klauzuli FROM, przepisuje zapytanie i ponawia próbę, w ramach limitu trzech prób określonego w instrukcjach.

from agents import Agent, Runner, function_tool

@function_tool
def execute_sql_query(sql: str) -> str:
    """Wykonuje zapytanie SQL w bazie danych."""
    # Symulacja: niektóre zapytania kończą się niepowodzeniem
    if "DROP" in sql.upper():
        return "BŁĄD: Zapytania destrukcyjne są zabronione."
    if "SELECT" in sql.upper() and "FROM" not in sql.upper():
        return "BŁĄD: Nieprawidłowa składnia SQL – brak klauzuli FROM."
    return json.dumps({
        "columns": ["name", "monthly_revenue", "region"],
        "rows": [
            ["Acme Corp", 45000, "Île-de-France"],
            ["TechStart", 12000, "Rhône-Alpes"],
        ],
        "result_count": 2
    })

analyst_agent = Agent(
    name="Data Analyst",
    instructions="""Analizujesz dane, wykonując zapytania SQL.
    Jeśli zapytanie się nie powiedzie:
    1. Przeanalizuj komunikat o błędzie
    2. Popraw zapytanie
    3. Ponów próbę
    Maksymalnie 3 próby na zapytanie.
    Nigdy nie używaj DROP, DELETE ani TRUNCATE.""",
    tools=[execute_sql_query],
    model="gpt-5.6-terra",
    max_turns=10,  # Wystarczająca liczba tur na poprawki
)

result = Runner.run_sync(
    analyst_agent,
    "Jaki jest całkowity przychód w podziale na regiony?"
)

Zauważ, że zakaz stosowania zapytań destrukcyjnych pojawia się w dwóch miejscach: w instrukcjach i w kodzie narzędzia. Instrukcja prowadzi model, ale tylko sprawdzenie po stronie serwera w narzędziu gwarantuje, że polecenie DROP TABLE nigdy nie przeniknie dalej.

Wzorzec: łańcuch wyspecjalizowanych agentów

W przypadku złożonych przepływów pracy lepiej połączyć kilku wyspecjalizowanych agentów niż obciążać jednego agenta wszystkimi obowiązkami. Każde ogniwo ma jasną rolę: kolektor gromadzi surowy materiał, analityk – wyposażony w model rozumujący – identyfikuje trendy, a pisarz formatuje wynik. Korzyść jest zarówno edukacyjna, jak i operacyjna: gdy końcowy raport zawodzi, od razu wiesz, którego z trzech agentów należy naprawić.

from agents import Agent, Runner

collection_agent = Agent(
    name="Data Collector",
    instructions="Zbierz wszystkie dane niezbędne do analizy.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analyst",
    instructions="Przeanalizuj zebrane dane i zidentyfikuj trendy.",
    model="gpt-5.6-sol",  # Zaawansowane rozumowanie do analizy
)

writing_agent = Agent(
    name="Writer",
    instructions="""Napisz jasny, ustrukturyzowany raport w języku angielskim
    na podstawie dostarczonej analizy. Format: wstęp, kluczowe punkty, rekomendacje.""",
    model="gpt-5.6-terra",
)

async def analysis_pipeline(question: str):
    # Krok 1: Zbieranie danych
    data = await Runner.run(collection_agent, question)

    # Krok 2: Analiza
    analysis = await Runner.run(
        analysis_agent,
        f"Przeanalizuj te dane: {data.final_output}"
    )

    # Krok 3: Napisanie raportu
    report = await Runner.run(
        writing_agent,
        f"Napisz raport na podstawie tej analizy: {analysis.final_output}"
    )

    return report.final_output

Kontrolowanie głębokości rozumowania

Wszystkie te pętle mają jedną wspólną cechę: mogą nigdy się nie zakończyć. Parametr max_turns jest Twoim głównym zabezpieczeniem; dostosowujesz go w zależności od ambicji zadania. Trzy tury wystarczą dla agenta, który ma odpowiedzieć za pierwszym razem; dwadzieścia pięć jest potrzebnych do eksploracji, która odpytuje wiele źródeł przed wyciągnięciem wniosków.

# Agent konserwatywny: mało tur
simple_agent = Agent(
    name="Simple Agent",
    instructions="Odpowiedz w jednej turze, jeśli to możliwe.",
    model="gpt-5.6-terra",
)
result = await Runner.run(simple_agent, "Proste pytanie", max_turns=3)

# Agent złożony: wiele tur
research_agent = Agent(
    name="Deep Researcher",
    instructions="Zbadaj wszystkie aspekty przed wyciągnięciem wniosków.",
    tools=[search_crm, execute_sql_query],
    model="gpt-5.6-terra",
)
result = await Runner.run(research_agent, "Kompletna analiza Q1", max_turns=25)

Ustaw tę wartość, obserwując swoje ślady (traces), a nie zgadując: jeśli Twoje rzeczywiste wykonania kończą się po sześciu turach, limit dwudziestu pięciu niczego nie zabezpiecza.

Kluczowe wnioski

  • Wzorzec planuj-wykonaj oddziela planowanie (model rozumujący) od wykonania
  • Agent samokorygujący analizuje swoje błędy i dostosowuje strategię
  • Łańcuchy wyspecjalizowanych agentów umożliwiają tworzenie złożonych, łatwych w utrzymaniu przepływów pracy
  • max_turns kontroluje głębokość rozumowania i chroni przed nieskończonymi pętlami
  • Rezerwuj zaawansowane możliwości rozumowania do planowania i analizy