Construire avec la réflexion étendue

La réflexion étendue confère à Claude des capacités de raisonnement améliorées pour les tâches complexes, tout en offrant différents niveaux de transparence dans son processus de réflexion étape par étape avant de livrer sa réponse finale.

Modèles pris en charge

La réflexion étendue est prise en charge dans les modèles suivants :

Claude Opus 4 (claude-opus-4-20250514)
Claude Sonnet 4 (claude-sonnet-4-20250514)
Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)

Le comportement de l’API diffère entre les modèles Claude 3.7 et Claude 4, mais les structures d’API restent exactement les mêmes.

Pour plus d’informations, consultez Différences de réflexion entre les versions de modèles.

Comment fonctionne la réflexion étendue

Lorsque la réflexion étendue est activée, Claude crée des blocs de contenu thinking où il expose son raisonnement interne. Claude intègre les idées issues de ce raisonnement avant d’élaborer une réponse finale.

La réponse de l’API inclura des blocs de contenu thinking, suivis de blocs de contenu text.

Voici un exemple du format de réponse par défaut :

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Analysons cela étape par étape...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "D'après mon analyse..."
    }
  ]
}

Pour plus d’informations sur le format de réponse de la réflexion étendue, consultez la Référence de l’API Messages.

Comment utiliser la réflexion étendue

Voici un exemple d’utilisation de la réflexion étendue dans l’API Messages :

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Y a-t-il un nombre infini de nombres premiers tels que n mod 4 == 3 ?"
        }
    ]
}'

Pour activer la réflexion étendue, ajoutez un objet thinking, avec le paramètre thinking défini sur enabled et le budget_tokens sur un budget de tokens spécifié pour la réflexion étendue.

Le paramètre budget_tokens détermine le nombre maximum de tokens que Claude est autorisé à utiliser pour son processus de raisonnement interne. Dans les modèles Claude 4, cette limite s’applique aux tokens de réflexion complète, et non à la sortie résumée. Des budgets plus importants peuvent améliorer la qualité des réponses en permettant une analyse plus approfondie des problèmes complexes, bien que Claude puisse ne pas utiliser l’intégralité du budget alloué, en particulier pour des plages supérieures à 32k.

budget_tokens doit être défini à une valeur inférieure à max_tokens. Cependant, lors de l’utilisation de la réflexion entrelacée avec des outils, vous pouvez dépasser cette limite car la limite de tokens devient votre fenêtre de contexte entière (200k tokens).

Réflexion résumée

Avec la réflexion étendue activée, l’API Messages pour les modèles Claude 4 renvoie un résumé du processus de réflexion complet de Claude. La réflexion résumée offre tous les avantages intellectuels de la réflexion étendue, tout en empêchant les utilisations abusives.

Voici quelques considérations importantes pour la réflexion résumée :

Vous êtes facturé pour les tokens de réflexion complète générés par la requête originale, pas pour les tokens du résumé.
Le nombre de tokens de sortie facturés ne correspondra pas au nombre de tokens que vous voyez dans la réponse.
Les premières lignes de la sortie de réflexion sont plus détaillées, fournissant un raisonnement détaillé particulièrement utile pour l’ingénierie des prompts.
Alors qu’Anthropic cherche à améliorer la fonctionnalité de réflexion étendue, le comportement de résumé est susceptible de changer.
La résumation préserve les idées clés du processus de réflexion de Claude avec une latence minimale ajoutée, permettant une expérience utilisateur diffusable et une migration facile des modèles Claude 3.7 vers les modèles Claude 4.
La résumation est traitée par un modèle différent de celui que vous ciblez dans vos requêtes. Le modèle de réflexion ne voit pas la sortie résumée.

Claude Sonnet 3.7 continue de renvoyer la sortie de réflexion complète.

Dans les rares cas où vous avez besoin d’accéder à la sortie de réflexion complète pour les modèles Claude 4, contactez notre équipe commerciale.

Diffusion en continu de la réflexion

Vous pouvez diffuser en continu les réponses de réflexion étendue en utilisant les événements envoyés par le serveur (SSE).

Lorsque la diffusion en continu est activée pour la réflexion étendue, vous recevez du contenu de réflexion via des événements thinking_delta.

Pour plus de documentation sur la diffusion en continu via l’API Messages, consultez Diffusion en continu des messages.

Voici comment gérer la diffusion en continu avec la réflexion :

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Combien font 27 * 453 ?"
        }
    ]
}'

Exemple de sortie en continu :

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-sonnet-4-20250514", "stop_reason": null, "stop_sequence": null}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Résolvons cela étape par étape :\n\n1. D'abord décomposons 27 * 453"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}

// Deltas de réflexion supplémentaires...

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12 231"}}

// Deltas de texte supplémentaires...

event: content_block_stop
data: {"type": "content_block_stop", "index": 1}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

Lorsque vous utilisez la diffusion en continu avec la réflexion activée, vous pourriez remarquer que le texte arrive parfois en plus gros morceaux alternant avec une livraison plus petite, token par token. C’est un comportement attendu, en particulier pour le contenu de réflexion.

Le système de diffusion en continu doit traiter le contenu par lots pour des performances optimales, ce qui peut entraîner ce modèle de livraison “par morceaux”, avec des délais possibles entre les événements de diffusion. Nous travaillons continuellement à améliorer cette expérience, avec des mises à jour futures axées sur une diffusion plus fluide du contenu de réflexion.

Réflexion étendue avec utilisation d’outils

La réflexion étendue peut être utilisée avec l’utilisation d’outils, permettant à Claude de raisonner sur la sélection d’outils et le traitement des résultats.

Lorsque vous utilisez la réflexion étendue avec des outils, soyez conscient des limitations suivantes :

Limitation du choix d’outil : L’utilisation d’outils avec réflexion ne prend en charge que tool_choice: any (pas specific, auto, ou d’autres valeurs).
Préservation des blocs de réflexion : Lors de l’utilisation d’outils, vous devez renvoyer les blocs thinking à l’API pour le dernier message de l’assistant. Incluez le bloc complet non modifié à l’API pour maintenir la continuité du raisonnement.

Exemple : Transmission des blocs de réflexion avec les résultats d'outils

Voici un exemple pratique montrant comment préserver les blocs de réflexion lors de la fourniture des résultats d’outils :

weather_tool = {
    "name": "get_weather",
    "description": "Obtenir la météo actuelle pour un lieu",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Première requête - Claude répond avec réflexion et demande d'outil
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Quel temps fait-il à Paris ?"}
    ]
)

La réponse de l’API inclura des blocs de réflexion, de texte et d’utilisation d’outil :

{
    "content": [
        {
            "type": "thinking",
            "thinking": "L'utilisateur veut connaître la météo actuelle à Paris. J'ai accès à une fonction `get_weather`...",
            "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
        },
        {
            "type": "text",
            "text": "Je peux vous aider à obtenir les informations météorologiques actuelles pour Paris. Laissez-moi vérifier cela pour vous"
        },
        {
            "type": "tool_use",
            "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
            "name": "get_weather",
            "input": {
                "location": "Paris"
            }
        }
    ]
}

Maintenant, continuons la conversation et utilisons l’outil

# Extraire le bloc de réflexion et le bloc d'utilisation d'outil
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Appeler votre API météo réelle, c'est ici que votre appel API réel se ferait
# supposons que c'est ce que nous obtenons en retour
weather_data = {"temperature": 88}

# Deuxième requête - Inclure le bloc de réflexion et le résultat de l'outil
# Aucun nouveau bloc de réflexion ne sera généré dans la réponse
continuation = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Quel temps fait-il à Paris ?"},
        # notez que le thinking_block est transmis ainsi que le tool_use_block
        # si cela n'est pas transmis, une erreur est générée
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Température actuelle : {weather_data['temperature']}°F"
        }]}
    ]
)

La réponse de l’API ne contiendra maintenant que du texte

{
    "content": [
        {
            "type": "text",
            "text": "Actuellement à Paris, la température est de 88°F (31°C)"
        }
    ]
}

Préservation des blocs de réflexion

Lors de l’utilisation d’outils, vous devez renvoyer les blocs thinking à l’API, et vous devez inclure le bloc complet non modifié à l’API. C’est essentiel pour maintenir le flux de raisonnement du modèle et l’intégrité de la conversation.

Bien que vous puissiez omettre les blocs thinking des tours précédents du rôle assistant, nous suggérons de toujours renvoyer tous les blocs de réflexion à l’API pour toute conversation à plusieurs tours. L’API va :

Filtrer automatiquement les blocs de réflexion fournis
Utiliser les blocs de réflexion pertinents nécessaires pour préserver le raisonnement du modèle
Facturer uniquement les tokens d’entrée pour les blocs montrés à Claude

Lorsque Claude invoque des outils, il met en pause la construction de sa réponse pour attendre des informations externes. Lorsque les résultats des outils sont renvoyés, Claude continuera à construire cette réponse existante. Cela nécessite de préserver les blocs de réflexion pendant l’utilisation des outils, pour plusieurs raisons :

Continuité du raisonnement : Les blocs de réflexion capturent le raisonnement étape par étape de Claude qui a conduit aux demandes d’outils. Lorsque vous publiez des résultats d’outils, l’inclusion de la réflexion originale garantit que Claude peut poursuivre son raisonnement là où il s’était arrêté.
Maintien du contexte : Bien que les résultats des outils apparaissent comme des messages utilisateur dans la structure de l’API, ils font partie d’un flux de raisonnement continu. La préservation des blocs de réflexion maintient ce flux conceptuel à travers plusieurs appels d’API. Pour plus d’informations sur la gestion du contexte, consultez notre guide sur les fenêtres de contexte.

Important : Lorsque vous fournissez des blocs thinking, la séquence entière de blocs thinking consécutifs doit correspondre aux sorties générées par le modèle lors de la requête originale ; vous ne pouvez pas réorganiser ou modifier la séquence de ces blocs.

Réflexion entrelacée

La réflexion étendue avec utilisation d’outils dans les modèles Claude 4 prend en charge la réflexion entrelacée, qui permet à Claude de réfléchir entre les appels d’outils et de faire un raisonnement plus sophistiqué après avoir reçu les résultats des outils.

Avec la réflexion entrelacée, Claude peut :

Raisonner sur les résultats d’un appel d’outil avant de décider quoi faire ensuite
Enchaîner plusieurs appels d’outils avec des étapes de raisonnement entre eux
Prendre des décisions plus nuancées basées sur des résultats intermédiaires

Pour activer la réflexion entrelacée, ajoutez l’en-tête bêta interleaved-thinking-2025-05-14 à votre requête API.

La réflexion entrelacée n’est prise en charge que pour les outils utilisés via l’API Messages.

Avec la réflexion entrelacée, le budget_tokens peut dépasser le paramètre max_tokens car il représente le budget total pour tous les blocs de réflexion au sein d’un tour d’assistant.

Utilisation d'outils sans réflexion entrelacée

import anthropic

client = anthropic.Anthropic()

# Définir les outils
calculator_tool = {
    "name": "calculator",
    "description": "Effectuer des calculs mathématiques",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Expression mathématique à évaluer"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Interroger la base de données de produits",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Requête SQL à exécuter"
            }
        },
        "required": ["query"]
    }
}

# Première requête - Claude réfléchit une fois avant tous les appels d'outils
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "Quel est le chiffre d'affaires total si nous avons vendu 150 unités du produit A à 50 $ chacune, et comment cela se compare-t-il à notre chiffre d'affaires mensuel moyen de la base de données ?"
    }]
)

# La réponse inclut la réflexion suivie des utilisations d'outils
# Remarque : Claude réfléchit une fois au début, puis prend toutes les décisions d'outils
print("Première réponse :")
for block in response.content:
    if block.type == "thinking":
        print(f"Réflexion (résumée) : {block.thinking}")
    elif block.type == "tool_use":
        print(f"Utilisation d'outil : {block.name} avec l'entrée {block.input}")
    elif block.type == "text":
        print(f"Texte : {block.text}")

# Vous exécuteriez les outils et renverriez les résultats...
# Après avoir obtenu les deux résultats d'outils, Claude répond directement sans réflexion supplémentaire

Dans cet exemple sans réflexion entrelacée :

Claude réfléchit une fois au début pour comprendre la tâche
Prend toutes les décisions d’utilisation d’outils à l’avance
Lorsque les résultats des outils sont renvoyés, Claude fournit immédiatement une réponse sans réflexion supplémentaire

Utilisation d'outils avec réflexion entrelacée

import anthropic

client = anthropic.Anthropic()

# Mêmes définitions d'outils que précédemment
calculator_tool = {
    "name": "calculator",
    "description": "Effectuer des calculs mathématiques",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Expression mathématique à évaluer"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Interroger la base de données de produits",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Requête SQL à exécuter"
            }
        },
        "required": ["query"]
    }
}

# Première requête avec réflexion entrelacée activée
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    # Activer la réflexion entrelacée avec l'en-tête bêta
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[{
        "role": "user",
        "content": "Quel est le chiffre d'affaires total si nous avons vendu 150 unités du produit A à 50 $ chacune, et comment cela se compare-t-il à notre chiffre d'affaires mensuel moyen de la base de données ?"
    }]
)

print("Réponse initiale :")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Réflexion : {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Utilisation d'outil : {block.name} avec l'entrée {block.input}")
    elif block.type == "text":
        print(f"Texte : {block.text}")

# Premier résultat d'outil (calculatrice)
calculator_result = "7500"  # 150 * 50

# Continuer avec le premier résultat d'outil
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "Quel est le chiffre d'affaires total si nous avons vendu 150 unités du produit A à 50 $ chacune, et comment cela se compare-t-il à notre chiffre d'affaires mensuel moyen de la base de données ?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nAprès le résultat de la calculatrice :")
# Avec la réflexion entrelacée, Claude peut réfléchir au résultat de la calculatrice
# avant de décider d'interroger la base de données
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Réflexion entrelacée : {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Utilisation d'outil : {block.name} avec l'entrée {block.input}")

# Deuxième résultat d'outil (base de données)
database_result = "5200"  # Exemple de chiffre d'affaires mensuel moyen

# Continuer avec le deuxième résultat d'outil
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "Quel est le chiffre d'affaires total si nous avons vendu 150 unités du produit A à 50 $ chacune, et comment cela se compare-t-il à notre chiffre d'affaires mensuel moyen de la base de données ?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nAprès le résultat de la base de données :")
# Avec la réflexion entrelacée, Claude peut réfléchir aux deux résultats
# avant de formuler la réponse finale
for block in response3.content:
    if block.type == "thinking":
        print(f"Réflexion finale : {block.thinking}")
    elif block.type == "text":
        print(f"Réponse finale : {block.text}")

Dans cet exemple avec réflexion entrelacée :

Claude réfléchit à la tâche initialement
Après avoir reçu le résultat de la calculatrice, Claude peut réfléchir à nouveau sur ce que ce résultat signifie
Claude décide ensuite comment interroger la base de données en fonction du premier résultat
Après avoir reçu le résultat de la base de données, Claude réfléchit une fois de plus aux deux résultats avant de formuler une réponse finale
Le budget de réflexion est réparti entre tous les blocs de réflexion au sein du tour

Ce modèle permet des chaînes de raisonnement plus sophistiquées où la sortie de chaque outil informe la décision suivante.

Réflexion étendue avec mise en cache des prompts

La mise en cache des prompts avec réflexion présente plusieurs considérations importantes :

Suppression des blocs de réflexion du contexte

Les blocs de réflexion des tours précédents sont supprimés du contexte, ce qui peut affecter les points de rupture du cache
Lors de la poursuite des conversations avec utilisation d’outils, les blocs de réflexion sont mis en cache et comptent comme des tokens d’entrée lorsqu’ils sont lus depuis le cache
Cela crée un compromis : bien que les blocs de réflexion ne consomment pas d’espace dans la fenêtre de contexte visuellement, ils comptent toujours dans votre utilisation de tokens d’entrée lorsqu’ils sont mis en cache
Si la réflexion devient désactivée, les requêtes échoueront si vous transmettez du contenu de réflexion dans le tour d’utilisation d’outil actuel. Dans d’autres contextes, le contenu de réflexion transmis à l’API est simplement ignoré

Modèles d’invalidation du cache

Les modifications des paramètres de réflexion (activé/désactivé ou allocation de budget) invalident les points de rupture du cache des messages
La réflexion entrelacée amplifie l’invalidation du cache, car les blocs de réflexion peuvent se produire entre plusieurs appels d’outils
Les prompts système et les outils restent mis en cache malgré les changements de paramètres de réflexion ou la suppression de blocs

Bien que les blocs de réflexion soient supprimés pour la mise en cache et les calculs de contexte, ils doivent être préservés lors de la poursuite des conversations avec utilisation d’outils, en particulier avec réflexion entrelacée.

Comprendre le comportement de mise en cache des blocs de réflexion

Lors de l’utilisation de la réflexion étendue avec des outils, les blocs de réflexion présentent un comportement de mise en cache spécifique qui affecte le comptage des tokens :

Comment ça marche :

La mise en cache ne se produit que lorsque vous faites une requête ultérieure qui inclut des résultats d’outils
Lorsque la requête ultérieure est faite, l’historique de conversation précédent (y compris les blocs de réflexion) peut être mis en cache
Ces blocs de réflexion mis en cache comptent comme des tokens d’entrée dans vos métriques d’utilisation lorsqu’ils sont lus depuis le cache
Lorsqu’un bloc utilisateur non-résultat-d’outil est inclus, tous les blocs de réflexion précédents sont ignorés et supprimés du contexte

Exemple détaillé de flux :

Requête 1 :

Utilisateur : "Quel temps fait-il à Paris ?"

Réponse 1 :

[thinking_block_1] + [tool_use block 1]

Requête 2 :

Utilisateur : ["Quel temps fait-il à Paris ?"], 
Assistant : [thinking_block_1] + [tool_use block 1], 
Utilisateur : [tool_result_1, cache=True]

Réponse 2 :

[thinking_block_2] + [text block 2]

La requête 2 écrit un cache du contenu de la requête (pas de la réponse). Le cache inclut le message utilisateur original, le premier bloc de réflexion, le bloc d’utilisation d’outil et le résultat de l’outil.

Requête 3 :

Utilisateur : ["Quel temps fait-il à Paris ?"], 
Assistant : [thinking_block_1] + [tool_use block 1], 
Utilisateur : [tool_result_1, cache=True], 
Assistant : [thinking_block_2] + [text block 2], 
Utilisateur : [Réponse textuelle, cache=True]

Comme un bloc utilisateur non-résultat-d’outil a été inclus, tous les blocs de réflexion précédents sont ignorés. Cette requête sera traitée de la même manière que :

Utilisateur : ["Quel temps fait-il à Paris ?"], 
Assistant : [tool_use block 1], 
Utilisateur : [tool_result_1, cache=True], 
Assistant : [text block 2], 
Utilisateur : [Réponse textuelle, cache=True]

Points clés :

Ce comportement de mise en cache se produit automatiquement, même sans marqueurs cache_control explicites
Ce comportement est cohérent, que vous utilisiez la réflexion régulière ou la réflexion entrelacée

Mise en cache du prompt système (préservée lorsque la réflexion change)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Supprimer les éléments script et style
    for script in soup(["script", "style"]):
        script.decompose()

    # Obtenir le texte
    text = soup.get_text()

    # Découper en lignes et supprimer les espaces en début et fin de chaque ligne
    lines = (line.strip() for line in text.splitlines())
    # Découper les titres multiples en une ligne chacun
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Supprimer les lignes vides
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Récupérer le contenu de l'article
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Utiliser juste assez de texte pour la mise en cache (premiers chapitres)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Vous êtes un assistant IA chargé d'analyser des textes littéraires. Analysez soigneusement le texte suivant.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analysez le ton de ce passage."
    }
]

# Première requête - établir le cache
print("Première requête - établissement du cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Utilisation de la première réponse : {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysez les personnages de ce passage."
})
# Deuxième requête - mêmes paramètres de réflexion (hit de cache attendu)
print("\nDeuxième requête - mêmes paramètres de réflexion (hit de cache attendu)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Utilisation de la deuxième réponse : {response2.usage}")

# Troisième requête - paramètres de réflexion différents (miss de cache pour les messages)
print("\nTroisième requête - paramètres de réflexion différents (miss de cache pour les messages)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Budget de réflexion modifié
    },
    system=SYSTEM_PROMPT,  # Le prompt système reste en cache
    messages=MESSAGES  # Le cache des messages est invalidé
)

print(f"Utilisation de la troisième réponse : {response3.usage}")

Mise en cache des messages (invalidée lorsque la réflexion change)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Supprimer les éléments script et style
    for script in soup(["script", "style"]):
        script.decompose()

    # Obtenir le texte
    text = soup.get_text()

    # Découper en lignes et supprimer les espaces en début et fin de chaque ligne
    lines = (line.strip() for line in text.splitlines())
    # Découper les titres multiples en une ligne chacun
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Supprimer les lignes vides
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Récupérer le contenu de l'article
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Utiliser juste assez de texte pour la mise en cache (premiers chapitres)
LARGE_TEXT = book_content[:5000]

# Pas de prompt système - mise en cache dans les messages à la place
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analysez le ton de ce passage."
            }
        ]
    }
]

# Première requête - établir le cache
print("Première requête - établissement du cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Utilisation de la première réponse : {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysez les personnages de ce passage."
})
# Deuxième requête - mêmes paramètres de réflexion (hit de cache attendu)
print("\nDeuxième requête - mêmes paramètres de réflexion (hit de cache attendu)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Même budget de réflexion
    },
    messages=MESSAGES
)

print(f"Utilisation de la deuxième réponse : {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysez le cadre dans ce passage."
})

# Troisième requête - budget de réflexion différent (miss de cache attendu)
print("\nTroisième requête - budget de réflexion différent (miss de cache attendu)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Un budget de réflexion différent casse le cache
    },
    messages=MESSAGES
)

print(f"Utilisation de la troisième réponse : {response3.usage}")

Voici la sortie du script (vous pourriez voir des nombres légèrement différents)

Première requête - établissement du cache
Utilisation de la première réponse : { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Deuxième requête - mêmes paramètres de réflexion (hit de cache attendu)

Utilisation de la deuxième réponse : { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Troisième requête - budget de réflexion différent (miss de cache attendu)
Utilisation de la troisième réponse : { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Cet exemple démontre que lorsque la mise en cache est configurée dans le tableau de messages, la modification des paramètres de réflexion (budget_tokens augmenté de 4000 à 8000) invalide le cache. La troisième requête ne montre aucun hit de cache avec cache_creation_input_tokens=1370 et cache_read_input_tokens=0, prouvant que la mise en cache basée sur les messages est invalidée lorsque les paramètres de réflexion changent.

Tokens maximum et taille de la fenêtre de contexte avec réflexion étendue

Dans les modèles Claude plus anciens (avant Claude Sonnet 3.7), si la somme des tokens du prompt et de max_tokens dépassait la fenêtre de contexte du modèle, le système ajustait automatiquement max_tokens pour s’adapter à la limite de contexte. Cela signifiait que vous pouviez définir une grande valeur max_tokens et le système la réduirait silencieusement selon les besoins.

Avec les modèles Claude 3.7 et 4, max_tokens (qui inclut votre budget de réflexion lorsque la réflexion est activée) est appliqué comme une limite stricte. Le système renverra désormais une erreur de validation si les tokens du prompt + max_tokens dépassent la taille de la fenêtre de contexte.

Vous pouvez consulter notre guide sur les fenêtres de contexte pour une analyse plus approfondie.

La fenêtre de contexte avec réflexion étendue

Lors du calcul de l’utilisation de la fenêtre de contexte avec la réflexion activée, il y a quelques considérations à prendre en compte :

Les blocs de réflexion des tours précédents sont supprimés et ne sont pas comptés dans votre fenêtre de contexte
La réflexion du tour actuel compte dans votre limite max_tokens pour ce tour

Le diagramme ci-dessous illustre la gestion spécialisée des tokens lorsque la réflexion étendue est activée :

La fenêtre de contexte effective est calculée comme suit :

fenêtre de contexte =
  (tokens d'entrée actuels - tokens de réflexion précédents) +
  (tokens de réflexion + tokens de réflexion chiffrés + tokens de sortie de texte)

Nous recommandons d’utiliser l’API de comptage de tokens pour obtenir des décomptes de tokens précis pour votre cas d’utilisation spécifique, en particulier lorsque vous travaillez avec des conversations à plusieurs tours qui incluent de la réflexion.

La fenêtre de contexte avec réflexion étendue et utilisation d’outils

Lors de l’utilisation de la réflexion étendue avec des outils, les blocs de réflexion doivent être explicitement préservés et renvoyés avec les résultats des outils.

Le calcul de la fenêtre de contexte effective pour la réflexion étendue avec utilisation d’outils devient :

fenêtre de contexte =
  (tokens d'entrée actuels + tokens de réflexion précédents + tokens d'utilisation d'outils) +
  (tokens de réflexion + tokens de réflexion chiffrés + tokens de sortie de texte)

Le diagramme ci-dessous illustre la gestion des tokens pour la réflexion étendue avec utilisation d’outils :

Gestion des tokens avec réflexion étendue

Étant donné le comportement de la fenêtre de contexte et de max_tokens avec les modèles Claude 3.7 et 4 à réflexion étendue, vous devrez peut-être :

Surveiller et gérer plus activement votre utilisation de tokens
Ajuster les valeurs max_tokens à mesure que la longueur de votre prompt change
Potentiellement utiliser les points de terminaison de comptage de tokens plus fréquemment
Être conscient que les blocs de réflexion précédents ne s’accumulent pas dans votre fenêtre de contexte

Ce changement a été fait pour fournir un comportement plus prévisible et transparent, en particulier alors que les limites maximales de tokens ont considérablement augmenté.

Chiffrement de la réflexion

Le contenu complet de la réflexion est chiffré et renvoyé dans le champ signature. Ce champ est utilisé pour vérifier que les blocs de réflexion ont été générés par Claude lorsqu’ils sont renvoyés à l’API. Lors de la diffusion en continu des réponses, la signature est ajoutée via un signature_delta à l’intérieur d’un événement content_block_delta juste avant l’événement content_block_stop.

Notez que le champ signature sera significativement plus long que dans les modèles précédents. C’est un champ opaque qui ne doit pas être interprété ou analysé - il existe uniquement à des fins de vérification.

Il n’est strictement nécessaire de renvoyer les blocs de réflexion que lors de l’utilisation d’outils avec réflexion étendue. Sinon, vous pouvez omettre les blocs de réflexion des tours précédents, ou laisser l’API les supprimer pour vous si vous les renvoyez.

Si vous renvoyez des blocs de réflexion, nous recommandons de tout renvoyer tel que vous l’avez reçu pour la cohérence et pour éviter d’éventuels problèmes.

Expurgation de la réflexion

Occasionnellement, le raisonnement interne de Claude sera signalé par nos systèmes de sécurité. Lorsque cela se produit, nous chiffrons une partie ou la totalité du bloc thinking et vous le renvoyons sous forme de bloc redacted_thinking. Les blocs redacted_thinking sont déchiffrés lorsqu’ils sont renvoyés à l’API, permettant à Claude de continuer sa réponse sans perdre de contexte.

Lors de la création d’applications destinées aux clients qui utilisent la réflexion étendue :

Soyez conscient que les blocs de réflexion expurgés contiennent du contenu chiffré qui n’est pas lisible par l’homme
Envisagez de fournir une explication simple comme : “Une partie du raisonnement interne de Claude a été automatiquement chiffrée pour des raisons de sécurité. Cela n’affecte pas la qualité des réponses.”
Si vous montrez des blocs de réflexion aux utilisateurs, vous pouvez filtrer les blocs expurgés tout en préservant les blocs de réflexion normaux
Soyez transparent sur le fait que l’utilisation des fonctionnalités de réflexion étendue peut occasionnellement entraîner le chiffrement de certains raisonnements
Implémentez une gestion d’erreurs appropriée pour gérer gracieusement la réflexion expurgée sans casser votre interface utilisateur

Voici un exemple montrant à la fois des blocs de réflexion normaux et expurgés :

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Analysons cela étape par étape...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "D'après mon analyse..."
    }
  ]
}

Voir des blocs de réflexion expurgés dans votre sortie est un comportement attendu. Le modèle peut toujours utiliser ce raisonnement expurgé pour informer ses réponses tout en maintenant les garde-fous de sécurité.

Si vous avez besoin de tester la gestion de la réflexion expurgée dans votre application, vous pouvez utiliser cette chaîne de test spéciale comme prompt : ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Lorsque vous transmettez des blocs thinking et redacted_thinking à l’API dans une conversation à plusieurs tours, vous devez inclure le bloc complet non modifié à l’API pour le dernier tour de l’assistant. C’est essentiel pour maintenir le flux de raisonnement du modèle. Nous suggérons de toujours renvoyer tous les blocs de réflexion à l’API. Pour plus de détails, consultez la section Préservation des blocs de réflexion ci-dessus.

Exemple : Travailler avec des blocs de réflexion expurgés

Cet exemple montre comment gérer les blocs redacted_thinking qui peuvent apparaître dans les réponses lorsque le raisonnement interne de Claude contient du contenu signalé par les systèmes de sécurité :

import anthropic

client = anthropic.Anthropic()

# Utilisation d'un prompt spécial qui déclenche la réflexion expurgée (à des fins de démonstration uniquement)
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Identifier les blocs de réflexion expurgés
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("La réponse contient des blocs de réflexion expurgés")
    # Ces blocs sont toujours utilisables dans les requêtes suivantes

    # Extraire tous les blocs (expurgés et non expurgés)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # Lors de la transmission aux requêtes suivantes, inclure tous les blocs sans modification
    # Cela préserve l'intégrité du raisonnement de Claude

    print(f"Trouvé {len(all_thinking_blocks)} blocs de réflexion au total")
    print(f"Ces blocs sont toujours facturables en tant que tokens de sortie")

Différences de réflexion entre les versions de modèles

L’API Messages gère la réflexion différemment entre les modèles Claude Sonnet 3.7 et Claude 4, principalement dans le comportement d’expurgation et de résumé.

Consultez le tableau ci-dessous pour une comparaison condensée :

Fonctionnalité	Claude Sonnet 3.7	Modèles Claude 4
Sortie de réflexion	Renvoie la sortie de réflexion complète	Renvoie la réflexion résumée
Réflexion entrelacée	Non prise en charge	Prise en charge avec l’en-tête bêta `interleaved-thinking-2025-05-14`

Tarification

La réflexion étendue utilise le schéma de tarification standard des tokens :

Modèle	Tokens d’entrée de base	Écritures de cache	Hits de cache	Tokens de sortie
Claude Opus 4	15 $ / MTok	18,75 $ / MTok	1,50 $ / MTok	75 $ / MTok
Claude Sonnet 4	3 $ / MTok	3,75 $ / MTok	0,30 $ / MTok	15 $ / MTok
Claude Sonnet 3.7	3 $ / MTok	3,75 $ / MTok	0,30 $ / MTok	15 $ / MTok

Le processus de réflexion entraîne des frais pour :

Les tokens utilisés pendant la réflexion (tokens de sortie)
Les blocs de réflexion du dernier tour de l’assistant inclus dans les requêtes suivantes (tokens d’entrée)
Les tokens de sortie de texte standard

Lorsque la réflexion étendue est activée, un prompt système spécialisé est automatiquement inclus pour prendre en charge cette fonctionnalité.

Lors de l’utilisation de la réflexion résumée :

Tokens d’entrée : Tokens dans votre requête originale (exclut les tokens de réflexion des tours précédents)
Tokens de sortie (facturés) : Les tokens de réflexion originaux que Claude a générés en interne
Tokens de sortie (visibles) : Les tokens de réflexion résumés que vous voyez dans la réponse
Pas de frais : Tokens utilisés pour générer le résumé

Le nombre de tokens de sortie facturés ne correspondra pas au nombre de tokens visibles dans la réponse. Vous êtes facturé pour le processus de réflexion complet, pas pour le résumé que vous voyez.

Meilleures pratiques et considérations pour la réflexion étendue

Travailler avec les budgets de réflexion

Optimisation du budget : Le budget minimum est de 1 024 tokens. Nous suggérons de commencer par le minimum et d’augmenter progressivement le budget de réflexion pour trouver la plage optimale pour votre cas d’utilisation. Des nombres de tokens plus élevés permettent un raisonnement plus complet, mais avec des rendements décroissants selon la tâche. L’augmentation du budget peut améliorer la qualité des réponses au prix d’une latence accrue. Pour les tâches critiques, testez différents paramètres pour trouver l’équilibre optimal. Notez que le budget de réflexion est un objectif plutôt qu’une limite stricte—l’utilisation réelle des tokens peut varier en fonction de la tâche.
Points de départ : Commencez avec des budgets de réflexion plus importants (16k+ tokens) pour les tâches complexes et ajustez en fonction de vos besoins.
Grands budgets : Pour les budgets de réflexion supérieurs à 32k, nous recommandons d’utiliser le traitement par lots pour éviter les problèmes de réseau. Les requêtes poussant le modèle à réfléchir au-delà de 32k tokens provoquent des requêtes de longue durée qui pourraient se heurter aux délais d’attente du système et aux limites de connexions ouvertes.
Suivi de l’utilisation des tokens : Surveillez l’utilisation des tokens de réflexion pour optimiser les coûts et les performances.

Considérations de performance

Temps de réponse : Soyez prêt à des temps de réponse potentiellement plus longs en raison du traitement supplémentaire requis pour le processus de raisonnement. Tenez compte du fait que la génération de blocs de réflexion peut augmenter le temps de réponse global.
Exigences de diffusion en continu : La diffusion en continu est requise lorsque max_tokens est supérieur à 21 333. Lors de la diffusion en continu, soyez prêt à gérer à la fois les blocs de contenu de réflexion et de texte à leur arrivée.

Compatibilité des fonctionnalités

La réflexion n’est pas compatible avec les modifications de temperature ou top_k ainsi qu’avec l’utilisation forcée d’outils.
Lorsque la réflexion est activée, vous pouvez définir top_p à des valeurs entre 1 et 0,95.
Vous ne pouvez pas pré-remplir les réponses lorsque la réflexion est activée.
Les modifications du budget de réflexion invalident les préfixes de prompt mis en cache qui incluent des messages. Cependant, les prompts système mis en cache et les définitions d’outils continueront à fonctionner lorsque les paramètres de réflexion changent.

Directives d’utilisation

Sélection des tâches : Utilisez la réflexion étendue pour des tâches particulièrement complexes qui bénéficient d’un raisonnement étape par étape comme les mathématiques, la programmation et l’analyse.
Gestion du contexte : Vous n’avez pas besoin de supprimer vous-même les blocs de réflexion précédents. L’API Anthropic ignore automatiquement les blocs de réflexion des tours précédents et ils ne sont pas inclus dans le calcul de l’utilisation du contexte.
Ingénierie de prompt : Consultez nos conseils d’ingénierie de prompt pour la réflexion étendue si vous souhaitez maximiser les capacités de réflexion de Claude.

Prochaines étapes

Essayez le livre de recettes de réflexion étendue

Explorez des exemples pratiques de réflexion dans notre livre de recettes.

Conseils d'ingénierie de prompt pour la réflexion étendue

Apprenez les meilleures pratiques d’ingénierie de prompt pour la réflexion étendue.

Mise en cache des prompts Messages en streaming

On this page

Modèles pris en charge
Comment fonctionne la réflexion étendue
Comment utiliser la réflexion étendue
Réflexion résumée
Diffusion en continu de la réflexion
Réflexion étendue avec utilisation d’outils
Préservation des blocs de réflexion
Réflexion entrelacée
Réflexion étendue avec mise en cache des prompts
Comprendre le comportement de mise en cache des blocs de réflexion
Tokens maximum et taille de la fenêtre de contexte avec réflexion étendue
La fenêtre de contexte avec réflexion étendue
La fenêtre de contexte avec réflexion étendue et utilisation d’outils
Gestion des tokens avec réflexion étendue
Chiffrement de la réflexion
Expurgation de la réflexion
Différences de réflexion entre les versions de modèles
Tarification
Meilleures pratiques et considérations pour la réflexion étendue
Travailler avec les budgets de réflexion
Considérations de performance
Compatibilité des fonctionnalités
Directives d’utilisation
Prochaines étapes

Premiers pas

Modèles et tarifs

Explorer les fonctionnalités

En savoir plus sur Claude

Centre juridique

Tester et évaluer

Composants d'agent

Construire avec la réflexion étendue

Modèles pris en charge

Comment fonctionne la réflexion étendue

Comment utiliser la réflexion étendue

Réflexion résumée

Diffusion en continu de la réflexion

Réflexion étendue avec utilisation d’outils

Préservation des blocs de réflexion

Réflexion entrelacée

Réflexion étendue avec mise en cache des prompts

Comprendre le comportement de mise en cache des blocs de réflexion

Tokens maximum et taille de la fenêtre de contexte avec réflexion étendue

La fenêtre de contexte avec réflexion étendue

La fenêtre de contexte avec réflexion étendue et utilisation d’outils

Gestion des tokens avec réflexion étendue

Chiffrement de la réflexion

Expurgation de la réflexion

Différences de réflexion entre les versions de modèles

Tarification

Meilleures pratiques et considérations pour la réflexion étendue

Travailler avec les budgets de réflexion

Considérations de performance

Compatibilité des fonctionnalités

Directives d’utilisation

Prochaines étapes

Essayez le livre de recettes de réflexion étendue

Conseils d'ingénierie de prompt pour la réflexion étendue

Premiers pas

Modèles et tarifs

Explorer les fonctionnalités

En savoir plus sur Claude

Centre juridique

Tester et évaluer

Composants d'agent

​Modèles pris en charge

​Comment fonctionne la réflexion étendue

​Comment utiliser la réflexion étendue

​Réflexion résumée

​Diffusion en continu de la réflexion

​Réflexion étendue avec utilisation d’outils

​Préservation des blocs de réflexion

​Réflexion entrelacée

​Réflexion étendue avec mise en cache des prompts

​Comprendre le comportement de mise en cache des blocs de réflexion

​Tokens maximum et taille de la fenêtre de contexte avec réflexion étendue

​La fenêtre de contexte avec réflexion étendue

​La fenêtre de contexte avec réflexion étendue et utilisation d’outils

​Gestion des tokens avec réflexion étendue

​Chiffrement de la réflexion

​Expurgation de la réflexion

​Différences de réflexion entre les versions de modèles

​Tarification

​Meilleures pratiques et considérations pour la réflexion étendue

​Travailler avec les budgets de réflexion

​Considérations de performance

​Compatibilité des fonctionnalités

​Directives d’utilisation

​Prochaines étapes

Essayez le livre de recettes de réflexion étendue

Conseils d'ingénierie de prompt pour la réflexion étendue

Modèles pris en charge

Comment fonctionne la réflexion étendue

Comment utiliser la réflexion étendue

Réflexion résumée

Diffusion en continu de la réflexion

Réflexion étendue avec utilisation d’outils

Préservation des blocs de réflexion

Réflexion entrelacée

Réflexion étendue avec mise en cache des prompts

Comprendre le comportement de mise en cache des blocs de réflexion

Tokens maximum et taille de la fenêtre de contexte avec réflexion étendue

La fenêtre de contexte avec réflexion étendue

La fenêtre de contexte avec réflexion étendue et utilisation d’outils

Gestion des tokens avec réflexion étendue

Chiffrement de la réflexion

Expurgation de la réflexion

Différences de réflexion entre les versions de modèles

Tarification

Meilleures pratiques et considérations pour la réflexion étendue

Travailler avec les budgets de réflexion

Considérations de performance

Compatibilité des fonctionnalités

Directives d’utilisation

Prochaines étapes