---
title: Édition du contexte
url: https://platform.claude.com/docs/fr/build-with-claude/context-editing
description: Gérez automatiquement le contexte de la conversation à mesure qu'il s'accroît grâce à l'édition du contexte.
---

<Note>
  Pour savoir comment la « zero data retention » (rétention zéro des données), ou ZDR, s'applique à cette fonctionnalité, consultez [API et rétention des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
</Note>

## Vue d'ensemble

<Note>
  Pour la plupart des cas d'usage, la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction) est la stratégie principale pour gérer le contexte dans les conversations de longue durée. Les stratégies présentées sur cette page sont utiles pour des scénarios spécifiques où vous avez besoin d'un contrôle plus fin sur le contenu effacé.
</Note>

Le « context editing » (édition du contexte) vous permet d'effacer de manière sélective un contenu spécifique de l'historique de conversation à mesure qu'il s'accroît. Au-delà de l'optimisation des coûts et du respect des limites, il s'agit de sélectionner activement ce que Claude voit : le contexte est une ressource finie aux rendements décroissants, et un contenu non pertinent dégrade la concentration du modèle. L'édition du contexte vous donne un contrôle fin, à l'exécution, sur cette sélection. Pour les principes plus généraux qui sous-tendent la gestion du contexte, consultez [Effective context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Cette page couvre :

* **Effacement des résultats d'outils** - Idéal pour les flux de travail agentiques avec une utilisation d'outils intensive, où les anciens résultats d'outils ne sont plus nécessaires
* **Effacement des blocs de réflexion** - Pour gérer les blocs de réflexion des tours précédents, avec des options permettant de conserver la réflexion récente pour assurer la continuité du contexte
* **Compaction SDK côté client** - Une alternative basée sur le SDK pour une gestion du contexte par résumé (la compaction côté serveur est généralement préférable)

| Approche         | Où elle s'exécute | Stratégies                                                                                                                        | Fonctionnement                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ---------------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Côté serveur** | API               | Effacement des résultats d'outils (`clear_tool_uses_20250919`)<br />Effacement des blocs de réflexion (`clear_thinking_20251015`) | Appliquée avant que le prompt n'atteigne Claude. Efface un contenu spécifique de l'historique de conversation. Chaque stratégie peut être configurée indépendamment.                                                                                                                                                                                                                                                                      |
| **Côté client**  | SDK               | Compaction                                                                                                                        | Disponible dans les [SDK TypeScript et Ruby](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) lors de l'utilisation de [`tool_runner`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-runner). Génère un résumé et remplace l'historique complet de la conversation. Voir [Compaction côté client](https://platform.claude.com/docs/fr/build-with-claude/context-editing#client-side-compaction-sdk). |

## Stratégies côté serveur

<Note>
  L'édition du contexte est en version bêta avec la prise en charge de l'effacement des résultats d'outils et de l'effacement des blocs de réflexion. Pour l'activer, utilisez l'en-tête bêta `context-management-2025-06-27` dans vos requêtes API.

  Partagez vos commentaires sur cette fonctionnalité via le [formulaire de commentaires](https://forms.gle/YXC2EKGMhjN1c4L88).
</Note>

### Effacement des résultats d'outils

La stratégie `clear_tool_uses_20250919` efface les résultats d'outils lorsque le contexte de la conversation dépasse le seuil que vous avez configuré. Ceci est particulièrement utile pour les flux de travail agentiques avec une utilisation d'outils intensive. Les anciens résultats d'outils (comme le contenu de fichiers ou les résultats de recherche) ne sont plus nécessaires une fois que Claude les a traités.

Lorsqu'elle est activée, l'API efface automatiquement les résultats d'outils les plus anciens dans l'ordre chronologique. L'API remplace chaque résultat effacé par un texte de substitution indiquant à Claude qu'il a été supprimé. Par défaut, seuls les résultats d'outils sont effacés. Vous pouvez éventuellement effacer à la fois les résultats d'outils et les appels d'outils (les paramètres d'utilisation d'outils) en définissant `clear_tool_inputs` sur true.

### Effacement des blocs de réflexion

La stratégie `clear_thinking_20251015` gère les blocs `thinking` des tours précédents de l'assistant. Cette stratégie vous donne le contrôle sur la préservation de la réflexion : vous pouvez choisir de conserver davantage de blocs de réflexion pour maintenir la continuité du raisonnement, ou de les effacer plus agressivement pour économiser de l'espace de contexte.

<Tip>
  **Comportement par défaut :** la valeur par défaut varie selon la classe de modèle.

  | Classe de modèle | Conserver toute la réflexion antérieure | Conserver uniquement la réflexion du dernier tour |
  | ---------------- | --------------------------------------- | ------------------------------------------------- |
  | Opus             | Claude Opus 4.5 et ultérieurs           | Claude Opus 4.1 et antérieurs                     |
  | Sonnet           | Claude Sonnet 4.6 et ultérieurs         | Claude Sonnet 4.5 (déprécié) et antérieurs        |
  | Haiku            | Claude Haiku 5.5 et ultérieurs          | Claude Haiku 4.5 et antérieurs                    |
  | Fable et Mythos  | Tous les modèles                        | (aucun)                                           |

  Utilisez cette stratégie pour remplacer la valeur par défaut. Si votre code s'exécute sur plusieurs niveaux de modèles, définissez `keep` explicitement plutôt que de vous fier à la valeur par défaut propre à chaque modèle.
</Tip>

Un tour de conversation de l'assistant peut inclure plusieurs blocs de contenu (par exemple, lors de l'utilisation d'outils) et plusieurs blocs de réflexion (par exemple, avec la [réflexion entrelacée](https://platform.claude.com/docs/fr/build-with-claude/thinking#interleaved-thinking)).

### L'édition du contexte s'effectue côté serveur

L'édition du contexte est appliquée côté serveur avant que le prompt n'atteigne Claude. Votre application cliente conserve l'historique de conversation complet et non modifié. Vous n'avez pas besoin de synchroniser l'état de votre client avec la version éditée. Continuez à gérer localement votre historique de conversation complet comme vous le feriez normalement.

Sur Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 et Claude Haiku 5.5, la gestion du contexte côté serveur n'invalide jamais les blocs de réflexion. Les modifications côté client apportées aux tours précédents peuvent invalider les blocs de réflexion de chaque tour ultérieur de l'assistant. Pour les nouveaux comptes créés à partir du 31 août 2026, une requête qui rejoue un bloc invalidé est rejetée, sauf si vous choisissez de le supprimer. Consultez [Conserver le préfixe inchangé](https://platform.claude.com/docs/fr/build-with-claude/preserved-thinking#prefix-check).

### Édition du contexte et mise en cache des prompts

L'interaction de l'édition du contexte avec la [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) (« prompt caching ») varie selon la stratégie :

* **Effacement des résultats d'outils :** invalide les préfixes de prompt mis en cache lorsque du contenu est effacé. Pour en tenir compte, effacez suffisamment de tokens pour que l'invalidation du cache en vaille la peine. Utilisez le paramètre `clear_at_least` pour garantir qu'un nombre minimal de tokens est effacé à chaque fois. Vous supporterez des coûts d'écriture en cache chaque fois que du contenu est effacé, mais les requêtes suivantes pourront réutiliser le préfixe nouvellement mis en cache.

* **Effacement des blocs de réflexion :** lorsque les blocs de réflexion sont **conservés** dans le contexte (non effacés), le cache de prompts est préservé, ce qui permet des accès au cache et réduit les coûts en tokens d'entrée. Lorsque les blocs de réflexion sont **effacés**, le cache est invalidé à l'endroit où l'effacement se produit. Configurez le paramètre `keep` selon que vous souhaitez privilégier les performances du cache ou la disponibilité de la fenêtre de contexte.

## Modèles pris en charge

L'édition du contexte est disponible sur tous les modèles Claude pris en charge.

## Utilisation de l'effacement des résultats d'outils

La façon la plus simple d'activer l'effacement des résultats d'outils est de spécifier uniquement le type de stratégie. Toutes les autres [options de configuration](https://platform.claude.com/docs/fr/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) utilisent leurs valeurs par défaut :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 4096,
          "messages": [
              {
                  "role": "user",
                  "content": "Search for recent developments in AI"
              }
          ],
          "tools": [
              {
                  "type": "web_search_20250305",
                  "name": "web_search"
              }
          ],
          "context_management": {
              "edits": [
                  {"type": "clear_tool_uses_20250919"}
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: Search for recent developments in AI
  tools:
    - type: web_search_20250305
      name: web_search
  context_management:
    edits:
      - type: clear_tool_uses_20250919
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[{"role": "user", "content": "Search for recent developments in AI"}],
      tools=[{"type": "web_search_20250305", "name": "web_search"}],
      betas=["context-management-2025-06-27"],
      context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Search for recent developments in AI"
      }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search"
      }
    ],
    context_management: {
      edits: [{ type: "clear_tool_uses_20250919" }]
    },
    betas: ["context-management-2025-06-27"]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Search for recent developments in AI" }
      ],
      Tools = [
          new BetaWebSearchTool20250305()
      ],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [new BetaClearToolUses20250919Edit()]
      },
      Betas = [AnthropicBeta.ContextManagement2025_06_27]
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for recent developments in AI")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{}},
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
  		},
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Search for recent developments in AI")
          .addTool(BetaWebSearchTool20250305.builder().build())
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder().build())
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Search for recent developments in AI']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          ['type' => 'web_search_20250305', 'name' => 'web_search']
      ],
      contextManagement: [
          'edits' => [
              ['type' => 'clear_tool_uses_20250919']
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Search for recent developments in AI" }
    ],
    tools: [
      { type: "web_search_20250305", name: "web_search" }
    ],
    context_management: {
      edits: [
        { type: "clear_tool_uses_20250919" }
      ]
    },
    betas: ["context-management-2025-06-27"]
  )
  puts response
  ```
</CodeGroup>

### Configuration avancée

Vous pouvez personnaliser le comportement de l'effacement des résultats d'outils avec des paramètres supplémentaires :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 4096,
          "messages": [
              {
                  "role": "user",
                  "content": "Create a simple command line calculator app using Python"
              }
          ],
          "tools": [
              {
                  "type": "text_editor_20250728",
                  "name": "str_replace_based_edit_tool",
                  "max_characters": 10000
              },
              {
                  "type": "web_search_20250305",
                  "name": "web_search",
                  "max_uses": 3
              }
          ],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_tool_uses_20250919",
                      "trigger": {
                          "type": "input_tokens",
                          "value": 30000
                      },
                      "keep": {
                          "type": "tool_uses",
                          "value": 3
                      },
                      "clear_at_least": {
                          "type": "input_tokens",
                          "value": 5000
                      },
                      "exclude_tools": ["web_search"]
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: Create a simple command line calculator app using Python
  tools:
    - type: text_editor_20250728
      name: str_replace_based_edit_tool
      max_characters: 10000
    - type: web_search_20250305
      name: web_search
      max_uses: 3
  context_management:
    edits:
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 30000
        keep:
          type: tool_uses
          value: 3
        clear_at_least:
          type: input_tokens
          value: 5000
        exclude_tools:
          - web_search
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Create a simple command line calculator app using Python",
          }
      ],
      tools=[
          {
              "type": "text_editor_20250728",
              "name": "str_replace_based_edit_tool",
              "max_characters": 10000,
          },
          {"type": "web_search_20250305", "name": "web_search", "max_uses": 3},
      ],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_tool_uses_20250919",
                  # Déclencher l'effacement lorsque le seuil est dépassé
                  "trigger": {"type": "input_tokens", "value": 30000},
                  # Nombre d'utilisations d'outils à conserver après l'effacement
                  "keep": {"type": "tool_uses", "value": 3},
                  # Facultatif : effacer au moins ce nombre de tokens
                  "clear_at_least": {"type": "input_tokens", "value": 5000},
                  # Exclure ces outils de l'effacement
                  "exclude_tools": ["web_search"],
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Create a simple command line calculator app using Python"
      }
    ],
    tools: [
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool",
        max_characters: 10000
      },
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 3
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          // Déclencher l'effacement lorsque le seuil est dépassé.
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          // Nombre d'utilisations d'outils à conserver après l'effacement.
          keep: {
            type: "tool_uses",
            value: 3
          },
          // Facultatif : effacer au moins ce nombre de tokens.
          clear_at_least: {
            type: "input_tokens",
            value: 5000
          },
          // Exclure ces outils de l'effacement.
          exclude_tools: ["web_search"]
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
      ],
      Tools = [
          new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
          new BetaWebSearchTool20250305 { MaxUses = 3 }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(30000),
                  Keep = new BetaToolUsesKeep(3),
                  ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
                  ExcludeTools = ["web_search"]
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a simple command line calculator app using Python")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{
  			MaxCharacters: anthropic.Int(10000),
  		}},
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
  			MaxUses: anthropic.Int(3),
  		}},
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 30000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 3,
  				},
  				ClearAtLeast: anthropic.BetaInputTokensClearAtLeastParam{
  					Value: 5000,
  				},
  				ExcludeTools: []string{"web_search"},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaInputTokensClearAtLeast;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Create a simple command line calculator app using Python")
          .addTool(BetaToolTextEditor20250728.builder()
              .maxCharacters(10000L)
              .build())
          .addTool(BetaWebSearchTool20250305.builder()
              .maxUses(3L)
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(30000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(3L)
                      .build())
                  .clearAtLeast(BetaInputTokensClearAtLeast.builder()
                      .value(5000L)
                      .build())
                  .addExcludeTool("web_search")
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          [
              'role' => 'user',
              'content' => 'Create a simple command line calculator app using Python'
          ]
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'text_editor_20250728',
              'name' => 'str_replace_based_edit_tool',
              'max_characters' => 10000
          ],
          [
              'type' => 'web_search_20250305',
              'name' => 'web_search',
              'max_uses' => 3
          ]
      ],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_tool_uses_20250919',
                  'trigger' => [
                      'type' => 'input_tokens',
                      'value' => 30000
                  ],
                  'keep' => [
                      'type' => 'tool_uses',
                      'value' => 3
                  ],
                  'clear_at_least' => [
                      'type' => 'input_tokens',
                      'value' => 5000
                  ],
                  'exclude_tools' => ['web_search']
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Create a simple command line calculator app using Python"
      }
    ],
    tools: [
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool",
        max_characters: 10000
      },
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 3
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          keep: {
            type: "tool_uses",
            value: 3
          },
          clear_at_least: {
            type: "input_tokens",
            value: 5000
          },
          exclude_tools: ["web_search"]
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

## Utilisation de l'effacement des blocs de réflexion

Utilisez l'effacement des blocs de réflexion pour gérer le contexte et la mise en cache des prompts dans les conversations qui contiennent des blocs de réflexion des tours précédents :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": {
                          "type": "thinking_turns",
                          "value": 2
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep:
          type: thinking_turns
          value: 2
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": {"type": "thinking_turns", "value": 2},
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(2)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 2,
  					},
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
  import com.anthropic.models.beta.messages.BetaThinkingTurns;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .addUserMessage("Hello")
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearThinking20251015Edit.builder()
                  .keep(BetaThinkingTurns.builder()
                      .value(2L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => [
                      'type' => 'thinking_turns',
                      'value' => 2
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

### Options de configuration pour l'effacement des blocs de réflexion

La stratégie `clear_thinking_20251015` prend en charge la configuration suivante :

| Option de configuration | Valeur par défaut | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ----------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `keep`                  | Propre au modèle  | Définit le nombre de tours récents de l'assistant contenant des blocs de réflexion à conserver. Utilisez `{type: "thinking_turns", value: N}`, où N doit être > 0, pour conserver les N derniers tours, ou `"all"` pour conserver tous les blocs de réflexion. Opus 4.5+, Sonnet 4.6+ et Haiku 5.5+ : tous les tours. Modèles Fable et Mythos : tous les tours. Les Opus/Sonnet antérieurs et les Haiku jusqu'à Claude Haiku 4.5 : dernier tour uniquement. |

**Exemples de configuration :**

Conserver les blocs de réflexion des 3 derniers tours de l'assistant :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": {
                          "type": "thinking_turns",
                          "value": 3
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep:
          type: thinking_turns
          value: 3
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": {"type": "thinking_turns", "value": 3},
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 3
          }
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(3)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 3,
  					},
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(16000L)
      .addUserMessage("Hello")
      .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
      .contextManagement(BetaContextManagementConfig.builder()
          .addEdit(BetaClearThinking20251015Edit.builder()
              .keep(BetaThinkingTurns.builder()
                  .value(3L)
                  .build())
              .build())
          .build())
      .build();

  BetaMessage response = client.beta().messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => [
                      'type' => 'thinking_turns',
                      'value' => 3
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 3
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

Conserver tous les blocs de réflexion (maximise les accès au cache) :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 16000,
          "messages": [{"role": "user", "content": "Hello"}],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": "all"
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Hello
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep: all
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[{"role": "user", "content": "Hello"}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": "all",
              }
          ]
      },
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: "all"
        }
      ]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new All()
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfAll: constant.ValueOf[constant.All](),
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(16000L)
      .addUserMessage("Hello")
      .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
      .contextManagement(BetaContextManagementConfig.builder()
          .addEdit(BetaClearThinking20251015Edit.builder()
              .keepAll()
              .build())
          .build())
      .build();

  BetaMessage response = client.beta().messages().create(params);
  IO.println(response);
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => 'all'
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [{ role: "user", content: "Hello" }],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: "all"
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

### Combinaison de stratégies

Vous pouvez utiliser conjointement l'effacement des blocs de réflexion et l'effacement des résultats d'outils :

<Note>
  Lors de l'utilisation de plusieurs stratégies, la stratégie `clear_thinking_20251015` doit figurer en premier dans le tableau `edits`.
</Note>

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 16000,
          "messages": [
              {
                  "role": "user",
                  "content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
              }
          ],
          "tools": [
              {
                  "type": "web_search_20250305",
                  "name": "web_search",
                  "max_uses": 5
              }
          ],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_thinking_20251015",
                      "keep": {
                          "type": "thinking_turns",
                          "value": 2
                      }
                  },
                  {
                      "type": "clear_tool_uses_20250919",
                      "trigger": {
                          "type": "input_tokens",
                          "value": 50000
                      },
                      "keep": {
                          "type": "tool_uses",
                          "value": 5
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 16000
  messages:
    - role: user
      content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
  tools:
    - type: web_search_20250305
      name: web_search
      max_uses: 5
  context_management:
    edits:
      - type: clear_thinking_20251015
        keep:
          type: thinking_turns
          value: 2
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 50000
        keep:
          type: tool_uses
          value: 5
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=16000,
      messages=[
          {
              "role": "user",
              "content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
          }
      ],
      tools=[
          {
              "type": "web_search_20250305",
              "name": "web_search",
              "max_uses": 5,
          }
      ],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_thinking_20251015",
                  "keep": {"type": "thinking_turns", "value": 2},
              },
              {
                  "type": "clear_tool_uses_20250919",
                  "trigger": {"type": "input_tokens", "value": 50000},
                  "keep": {"type": "tool_uses", "value": 5},
              },
          ]
      },
  )

  print(response)
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [
      {
        role: "user",
        content:
          "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
      }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 5
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        },
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 50000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  });

  console.log(response);
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 16000,
      Messages = [
          new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
      ],
      Tools = [
          new BetaWebSearchTool20250305 { MaxUses = 5 }
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearThinking20251015Edit
              {
                  Keep = new BetaThinkingTurns(2)
              },
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(50000),
                  Keep = new BetaToolUsesKeep(5)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 16000,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
  			MaxUses: anthropic.Int(5),
  		}},
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
  				Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
  					OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
  						Value: 2,
  					},
  				},
  			}},
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 50000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 5,
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaThinkingTurns;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(16000L)
          .addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
          .addTool(BetaWebSearchTool20250305.builder()
              .maxUses(5L)
              .build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearThinking20251015Edit.builder()
                  .keep(BetaThinkingTurns.builder()
                      .value(2L)
                      .build())
                  .build())
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(50000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(5L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 16000,
      messages: [
          [
              'role' => 'user',
              'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
          ]
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'web_search_20250305',
              'name' => 'web_search',
              'max_uses' => 5
          ]
      ],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_thinking_20251015',
                  'keep' => [
                      'type' => 'thinking_turns',
                      'value' => 2
                  ]
              ],
              [
                  'type' => 'clear_tool_uses_20250919',
                  'trigger' => [
                      'type' => 'input_tokens',
                      'value' => 50000
                  ],
                  'keep' => [
                      'type' => 'tool_uses',
                      'value' => 5
                  ]
              ]
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 16000,
    messages: [
      {
        role: "user",
        content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
      }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 5
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_thinking_20251015",
          keep: {
            type: "thinking_turns",
            value: 2
          }
        },
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 50000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

## Options de configuration pour l'effacement des résultats d'outils

| Option de configuration | Valeur par défaut       | Description                                                                                                                                                                                                                                                                                   |
| ----------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger`               | 100 000 tokens d'entrée | Définit le moment où la stratégie d'édition du contexte s'active. Une fois que le prompt dépasse ce seuil, l'effacement commence. Vous pouvez spécifier cette valeur en `input_tokens` ou en `tool_uses`.                                                                                     |
| `keep`                  | 3 utilisations d'outils | Définit le nombre de paires récentes utilisation d'outil/résultat à conserver après l'effacement. L'API supprime d'abord les interactions d'outils les plus anciennes, en préservant les plus récentes.                                                                                       |
| `clear_at_least`        | Aucune                  | Garantit qu'un nombre minimal de tokens est effacé chaque fois que la stratégie s'active. Si l'API ne peut pas effacer au moins la quantité spécifiée, la stratégie ne sera pas appliquée. Cela aide à déterminer si l'effacement du contexte vaut la peine de rompre votre cache de prompts. |
| `exclude_tools`         | Aucune                  | Liste des noms d'outils dont les utilisations et les résultats ne doivent jamais être effacés. Utile pour préserver un contexte important.                                                                                                                                                    |
| `clear_tool_inputs`     | `false`                 | Contrôle si les paramètres d'appel d'outil sont effacés en même temps que les résultats d'outils. Par défaut, seuls les résultats d'outils sont effacés, tandis que les appels d'outils originaux de Claude restent visibles.                                                                 |

## Réponse de l'édition du contexte

Vous pouvez voir quelles éditions de contexte ont été appliquées à votre requête à l'aide du champ de réponse `context_management`, ainsi que des statistiques utiles sur le contenu et les tokens d'entrée effacés.

```json Output
{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    // ...
  ],
  "usage": {
    // ...
  },
  "context_management": {
    "applied_edits": [
      // When using `clear_thinking_20251015`
      {
        "type": "clear_thinking_20251015",
        "cleared_thinking_turns": 3,
        "cleared_input_tokens": 15000
      },
      // When using `clear_tool_uses_20250919`
      {
        "type": "clear_tool_uses_20250919",
        "cleared_tool_uses": 8,
        "cleared_input_tokens": 50000
      }
    ]
  }
}
```

Pour les réponses en streaming, les éditions de contexte sont incluses dans l'événement final `message_delta` :

```json Streaming Response
{
  "type": "message_delta",
  "delta": {
    "stop_reason": "end_turn",
    "stop_sequence": null
  },
  "usage": {
    "output_tokens": 1024
  },
  "context_management": {
    "applied_edits": [
      // ...
    ]
  }
}
```

## Comptage des tokens

Le point de terminaison de [comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) prend en charge la gestion du contexte, ce qui vous permet de prévisualiser le nombre de tokens que votre prompt utilisera une fois l'édition du contexte appliquée.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages/count_tokens \
      --header "x-api-key: $ANTHROPIC_API_KEY" \
      --header "anthropic-version: 2023-06-01" \
      --header "content-type: application/json" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "messages": [
              {
                  "role": "user",
                  "content": "Continue our conversation..."
              }
          ],
          "context_management": {
              "edits": [
                  {
                      "type": "clear_tool_uses_20250919",
                      "trigger": {
                          "type": "input_tokens",
                          "value": 30000
                      },
                      "keep": {
                          "type": "tool_uses",
                          "value": 5
                      }
                  }
              ]
          }
      }'
  ```

  ```bash CLI
  ORIGINAL=$(ant beta:messages count-tokens \
    --beta context-management-2025-06-27 \
    --transform context_management.original_input_tokens \
    --raw-output <<'YAML'
  model: claude-opus-5-5
  messages:
    - role: user
      content: Continue our conversation...
  context_management:
    edits:
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 30000
        keep:
          type: tool_uses
          value: 5
  YAML
  )

  INPUT_TOKENS=$(ant beta:messages count-tokens \
    --beta context-management-2025-06-27 \
    --transform input_tokens --raw-output <<'YAML'
  model: claude-opus-5-5
  messages:
    - role: user
      content: Continue our conversation...
  context_management:
    edits:
      - type: clear_tool_uses_20250919
        trigger:
          type: input_tokens
          value: 30000
        keep:
          type: tool_uses
          value: 5
  YAML
  )

  printf 'Original tokens: %s\n' "$ORIGINAL"
  printf 'After clearing: %s\n' "$INPUT_TOKENS"
  printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))"
  ```

  ```python Python
  response = client.beta.messages.count_tokens(
      model="claude-opus-5-5",
      messages=[{"role": "user", "content": "Continue our conversation..."}],
      betas=["context-management-2025-06-27"],
      context_management={
          "edits": [
              {
                  "type": "clear_tool_uses_20250919",
                  "trigger": {"type": "input_tokens", "value": 30000},
                  "keep": {"type": "tool_uses", "value": 5},
              }
          ]
      },
  )

  print(f"Original tokens: {response.context_management.original_input_tokens}")
  print(f"After clearing: {response.input_tokens}")
  print(
      f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.countTokens({
    model: "claude-opus-5-5",
    messages: [
      {
        role: "user",
        content: "Continue our conversation..."
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  });

  console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
  console.log(`After clearing: ${response.input_tokens}`);
  console.log(
    `Savings: ${
      (response.context_management?.original_input_tokens || 0) - response.input_tokens
    } tokens`
  );
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCountTokensParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [
              new BetaClearToolUses20250919Edit
              {
                  Trigger = new BetaInputTokensTrigger(30000),
                  Keep = new BetaToolUsesKeep(5)
              }
          ]
      }
  };

  var response = await client.Beta.Messages.CountTokens(parameters);

  Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
  Console.WriteLine($"After clearing: {response.InputTokens}");
  Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens");
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
  	Model: anthropic.ModelClaudeOpus5_5,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Continue our conversation...")),
  	},
  	Betas: []anthropic.AnthropicBeta{
  		anthropic.AnthropicBetaContextManagement2025_06_27,
  	},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
  				Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
  					OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
  						Value: 30000,
  					},
  				},
  				Keep: anthropic.BetaToolUsesKeepParam{
  					Value: 5,
  				},
  			}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
  fmt.Printf("After clearing: %d\n", response.InputTokens)
  fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaMessageTokensCount;
  import com.anthropic.models.beta.messages.MessageCountTokensParams;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
  import com.anthropic.models.beta.messages.BetaToolUsesKeep;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCountTokensParams params = MessageCountTokensParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .addUserMessage("Continue our conversation...")
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder()
                  .trigger(BetaInputTokensTrigger.builder()
                      .value(30000L)
                      .build())
                  .keep(BetaToolUsesKeep.builder()
                      .value(5L)
                      .build())
                  .build())
              .build())
          .build();

      BetaMessageTokensCount response = client.beta().messages().countTokens(params);

      IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
      IO.println("After clearing: " + response.inputTokens());
      IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->countTokens(
      messages: [
          ['role' => 'user', 'content' => 'Continue our conversation...']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      contextManagement: [
          'edits' => [
              [
                  'type' => 'clear_tool_uses_20250919',
                  'trigger' => [
                      'type' => 'input_tokens',
                      'value' => 30000
                  ],
                  'keep' => [
                      'type' => 'tool_uses',
                      'value' => 5
                  ]
              ]
          ]
      ],
  );

  echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
  echo "After clearing: " . $response->inputTokens . "\n";
  echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.count_tokens(
    model: "claude-opus-5-5",
    messages: [
      { role: "user", content: "Continue our conversation..." }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        {
          type: "clear_tool_uses_20250919",
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          keep: {
            type: "tool_uses",
            value: 5
          }
        }
      ]
    }
  )

  puts "Original tokens: #{response.context_management.original_input_tokens}"
  puts "After clearing: #{response.input_tokens}"
  puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"
  ```
</CodeGroup>

```json Output
{
  "input_tokens": 25000,
  "context_management": {
    "original_input_tokens": 70000
  }
}
```

La réponse indique à la fois le nombre final de tokens après application de la gestion du contexte (`input_tokens`) et le nombre de tokens d'origine avant tout effacement (`original_input_tokens`).

## Utilisation avec l'outil de mémoire

L'édition du contexte peut être combinée avec l'[outil de mémoire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool). Lorsque le contexte de votre conversation approche du seuil d'effacement configuré, Claude reçoit un avertissement automatique l'invitant à préserver les informations importantes. Cela permet à Claude d'enregistrer les résultats d'outils ou le contexte dans ses fichiers de mémoire avant qu'ils ne soient effacés de l'historique de conversation.

Cette combinaison vous permet de :

* **Préserver le contexte important :** Claude peut écrire les informations essentielles issues des résultats d'outils dans des fichiers de mémoire avant que ces résultats ne soient effacés
* **Maintenir des flux de travail de longue durée :** permettre des flux de travail agentiques qui dépasseraient autrement les limites de contexte en déchargeant les informations vers un stockage persistant
* **Accéder aux informations à la demande :** Claude peut rechercher des informations précédemment effacées dans les fichiers de mémoire lorsque c'est nécessaire, plutôt que de tout conserver dans la fenêtre de contexte active

Par exemple, dans un flux de travail d'édition de fichiers où Claude effectue de nombreuses opérations, Claude peut résumer les modifications terminées dans des fichiers de mémoire à mesure que le contexte s'accroît. Lorsque les résultats d'outils sont effacés, Claude conserve l'accès à ces informations via son système de mémoire et peut continuer à travailler efficacement.

Pour utiliser les deux fonctionnalités ensemble, activez-les dans votre requête API :

<CodeGroup>
  ```bash cURL
  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" \
      --header "anthropic-beta: context-management-2025-06-27" \
      --data '{
          "model": "claude-opus-5-5",
          "max_tokens": 4096,
          "messages": [
              {
                  "role": "user",
                  "content": "Hello"
              }
          ],
          "tools": [
              {
                  "type": "memory_20250818",
                  "name": "memory"
              }
          ],
          "context_management": {
              "edits": [
                  {"type": "clear_tool_uses_20250919"}
              ]
          }
      }'
  ```

  ```bash CLI
  ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: Hello
  tools:
    - type: memory_20250818
      name: memory
  context_management:
    edits:
      - type: clear_tool_uses_20250919
  YAML
  ```

  ```python Python
  response = client.beta.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[{"role": "user", "content": "Hello"}],
      tools=[{"type": "memory_20250818", "name": "memory"}],
      betas=["context-management-2025-06-27"],
      context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
  )
  ```

  ```typescript TypeScript
  const anthropic = new Anthropic({
    apiKey: process.env.ANTHROPIC_API_KEY
  });

  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [{ role: "user", content: "Hello" }],
    tools: [
      {
        type: "memory_20250818",
        name: "memory"
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [{ type: "clear_tool_uses_20250919" }]
    }
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Messages = Anthropic.Models.Messages;

  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() { Role = Role.User, Content = "Hello" }
      ],
      Tools = [
          new BetaMemoryTool20250818()
      ],
      Betas = [AnthropicBeta.ContextManagement2025_06_27],
      ContextManagement = new BetaContextManagementConfig
      {
          Edits = [new BetaClearToolUses20250919Edit()]
      }
  };

  var response = await client.Beta.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
  	},
  	Tools: []anthropic.BetaToolUnionParam{
  		{OfMemoryTool20250818: &anthropic.BetaMemoryTool20250818Param{}},
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
  	ContextManagement: anthropic.BetaContextManagementConfigParam{
  		Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
  			{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
  import com.anthropic.models.beta.messages.BetaContextManagementConfig;
  import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
  import com.anthropic.models.beta.AnthropicBeta;
  // ...
  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Hello")
          .addTool(BetaMemoryTool20250818.builder().build())
          .addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
          .contextManagement(BetaContextManagementConfig.builder()
              .addEdit(BetaClearToolUses20250919Edit.builder().build())
              .build())
          .build();

      BetaMessage response = client.beta().messages().create(params);
      IO.println(response);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->beta->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Hello']
      ],
      model: 'claude-opus-5-5',
      betas: ['context-management-2025-06-27'],
      tools: [
          [
              'type' => 'memory_20250818',
              'name' => 'memory'
          ]
      ],
      contextManagement: [
          'edits' => [
              ['type' => 'clear_tool_uses_20250919']
          ]
      ],
  );

  echo $response;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.beta.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [{ role: "user", content: "Hello" }],
    tools: [
      {
        type: "memory_20250818",
        name: "memory"
      }
    ],
    betas: ["context-management-2025-06-27"],
    context_management: {
      edits: [
        { type: "clear_tool_uses_20250919" }
      ]
    }
  )
  puts response
  ```
</CodeGroup>

Pour la référence complète de l'outil de mémoire, y compris les commandes et les exemples, consultez [Outil de mémoire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool).

## Compaction côté client (SDK)

<Warning>
  **Anthropic recommande la compaction côté serveur plutôt que la compaction SDK.** La [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction) gère automatiquement le contexte avec une complexité d'intégration moindre, un meilleur calcul de l'utilisation des tokens et aucune limitation côté client. N'utilisez la compaction SDK que si vous avez spécifiquement besoin d'un contrôle côté client sur le processus de résumé.

  Le paramètre `compaction_control` est déprécié dans les SDK TypeScript et Ruby et sera supprimé dans une version future. Les SDK émettent un avertissement de dépréciation lorsqu'il est activé. Le SDK Python l'a supprimé dans la v1.0. Pour utiliser la compaction côté serveur avec un tool runner, passez l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
</Warning>

<Note>
  La compaction est disponible dans les [SDK TypeScript et Ruby](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) lors de l'utilisation de la [méthode `tool_runner`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-runner).
</Note>

La compaction est une fonctionnalité du SDK qui gère automatiquement le contexte de la conversation en générant des résumés lorsque l'utilisation des tokens devient trop importante. Contrairement aux stratégies d'édition du contexte côté serveur qui effacent du contenu, la compaction demande à Claude de résumer l'historique de la conversation, puis remplace l'historique complet par ce résumé. Cela permet à Claude de continuer à travailler sur des tâches de longue durée qui dépasseraient autrement la [fenêtre de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-windows) (« context window »).

### Fonctionnement de la compaction

Lorsque la compaction est activée, le SDK surveille l'utilisation des tokens après chaque réponse du modèle :

1. **Vérification du seuil :** le SDK calcule le total des tokens comme `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (voir [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) pour les champs de tokens de cache).
2. **Génération du résumé :** lorsque le seuil est dépassé, un prompt de résumé est injecté en tant que tour utilisateur, et Claude génère un résumé structuré encadré par des balises `<summary></summary>`.
3. **Remplacement du contexte :** le SDK extrait le résumé et remplace l'intégralité de l'historique des messages par celui-ci.
4. **Poursuite :** la conversation reprend à partir du résumé, Claude reprenant là où il s'était arrêté.

### Utilisation de la compaction

Ajoutez `compaction_control` à votre appel `tool_runner` pour activer le résumé automatique lorsque l'utilisation des tokens dépasse le seuil.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compaction s'exécute côté client dans les assistants `tool_runner` du SDK, elle n'a donc pas d'équivalent HTTP direct. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI n'inclut pas d'assistant `tool_runner`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic sans intégration côté SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      Dans la v1.0 et les versions ultérieures, le tool runner du SDK Python ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: { enabled: true, contextTokenThreshold: 100000 }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      Le SDK C# inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Le SDK Go inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Le SDK Java inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Le SDK PHP inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: { enabled: true, context_token_threshold: 100000 }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### Ce qui se passe pendant la compaction

À mesure que la conversation s'accroît, l'historique des messages s'accumule :

**Avant la compaction (approchant 100 000 tokens) :**

```json
[
  { "role": "user", "content": "Analyze all files and write a report..." },
  { "role": "assistant", "content": "I'll help. Let me start by reading..." },
  {
    "role": "user",
    "content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
  },
  { "role": "assistant", "content": "Based on file1.txt, I see..." },
  {
    "role": "user",
    "content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
  },
  { "role": "assistant", "content": "After analyzing file2.txt..." }
  // ... 50 more exchanges like this ...
]
```

Lorsque les tokens dépassent le seuil, le SDK injecte une demande de résumé et Claude génère un résumé. L'intégralité de l'historique est alors remplacée :

**Après la compaction (retour à environ 2 000 à 3 000 tokens) :**

```json
[
  {
    "role": "assistant",
    "content": "# Task Overview\nThe user requested analysis of directory files to produce a summary report...\n\n# Current State\nAnalyzed 52 files across 3 subdirectories. Key findings documented in report.md...\n\n# Important Discoveries\n- Configuration files use YAML format\n- Found 3 deprecated dependencies\n- Test coverage at 67%\n\n# Next Steps\n1. Analyze remaining files in /src/legacy\n2. Complete final report sections...\n\n# Context to Preserve\nUser prefers markdown format with executive summary first..."
  }
]
```

Claude continue à travailler à partir de ce résumé comme s'il s'agissait de l'historique de conversation d'origine.

### Options de configuration

| Paramètre                 | Type    | Obligatoire | Valeur par défaut                                                                                                                | Description                                                 |
| ------------------------- | ------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| `enabled`                 | boolean | Oui         | -                                                                                                                                | Indique s'il faut activer la compaction automatique         |
| `context_token_threshold` | number  | Non         | 100 000                                                                                                                          | Nombre de tokens à partir duquel la compaction se déclenche |
| `model`                   | string  | Non         | Identique au modèle principal                                                                                                    | Modèle à utiliser pour générer les résumés                  |
| `summary_prompt`          | string  | Non         | Voir [Prompt de résumé par défaut](https://platform.claude.com/docs/fr/build-with-claude/context-editing#default-summary-prompt) | Prompt personnalisé pour la génération du résumé            |

#### Choix d'un seuil de tokens

Le seuil détermine le moment où la compaction se produit. Un seuil plus bas signifie des compactions plus fréquentes avec des fenêtres de contexte plus petites. Un seuil plus élevé permet davantage de contexte mais risque d'atteindre les limites.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compaction s'exécute côté client dans les assistants `tool_runner` du SDK, elle n'a donc pas d'équivalent HTTP direct. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI n'inclut pas d'assistant `tool_runner`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic sans intégration côté SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      À partir de la version 1.0, le tool runner du SDK Python ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant l'édition `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      // Des valeurs plus basses compactent plus souvent ; passez à 150000 si la tâche requiert plus de contexte.
      compactionControl: { enabled: true, contextTokenThreshold: 50000 }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      Le SDK C# inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Le SDK Go inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Le SDK Java inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Le SDK PHP inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      # Des valeurs plus basses compactent plus souvent ; passez à 150000 si la tâche requiert plus de contexte.
      compaction_control: { enabled: true, context_token_threshold: 50000 }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### Utilisation d'un modèle différent pour les résumés

Vous pouvez utiliser un modèle plus rapide ou moins coûteux pour générer les résumés :

<Tabs>
  <Tab title="cURL">
    <Note>
      La compaction s'exécute côté client dans les assistants `tool_runner` du SDK, elle n'a donc pas d'équivalent HTTP direct. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI n'inclut pas d'assistant `tool_runner`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic sans intégration côté SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      À partir de la version 1.0, le tool runner du SDK Python ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: {
        enabled: true,
        contextTokenThreshold: 100000,
        model: "claude-haiku-4-5"
      }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      Le SDK C# inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Le SDK Go inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Le SDK Java inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Le SDK PHP inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        model: "claude-haiku-4-5"
      }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

#### Prompts de résumé personnalisés

Vous pouvez fournir un prompt personnalisé pour des besoins propres à un domaine. Votre prompt doit demander à Claude d'encadrer son résumé par des balises `<summary></summary>`.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compaction s'exécute côté client dans les assistants `tool_runner` du SDK, elle n'a donc pas d'équivalent HTTP direct. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI n'inclut pas d'assistant `tool_runner`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic sans intégration côté SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      À partir de la version 1.0, le tool runner du SDK Python ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="TypeScript">
    ```typescript TypeScript
    const client = new Anthropic();

    const runner = client.beta.messages.toolRunner({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [readFile],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compactionControl: {
        enabled: true,
        contextTokenThreshold: 100000,
        summaryPrompt: `Summarize the research conducted so far, including:
    - Sources consulted and key findings
    - Questions answered and remaining unknowns
    - Recommended next steps

    Wrap your summary in <summary></summary> tags.`
      }
    });

    for await (const message of runner) {
      console.log(`Tokens used: ${message.usage.input_tokens}`);
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      Le SDK C# inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Le SDK Go inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Le SDK Java inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Le SDK PHP inclut un tool runner, mais celui-ci ne prend pas en charge `compaction_control` côté client. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction-threshold) : elle fonctionne avec le tool runner en transmettant la modification `compact_20260112` dans le paramètre `context_management` de la requête.
    </Note>
  </Tab>

  <Tab title="Ruby">
    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        summary_prompt: <<~PROMPT
          Summarize the research conducted so far, including:
          - Sources consulted and key findings
          - Questions answered and remaining unknowns
          - Recommended next steps

          Wrap your summary in <summary></summary> tags.
        PROMPT
      }
    )

    runner.each_message do |message|
      puts "Tokens used: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

### Prompt de résumé par défaut

Le prompt de résumé intégré demande à Claude de créer un résumé de continuation structuré comprenant :

1. **Vue d'ensemble de la tâche :** la demande principale de l'utilisateur, les critères de réussite et les contraintes.
2. **État actuel :** ce qui a été accompli, les fichiers modifiés et les artefacts produits.
3. **Découvertes importantes :** les contraintes techniques, les décisions prises, les erreurs résolues et les approches ayant échoué.
4. **Prochaines étapes :** les actions spécifiques nécessaires, les points de blocage et l'ordre de priorité.
5. **Contexte à préserver :** les préférences de l'utilisateur, les détails propres au domaine et les engagements pris.

Cette structure permet à Claude de reprendre le travail efficacement sans perdre de contexte important ni répéter des erreurs.

<Accordion title="Voir le prompt par défaut complet">
  ```text wrap
  You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:

  1. Task Overview
  The user's core request and success criteria
  Any clarifications or constraints they specified

  2. Current State
  What has been completed so far
  Files created, modified, or analyzed (with paths if relevant)
  Key outputs or artifacts produced

  3. Important Discoveries
  Technical constraints or requirements uncovered
  Decisions made and their rationale
  Errors encountered and how they were resolved
  What approaches were tried that didn't work (and why)

  4. Next Steps
  Specific actions needed to complete the task
  Any blockers or open questions to resolve
  Priority order if multiple steps remain

  5. Context to Preserve
  User preferences or style requirements
  Domain-specific details that aren't obvious
  Any promises made to the user

  Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.

  Wrap your summary in <summary></summary> tags.
  ```
</Accordion>

### Limitations

#### Outils côté serveur

<Warning>
  La compaction nécessite une attention particulière lors de l'utilisation d'outils côté serveur tels que la [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) ou la [récupération web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool).
</Warning>

Lors de l'utilisation d'outils côté serveur, le SDK peut calculer incorrectement l'utilisation des tokens, ce qui déclenche la compaction au mauvais moment.

Par exemple, après une opération de recherche web, la réponse de l'API peut indiquer :

```json Output
{
  "usage": {
    "input_tokens": 63000,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 270000,
    "output_tokens": 1400
  }
}
```

Le SDK calcule l'utilisation totale comme 63 000 + 0 + 270 000 + 1 400 = 334 400 tokens. Cependant, la valeur `cache_read_input_tokens` inclut les lectures cumulées de plusieurs appels API internes effectués par l'outil côté serveur, et non le contexte réel de votre conversation. La longueur réelle de votre contexte peut n'être que les 63 000 `input_tokens`, mais le SDK voit 334 000 et déclenche la compaction prématurément.

**Solutions de contournement :**

* Utilisez le point de terminaison de [comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting) pour obtenir une longueur de contexte précise
* Évitez la compaction lorsque vous utilisez intensivement des outils côté serveur

#### Cas limites de l'utilisation d'outils

Lorsque le SDK déclenche la compaction alors qu'une réponse d'utilisation d'outil est en attente, il supprime le bloc d'utilisation d'outil de l'historique des messages avant de générer le résumé. Claude réémettra l'appel d'outil après la reprise à partir du résumé s'il est toujours nécessaire.

### Surveillance de la compaction

Comprendre quand la compaction se déclenche vous aide à ajuster les seuils et à vérifier le comportement attendu.

<Tabs>
  <Tab title="cURL">
    <Note>
      La compaction s'exécute côté client dans les assistants `tool_runner` du SDK, elle n'a donc pas d'équivalent HTTP direct. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI n'inclut pas d'assistant `tool_runner`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction), qui gère la compaction sur les serveurs d'Anthropic sans intégration côté SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      À partir de la v1.0, le tool runner du SDK Python ne prend pas en charge `compaction_control`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="TypeScript">
    Le `toolRunner` du SDK TypeScript prend en charge la compaction mais ne journalise pas les événements. Détectez la compaction en observant la diminution de `runner.params.messages.length` entre les tours :

    ```typescript TypeScript
    let prevMsgCount = 0;
    for await (const message of runner) {
      const currMsgCount = runner.params.messages.length;
      if (currMsgCount < prevMsgCount) {
        console.log(`Compaction occurred: ${prevMsgCount} -> ${currMsgCount} messages`);
        console.log(`Input tokens after compaction: ${message.usage.input_tokens}`);
      }
      prevMsgCount = currMsgCount;
    }
    ```
  </Tab>

  <Tab title="C#">
    <Note>
      Le tool runner du SDK C# ne prend pas en charge `compaction_control`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Le tool runner du SDK Go ne prend pas en charge `compaction_control`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Le tool runner du SDK Java ne prend pas en charge `compaction_control`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Le tool runner du SDK PHP ne prend pas en charge `compaction_control`. Utilisez plutôt la [compaction côté serveur](https://platform.claude.com/docs/fr/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Ruby">
    Le SDK Ruby prend en charge un callback `on_compact:` qui se déclenche lorsque la compaction se produit. Ajoutez-le à votre configuration `compaction_control` :

    ```ruby Ruby
    client = Anthropic::Client.new

    runner = client.beta.messages.tool_runner(
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: [ReadFile.new],
      messages: [{ role: "user", content: "What's in config.json?" }],
      compaction_control: {
        enabled: true,
        context_token_threshold: 100000,
        on_compact: ->(tokens_before, tokens_after) do
          puts "Compaction occurred: #{tokens_before} -> #{tokens_after} tokens"
        end
      }
    )

    runner.each_message do |message|
      puts "Tokens: #{message.usage.input_tokens}"
    end
    ```
  </Tab>
</Tabs>

### Quand utiliser la compaction

**Bons cas d'usage :**

* Tâches d'agent de longue durée qui traitent de nombreux fichiers ou sources de données
* Flux de travail de recherche qui accumulent de grandes quantités d'informations
* Tâches en plusieurs étapes avec une progression claire et mesurable
* Tâches qui produisent des artefacts (fichiers, rapports) qui persistent en dehors de la conversation

**Cas d'usage moins adaptés :**

* Tâches nécessitant un rappel précis des détails du début de la conversation
* Flux de travail utilisant intensivement des outils côté serveur
* Tâches qui doivent maintenir un état exact sur de nombreuses variables

## Prochaines étapes

<CardGroup cols={2}>
  <Card title="Compaction" icon="arrows-clockwise" href="https://platform.claude.com/docs/fr/build-with-claude/compaction">
    Gérez les longues conversations avec la compaction côté serveur, la stratégie recommandée pour la plupart des cas d'usage.
  </Card>

  <Card title="Mise en cache des prompts" icon="database" href="https://platform.claude.com/docs/fr/build-with-claude/prompt-caching">
    Réduisez les coûts et la latence en mettant en cache les préfixes de prompt, et découvrez comment l'édition du contexte interagit avec le cache.
  </Card>
</CardGroup>