Claude Architect · Lekcja

Wzorce konwersacyjne i narzędzia agentowe

Pamięć wieloturowa, trwałość instrukcji i bezpieczne narzędzia

Lekcja 4 z 413 kroki

Wzorce konwersacyjne i narzędzia agentowe to bezpłatna lekcja Claude Architect na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Claude Architect, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Claude Architect zawiera 4 lekcji w sumie.

Prawda bezstanowa

Scenariusz 7 egzaminu dotyczy wzorców architektury konwersacyjnej AI. W pierwszej kolejności sprawdza, czy rozumieją Państwo, że Claude API jest bezstanowe: model nie zachowuje żadnej pamięci między żądaniami.

W każdej turze należy wysłać pełną historię wiadomości w tablicy messages. „Pamięć” w aplikacji konwersacyjnej jest czymś, co Państwo implementują po stronie klienta, a nie sesją serwerową przechowywaną przez model.

system zawiera trwałe instrukcje
messages zawiera pełną historię wszystkich tur, przy każdym żądaniu

import anthropic

client = anthropic.Anthropic()

# Memory = the list YOU maintain and resend each turn
history = [
    {"role": "user", "content": "My order id is 8842."},
    {"role": "assistant", "content": "Got it, order 8842."},
    {"role": "user", "content": "When does it ship?"},
]

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a concise support agent.",
    messages=history,  # FULL history, every single turn
)

Trwałość instrukcji zapewnia system

W czacie wieloturowym instrukcje, które muszą obowiązywać przez całą sesję, należy umieścić w polu system, a nie ukrywać w wiadomości użytkownika sprzed 20 wiadomości.

Dlaczego ma to znaczenie: modele wykazują zachowanie typu lost-in-the-middle — zwracają większą uwagę na początek i koniec kontekstu niż na jego środek. Instrukcja umieszczona w 7. turze czatu liczącego 40 tur jest dla modelu najłatwiejsza do pominięcia.

Prompt system jest ponownie dostarczany dosłownie przy każdym żądaniu, dlatego jest najbardziej niezawodnym miejscem na trwałe reguły: ton wypowiedzi, rolę, zasady odmowy i ograniczenia danych wyjściowych.

Odczytywanie przyczyny zatrzymania

Tury konwersacji kończą się wartością stop_reason. Na jej podstawie należy sterować przepływem programu, nigdy nie wyszukując w tekście asystenta słów takich jak „gotowe” lub „zakończone”.

end_turn — model zakończył odpowiedź
tool_use — model chce uruchomić narzędzie przed kontynuowaniem
max_tokens — dane wyjściowe zostały obcięte
stop_sequence — zadziałała skonfigurowana sekwencja zatrzymująca

Parsowanie tekstu w celu wykrywania sygnałów zakończenia to klasyczny antywzorzec egzaminacyjny i niemal zawsze błędna odpowiedź.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system=SYSTEM,
    messages=history,
    tools=TOOLS,
)

if resp.stop_reason == "tool_use":
    run_tools_and_append(resp, history)   # then loop again
elif resp.stop_reason == "end_turn":
    deliver(resp)                         # turn is complete
elif resp.stop_reason == "max_tokens":
    handle_truncation(resp)               # continue / raise budget

Pętla agentowa

Narzędzia agentowe zmieniają czat w wykonawcę działań. Pętla jest stała i prosta:

wyślij żądanie
sprawdź stop_reason
jeśli występuje tool_use: uruchom narzędzie lub narzędzia, dopisz wyniki do historii i wyślij żądanie ponownie
powtarzaj do momentu uzyskania end_turn

Decyzje są podejmowane przez model. Limit iteracji jest mechanizmem bezpieczeństwa zapobiegającym niekontrolowanym pętlom — nigdy głównym mechanizmem zatrzymania. Należy kończyć działanie na podstawie przyczyny zatrzymania; limit służy tylko do przechwytywania patologicznych przypadków.

MAX_ITERS = 10  # SAFETY NET only, not the real stop condition

for _ in range(MAX_ITERS):
    resp = client.messages.create(
        model="claude-sonnet-4-5", max_tokens=1024,
        system=SYSTEM, messages=history, tools=TOOLS,
    )
    history.append({"role": "assistant", "content": resp.content})

    if resp.stop_reason != "tool_use":
        break  # end_turn -> we are genuinely done

    results = execute_tool_calls(resp.content)
    history.append({"role": "user", "content": results})

Wyniki narzędzi wracają jako kontekst

Po uruchomieniu narzędzia jego wynik jest dopisywany do messages jako blok tool_result zawierający pasujący element tool_use_id. Model odczytuje ten wynik przy następnym żądaniu i kontynuuje rozumowanie.

Wskazówka dotycząca niezawodności z egzaminu: przed dopisaniem należy ograniczyć obszerne dane wyjściowe narzędzia do odpowiednich pól. Umieszczenie w historii surowego ładunku API o rozmiarze 5000 tokenów marnuje okno kontekstu, pogłębia problem lost-in-the-middle i rozprasza uwagę. Należy zachować pola, których model faktycznie potrzebuje do działania.

Narzędzia wybierane na podstawie opisów

W przypadku bezpiecznych narzędzi agentowych podstawowym mechanizmem wyboru jest opis, a nie nazwa narzędzia. Model kieruje żądania na podstawie opisów, dlatego należy pisać je jak kontrakt:

przeznaczenie — co narzędzie robi i kiedy należy go użyć
zwracane wartości — jakie dane są zwracane
formaty danych wejściowych wraz z przykładami
przypadki brzegowe i granice zastosowania

Nakładające się lub niejednoznaczne opisy powodują błędne kierowanie. Należy dążyć do 4–5 narzędzi na agenta; przy około 18 narzędziach niezawodność wyboru gwałtownie spada. Zakres narzędzi powinien być ściśle dopasowany do roli.

lookup_order = {
    "name": "lookup_order",
    "description": (
        "Fetch the status of ONE order by its numeric id. "
        "Returns {order_id, status, ships_on}. "
        "Input: order_id as an integer, e.g. 8842. "
        "Use ONLY after the customer identity is verified. "
        "Returns an empty result (not an error) if the id does not exist."
    ),
    "input_schema": {
        "type": "object",
        "properties": {"order_id": {"type": "integer"}},
        "required": ["order_id"],
    },
}

Sterowanie za pomocą tool_choice

tool_choice określa, czy i w jaki sposób model używa narzędzi w danej turze:

"auto" — model decyduje, czy odpowiedzieć tekstem, czy wywołać narzędzie (domyślne ustawienie w konwersacji)
"any" — model musi wywołać dowolne narzędzie; gwarantuje to ustrukturyzowane dane wyjściowe
{"type":"tool","name":"X"} — wymusza użycie konkretnego narzędzia

W otwartej konwersacji zwykle należy użyć "auto", aby Claude mógł odpowiednio rozmawiać lub działać. Po "any" albo wymuszenie konkretnego narzędzia należy sięgnąć, gdy potrzebny jest wynik o ustrukturyzowanej formie i zweryfikowany względem schematu, a nie swobodny tekst.

# Conversational default: let Claude talk OR act
resp = client.messages.create(
    model="claude-sonnet-4-5", max_tokens=1024,
    system=SYSTEM, messages=history, tools=TOOLS,
    tool_choice={"type": "auto"},
)

# Force a structured extraction instead of prose
resp = client.messages.create(
    model="claude-sonnet-4-5", max_tokens=1024,
    system=SYSTEM, messages=history, tools=[extract_tool],
    tool_choice={"type": "any"},
)

Obsługa niejednoznacznych danych wejściowych

Rzeczywiste konwersacje bywają chaotyczne. Gdy żądanie użytkownika jest niejednoznaczne, bezpieczny wzorzec polega na tym, aby poprosić o dodatkowe identyfikatory — nigdy nie zgadywać.

Klasyczny przypadek egzaminacyjny: wyszukiwanie zwraca wiele pasujących rekordów klienta. Prawidłowym działaniem jest poproszenie o identyfikator rozstrzygający (adres e-mail, identyfikator zamówienia), a nie ciche wybranie pierwszego wiersza. Zgadywanie grozi wykonaniem działania na niewłaściwym koncie.

W przypadku użytkowników rozemocjonowanych lub sfrustrowanych należy: uznać ich emocje, zaproponować konkretne rozwiązanie i eskalować sprawę dopiero po ponownym zgłoszeniu żądania.

Bezpieczne narzędzia: warunki wstępne i hooki

„Bezpieczne narzędzia” oznaczają, że wrażliwe działanie nie może zostać wykonane, dopóki nie zostaną spełnione wymagane gwarancje. Służą do tego dwie warstwy:

Warunki wstępne egzekwowane programowo — np. blokowanie process_refund, dopóki get_customer nie zwróci zweryfikowanego identyfikatora. Jest to deterministyczna gwarancja, której nie może zapewnić sama instrukcja w prompcie.
Hooki — PostToolUse przechwytuje wyniki, zanim zobaczy je model; hooki wywołań wychodzących blokują działania naruszające zasady (np. zwrot środków > $500).

Hooki są w 100% deterministyczne, a prompty — probabilistyczne w około 90%. Krytyczne reguły należy egzekwować za pomocą hooków lub warunków wstępnych zawsze wtedy, gdy ich naruszenie ma konsekwencje finansowe, prawne lub dotyczące bezpieczeństwa. Egzekwowanie takich reguł wyłącznie za pomocą promptów jest antywzorcem.

def process_refund(amount, customer):
    # Deterministic precondition — not a polite prompt request
    if not customer.get("verified_id"):
        raise PermissionError("Identity not verified")
    if amount > 500:
        # Out-of-prompt enforcement; hook blocks this path too
        return escalate_to_human(reason="refund_over_limit",
                                 amount=amount)
    return issue_refund(customer["id"], amount)

Ustrukturyzowane błędy zamiast ogólnych awarii

Agent odzyskuje sprawność tylko na tyle, na ile pozwalają mu na to komunikaty błędów. Ogólny błąd "Operation failed" blokuje odzyskiwanie, natomiast ustrukturyzowany błąd umożliwia inteligentne kierowanie.

Należy odróżniać awarię dostępu (można spróbować ponownie) od prawidłowego pustego wyniku (brak dopasowań — nie ponawiać próby). Warto udostępniać następujące pola strukturalne:

errorCategory — przejściowy / walidacyjny / biznesowy / uprawnień
isRetryable
attempted_query oraz ewentualne partial_results

Błędy przejściowe należy obsługiwać lokalnie w subagencie, a nieusuwalne awarie eskalować razem z częściowymi wynikami. Nigdy nie należy po cichu pomijać błędu ani przerywać całej konwersacji z powodu jednego nieudanego wywołania narzędzia.

{
  "isError": true,
  "errorCategory": "transient",
  "isRetryable": true,
  "message": "Order service timed out",
  "attempted_query": {"order_id": 8842},
  "partial_results": []
}

Zapewnianie niezawodności długich konwersacji

W miarę rozrastania się czatu należy zarządzać oknem kontekstu bez utraty faktów. Stopniowe podsumowywanie kompresuje starsze tury, ale sprawia, że liczby, wartości procentowe i daty stają się nieprecyzyjne.

Rozwiązanie polega na przeniesieniu faktów transakcyjnych (identyfikatorów zamówień, kwot, dat, zweryfikowanej tożsamości) do osobnego bloku „fakty sprawy”, przechowywanego dosłownie poza podsumowaniem. Należy podsumowywać rozmowę, ale nigdy fakty, na podstawie których agent musi działać.

W połączeniu z ograniczaniem obszernych danych wyjściowych narzędzi i umieszczaniem trwałych reguł w system pozwala to zachować dokładność agentów wieloturowych podczas długich sesji.

Szybkie sprawdzenie: zatrzymywanie pętli agentowej

Decyzja oparta na scenariuszu ze Scenariusza 8 (narzędzia agentowe AI).

Odpowiedz w interaktywnej lekcji

Podsumowanie: wzorce konwersacyjne i narzędzia agentowe

To należy zapamiętać przed egzaminem:

Model bezstanowy — w każdej turze ponownie wysyłają Państwo pełną historię messages; „pamięć” jest implementowana po stronie klienta.
Trwałe instrukcje znajdują się w system; reguły umieszczone w środku historii mogą zostać pominięte.
Przyczyny zatrzymania sterują przepływem programu — pętla działa dla tool_use, a kończy się dla end_turn; nigdy nie należy analizować tekstu w poszukiwaniu słowa „gotowe”.
Limity są mechanizmami bezpieczeństwa, a nie głównym sposobem zatrzymania.
Opisy narzędzi (nie ich nazwy) służą do wyboru narzędzi; należy używać 4–5 narzędzi na agenta, w zakresie dopasowanym do roli.
tool_choice: auto do rozmowy lub działania, any do zagwarantowania ustrukturyzowanych danych wyjściowych, a wymuszenie — dla konkretnego narzędzia.
Niejednoznaczność → poproś o dodatkowe identyfikatory, nigdy nie zgaduj.
Bezpieczne narzędzia = warunki wstępne + hooki (deterministyczne) dla reguł finansowych, prawnych i bezpieczeństwa — nie same prompty.
Ustrukturyzowane błędy umożliwiają odzyskiwanie; fakty sprawy należy przechowywać dosłownie poza podsumowaniami.

Bezpłatny start

Ucz się Python dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 26
Lekcje: 104

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Wzorce konwersacyjne i narzędzia agentowe” jest bezpłatna?

Tak — pełny tekst „Wzorce konwersacyjne i narzędzia agentowe” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Claude Architect, przejdź na CoddyKit PRO. Kurs Claude Architect zawiera 4 lekcji w sumie.

Co nauczysz się w „Wzorce konwersacyjne i narzędzia agentowe”?

Pamięć wieloturowa, trwałość instrukcji i bezpieczne narzędzia Ćwiczysz Claude Architect z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Claude Architect?

Nie wymagamy żadnego doświadczenia. Claude Architect w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Wzorce konwersacyjne i narzędzia agentowe”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Claude Architect?

Tak. Każda lekcja Claude Architect zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Agent wsparcia i badanie wieloagentowe
Generowanie kodu i produktywność programistów
CI/CD i ustrukturyzowana ekstrakcja
Wzorce konwersacyjne i narzędzia agentowe

← Powrót do Claude Architect