---
title: Редактирование контекста
url: https://platform.claude.com/docs/ru/build-with-claude/context-editing
description: Автоматически управляйте контекстом разговора по мере его роста с помощью редактирования контекста.
featureMetadata:
  status: beta
  betaHeader: context-management-2025-06-27
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Правки контекста (очистка использования инструментов и очистка размышлений) применяются в реальном времени.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: beta
    Amazon Bedrock: beta
    Amazon Bedrock (bedrock-runtime): beta
    Claude Platform on AWS: beta
    Claude Models on Google Cloud (Anthropic managed): beta
    Claude Models on Google Cloud (Google managed): beta
    Microsoft Foundry: beta
---

## Обзор

<Note>
  Для большинства сценариев использования [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction) является основной стратегией управления контекстом в длительных разговорах. Стратегии, описанные на этой странице, полезны в конкретных сценариях, когда вам нужен более детальный контроль над тем, какое содержимое очищается.
</Note>

«Context editing» (редактирование контекста) позволяет выборочно очищать определённое содержимое из истории разговора по мере её роста. Помимо оптимизации затрат и соблюдения ограничений, речь идёт об активном отборе того, что получает Claude: контекст — это ограниченный ресурс с убывающей отдачей, а нерелевантное содержимое снижает сосредоточенность модели. Редактирование контекста даёт вам детальный контроль над этим отбором во время выполнения. Общие принципы управления контекстом описаны в статье [Эффективная инженерия контекста](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). На этой странице рассматриваются:

* **Очистка результатов инструментов:** лучше всего подходит для агентных рабочих процессов с интенсивным использованием инструментов, где старые результаты инструментов больше не нужны
* **Очистка блоков размышлений:** для управления блоками размышлений из предыдущих ходов с возможностью сохранить недавние размышления для непрерывности контекста
* **Клиентское сжатие в SDK:** альтернатива на основе SDK для управления контекстом с помощью резюме (обычно предпочтительнее серверное сжатие)

| Подход                 | Где выполняется | Стратегии                                                                                                                 | Как это работает                                                                                                                                                                                                                                                                                                                                                                                           |
| ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **На стороне сервера** | API             | Очистка результатов инструментов (`clear_tool_uses_20250919`)<br />Очистка блоков размышлений (`clear_thinking_20251015`) | Применяется до того, как подсказка достигнет Claude. Очищает определённое содержимое из истории разговора. Каждую стратегию можно настраивать независимо.                                                                                                                                                                                                                                                  |
| **На стороне клиента** | SDK             | Сжатие                                                                                                                    | Доступно в [SDK для TypeScript и Ruby](https://platform.claude.com/docs/ru/cli-sdks-libraries/overview) при использовании [`tool_runner`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-runner). Генерирует резюме и заменяет им полную историю разговора. См. [Клиентское сжатие](https://platform.claude.com/docs/ru/build-with-claude/context-editing#client-side-compaction-sdk). |

## Стратегии на стороне сервера

<Note>
  Редактирование контекста находится в бета-версии с поддержкой очистки результатов инструментов и очистки блоков размышлений. Чтобы включить его, используйте бета-заголовок `context-management-2025-06-27` в ваших запросах к API.

  Поделитесь отзывом об этой функции через [форму обратной связи](https://forms.gle/YXC2EKGMhjN1c4L88).
</Note>

### Очистка результатов инструментов

Стратегия `clear_tool_uses_20250919` очищает результаты инструментов, когда контекст разговора превышает настроенный вами порог. Это особенно полезно для агентных рабочих процессов с интенсивным использованием инструментов. Более старые результаты инструментов (например, содержимое файлов или результаты поиска) больше не нужны после того, как Claude их обработал.

При активации API автоматически очищает самые старые результаты инструментов в хронологическом порядке. API заменяет каждый очищенный результат текстом-заполнителем, указывающим Claude, что он был удалён. По умолчанию очищаются только результаты инструментов. При желании вы можете очищать как результаты инструментов, так и вызовы инструментов (параметры использования инструментов), установив для `clear_tool_inputs` значение `true`.

### Очистка блоков размышлений

Стратегия `clear_thinking_20251015` управляет блоками `thinking` из предыдущих ходов ассистента. Эта стратегия даёт вам контроль над сохранением размышлений: вы можете сохранять больше блоков размышлений для поддержания непрерывности рассуждений или очищать их более агрессивно, чтобы сэкономить место в контексте.

<Tip>
  **Поведение по умолчанию:** если запрос не включает стратегию `clear_thinking_20251015`, значение по умолчанию зависит от класса модели.

  | Класс модели   | Сохранять все предыдущие размышления | Сохранять размышления только для текущего хода |
  | -------------- | ------------------------------------ | ---------------------------------------------- |
  | Opus           | Claude Opus 4.5 и новее              | Claude Opus 4.1 и старше                       |
  | Sonnet         | Claude Sonnet 4.6 и новее            | Claude Sonnet 4.5 (устарела) и более ранние    |
  | Haiku          | Claude Haiku 5.5 и новее             | Claude Haiku 4.5 и более ранние                |
  | Fable и Mythos | Все модели                           | (нет)                                          |

  Используйте эту стратегию, чтобы переопределить значение по умолчанию. Если ваш код работает с несколькими классами моделей, включите эту стратегию и задайте `keep` явно, а не полагайтесь на значение по умолчанию для конкретной модели.
</Tip>

Ход ассистента в разговоре может включать несколько блоков содержимого (например, при использовании инструментов) и несколько блоков размышлений (например, при [чередующихся размышлениях](https://platform.claude.com/docs/ru/build-with-claude/thinking#interleaved-thinking)).

### Редактирование контекста выполняется на стороне сервера

Редактирование контекста применяется на стороне сервера до того, как подсказка достигнет Claude. Ваше клиентское приложение сохраняет полную, неизменённую историю разговора. Вам не нужно синхронизировать состояние клиента с отредактированной версией. Продолжайте управлять полной историей разговора локально, как обычно.

В [моделях с сохранёнными размышлениями](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking/prefix-checks#outcomes) управление контекстом на стороне сервера никогда не делает недействительными блоки размышлений. Изменения более ранних ходов на стороне клиента могут сделать недействительными блоки размышлений во всех последующих ходах ассистента. См. [Что должно оставаться неизменным и почему](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking/prefix-checks#prefix-check).

Модели с функцией «preserved thinking» (Сохранённые размышления) — это Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 и Claude Haiku 5.5.

### Редактирование контекста и кэширование подсказок

Взаимодействие редактирования контекста с [кэшированием подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching) («prompt caching») зависит от стратегии:

* **Очистка результатов инструментов:** делает недействительными кэшированные префиксы подсказок при очистке содержимого. Чтобы учесть это, очищайте достаточно токенов, чтобы инвалидация кэша была оправданной. Используйте параметр `clear_at_least`, чтобы гарантировать очистку минимального количества токенов каждый раз. Вы будете нести затраты на запись в кэш при каждой очистке содержимого, но последующие запросы смогут повторно использовать новый кэшированный префикс.

* **Очистка блоков размышлений:** когда блоки размышлений **сохраняются** в контексте (не очищаются), кэш подсказок сохраняется, что обеспечивает попадания в кэш и снижает затраты на входные токены. Когда блоки размышлений **очищаются**, кэш становится недействительным с той точки, где происходит очистка. Настройте параметр `keep` в зависимости от того, что для вас приоритетнее: производительность кэша или доступный объём «context window» (контекстного окна).

## Поддерживаемые модели

Редактирование контекста доступно во всех поддерживаемых моделях Claude.

## Использование очистки результатов инструментов

Один из способов включить очистку результатов инструментов — указать только тип стратегии. Все остальные [параметры конфигурации](https://platform.claude.com/docs/ru/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) используют значения по умолчанию:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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 BetaUserMessageParam { 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: 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: Anthropic::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>

### Расширенная конфигурация

Вы можете настроить поведение очистки результатов инструментов с помощью дополнительных параметров:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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",
                  # Запускать очистку при превышении порога
                  "trigger": {"type": "input_tokens", "value": 30000},
                  # Количество использований инструментов, сохраняемых после очистки
                  "keep": {"type": "tool_uses", "value": 3},
                  # Необязательно: очищать не менее указанного числа токенов
                  "clear_at_least": {"type": "input_tokens", "value": 5000},
                  # Исключить эти инструменты из очистки
                  "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",
          // Запускать очистку при превышении порога
          trigger: {
            type: "input_tokens",
            value: 30000
          },
          // Число использований инструментов, сохраняемых после очистки
          keep: {
            type: "tool_uses",
            value: 3
          },
          // Необязательно: очищать не менее указанного числа токенов
          clear_at_least: {
            type: "input_tokens",
            value: 5000
          },
          // Исключить эти инструменты из очистки
          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 BetaUserMessageParam { 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: 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: Anthropic::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>

## Использование очистки блоков размышлений

Используйте очистку блоков размышлений для управления контекстом и кэшированием подсказок в разговорах, которые содержат блоки размышлений из предыдущих ходов:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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 BetaUserMessageParam { 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: 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: Anthropic::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>

### Параметры конфигурации для очистки блоков размышлений

Стратегия `clear_thinking_20251015` поддерживает следующую конфигурацию:

| Параметр конфигурации | По умолчанию                         | Описание                                                                                                                                                                                                                                         |
| --------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `keep`                | `{type: "thinking_turns", value: 1}` | Определяет, сколько последних ходов ассистента сохраняют свои блоки размышлений. Используйте `{type: "thinking_turns", value: N}`, где N должно быть > 0, чтобы сохранить последние N ходов, или `"all"`, чтобы сохранить все блоки размышлений. |

Запрос, который включает эту стратегию без `keep`, получает `{type: "thinking_turns", value: 1}` на любой модели, включая модели, чьё [значение по умолчанию для конкретной модели](https://platform.claude.com/docs/ru/build-with-claude/context-editing#thinking-block-clearing) сохраняет все размышления. Запрос без этой стратегии получает значение по умолчанию для конкретной модели.

N учитывает текущий ход ассистента и ходы без блоков размышлений. Сообщение пользователя, содержащее только блоки `tool_result`, продолжает текущий ход. Любое другое сообщение пользователя начинает новый ход. Когда запрос заканчивается сообщением, начинающим новый ход, значение 1 очищает размышления из всех предыдущих ходов ассистента.

**Примеры конфигураций:**

Сохранять блоки размышлений из последних 3 ходов ассистента с учётом текущего хода:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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 BetaUserMessageParam { 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: 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: Anthropic::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>

Сохранять все блоки размышлений (максимизирует попадания в кэш):

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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 BetaUserMessageParam { 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: 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: Anthropic::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>

### Комбинирование стратегий

Вы можете использовать очистку блоков размышлений и очистку результатов инструментов вместе:

<Note>
  При использовании нескольких стратегий стратегия `clear_thinking_20251015` должна быть указана первой в массиве `edits`.
</Note>

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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
  client = anthropic.Anthropic()

  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 BetaUserMessageParam { 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: 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: Anthropic::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>

## Параметры конфигурации для очистки результатов инструментов

| Параметр конфигурации | По умолчанию                 | Описание                                                                                                                                                                                                                                                        |
| --------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger`             | 100 000 входных токенов      | Определяет, когда активируется стратегия редактирования контекста. Как только подсказка превышает этот порог, начинается очистка. Это значение можно указать в `input_tokens` или в `tool_uses`.                                                                |
| `keep`                | 3 использования инструментов | Определяет, сколько последних пар использование инструмента/результат сохранять после очистки. API сначала удаляет самые старые взаимодействия с инструментами, сохраняя самые последние.                                                                       |
| `clear_at_least`      | Нет                          | Гарантирует очистку минимального количества токенов при каждой активации стратегии. Если API не может очистить хотя бы указанное количество, стратегия не будет применена. Это помогает определить, стоит ли очистка контекста нарушения вашего кэша подсказок. |
| `exclude_tools`       | Нет                          | Список имён инструментов, чьи использования и результаты никогда не должны очищаться. Полезно для сохранения важного контекста.                                                                                                                                 |
| `clear_tool_inputs`   | `false`                      | Управляет тем, очищаются ли параметры вызова инструмента вместе с результатами инструмента. По умолчанию очищаются только результаты инструментов, а исходные вызовы инструментов Claude остаются видимыми.                                                     |

## Ответ редактирования контекста

Вы можете увидеть, какие правки контекста были применены к вашему запросу, с помощью поля ответа `context_management`, а также полезную статистику об очищенном содержимом и входных токенах.

```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
      }
    ]
  }
}
```

Для ответов с потоковой передачей правки контекста включаются в финальное событие `message_delta`:

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

## Подсчёт токенов

Конечная точка [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting) поддерживает управление контекстом, позволяя вам заранее увидеть, сколько токенов будет использовать ваша подсказка после применения редактирования контекста.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages/count_tokens \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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
  ant beta:messages count-tokens --beta context-management-2025-06-27 <<'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
  ```

  ```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 BetaUserMessageParam { 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: 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: Anthropic::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
  }
}
```

В ответе показано как итоговое количество токенов после применения управления контекстом (`input_tokens`), так и исходное количество токенов до какой-либо очистки (`original_input_tokens`).

## Использование с инструментом памяти

Редактирование контекста можно комбинировать с [инструментом памяти](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/memory-tool). Когда контекст разговора приближается к настроенному порогу очистки, Claude получает автоматическое предупреждение о необходимости сохранить важную информацию. Это позволяет Claude сохранить результаты инструментов или контекст в свои файлы памяти до того, как они будут очищены из истории разговора.

Эта комбинация позволяет вам:

* **Сохранять важный контекст:** Claude может записать существенную информацию из результатов инструментов в файлы памяти до того, как эти результаты будут очищены.
* **Поддерживать длительные рабочие процессы:** Claude может продолжать агентные рабочие процессы, которые иначе превысили бы ограничения контекста, выгружая информацию в постоянное хранилище.
* **Получать доступ к информации по требованию:** Claude может при необходимости найти ранее очищенную информацию в файлах памяти, вместо того чтобы держать всё в активном контекстном окне.

Например, в рабочем процессе редактирования файлов, где Claude выполняет множество операций, Claude может резюмировать выполненные изменения в файлы памяти по мере роста контекста. Когда результаты инструментов очищаются, Claude сохраняет доступ к этой информации через свою систему памяти и может продолжать эффективно работать.

Чтобы использовать обе функции вместе, включите их в вашем запросе к API:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -H "anthropic-beta: context-management-2025-06-27" \
    -d '{
      "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 BetaUserMessageParam { 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: 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: Anthropic::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>

Полный справочник по инструменту памяти, включая команды и примеры, см. в разделе [Инструмент памяти](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/memory-tool).

## Клиентское сжатие (SDK)

<Warning>
  **Anthropic рекомендует серверное сжатие вместо сжатия в SDK.** [Серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction) автоматически управляет контекстом с меньшей сложностью интеграции, более точным расчётом использования токенов и без ограничений на стороне клиента. Используйте сжатие в SDK только в том случае, если вам специально нужен контроль над процессом резюмирования на стороне клиента.

  Параметр `compaction_control` устарел в SDK для TypeScript и Ruby и будет удалён в будущей версии. SDK для TypeScript и Ruby выдают предупреждение об устаревании, когда он включён. В Python SDK он удалён в версии v1.0. Чтобы использовать серверное сжатие с исполнителем инструментов, передайте изменение `compact_20260112` в параметре запроса `context_management`.
</Warning>

<Note>
  Сжатие доступно в [SDK для TypeScript и Ruby](https://platform.claude.com/docs/ru/cli-sdks-libraries/overview) при использовании [метода `tool_runner`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-runner).
</Note>

«Compaction» (сжатие) — это функция SDK, которая автоматически управляет контекстом разговора, генерируя резюме, когда использование токенов становится слишком большим. В отличие от стратегий редактирования контекста на стороне сервера, которые очищают содержимое, сжатие поручает Claude резюмировать историю разговора, а затем заменяет полную историю этим резюме. Это позволяет Claude продолжать работу над длительными задачами, которые иначе превысили бы [контекстное окно](https://platform.claude.com/docs/ru/build-with-claude/context-windows).

### Как работает сжатие

Когда сжатие включено, SDK отслеживает использование токенов после каждого ответа модели:

1. **Проверка порога:** SDK вычисляет общее количество токенов как `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (поля токенов кэша см. в разделе [Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching)).
2. **Генерация резюме:** когда порог превышен, подсказка для резюме вставляется как ход пользователя, и Claude генерирует структурированное резюме, обёрнутое в теги `<summary></summary>`.
3. **Замена контекста:** SDK извлекает резюме и заменяет им всю историю сообщений.
4. **Продолжение:** разговор возобновляется с резюме, и Claude продолжает с того места, где остановился.

### Использование сжатия

Добавьте `compaction_control` в ваш вызов `tool_runner`, чтобы включить автоматическое резюмирование, когда использование токенов превышает порог.

<Tabs>
  <Tab title="cURL">
    <Note>
      Сжатие выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у него нет прямого HTTP-эквивалента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic без интеграции на стороне SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      В версии v1.0 и новее исполнитель инструментов в Python SDK не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>
      C# SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Go SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Java SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      PHP SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>

#### Что происходит во время сжатия

По мере роста разговора история сообщений накапливается:

**До сжатия (приближение к 100 тыс. токенов):**

```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 ...
]
```

Когда количество токенов превышает порог, SDK вставляет запрос на резюме, и Claude генерирует резюме. Затем вся история заменяется:

**После сжатия (снова \~2–3 тыс. токенов):**

```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 продолжает работу с этого резюме, как если бы это была исходная история разговора.

### Параметры конфигурации

| Параметр                  | Тип     | Обязательный | По умолчанию                                                                                                                          | Описание                                           |
| ------------------------- | ------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
| `enabled`                 | boolean | Да           | -                                                                                                                                     | Включать ли автоматическое сжатие                  |
| `context_token_threshold` | number  | Нет          | 100 000                                                                                                                               | Количество токенов, при котором срабатывает сжатие |
| `model`                   | string  | Нет          | Та же, что и основная модель                                                                                                          | Модель, используемая для генерации резюме          |
| `summary_prompt`          | string  | Нет          | См. [Подсказка для резюме по умолчанию](https://platform.claude.com/docs/ru/build-with-claude/context-editing#default-summary-prompt) | Пользовательская подсказка для генерации резюме    |

#### Выбор порога токенов

Порог определяет, когда происходит сжатие. Более низкий порог означает более частое сжатие с меньшими контекстными окнами. Более высокий порог допускает больше контекста, но создаёт риск достижения лимитов.

<Tabs>
  <Tab title="cURL">
    <Note>
      Сжатие выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у него нет прямого HTTP-эквивалента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic без интеграции на стороне SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      В версии v1.0 и новее исполнитель инструментов в Python SDK не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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?" }],
      // Меньшие значения — более частое сжатие; увеличьте до 150000, если задаче нужно больше контекста
      compactionControl: { enabled: true, contextTokenThreshold: 50000 }
    });

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

  <Tab title="C#">
    <Note>
      C# SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Go SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Java SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      PHP SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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?" }],
      # Меньшие значения чаще запускают сжатие; увеличьте до 150000, если задаче нужно больше контекста
      compaction_control: { enabled: true, context_token_threshold: 50000 }
    )

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

#### Использование другой модели для резюме

Вы можете использовать более быструю или дешёвую модель для генерации резюме:

<Tabs>
  <Tab title="cURL">
    <Note>
      Сжатие выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у него нет прямого HTTP-эквивалента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic без интеграции на стороне SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      В версии v1.0 и новее исполнитель инструментов в Python SDK не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>
      C# SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Go SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Java SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      PHP SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>

#### Пользовательские подсказки для резюме

Вы можете предоставить пользовательскую подсказку для предметно-ориентированных нужд. Ваша подсказка должна поручать Claude обернуть резюме в теги `<summary></summary>`.

<Tabs>
  <Tab title="cURL">
    <Note>
      Сжатие выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у него нет прямого HTTP-эквивалента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic без интеграции на стороне SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      В версии v1.0 и новее исполнитель инструментов в Python SDK не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>
      C# SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Go SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Java SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      PHP SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие по порогу токенов](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов при передаче изменения `compact_20260112` в параметре запроса `context_management`.
    </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>

### Подсказка для резюме по умолчанию

Встроенная подсказка для резюме поручает Claude создать структурированное резюме для продолжения, включающее:

1. **Обзор задачи:** основной запрос пользователя, критерии успеха и ограничения.
2. **Текущее состояние:** что выполнено, какие файлы изменены и какие артефакты созданы.
3. **Важные открытия:** технические ограничения, принятые решения, устранённые ошибки и неудачные подходы.
4. **Следующие шаги:** конкретные необходимые действия, блокирующие факторы и порядок приоритетов.
5. **Контекст для сохранения:** предпочтения пользователя, предметно-ориентированные детали и взятые обязательства.

Такая структура позволяет Claude эффективно возобновить работу, не теряя важного контекста и не повторяя ошибок.

<Accordion title="Посмотреть полную подсказку по умолчанию">
  ```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>

### Ограничения

#### Инструменты на стороне сервера

<Warning>
  Сжатие требует особого внимания при использовании инструментов на стороне сервера, таких как [веб-поиск](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-search-tool) или [веб-загрузка](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-fetch-tool).
</Warning>

При использовании инструментов на стороне сервера SDK может неправильно рассчитывать использование токенов, из-за чего сжатие запускается в неподходящий момент.

Например, после операции веб-поиска ответ API может показать:

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

SDK вычисляет общее использование как 63 000 + 0 + 270 000 + 1 400 = 334 400 токенов. Однако значение `cache_read_input_tokens` включает накопленные чтения из множества внутренних вызовов API, выполненных инструментом на стороне сервера, а не ваш фактический контекст разговора. Реальная длина вашего контекста может составлять всего 63 000 `input_tokens`, но SDK вычисляет 334 тыс. и преждевременно запускает сжатие.

**Обходные решения:**

* Используйте конечную точку [подсчёта токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting), чтобы получить точную длину контекста.
* Избегайте сжатия при интенсивном использовании инструментов на стороне сервера.

#### Пограничные случаи использования инструментов

Когда SDK запускает сжатие, пока ожидается ответ на использование инструмента, он удаляет блок использования инструмента из истории сообщений перед генерацией резюме. После возобновления с резюме Claude повторно выполняет вызов инструмента, если он всё ещё нужен.

### Мониторинг сжатия

Понимание того, когда срабатывает сжатие, помогает настраивать пороги и проверять ожидаемое поведение.

<Tabs>
  <Tab title="cURL">
    <Note>
      Сжатие выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у него нет прямого HTTP-эквивалента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic.
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction), которое выполняет сжатие на серверах Anthropic без интеграции на стороне SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    <Note>
      В версии v1.0 и новее исполнитель инструментов в Python SDK не поддерживает `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="TypeScript">
    `toolRunner` в TypeScript SDK поддерживает сжатие, но не журналирует события. Обнаруживайте сжатие, отслеживая уменьшение `runner.params.messages.length` между ходами:

    ```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>
      Исполнитель инструментов в C# SDK не поддерживает `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Go">
    <Note>
      Исполнитель инструментов в Go SDK не поддерживает `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Java">
    <Note>
      Исполнитель инструментов в Java SDK не поддерживает `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="PHP">
    <Note>
      Исполнитель инструментов в PHP SDK не поддерживает `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction).
    </Note>
  </Tab>

  <Tab title="Ruby">
    Ruby SDK поддерживает обратный вызов `on_compact:`, который срабатывает при сжатии. Добавьте его в вашу конфигурацию `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>

### Когда использовать сжатие

**Подходящие сценарии использования:**

* Длительные агентные задачи, обрабатывающие множество файлов или источников данных
* Исследовательские рабочие процессы, накапливающие большие объёмы информации
* Многошаговые задачи с чётким, измеримым прогрессом
* Задачи, создающие артефакты (файлы, отчёты), которые сохраняются вне разговора

**Менее подходящие сценарии использования:**

* Задачи, требующие точного воспроизведения деталей начала разговора
* Рабочие процессы, интенсивно использующие инструменты на стороне сервера
* Задачи, которым необходимо поддерживать точное состояние множества переменных

## Следующие шаги

<CardGroup cols={2}>
  <Card title="Сжатие" icon="arrows-clockwise" href="https://platform.claude.com/docs/ru/build-with-claude/compaction">
    Управляйте длинными разговорами с помощью серверного сжатия — рекомендуемой стратегии для большинства сценариев использования.
  </Card>

  <Card title="Кэширование подсказок" icon="database" href="https://platform.claude.com/docs/ru/build-with-claude/prompt-caching">
    Снижайте затраты и задержку за счёт кэширования префиксов подсказок и узнайте, как редактирование контекста взаимодействует с кэшем.
  </Card>
</CardGroup>

## Доступность

Редактирование контекста находится в бета-версии для всех моделей и подпадает под нулевое хранение данных.

### Поддержка API

#### [Messages API](https://platform.claude.com/docs/ru/build-with-claude/working-with-messages)

* Доступность: Доступно

| Статус | Облачные платформы           |
| ------ | ---------------------------- |
| Бета   | Все поддерживаемые платформы |

### Обязательные бета-заголовки

[Обзор бета-заголовков](https://platform.claude.com/docs/ru/api/beta-headers)

Бета-заголовки позволяют получить доступ к экспериментальным функциям и новым возможностям моделей до того, как они станут частью стандартного API.

* `context-management-2025-06-27`

### Обработка данных

[Обзор обработки данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#feature-eligibility)

| Элемент     | Нулевое хранение данных                                                                                                                                        | HIPAA          |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
| Статус      | Допускается (кроме [Охватываемые модели](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Не допускается |
| Подробности | Правки контекста (очистка использования инструментов и очистка размышлений) применяются в реальном времени.                                                    | —              |

Применимые конечные точки:

* `/v1/messages` с `context_management`
