Comment utiliser le mode de raisonnement dans claude 4.5 ?

“Thinking mode” (également appelé extended thinking, thinking ou thinking blocks) dans Claude 4.5 est un mode de fonctionnement explicite et configurable qui demande au modèle de consacrer un nombre de jetons distinctement budgété à la génération d’un raisonnement interne, étape par étape (une « chaîne de raisonnement ») avant de produire la réponse finale. Il est conçu pour améliorer les performances sur le raisonnement multi‑étapes, le code complexe, les workflows agentiques et les tâches de recherche, en échangeant latence et coût en jetons contre une délibération interne plus profonde. Claude 4.5 expose cette capacité au niveau de l’API Messages avec des paramètres explicites (par exemple, thinking / budget_tokens ou un en‑tête d’effort/« interleaved‑thinking »), préserve et optionnellement chiffre les blocs de réflexion pour vérification ultérieure ou usage par des outils, et introduit des comportements de cache et de comptabilisation des jetons que vous devez gérer en production.

Qu’est‑ce que Claude 4.5 ? (Et quels modèles vous concernent ?)

Claude 4.5 est la dernière série de modèles Claude publiés sous forme de mises à jour incrémentales « 4.5 » (par exemple, Sonnet 4.5 et Opus 4.5). Sonnet 4.5 est positionné comme le meilleur équilibre entre intelligence, performance en code et capacités agentiques pour la plupart des développeurs ; Opus 4.5 se concentre sur un raisonnement à très haute intensité et préserve les blocs de réflexion pour améliorer la continuité multi‑tour. Les deux modèles prennent en charge les capacités d’extended thinking de Claude, bien que certains comportements (par ex., réflexion résumée vs complète) diffèrent selon le modèle.

Les gains de performance de Claude 4.5, en particulier dans Sonnet 4.5, sont les plus visibles sur le benchmark SWE‑bench Verified, qui mesure la capacité d’une IA à résoudre de vrais tickets GitHub.

Ces chiffres indiquent que Claude 4.5 n’est pas seulement meilleur pour écrire des extraits ; il est nettement plus capable de naviguer dans des systèmes de fichiers entiers et d’exécuter des tâches autonomes sans intervention humaine.

Pourquoi c’est important

• Code & agents : Sonnet 4.5 montre de fortes avancées sur des tâches logicielles réelles et des travaux de code de long terme — en faisant un choix naturel pour la génération de code, l’édition de code et les flux d’agent autonome.
• Extended thinking & contexte : Les modèles de la famille Claude 4.5 sont conçus pour raisonner avec de très grands carnets internes (des dizaines de milliers de jetons ou plus), permettant un raisonnement multi‑étapes plus profond. Cela change la façon dont vous concevez les prompts, les budgets de jetons et les interactions avec les outils.

Qu’est‑ce que le Thinking Mode dans Claude 4.5 ?

Le Thinking Mode (officiellement appelé « Extended Thinking ») est une capacité qui permet au modèle de « montrer son travail » à lui‑même avant de livrer une sortie finale. Contrairement aux modèles standards qui s’engagent immédiatement sur une réponse, Claude 4.5 utilise un espace de raisonnement dédié pour explorer plusieurs hypothèses, identifier d’éventuelles erreurs dans sa logique et affiner sa stratégie.

Anatomie d’une réponse

Dans une interaction standard, le modèle reçoit un prompt et commence à générer la réponse. En Thinking Mode, la réponse est scindée en deux blocs distincts :

Propriétés clés du thinking mode

• Activation sur demande : Vous passez un objet thinking dans l’appel API tel que {"type":"enabled","budget_tokens":10000} pour l’activer et donner au modèle un budget interne de jetons pour raisonner.
• Budgétisation : budget_tokens plafonne les jetons de raisonnement internes du modèle. Plus de budget => potentiel de raisonnement plus profond mais coût et latence plus élevés. Dans les modèles Claude 4, les jetons de réflexion sont facturés même si vous ne recevez qu’une vue résumée.
• Synthèse & caviardage : Pour de nombreux modèles Claude 4, l’utilisateur voit une version résumée du contenu de réflexion ; certains raisonnements internes peuvent être caviardés (chiffrés) par les systèmes de sécurité et renvoyés comme redacted_thinking.
• Signatures & vérification : Les blocs de réflexion incluent une signature opaque utilisée pour la vérification lors du renvoi des blocs de réflexion à l’API (particulièrement nécessaire lors de l’utilisation d’outils). Traitez la signature comme opaque — n’essayez pas de l’analyser.
• Réflexion intercalée avec des outils : Claude 4 prend en charge l’entrelacement de blocs de réflexion avec des exécutions d’outils (bêta et parfois activé par drapeaux). C’est puissant pour le travail agentique (exécuter un outil, réfléchir, exécuter un autre outil, etc.).

Pour des exemples pratiques et les paramètres les plus à jour, la documentation Messages/Extended Thinking d’Anthropic est la référence canonique.

Comment l’API Messages renvoie le contenu de réflexion

Réflexion résumée vs complète ; chiffrement & signatures

Différentes versions des modèles Claude gèrent la réflexion différemment : les modèles Claude 4 plus récents (comme Sonnet/Opus 4.5) renvoient souvent une vue publique résumée du raisonnement interne tandis que le carnet complet peut être chiffré et disponible uniquement via un champ signature (ou des blocs caviardés). Lorsque des outils sont utilisés (ou que vous devez préserver l’état interne à travers des appels d’outils), vous devez renvoyer les blocs de réflexion à l’API ou utiliser le mécanisme de signature décrit dans la documentation. Ce mécanisme aide à protéger le raisonnement interne sensible tout en permettant une poursuite sûre du processus de réflexion lorsque nécessaire.

Schéma de gestion pratique

Usage d’outils / continuation : si votre requête suivante doit continuer le même état interne (par ex., des outils ont été lancés sur la base de la réflexion), incluez le bloc de réflexion renvoyé ou la signature lors du prochain appel API pour que le modèle puisse déchiffrer et reprendre là où il s’était arrêté.

Request : envoyez thinking: {type: "enabled", budget_tokens: N}.

Response : vous pouvez recevoir (a) une sortie publique résumée, (b) une signature chiffrée ou un bloc redacted_thinking, ou (c) les deux.

CometAPI propose l’API Claude 4.5 à 20 % du prix officiel, et elle peut aussi être appelée via Anthropic Messages. Vous devrez obtenir une clé API avant de commencer.

Exemple 1 — curl simple (non‑streaming) avec thinking activé

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."}
    ]
  }'

La réponse contiendra des blocs content. Inspectez chaque bloc et privilégiez les blocs text pour la sortie finale ; les blocs thinking contiennent le résumé de l’analyse interne du modèle.

Exemple 2 — Python : requête, analyse des blocs de réflexion et de texte

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"))

Ce code extrait et affiche la réflexion résumée et la réponse finale. Si vous devez préserver la continuité dans des flux d’agent multi‑tour, incluez les blocs de réflexion non modifiés dans le tableau messages de la requête suivante (voir l’exemple suivant).

Exemple 3 — réutiliser des blocs de réflexion dans un flux multi‑tour (pseudo Python)

# 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)

Préserver exactement les blocs de réflexion non modifiés est crucial lors de workflows intégrant des outils ou pour de longs travaux d’agent. Opus 4.5 propose de meilleurs paramètres par défaut pour la préservation et le caching des blocs de réflexion.

Comment diffuser (stream) les sorties de réflexion et afficher la progression dans une interface

Bonnes pratiques de streaming

• Utilisez les endpoints de streaming des SDK (les SDK Python/TypeScript disposent d’aides au stream). Pour des tâches de raisonnement longues ou à budget élevé, le streaming évite les timeouts HTTP et vous donne du texte partiel pendant le calcul. Le code typique utilise un itérateur sur text_stream (Python) ou un parseur d’événements (JS).
• Attendez parfois des flux en deux phases : le modèle peut d’abord produire des fragments de raisonnement visibles, puis finaliser avec la réponse. Concevez votre interface pour gérer le contenu fragmenté et afficher des états « en réflexion… » vs réponse finale.
• Si l’API renvoie un signature_delta ou content_block_delta lors du streaming, capturez‑le et joignez‑le aux appels suivants comme l’exige la spécification.

Si vous devez montrer la progression de la réflexion intermédiaire dans une interface, streamez la réponse. Le serveur émettra des événements thinking_delta suivis d’événements 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." } ]
  }'

En streaming, gérez les événements content_block_start, content_block_delta (qui incluent thinking_delta et text_delta) et content_block_stop dans l’ordre. C’est ainsi que vous pouvez afficher le raisonnement étape par étape du modèle au fil de l’eau.

Comment Claude Code interagit avec le thinking mode ? (terminal + VS Code)

Claude Code est un terminal de code interactif et agentique qui intègre l’API Messages et des exécuteurs d’outils. L’expérience CLI/IDE expose la réflexion de deux manières :

• Paramètres globaux / par session : Claude Code propose un panneau /config pour ajuster le comportement (comment l’agent demande des autorisations, s’il préserve les blocs de réflexion, etc.). Utilisez cette interface plutôt que de retaper du JSON brut si vous souhaitez modifier le comportement de façon persistante.
• Sélection de modèle & commandes CLI : Vous pouvez choisir claude-sonnet-4-5 ou claude-opus-4-5 comme modèle actif dans le REPL ; les outils et le comportement de réflexion suivent ensuite la sémantique de l’API Messages. Le CHANGELOG et les notes de version indiquent que la réflexion est désormais activée par défaut pour certains déploiements Opus 4.5 et que la configuration de la réflexion est exposée via /config.

Flux pratique dans Claude Code :

1. Démarrez un projet dans le REPL.
2. Utilisez /config pour inspecter les drapeaux liés à la réflexion (préservation, verbosité, etc.).
3. Demandez à l’agent d’exécuter une tâche longue — il produira du contenu de réflexion et, si nécessaire, demandera l’autorisation d’exécuter certaines étapes bash. Préservez les blocs de réflexion lorsque vous devez vérifier ou rejouer des décisions ultérieurement.

Installation et configuration

Claude Code nécessite Node.js et peut être installé globalement.

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

# Authenticate
claude-code --init

Activer la réflexion dans le terminal

Claude Code prend en charge divers drapeaux et déclencheurs en langage naturel pour contrôler la profondeur du raisonnement.

Conseils :

• Utilisez think/think harder lorsque vous souhaitez que l’agent explore des implémentations alternatives.
• Lorsque Claude Code effectue des appels d’outils (exécuter des tests, opérations git), préservez les blocs thinking si la CLI/l’agent les renvoie ; sinon l’agent peut perdre du contexte entre les étapes.

Avantages de la réflexion entrelacée et de la préservation des blocs

Pour des workflows agentiques avancés, Claude 4.5 introduit deux fonctionnalités bêta qui renforcent significativement les interactions multi‑tour et l’usage d’outils : Interleaved Thinking et Thinking Block Preservation.

Interleaved Thinking (Beta)

La réflexion standard se produit une fois avant la sortie. Interleaved Thinking (activé via l’en‑tête interleaved-thinking-2025-05-14) permet à Claude de « réfléchir » entre les appels d’outils.

Imaginez que Claude débogue un serveur :

1. Réflexion : « Je devrais consulter les logs d’abord. »
2. Appel d’outil : read_file(logs.txt)
3. Réflexion : « Les logs indiquent un timeout de base de données. Je dois maintenant vérifier les paramètres du pool de connexions. »
4. Appel d’outil : read_file(db_config.yml)

Cette « réflexion continue » garantit que le modèle adapte sa stratégie en fonction des données reçues des outils, plutôt que de suivre un plan rigide prédéfini.

Préservation des blocs de réflexion

Dans les conversations multi‑tour, surtout celles impliquant des outils, il est crucial de renvoyer les blocs thinking précédents à l’API.

• Continuité du raisonnement : En recevant ses réflexions précédentes, Claude maintient le contexte logique de son parcours.
• Optimisation Opus 4.5 : Dans Claude Opus 4.5, ce comportement est automatisé. Le modèle préserve par défaut tous les blocs de réflexion précédents dans son contexte, garantissant que même lors de sessions de plus de 30 heures, le modèle ne « oublie » pas pourquoi il a pris certaines décisions d’architecture dix tours plus tôt.

Bonnes pratiques pour utiliser le mode THINKING avec Claude 4.5

Choisir le bon modèle et budget pour la tâche :

Utilisez Sonnet 4.5 pour le code et les workflows agentiques lorsque vous avez besoin du meilleur compromis entre rapidité, coût et fortes capacités de codage ; utilisez Opus 4.5 pour le raisonnement le plus profond et les fenêtres de contexte les plus grandes ou lorsque vous envisagez de lancer de longues sessions autonomes. Les deux prennent en charge l’extended thinking. Choisissez budget_tokens proportionnellement à la complexité de la tâche (commencez petit pour l’expérimentation ; augmentez le budget seulement si vous observez des améliorations de qualité substantielles).

Surveiller et contrôler le coût & la latence

Vous êtes facturé pour la totalité des jetons de réflexion que Claude produit, pas pour la sortie résumée que vous recevez. Cela signifie que de longues délibérations internes augmentent le coût même si vous ne voyez qu’un court résumé. Suivez l’usage des jetons et envisagez un tuning progressif (par exemple : 2k → 8k → 32k) lors du passage de l’exploration à la production.

Préserver les blocs de réflexion uniquement lorsque nécessaire

Les blocs de réflexion peuvent être signés cryptographiquement et préservés pour vérification ultérieure et usage intercalé avec des outils. Évitez de ré‑inclure des blocs de réflexion à chaque requête suivante à moins que votre workflow ne nécessite que le modèle conserve ses délibérations internes antérieures (par exemple, lorsqu’un agent doit rejouer des étapes et a besoin des justifications préservées). Préserver systématiquement la réflexion augmente le volume de contexte et peut compliquer la comptabilisation des jetons.

Quand diffuser la réflexion aux utilisateurs

La réflexion diffusée est excellente pour les outils développeur et les interfaces éducatives (montrer « travail en cours » pendant la délibération du modèle). Ne diffusez pas la réflexion brute aux utilisateurs finaux d’applications grand public sans prendre en compte la sécurité et le caviardage : la réflexion résumée existe précisément pour cette raison. Si vous diffusez, fournissez des affordances UI qui étiquettent le raisonnement interne (par ex., « Raisonnement de l’assistant — interne »), et contrôlez si l’utilisateur final voit la réflexion résumée ou complète.

Usage d’outils et entrelacement

Lors de la combinaison de la réflexion avec des outils (exécution de code, fetch web, processus locaux), utilisez le design de réflexion entrelacée quand vous avez besoin que le modèle sélectionne des outils, les exécute, et raisonne sur les résultats au sein du même tour. L’entrelacement augmente la complexité (et peut nécessiter des drapeaux de fonctionnalité) mais est puissant pour l’automatisation agentique. Soyez explicite sur la réflexion que vous préservez, et testez comment le modèle sélectionne les outils lors d’un run avec réflexion activée.

Notes pratiques de dépannage et d’exploitation

Erreurs courantes et leur signification

• Thinking invalide + choix forcé d’outil : Si vous demandez de la réflexion mais forcez des modes d’usage d’outils incompatibles avec la réflexion, l’API renverra une erreur — n’associez pas tool_choice: {"type":"tool","name":"..."} avec la réflexion.
• Budget > max_tokens : Pour des scénarios de réflexion entrelacée, les règles effectives de jetons diffèrent — la plateforme documente les cas où budget_tokens peut dépasser max_tokens. Lisez attentivement la section « interleaved thinking » avant de tester de grands budgets.
• Validation de signature : Si vous préservez des blocs de réflexion pour des appels ultérieurs, incluez la signature renvoyée afin que l’API puisse vérifier qu’ils proviennent de Claude ; cela empêche la falsification et conserve une chaîne vérifiable.

Observabilité & instrumentation

Journalisez : (1) la sélection du model, (2) thinking.budget_tokens, (3) la consommation réelle de jetons de réflexion (vous en êtes facturé), (4) les latences de streaming (temps jusqu’au premier thinking_delta), et (5) les jetons de texte final. Utilisez ces métriques pour construire des budgets et des SLO pour les flux orientés utilisateur.

Déploiement progressif & humain dans la boucle

Déployez les modèles avec réflexion activée derrière des drapeaux de fonctionnalité. Commencez avec un pourcentage de trafic développeur ou interne, collectez les échecs ou caviardages, et itérez sur les prompts et les budgets. Pour les domaines sensibles, exigez une revue humaine des sorties incluant une réflexion interne substantielle avant la mise en production.

Conseils de débogage

• Commencez petit : activez un budget_tokens faible et augmentez progressivement pour comprendre les améliorations incrémentales.
• Activez le streaming et journalisez les événements content_block_delta / signature pour comprendre quand le modèle produit des blocs de réflexion.
• Si vous utilisez Claude Code : vérifiez /config et les paramètres au niveau du projet ; consultez le changelog de Claude Code si le comportement ne correspond pas aux valeurs par défaut attendues.

Conclusion :

Claude 4.5, combiné à la puissance de l’Extended Thinking et de la CLI Claude Code, représente le saut le plus significatif en productivité développeur depuis l’invention de l’IDE. En permettant au modèle de « montrer son travail » et de délibérer sur des problèmes complexes, Anthropic dépasse l’ère du « chatbot » pour entrer dans l’« ère agentique ».

Que vous intégriez l’API Messages dans un outil développeur personnalisé ou que vous utilisiez Claude Code pour gérer vos PR quotidiennes, maîtriser le Thinking Mode est essentiel. Il apporte la transparence nécessaire à la confiance et la profondeur de raisonnement nécessaire à l’excellence.

Les développeurs peuvent accéder au modèle Claude 4.5 (Claude Sonnet 4.5, Claude Haiku 4.5, Claude Opus 4.5) via CometAPI. Pour commencer, explorez les capacités des modèles de CometAPI dans le Playground et consultez le guide API pour des instructions détaillées. Avant d’y accéder, assurez‑vous d’avoir connecté votre compte CometAPI et obtenu la clé API. CometAPI propose un prix bien inférieur au tarif officiel pour vous aider à intégrer.

Prêt à démarrer ?→ Essai gratuit de Claude 4.5!