Jak korzystać z trybu myślenia w claude 4.5?

„Tryb myślenia” (nazywany także rozszerzonym myśleniem, myśleniem lub blokami myślenia) w Claude 4.5 to jawny, konfigurowalny tryb działania, który instruuje model, aby poświęcił odrębnie budżetowaną liczbę tokenów na generowanie wewnętrznego, krok po kroku rozumowania („łańcucha rozumowania”) przed podaniem finalnej odpowiedzi. Został zaprojektowany, by poprawiać wyniki w zadaniach wieloetapowego wnioskowania, złożonego kodowania i agentowych przepływów oraz prac badawczych, wymieniając opóźnienie i koszt tokenów na głębszą wewnętrzną deliberację. Claude 4.5 udostępnia tę funkcję na poziomie Messages API poprzez jawne parametry (np. thinking / budget_tokens albo nagłówek effort/„interleaved-thinking”), zachowuje i opcjonalnie szyfruje bloki myślenia do późniejszej weryfikacji lub użycia przez narzędzia oraz wprowadza zachowania związane z cache i rozliczaniem tokenów, którymi musisz zarządzać, budując środowiska produkcyjne.

Czym jest Claude 4.5? (I które modele są istotne?)

Claude 4.5 to najnowszy zestaw modeli Claude wydanych jako przyrostowe aktualizacje „4.5” (na przykład Sonnet 4.5 i Opus 4.5). Sonnet 4.5 jest pozycjonowany jako najlepszy kompromis między inteligencją, kodowaniem i wydajnością agentową dla większości deweloperów; Opus 4.5 koncentruje się na bardzo wytężonym rozumowaniu i zachowuje bloki myślenia, aby poprawić ciągłość w dialogach wieloturnowych. Oba modele wspierają rozszerzone myślenie, choć niektóre zachowania (np. podsumowane vs pełne myślenie) różnią się w zależności od modelu.

Zyski wydajności w Claude 4.5, szczególnie w Sonnet 4.5, są najbardziej widoczne w benchmarku SWE-bench Verified, który mierzy zdolność SI do rozwiązywania rzeczywistych problemów z GitHuba.

Te liczby wskazują, że Claude 4.5 nie tylko lepiej pisze fragmenty kodu; jest znacząco bardziej zdolny do nawigowania po całych systemach plików i wykonywania autonomicznych zadań bez interwencji człowieka.

Dlaczego to ma znaczenie

• Kodowanie i agenci: Sonnet 4.5 pokazuje duże wzrosty w realnych zadaniach programistycznych i długohoryzontalnych pracach nad kodem — czyniąc go naturalnym wyborem do generowania kodu, edycji kodu i agentowych przepływów pracy.
• Rozszerzone myślenie i kontekst: Modele z rodziny Claude 4.5 są zbudowane tak, by rozumować przy użyciu bardzo dużych wewnętrznych notatników roboczych (dziesiątki tysięcy tokenów lub więcej), co umożliwia głębsze wieloetapowe wnioskowanie. To zmienia sposób projektowania promptów, budżetów tokenów i interakcji z narzędziami.

Czym jest Tryb Myślenia w Claude 4.5?

Tryb Myślenia (oficjalnie „Rozszerzone myślenie”) to możliwość, która pozwala modelowi „pokazać sobie tok rozumowania” zanim dostarczy wynik końcowy. W przeciwieństwie do standardowych modeli, które od razu zobowiązują się do odpowiedzi, Claude 4.5 korzysta z wydzielonej przestrzeni rozumowania, aby eksplorować wiele hipotez, identyfikować potencjalne błędy w logice i dopracowywać strategię.

Anatomia odpowiedzi

W standardowej interakcji model otrzymuje prompt i zaczyna generować odpowiedź. W Trybie Myślenia odpowiedź jest podzielona na dwa odrębne bloki:

Kluczowe właściwości trybu myślenia

• Włączany na żądanie: Przekazujesz obiekt thinking w wywołaniu API, taki jak {"type":"enabled","budget_tokens":10000}, aby go włączyć i dać modelowi wewnętrzny budżet tokenów na rozumowanie.
• Budżetowanie: budget_tokens ogranicza liczbę wewnętrznych tokenów rozumowania modelu. Większy budżet => potencjał głębszego rozumowania, ale wyższy koszt i opóźnienie. W modelach Claude 4 tokeny myślenia są rozliczane, nawet jeśli otrzymujesz tylko podsumowany widok.
• Podsumowanie i zaczernianie: Dla wielu modeli Claude 4 użytkownik widzi podsumowaną wersję treści myślenia; część wewnętrznego rozumowania może być zaczerniona (zaszyfrowana) przez systemy bezpieczeństwa i zwrócona jako redacted_thinking.
• Podpisy i weryfikacja: Bloki myślenia zawierają nieprzezroczysty signature używany do weryfikacji przy zwracaniu bloków myślenia do API (szczególnie potrzebny przy użyciu narzędzi). Powinieneś traktować podpis jako nieprzezroczysty — nie próbuj go parsować.
• Przeplatane myślenie z narzędziami: Claude 4 wspiera przeplatanie bloków myślenia z wywołaniami narzędzi (w beta i w niektórych przypadkach sterowane flagami). Jest to potężne w pracy agentowej (uruchom narzędzie, pomyśl, uruchom kolejne, itd.).

W przypadku praktycznych przykładów i najaktualniejszych parametrów, dokumentacja Anthropic dotycząca Messages/Extended Thinking jest kanonicznym źródłem.

Jak Messages API zwraca treść myślenia

Podsumowane vs pełne myślenie; szyfrowanie i podpisy

Różne wersje modeli Claude obsługują myślenie inaczej: nowsze modele Claude 4 (jak Sonnet/Opus 4.5) często zwracają podsumowany publiczny widok wewnętrznego rozumowania, podczas gdy pełny „scratchpad” może być zaszyfrowany i dostępny tylko poprzez pole signature (lub zaczernione bloki). Gdy używane są narzędzia (lub trzeba zachować stan wewnętrzny między wywołaniami narzędzi), musisz przekazywać bloki myślenia z powrotem do API albo użyć opisanego w dokumentacji mechanizmu podpisu. Ten mechanizm pomaga chronić wrażliwe wewnętrzne rozumowanie, a jednocześnie pozwala bezpiecznie kontynuować tok myślowy, gdy to potrzebne.

Praktyczny schemat obsługi

• Użycie narzędzi / kontynuacja: jeśli Twoje kolejne żądanie musi kontynuować ten sam stan wewnętrzny (np. narzędzia zostały uruchomione na podstawie myślenia), dołącz zwrócony blok myślenia lub podpis przy ponownym wywołaniu API, aby model mógł odszyfrować i kontynuować od miejsca, w którym przerwał.

• Żądanie: wyślij thinking: {type: "enabled", budget_tokens: N}.

• Odpowiedź: możesz otrzymać (a) podsumowany publiczny wynik, (b) zaszyfrowany signature lub blok redacted_thinking, albo (c) oba.

CometAPI oferuje API Claude 4.5 w cenie 20% oficjalnej ceny API i może być wywoływane z użyciem Anthropic Messages. Przed rozpoczęciem musisz uzyskać klucz API.

Przykład 1 — proste curl (bez strumieniowania) z włączonym myśleniem

curl https://api.cometapi.com/v1/messages \
  -H "x-api-key: $CometAPI_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {
      "type": "enabled",
      "budget_tokens": 10000
    },
    "messages": [
      {"role": "user", "content": "Design a robust data validation strategy for CSV imports, show tests + code."}
    ]
  }'

Odpowiedź będzie zawierała bloki content. Przeanalizuj każdy blok i preferuj bloki text jako wynik końcowy; bloki thinking zawierają podsumowanie wewnętrznej analizy modelu.

Przykład 2 — Python: żądanie, parsowanie bloków myślenia i tekstu

import os, requests

API_KEY = os.environ["CometAPI_API_KEY"]
URL = "https://api.cometapi.com/v1/messages"
HEADERS = {
    "x-api-key": API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "thinking": {"type": "enabled", "budget_tokens": 8000},
    "messages": [{"role": "user", "content": "Explain how to do property-based testing in Python; include example code."}]
}

r = requests.post(URL, headers=HEADERS, json=payload)
r.raise_for_status()
resp = r.json()

# Parse blocks
for block in resp.get("content", []):
    if block.get("type") == "thinking":
        thinking_summary = block.get("thinking")
        print("=== THINKING (summary) ===")
        print(thinking_summary[:1000])  # truncate for logs
        print("signature:", block.get("signature")[:64], "...")
    elif block.get("type") == "text":
        print("=== FINAL TEXT ===")
        print(block.get("text"))

Ten kod wyodrębnia i drukuje podsumowane myślenie i finalną odpowiedź. Jeśli potrzebujesz zachować ciągłość w agentowych przepływach wieloturnowych, dołącz niezmodyfikowane bloki myślenia w kolejnej tablicy messages (zob. następny przykład).

Przykład 3 — ponowne użycie bloków myślenia w przepływie wieloturnowym (Python pseudo)

# After initial response (resp above):
# Add the assistant message including the thinking block back into the conversation
assistant_message = {
  "role": "assistant",
  "content": resp["content"]  # include raw content array (contains thinking + text blocks)
}

# Next user turn: ask follow-up and include previous assistant message
payload2 = {
  "model": "claude-opus-4-5",  # Opus preserves thinking blocks better across turns
  "max_tokens": 20000,
  "thinking": {"type": "enabled", "budget_tokens": 12000},
  "messages": [
    {"role": "user", "content": "Now adapt the validation logic for an avro pipeline."},
    assistant_message
  ]
}
r2 = requests.post(URL, headers=HEADERS, json=payload2)

Zachowanie dokładnie niezmodyfikowanych bloków myślenia jest krytyczne przy integracji z narzędziami lub długich, agentowych przepływach. Opus 4.5 ma ulepszone domyślne ustawienia dotyczące zachowywania bloków myślenia i cache’owania.

Jak strumieniować treści myślenia i pokazywać postęp w UI?

Najlepsze praktyki strumieniowania

• Używaj końcówek strumieniowych SDK (SDK dla Pythona/TypeScript mają pomocniki strumieniowania). Dla długotrwałych lub z wysokim budżetem zadań rozumowania strumieniowanie zapobiega timeoutom HTTP i daje częściowy tekst w trakcie obliczeń modelu. Typowy kod korzysta z iteratora po text_stream (Python) lub zdarzeń (JS).
• Spodziewaj się czasem strumieni w dwóch fazach: model może najpierw produkować widoczne fragmenty rozumowania, a następnie finalizować odpowiedź. Zbuduj UI tak, by obsługiwał porcjowaną treść i by pokazywał stany „myślenie…” vs odpowiedź końcowa.
• Jeśli API zwraca signature_delta lub content_block_delta podczas strumieniowania, przechwyć to i dołącz do kolejnych wywołań zgodnie ze specyfikacją.

Jeśli musisz pokazywać użytkownikowi postęp rozumowania, strumieniuj odpowiedź. Serwer wyemituje zdarzenia thinking_delta, a następnie text_delta.

curl https://api.cometapi.com/v1/messages \
  --header "x-api-key: $CometAPI_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 16000,
    "stream": true,
    "thinking": { "type": "enabled", "budget_tokens": 8000 },
    "messages": [ { "role": "user", "content": "Walk me through debugging this failing unit test and propose fixes." } ]
  }'

Podczas strumieniowania obsługuj zdarzenia content_block_start, content_block_delta (zawierające thinking_delta i text_delta) oraz content_block_stop w odpowiedniej kolejności. Tak możesz wyświetlać krok po kroku rozumowanie modelu w trakcie jego powstawania.

Jak Claude Code współpracuje z trybem myślenia? (terminal + VS Code)

Claude Code to interaktywne, agentowe terminalowe narzędzie do kodowania integrujące Messages API i uruchamiacze narzędzi. Doświadczenie w CLI/IDE eksponuje myślenie na dwa sposoby:

• Ustawienia globalne / na sesję: Claude Code udostępnia panel ustawień /config, aby dostosować zachowanie (jak agent prosi o uprawnienia, czy zachowywać bloki myślenia itd.). Użyj tego UI zamiast przepisywać surowy JSON, jeśli chcesz wprowadzić trwałą zmianę zachowania.
• Wybór modelu i komendy CLI: Możesz wybrać claude-sonnet-4-5 lub claude-opus-4-5 jako aktywny model w REPL; zachowanie narzędzi i myślenia podąża wtedy za semantyką Messages API. CHANGELOG i notatki wydawnicze wskazują, że myślenie jest domyślnie włączone dla niektórych wdrożeń Opus 4.5 i że konfiguracja myślenia jest widoczna przez /config.

Praktyczny przebieg w Claude Code:

1. Rozpocznij projekt w REPL.
2. Użyj /config, aby sprawdzić flagi związane z myśleniem (zachowanie, szczegółowość itd.).
3. Poproś agenta o wykonanie długiego zadania — wygeneruje treści myślenia i, jeśli to potrzebne, poprosi o uprawnienia do uruchomienia konkretnych kroków bash. Zachowuj bloki myślenia, gdy chcesz weryfikować lub ponownie odtwarzać decyzje później.

Instalacja i konfiguracja

Claude Code wymaga Node.js i może być zainstalowany globalnie.

# Install Claude Code CLI
npm install -g @anthropic/claude-code

# Authenticate
claude-code --init

Aktywacja myślenia w terminalu

Claude Code obsługuje różne flagi i wyzwalacze języka naturalnego do sterowania głębokością rozumowania.

Wskazówki:

• Używaj think/think harder, gdy chcesz, by agent zbadał alternatywne implementacje.
• Gdy Claude Code wykonuje wywołania narzędzi (uruchamianie testów, operacje git), zachowuj bloki thinking, jeśli CLI/agent je zwraca; w przeciwnym razie agent może tracić kontekst między krokami.

Korzyści z przeplatanego myślenia i zachowywania bloków

Dla zaawansowanych agentowych przepływów pracy Claude 4.5 wprowadza dwie funkcje beta, które znacząco poprawiają interakcje wieloturnowe i użycie narzędzi: Przeplatane myślenie i Zachowywanie bloków myślenia.

Przeplatane myślenie (Beta)

Standardowe rozumowanie zachodzi raz przed wyjściem. Przeplatane myślenie (włączane przez nagłówek interleaved-thinking-2025-05-14) pozwala Claude „myśleć” pomiędzy wywołaniami narzędzi.

Wyobraź sobie, że Claude debugguje serwer:

1. Myślenie: „Najpierw powinienem sprawdzić logi.”
2. Wywołanie narzędzia: read_file(logs.txt)
3. Myślenie: „Logi pokazują timeout bazy danych. Muszę teraz sprawdzić ustawienia puli połączeń.”
4. Wywołanie narzędzia: read_file(db_config.yml)

To „ciągłe reflektowanie” zapewnia, że model dostosowuje strategię na podstawie danych otrzymanych z narzędzi, a nie podąża sztywnym, wcześniej zdefiniowanym planem.

Zachowywanie bloków myślenia

W rozmowach wieloturnowych, szczególnie tych z użyciem narzędzi, kluczowe jest przekazywanie poprzednich bloków thinking z powrotem do API.

• Ciągłość rozumowania: Otrzymując swoje wcześniejsze myśli, Claude utrzymuje logiczny kontekst swojej drogi.
• Optymalizacja w Opus 4.5: W Claude Opus 4.5 zachowanie to jest zautomatyzowane. Model domyślnie zachowuje wszystkie poprzednie bloki myślenia w swoim kontekście, zapewniając, że nawet w sesjach trwających 30+ godzin model nie „zapomina”, dlaczego podjął pewne decyzje architektoniczne dziesięć tur wcześniej.

Najlepsze praktyki używania TRYBU MYŚLENIA z Claude 4.5

Wybierz właściwy model i budżet do zadania:

Używaj Sonnet 4.5 do kodowania i agentowych przepływów, gdzie potrzebujesz najlepszego kompromisu między szybkością, kosztem i wysokimi umiejętnościami kodowania; używaj Opus 4.5 do najgłębszego rozumowania i największych okien kontekstowych lub gdy planujesz długie autonomiczne sesje. Oba wspierają rozszerzone myślenie. Dobieraj budget_tokens proporcjonalnie do złożoności zadania (zacznij od małych wartości; podnoś budżet tylko wtedy, gdy obserwujesz materialne poprawy jakości).

Monitoruj i kontroluj koszt i opóźnienie

Jesteś rozliczany za wszystkie tokeny myślenia wygenerowane przez Claude, a nie za podsumowany wynik, który otrzymujesz. Oznacza to, że długie wewnętrzne deliberacje zwiększają koszt, nawet jeśli widzisz tylko krótkie podsumowanie. Śledź użycie tokenów i rozważ stopniowe strojenie (np. 2k → 8k → 32k), przechodząc od eksploracji do produkcji.

Zachowuj bloki myślenia tylko, gdy to konieczne

Bloki myślenia mogą być kryptograficznie podpisywane i zachowywane do późniejszej weryfikacji oraz do przeplatanego użycia z narzędziami. Unikaj odtwarzania bloków myślenia w każdym kolejnym żądaniu, chyba że Twój przepływ wymaga, by model zachował wcześniejsze wewnętrzne deliberacje (np. gdy agent będzie powtarzać kroki i potrzebuje zachowanych racjonalizacji). Ciągłe zachowywanie myślenia zwiększa objętość kontekstu i może komplikować rozliczanie tokenów.

Kiedy strumieniować myślenie użytkownikom

Strumieniowane myślenie jest świetne dla narzędzi deweloperskich i edukacyjnych UI (pokazywanie „pracy w toku” podczas deliberacji modelu). Nie strumieniuj surowego myślenia do użytkowników końcowych aplikacji konsumenckich bez uwzględnienia kwestii bezpieczeństwa i zaczerniania: podsumowane myślenie istnieje właśnie z tego powodu. Jeśli strumieniujesz, zapewnij elementy UI, które etykietują wewnętrzne rozumowanie (np. „Rozumowanie asystenta — wewnętrzne”) i kontroluj, czy użytkownik finalnie widzi podsumowane, czy pełne rozumowanie.

Użycie narzędzi i przeplatanie

Łącząc myślenie z narzędziami (wykonywanie kodu, pobieranie z sieci, procesy lokalne), używaj wzorca przeplatanego myślenia, gdy chcesz, aby model wybierał narzędzia, uruchamiał je i rozumował nad wynikami w ramach tej samej tury. Przeplatanie zwiększa złożoność (i może wymagać flag funkcji), ale jest potężne dla automatyzacji agentowej. Bądź precyzyjny w kwestii tego, które myślenie zachowujesz, i testuj, jak model wybiera narzędzia przy włączonym myśleniu.

Praktyczne rozwiązywanie problemów i uwagi operacyjne

Typowe błędy i ich znaczenie

• Nieprawidłowe myślenie + wymuszone użycie narzędzia: Jeśli żądasz myślenia, ale jednocześnie wymuszasz konkretne tryby użycia narzędzi niezgodne z myśleniem, API zwróci błąd — nie mieszaj wymuszonego tool_choice: {"type":"tool","name":"..."} z myśleniem.
• Budget > max_tokens: Dla scenariuszy przeplatanego myślenia obowiązują inne efektywne reguły tokenów — dokumentacja platformy wyjaśnia, kiedy budget_tokens może przekraczać max_tokens. Przeczytaj uważnie sekcję „interleaved thinking” przed testowaniem dużych budżetów.
• Weryfikacja podpisu: Jeśli zachowujesz bloki myślenia na późniejsze wywołania, dołącz zwrócony signature, aby API mogło zweryfikować, że pochodzą od Claude; to zapobiega manipulacjom i utrzymuje weryfikowalny łańcuch.

Obserwowalność i instrumentacja

Loguj: (1) wybór model, (2) thinking.budget_tokens, (3) faktyczne zużycie tokenów myślenia (to za nie płacisz), (4) opóźnienia strumieniowania (czas do pierwszego thinking_delta) oraz (5) końcowe tokeny tekstu. Użyj tych metryk, by budować budżety i SLO dla przepływów użytkownika.

Stopniowe wdrażanie i „human-in-the-loop”

Wdrażaj modele z włączonym myśleniem za flagami funkcji. Zacznij od procenta ruchu deweloperskiego lub wewnętrznego, zbierz przypadki awarii lub zaczernienia i iteruj prompty oraz budżety. Dla wrażliwych domen wymagaj ludzkiego przeglądu wyników zawierających znaczną wewnętrzną treść rozumowania przed upublicznieniem.

Wskazówki debugowania

• Zacznij od małych wartości: włącz niski budget_tokens i skaluj, aby zrozumieć przyrostowe poprawy.
• Włącz strumieniowanie i loguj zdarzenia content_block_delta / podpisu, aby zrozumieć, kiedy model produkuje bloki myślenia.
• Jeśli używasz Claude Code: sprawdź /config i ustawienia na poziomie projektu; zajrzyj do changelogu Claude Code, jeśli zachowanie nie pasuje do oczekiwanych domyślnych ustawień.

Podsumowanie:

Claude 4.5, w połączeniu z mocą Rozszerzonego Myślenia i CLI Claude Code, stanowi najistotniejszy skok produktywności deweloperów od czasu wynalezienia IDE. Pozwalając modelowi „pokazać tok rozumowania” i deliberować nad złożonymi problemami, Anthropic wyszedł poza erę „chatbotów” i wszedł w erę „agentów”.

Niezależnie od tego, czy integrujesz Messages API z własnym narzędziem deweloperskim, czy używasz Claude Code do zarządzania codziennymi PR-ami, opanowanie Trybu Myślenia jest kluczowe. Zapewnia transparentność potrzebną do zaufania i głębię rozumowania potrzebną do doskonałości.

Deweloperzy mogą uzyskać dostęp do modeli Claude 4.5 (Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5) poprzez CometAPI. Aby zacząć, zapoznaj się z możliwościami modeli CometAPI w Playground i skonsultuj przewodnik po API, aby uzyskać szczegółowe instrukcje. Przed dostępem upewnij się, że zalogowałeś się do CometAPI i uzyskałeś klucz API. CometAPI oferuje cenę znacznie niższą niż oficjalna, aby ułatwić integrację.

Gotowy, by zacząć?→ Bezpłatna wersja próbna Claude 4.5!