Wywołujesz Claude API — interfejs Anthropic do programistycznego wysyłania promptów i odbierania odpowiedzi — i proste zadania działają świetnie. Ekstrakcja, podsumowania, klasyfikacja: Claude daje radę. Potem rzucasz mu coś trudnego. Zrób review pull requesta na 2000 linii. Zaplanuj migrację bazy danych. Zdebuguj race condition. Odpowiedź wraca szybko, pewnie i subtelnie błędnie. Jak student, który przeleciał podręcznik po łebkach i improwizuje na egzaminie.

Problem nie leży w modelu. Problem w tym, że nie dajesz mu brudnopisu.

Dlaczego "po prostu przeczytaj dokumentację" nie wystarczy

Claude ma funkcję zwaną extended thinking — zdolność do wewnętrznego rozumowania krok po kroku przed udzieleniem odpowiedzi, jak pokazywanie obliczeń na matmie, tyle że obliczenia zostają ukryte. Anthropic wprowadziło to 24 lutego 2025 wraz z Claude 3.7 Sonnet i od tamtej pory mechanizm przeszedł dramatyczną ewolucję.

Dokumentacja jest dokładna. Jest też na 4000 słów — tabele parametrów, informacje o deprecjacjach i przewodniki migracyjne rozrzucone po trzech osobnych stronach. Większość developerów robi jedną z trzech rzeczy: pomija thinking całkowicie, kopiuje config z posta na blogu pisanego pod starszy model albo włącza go bez kontroli kosztów i dostaje niespodziewany rachunek na 200 złotych.

16 kwietnia 2026 Anthropic wypuściło Claude Opus 4.7 i rozwaliło wszystkie trzy podejścia. Manualny parametr budget_tokens, który kiedyś kontrolował koszt rozumowania? Zwraca błąd 400. Nowy tokenizer pompuje liczbę tokenów o nawet 35%. A thinking jest domyślnie niewidoczny — wciąż fakturowany po pełnej stawce $25 za milion tokenów.

Oto jak to skonfigurować poprawnie — stan na 27 kwietnia 2026.

Krok 1: Włącz Adaptive Thinking

Na Opus 4.7 używasz adaptive thinking — model sam decyduje, ile myśleć, w zależności od trudności problemu. Żadnych ręcznych budżetów tokenów. Intensywność kontrolujesz parametrem effort (prosta etykieta typu "low", "high" lub "max") zamiast zgadywać liczbę.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[{
        "role": "user",
        "content": "Review this SQL migration for correctness and edge cases: ..."
    }],
)

Trzy dodane linie: thinking, output_config i większy max_tokens — górny limit tokenów (kawałków słów przetwarzanych przez AI, w przybliżeniu ¾ angielskiego wyrazu) w odpowiedzi. Tokeny myślenia wliczają się w ten limit, więc ustaw go na co najmniej 16 000. Anthropic rekomenduje 32 000+ dla złożonych zadań. Jeśli samo myślenie przekroczyłoby twój max, request się wysypie — żadnej częściowej odpowiedzi, tylko błąd.

/faion to narzędzie Nero do generowania działającego kodu ze specyfikacji — wklej blok poniżej i dostaniesz gotowy punkt startowy.

/faion
Generate a Python function `call_with_thinking(prompt: str, effort: str = "high") -> str` that calls Claude Opus 4.7 with adaptive thinking using the anthropic Python SDK. Accept an effort parameter ("low", "medium", "high", "xhigh", "max"). Set max_tokens to 16000. Return the text response. Include error handling for API errors and a docstring explaining the effort levels.

Krok 2: Dobierz odpowiedni poziom Effort

Nie każdy prompt zasługuje na doktorat z filozofii. Oto ściąga, oparta na wytycznych Anthropic i danych produkcyjnych z testów Resolve AI:

Effort Co robi Kiedy używać
low Pomija myślenie dla trywialnych zadań Klasyfikacja, ekstrakcja, pipeline'y na dużym wolumenie
medium Umiarkowane rozumowanie, może pominąć Balans koszt/jakość, większość agentowych workflow
high Prawie zawsze myśli głęboko Code review, analiza, planowanie
xhigh Rozszerzona eksploracja (tylko Opus 4.7) Kodowanie wieloplikowe, długie łańcuchy agentowe
max Bez ograniczeń na myślenie Problemy graniczne, research, nieograniczony budżet

Kluczowe odkrycie Resolve AI: Sonnet 4.6 na medium effort daje jakość zbliżoną do Opus 4.6 za ułamek ceny. Nie sięgaj po największy model — sięgnij po odpowiedni poziom effort na tańszym. Najlepsza optymalizacja to często w ogóle nie płacić za Opusa.

Krok 3: Streamuj Thinking dla UX w czasie rzeczywistym

Bez streamingu request z ciężkim myśleniem oznacza, że twój użytkownik gapi się w martwy ekran przez 30+ sekund. Ze streamingiem widzi, jak rozumowanie modelu rozwija się na żywo — widoczny postęp zamiast egzystencjalnych wątpliwości, czy apka się nie wykrzaczyła.

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive", "display": "summarized"},
    messages=[{"role": "user", "content": "Analyze this codebase architecture..."}],
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                print(f"[thinking] {event.delta.thinking}", end="", flush=True)
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

Zwróć uwagę na "display": "summarized". Na Opus 4.7 domyślna wartość to "omitted" — model myśli, płacisz za tokeny, ale tekst rozumowania wraca pusty. Musisz ustawić display jawnie, jeśli chcesz zobaczyć, o czym model rozmyślał. Debugowanie niewidocznego rozumowania jest dokładnie tak zabawne, jak brzmi.

/faion
Generate a Python function `stream_thinking_response(prompt: str, effort: str = "high")` that calls Claude Opus 4.7 with adaptive thinking and streaming enabled via the anthropic Python SDK. Set display to "summarized". Print thinking deltas prefixed with "[thinking]" and text deltas without prefix. Set max_tokens to 32000. Handle stream cleanup properly with a context manager.

Krok 4: Obsłuż Tool Use bez zrywania łańcucha

Jeśli twoja integracja używa narzędzi — funkcji, które model może wywoływać, jak odpytywanie bazy danych czy uderzanie do zewnętrznego API — musisz zachować bloki thinking przy kontynuowaniu konwersacji. Wyrzuć je, a Claude traci kontekst rozumowania w połowie procesu.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[your_tool],
    messages=[
        {"role": "user", "content": "What's the production error rate?"},
        {"role": "assistant", "content": [
            thinking_block,   # ZACHOWAJ TO — usunięcie zabija kontekst
            tool_use_block
        ]},
        {"role": "user", "content": [tool_result]},
    ],
)

Jedno ograniczenie, które ugryzie architekturę agentową: z włączonym thinking, tool_choice — kontrolujący, czy Claude ma użyć konkretnego narzędzia — obsługuje tylko "auto" lub "none". Wymuszenie konkretnego narzędzia zwraca błąd.

Krok 5: Monitoruj, za co tak naprawdę płacisz

Każda odpowiedź zawiera obiekt usage. Po włączeniu thinking, to staje się najważniejszą linijką w twoim codebase:

cost_per_mtok = 25  # Opus 4.7 cena za output
output_cost = (response.usage.output_tokens / 1_000_000) * cost_per_mtok
print(f"Output tokens: {response.usage.output_tokens} (${output_cost:.4f})")

Liczba tokenów output obejmuje WSZYSTKIE tokeny myślenia — nawet te niewidoczne przy display: "omitted". Jeśli twoja widoczna odpowiedź to 500 tokenów, ale output_tokens mówi 8000, właśnie zapłaciłeś za 7500 tokenów rozumowania, których nikt nie widział. Według cennika Anthropic tokeny myślenia są fakturowane po pełnej stawce output: $25/MTok za Opusa, $15/MTok za Sonneta.

/faion
Generate a Python helper function `log_thinking_cost(response, model: str = "claude-opus-4-7")` that takes an Anthropic Messages API response object and prints a cost breakdown: input tokens, output tokens (including thinking), cache read tokens, and total estimated cost in USD. Use a dict of per-model pricing (Opus 4.7: $15 input / $25 output, Sonnet 4.6: $3 input / $15 output). Warn if output_tokens exceeds 5000 with a note about possible high thinking usage.

Pułapki, które cię ugryzą

Podatek tokenizerowy. Nowy tokenizer Opus 4.7 generuje do 35% więcej tokenów za ten sam tekst w porównaniu z Opus 4.6. Twoje koszty rosną przy zerowych zmianach w kodzie, kiedy przechodzisz na nowszy model. Proces myślenia, który kosztował $0.25 na Opus 4.6, może kosztować $0.34 na 4.7 — to samo rozumowanie, większy rachunek. Monitoruj usage przed i po zmianie modelu.

Tokeny myślenia nie podlegają Prompt Caching. Prompt caching — funkcja Anthropic dająca zniżkę na powtarzające się tokeny wejściowe — nie obejmuje treści thinking. W pętlach agentowych z wieloma wywołaniami narzędzi Claude czyta bloki thinking z poprzednich tur jako input. To tworzy narastające koszty, których nie zauważysz, jeśli nie śledzisz cache_read_input_tokens osobno.

Pułapka legacy. Wciąż na Claude Sonnet 4.6 lub Opus 4.6? budget_tokens nadal działa. Przejdź na Opus 4.7, a dostaniesz błąd 400 bez żadnego ostrzeżenia o deprecjacji — tylko twardy fail. Testuj zanim wdrożysz.

Sufit max_tokens. Tokeny myślenia i tokeny odpowiedzi dzielą ten sam limit max_tokens. Ustaw max_tokens: 4000, a jeśli model pomyśli przez 3800 tokenów, dostaniesz odpowiedź na 200 tokenów. Zawsze ustawiaj wyżej, niż ci się wydaje, że potrzebujesz.

Co możesz zrobić teraz

Masz dwa biegi. Dla rutynowych 80% — ekstrakcja, formatowanie, proste Q&A — użyj effort: "low" albo pomiń thinking całkowicie. Dla trudnych 20% — code review, planowanie architektury, złożona analiza — użyj "high" lub "xhigh" ze streamingiem i monitorowaniem kosztów. Puść 100 requestów, sprawdź liczby w usage, potem dostosuj.

Rok temu każde wywołanie Claude API działało na tej samej głębokości — szybko, płytko, jeden bieg. Teraz kontrolujesz pokrętło. Model, który myśli przez 30 sekund nad trudnym bugiem, to ten sam model, który pomija thinking przy klasyfikacji. Ten sam endpoint, ten sam kod, trzy linie konfiguracji różnicy. Przekręć.