Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Pensée adaptative
<a name="claude-messages-adaptive-thinking"></a>

La pensée adaptative est la méthode recommandée pour utiliser [Réflexion étendue](claude-messages-extended-thinking.md) la version Claude Opus 4.6. Au lieu de définir manuellement un budget symbolique, la pensée adaptative permet de décider Claude dynamiquement quand et dans quelle mesure réfléchir en fonction de la complexité de chaque demande. La pensée adaptative entraîne de manière fiable de meilleures performances que la pensée étendue avec une approche fixe`budget_tokens`, et nous vous recommandons de passer à la pensée adaptative pour obtenir les réponses les plus intelligentes de la Claude Opus version 4.6. Aucun en-tête bêta n'est requis.

Les modèles suivants sont pris en charge :


| Modèle | ID du modèle | 
| --- | --- | 
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` | 
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` | 

**Note**  
`thinking.type: "enabled"`et `budget_tokens` sont obsolètes dans la version Claude Opus 4.6 et seront supprimés dans une future version du modèle. À utiliser plutôt `thinking.type: "adaptive"` avec le paramètre effort.  
Les anciens modèles (Claude Opus4.5Claude Sonnet 4.5, etc.) ne prennent pas en charge la pensée adaptative et nécessitent `thinking.type: "enabled"` avec`budget_tokens`.

## Comment fonctionne la pensée adaptative
<a name="claude-messages-adaptive-thinking-how-it-works"></a>

En mode adaptatif, Claude évalue la complexité de chaque demande et décide s'il convient de réfléchir et dans quelle mesure. Au niveau d'effort par défaut (`high`), je Claude penserai presque toujours. À un niveau d'effort moindre, vous Claude pouvez éviter de penser à des problèmes plus simples.

La pensée adaptative le permet également automatiquement[Réflexion entrelacée (bêta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved). Cela Claude permet de réfléchir entre les appels d'outils, ce qui le rend particulièrement efficace pour les flux de travail agentiques.

Définissez `thinking.type` ce paramètre `"adaptive"` dans votre demande d'API :

------
#### [ CLI ]

```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```

------
#### [ Python ]

```
import boto3
import json

bedrock_runtime = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-2'
)

response = bedrock_runtime.invoke_model(
    modelId="us.anthropic.claude-opus-4-6-v1",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 16000,
        "thinking": {
            "type": "adaptive"
        },
        "messages": [{
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even."
        }]
    })
)

response_body = json.loads(response["body"].read())

for block in response_body["content"]:
    if block["type"] == "thinking":
        print(f"\nThinking: {block['thinking']}")
    elif block["type"] == "text":
        print(f"\nResponse: {block['text']}")
```

------
#### [ TypeScript ]

```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";

async function main() {
    const client = new BedrockRuntimeClient({});

    const command = new InvokeModelCommand({
        modelId: "us.anthropic.claude-opus-4-6-v1",
        body: JSON.stringify({
            anthropic_version: "bedrock-2023-05-31",
            max_tokens: 16000,
            thinking: {
                type: "adaptive"
            },
            messages: [{
                role: "user",
                content: "Explain why the sum of two even numbers is always even."
            }]
        })
    });

    const response = await client.send(command);
    const responseBody = JSON.parse(new TextDecoder().decode(response.body));

    for (const block of responseBody.content) {
        if (block.type === "thinking") {
            console.log(`\nThinking: ${block.thinking}`);
        } else if (block.type === "text") {
            console.log(`\nResponse: ${block.text}`);
        }
    }
}

main().catch(console.error);
```

------

## Pensée adaptative avec le paramètre d'effort
<a name="claude-messages-adaptive-thinking-effort"></a>

Vous pouvez associer la pensée adaptative au paramètre d'effort pour déterminer l'efficacité de la Claude réflexion. Le niveau d'effort sert de guide souple pour Claude la répartition de la réflexion :


| Niveau d'effort | Comportement de réflexion | 
| --- | --- | 
| max | Claudepense toujours sans aucune contrainte quant à la profondeur de réflexion. Claude Opus4.6 uniquement — les demandes utilisées max sur d'autres modèles renverront une erreur. | 
| high (par défaut) | Claudepense toujours. Fournit un raisonnement approfondi sur des tâches complexes. | 
| medium | Claudeutilise une pensée modérée. Peut éviter de réfléchir pour des requêtes très simples. | 
| low | Claudeminimise la réflexion. Évite de penser à des tâches simples où la rapidité compte le plus. | 

## Mise en cache des invites
<a name="claude-messages-adaptive-thinking-prompt-caching"></a>

Les requêtes consécutives utilisant `adaptive` Thinking préservent les points d'arrêt rapides du cache. Cependant, le basculement entre les modes`enabled`/`adaptive`et/`disabled`thinking permet de briser les points d'arrêt du cache pour les messages. Les instructions système et les définitions d'outils restent en cache indépendamment des changements de mode.

## Régler le comportement de réflexion
<a name="claude-messages-adaptive-thinking-tuning"></a>

Si vous Claude réfléchissez plus ou moins souvent que vous ne le souhaiteriez, vous pouvez ajouter des instructions à l'invite de votre système :

```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```

**Avertissement**  
ClaudeRéfléchir moins souvent peut réduire la qualité des tâches pour lesquelles le raisonnement est bénéfique. Mesurez l'impact sur vos charges de travail spécifiques avant de déployer un réglage de la production basé sur des instructions. Envisagez d'abord de tester avec des niveaux d'effort moindres.