---
title: Редактирование контекста
url: https://platform.claude.com/docs/ru/build-with-claude/context-editing
description: Автоматически управляйте контекстом разговора по мере его роста с помощью редактирования контекста.
---
Чтобы узнать, как «zero data retention» (нулевое хранение данных), или ZDR, применяется к этой функции, см. раздел [API и хранение данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention).
## Обзор
Для большинства сценариев использования [компактизация на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction) является основной стратегией управления контекстом в длительных разговорах. Стратегии, описанные на этой странице, полезны в конкретных сценариях, когда вам нужен более детальный контроль над тем, какое содержимое очищается.
«Context editing» (редактирование контекста) позволяет выборочно очищать определённое содержимое из истории разговора по мере её роста. Помимо оптимизации затрат и соблюдения лимитов, речь идёт об активном отборе того, что видит Claude: контекст — это конечный ресурс с убывающей отдачей, а нерелевантное содержимое снижает сосредоточенность модели. Редактирование контекста даёт вам детальный контроль над этим отбором во время выполнения. Более общие принципы управления контекстом см. в статье [Effective context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). На этой странице рассматриваются:
* **Очистка результатов инструментов** — лучше всего подходит для агентных рабочих процессов с интенсивным использованием инструментов, где старые результаты инструментов больше не нужны
* **Очистка блоков размышлений** — для управления блоками «thinking» (размышлений) из предыдущих ходов с возможностью сохранять недавние размышления для непрерывности контекста
* **Компактизация на стороне клиента в SDK** — основанная на SDK альтернатива для управления контекстом на основе резюме (компактизация на стороне сервера, как правило, предпочтительнее)
| Подход | Где выполняется | Стратегии | Как это работает |
| ---------------------- | --------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **На стороне сервера** | API | Очистка результатов инструментов (`clear_tool_uses_20250919`)
Очистка блоков размышлений (`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). |
## Стратегии на стороне сервера
Редактирование контекста находится в бета-версии с поддержкой очистки результатов инструментов и очистки блоков размышлений. Чтобы включить его, используйте бета-заголовок `context-management-2025-06-27` в ваших запросах к API.
Поделитесь отзывом об этой функции через [форму обратной связи](https://forms.gle/YXC2EKGMhjN1c4L88).
### Очистка результатов инструментов
Стратегия `clear_tool_uses_20250919` очищает результаты инструментов, когда контекст разговора превышает настроенный вами порог. Это особенно полезно для агентных рабочих процессов с интенсивным использованием инструментов. Старые результаты инструментов (например, содержимое файлов или результаты поиска) больше не нужны после того, как Claude их обработал.
При активации API автоматически очищает самые старые результаты инструментов в хронологическом порядке. API заменяет каждый очищенный результат текстом-заполнителем, указывающим Claude, что он был удалён. По умолчанию очищаются только результаты инструментов. При желании вы можете очищать как результаты инструментов, так и вызовы инструментов (параметры использования инструментов), установив для `clear_tool_inputs` значение true.
### Очистка блоков размышлений
Стратегия `clear_thinking_20251015` управляет блоками `thinking` из предыдущих ходов ассистента. Эта стратегия даёт вам контроль над сохранением размышлений: вы можете сохранять больше блоков размышлений для поддержания непрерывности рассуждений или очищать их более агрессивно, чтобы сэкономить место в контексте.
**Поведение по умолчанию:** значение по умолчанию зависит от класса модели.
| Класс модели | Сохранять все предыдущие размышления | Сохранять только размышления последнего хода |
| -------------- | ------------------------------------ | -------------------------------------------- |
| 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` явно, а не полагайтесь на значение по умолчанию для конкретной модели.
Ход ассистента в разговоре может включать несколько блоков содержимого (например, при использовании инструментов) и несколько блоков размышлений (например, при [чередующихся размышлениях](https://platform.claude.com/docs/ru/build-with-claude/thinking#interleaved-thinking)).
### Редактирование контекста происходит на стороне сервера
Редактирование контекста применяется на стороне сервера до того, как подсказка достигнет Claude. Ваше клиентское приложение сохраняет полную, неизменённую историю разговора. Вам не нужно синхронизировать состояние клиента с отредактированной версией. Продолжайте управлять полной историей разговора локально, как обычно.
В Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 и Claude Haiku 5.5 серверное управление контекстом никогда не делает блоки размышлений недействительными. Клиентские правки более ранних ходов могут сделать недействительными блоки размышлений во всех последующих ходах ассистента. Для новых аккаунтов, созданных 31 августа 2026 года или позже, запрос, повторно передающий недействительный блок, отклоняется, если вы не включили его отбрасывание. См. [Сохранение префикса неизменным](https://platform.claude.com/docs/ru/build-with-claude/preserved-thinking#prefix-check).
### Редактирование контекста и кэширование подсказок
Взаимодействие редактирования контекста с [кэшированием подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching) («prompt caching») зависит от стратегии:
* **Очистка результатов инструментов:** делает недействительными кэшированные префиксы подсказок при очистке содержимого. Чтобы учесть это, очищайте достаточно токенов, чтобы инвалидация кэша была оправданной. Используйте параметр `clear_at_least`, чтобы гарантировать очистку минимального количества токенов каждый раз. Вы будете нести затраты на запись в кэш при каждой очистке содержимого, но последующие запросы смогут повторно использовать новый кэшированный префикс.
* **Очистка блоков размышлений:** когда блоки размышлений **сохраняются** в контексте (не очищаются), кэш подсказок сохраняется, что обеспечивает попадания в кэш и снижает затраты на входные токены. Когда блоки размышлений **очищаются**, кэш становится недействительным в точке, где происходит очистка. Настраивайте параметр `keep` в зависимости от того, хотите ли вы отдать приоритет производительности кэша или доступности контекстного окна.
## Поддерживаемые модели
Редактирование контекста доступно во всех поддерживаемых моделях Claude.
## Использование очистки результатов инструментов
Самый простой способ включить очистку результатов инструментов — указать только тип стратегии. Все остальные [параметры конфигурации](https://platform.claude.com/docs/ru/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) используют значения по умолчанию:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Search for recent developments in AI"
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Search for recent developments in AI
tools:
- type: web_search_20250305
name: web_search
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Search for recent developments in AI"}],
tools=[{"type": "web_search_20250305", "name": "web_search"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Search for recent developments in AI"
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search"
}
],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
},
betas: ["context-management-2025-06-27"]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Search for recent developments in AI" }
],
Tools = [
new BetaWebSearchTool20250305()
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
},
Betas = [AnthropicBeta.ContextManagement2025_06_27]
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for recent developments in AI")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{}},
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Search for recent developments in AI")
.addTool(BetaWebSearchTool20250305.builder().build())
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Search for recent developments in AI']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
['type' => 'web_search_20250305', 'name' => 'web_search']
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{ role: "user", content: "Search for recent developments in AI" }
],
tools: [
{ type: "web_search_20250305", name: "web_search" }
],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
},
betas: ["context-management-2025-06-27"]
)
puts response
```
### Расширенная конфигурация
Вы можете настроить поведение очистки результатов инструментов с помощью дополнительных параметров:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
"tools": [
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 3
},
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
"exclude_tools": ["web_search"]
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Create a simple command line calculator app using Python
tools:
- type: text_editor_20250728
name: str_replace_based_edit_tool
max_characters: 10000
- type: web_search_20250305
name: web_search
max_uses: 3
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 3
clear_at_least:
type: input_tokens
value: 5000
exclude_tools:
- web_search
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python",
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000,
},
{"type": "web_search_20250305", "name": "web_search", "max_uses": 3},
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
# Запускать очистку при превышении порога
"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() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
],
Tools = [
new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
new BetaWebSearchTool20250305 { MaxUses = 3 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(3),
ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
ExcludeTools = ["web_search"]
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a simple command line calculator app using Python")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{
MaxCharacters: anthropic.Int(10000),
}},
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(3),
}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 3,
},
ClearAtLeast: anthropic.BetaInputTokensClearAtLeastParam{
Value: 5000,
},
ExcludeTools: []string{"web_search"},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaInputTokensClearAtLeast;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Create a simple command line calculator app using Python")
.addTool(BetaToolTextEditor20250728.builder()
.maxCharacters(10000L)
.build())
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(3L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(3L)
.build())
.clearAtLeast(BetaInputTokensClearAtLeast.builder()
.value(5000L)
.build())
.addExcludeTool("web_search")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
[
'role' => 'user',
'content' => 'Create a simple command line calculator app using Python'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'text_editor_20250728',
'name' => 'str_replace_based_edit_tool',
'max_characters' => 10000
],
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 3
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 3
],
'clear_at_least' => [
'type' => 'input_tokens',
'value' => 5000
],
'exclude_tools' => ['web_search']
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Create a simple command line calculator app using Python"
}
],
tools: [
{
type: "text_editor_20250728",
name: "str_replace_based_edit_tool",
max_characters: 10000
},
{
type: "web_search_20250305",
name: "web_search",
max_uses: 3
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 3
},
clear_at_least: {
type: "input_tokens",
value: 5000
},
exclude_tools: ["web_search"]
}
]
}
)
puts response
```
## Использование очистки блоков размышлений
Используйте очистку блоков размышлений для управления контекстом и кэшированием подсказок в разговорах, которые содержат блоки размышлений из предыдущих ходов:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
)
puts response
```
### Параметры конфигурации для очистки блоков размышлений
Стратегия `clear_thinking_20251015` поддерживает следующую конфигурацию:
| Параметр конфигурации | По умолчанию | Описание |
| --------------------- | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `keep` | Зависит от модели | Определяет, сколько последних ходов ассистента с блоками размышлений нужно сохранить. Используйте `{type: "thinking_turns", value: N}`, где N должно быть > 0, чтобы сохранить последние N ходов, или `"all"`, чтобы сохранить все блоки размышлений. Opus 4.5+, Sonnet 4.6+ и Haiku 5.5+: все ходы. Модели Fable и Mythos: все ходы. Более ранние Opus/Sonnet и Haiku до Claude Haiku 4.5 включительно: только последний ход. |
**Примеры конфигураций:**
Сохранять блоки размышлений из последних 3 ходов ассистента:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 3
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 3
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 3},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(3)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 3,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(3L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 3
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
)
puts response
```
Сохранять все блоки размышлений (максимизирует попадания в кэш):
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep: all
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all",
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new All()
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfAll: constant.ValueOf[constant.All](),
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keepAll()
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => 'all'
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
)
puts response
```
### Комбинирование стратегий
Вы можете использовать очистку блоков размышлений и очистку результатов инструментов вместе:
При использовании нескольких стратегий стратегия `clear_thinking_20251015` должна быть указана первой в массиве `edits`.
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
},
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 50000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
tools:
- type: web_search_20250305
name: web_search
max_uses: 5
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 50000
keep:
type: tool_uses
value: 5
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
}
],
tools=[
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5,
}
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
},
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 50000},
"keep": {"type": "tool_uses", "value": 5},
},
]
},
)
print(response)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content:
"Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(response);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
],
Tools = [
new BetaWebSearchTool20250305 { MaxUses = 5 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
},
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(50000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(5),
}},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 50000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(5L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(50000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 5
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
],
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 50000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts response
```
## Параметры конфигурации для очистки результатов инструментов
| Параметр конфигурации | По умолчанию | Описание |
| --------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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) поддерживает управление контекстом, позволяя вам заранее увидеть, сколько токенов будет использовать ваша подсказка после применения редактирования контекста.
```bash cURL
curl https://api.anthropic.com/v1/messages/count_tokens \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"messages": [
{
"role": "user",
"content": "Continue our conversation..."
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ORIGINAL=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform context_management.original_input_tokens \
--raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
INPUT_TOKENS=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform input_tokens --raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
printf 'Original tokens: %s\n' "$ORIGINAL"
printf 'After clearing: %s\n' "$INPUT_TOKENS"
printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))"
```
```python Python
response = client.beta.messages.count_tokens(
model="claude-opus-5-5",
messages=[{"role": "user", "content": "Continue our conversation..."}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 30000},
"keep": {"type": "tool_uses", "value": 5},
}
]
},
)
print(f"Original tokens: {response.context_management.original_input_tokens}")
print(f"After clearing: {response.input_tokens}")
print(
f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.countTokens({
model: "claude-opus-5-5",
messages: [
{
role: "user",
content: "Continue our conversation..."
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
console.log(`After clearing: ${response.input_tokens}`);
console.log(
`Savings: ${
(response.context_management?.original_input_tokens || 0) - response.input_tokens
} tokens`
);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCountTokensParams
{
Model = Messages::Model.ClaudeOpus5_5,
Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.CountTokens(parameters);
Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
Console.WriteLine($"After clearing: {response.InputTokens}");
Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens");
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
Model: anthropic.ModelClaudeOpus5_5,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Continue our conversation...")),
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
fmt.Printf("After clearing: %d\n", response.InputTokens)
fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens)
```
```java Java
import com.anthropic.models.beta.messages.BetaMessageTokensCount;
import com.anthropic.models.beta.messages.MessageCountTokensParams;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.addUserMessage("Continue our conversation...")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessageTokensCount response = client.beta().messages().countTokens(params);
IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
IO.println("After clearing: " + response.inputTokens());
IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->countTokens(
messages: [
['role' => 'user', 'content' => 'Continue our conversation...']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
echo "After clearing: " . $response->inputTokens . "\n";
echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n";
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.count_tokens(
model: "claude-opus-5-5",
messages: [
{ role: "user", content: "Continue our conversation..." }
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts "Original tokens: #{response.context_management.original_input_tokens}"
puts "After clearing: #{response.input_tokens}"
puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"
```
```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 сохраняет доступ к этой информации через свою систему памяти и может продолжать эффективно работать.
Чтобы использовать обе функции вместе, включите их в вашем запросе к API:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello"
}
],
"tools": [
{
"type": "memory_20250818",
"name": "memory"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello
tools:
- type: memory_20250818
name: memory
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Hello"}],
tools=[{"type": "memory_20250818", "name": "memory"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Tools = [
new BetaMemoryTool20250818()
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfMemoryTool20250818: &anthropic.BetaMemoryTool20250818Param{}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Hello")
.addTool(BetaMemoryTool20250818.builder().build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'memory_20250818',
'name' => 'memory'
]
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
}
)
puts response
```
Полный справочник по инструменту памяти, включая команды и примеры, см. в разделе [Инструмент памяти](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/memory-tool).
## Компактизация на стороне клиента (SDK)
**Anthropic рекомендует компактизацию на стороне сервера вместо компактизации в SDK.** [Компактизация на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction) автоматически управляет контекстом с меньшей сложностью интеграции, более точным расчётом использования токенов и без ограничений на стороне клиента. Используйте компактизацию в SDK только в том случае, если вам специально нужен контроль над процессом резюмирования на стороне клиента.
Параметр `compaction_control` объявлен устаревшим в SDK для TypeScript и Ruby и будет удалён в будущей версии. SDK выдают предупреждение об устаревании, когда он включён. В Python SDK он удалён в версии v1.0. Чтобы использовать компактизацию на стороне сервера с tool runner, передайте правку `compact_20260112` в параметре `context_management` запроса.
Компактизация доступна в [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).
«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 генерирует структурированное резюме, обёрнутое в теги ``.
3. **Замена контекста:** SDK извлекает резюме и заменяет им всю историю сообщений.
4. **Продолжение:** разговор возобновляется с резюме, и Claude продолжает с того места, где остановился.
### Использование компактизации
Добавьте `compaction_control` в ваш вызов `tool_runner`, чтобы включить автоматическое резюмирование, когда использование токенов превышает порог.
Компактизация выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у неё нет прямого HTTP-эквивалента. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic.
CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic без интеграции на стороне SDK.
В версии v1.0 и новее исполнитель инструментов Python SDK не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов, если передать правку `compact_20260112` в параметре запроса `context_management`.
```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}`);
}
```
C# SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов, если передать правку `compact_20260112` в параметре запроса `context_management`.
Go SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов, если передать правку `compact_20260112` в параметре запроса `context_management`.
Java SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов, если передать правку `compact_20260112` в параметре запроса `context_management`.
PHP SDK включает исполнитель инструментов, но он не поддерживает клиентский `compaction_control`. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает с исполнителем инструментов, если передать правку `compact_20260112` в параметре запроса `context_management`.
```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
```
#### Что происходит во время компактизации
По мере роста разговора история сообщений накапливается:
**До компактизации (приближение к 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) | Пользовательская подсказка для генерации резюме |
#### Выбор порога токенов
Порог определяет, когда происходит компактизация. Более низкий порог означает более частые компактизации с меньшими контекстными окнами. Более высокий порог допускает больше контекста, но создаёт риск достижения лимитов.
Компактизация выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у неё нет прямого HTTP-эквивалента. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic.
CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic без интеграции на стороне SDK.
В версии v1.0 и более поздних «tool runner» (средство запуска инструментов) в Python SDK не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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}`);
}
```
C# SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Go SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Java SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
PHP SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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
```
#### Использование другой модели для резюме
Вы можете использовать более быструю или дешёвую модель для генерации резюме:
Компактизация выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у неё нет прямого HTTP-эквивалента. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic.
CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic без интеграции на стороне SDK.
В версии v1.0 и более поздних средство запуска инструментов в Python SDK не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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}`);
}
```
C# SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Go SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Java SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
PHP SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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
```
#### Пользовательские подсказки для резюме
Вы можете предоставить пользовательскую подсказку для предметно-ориентированных нужд. Ваша подсказка должна поручать Claude обернуть резюме в теги ``.
Компактизация выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у неё нет прямого HTTP-эквивалента. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic.
CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic без интеграции на стороне SDK.
В версии v1.0 и более поздних средство запуска инструментов в Python SDK не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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 tags.`
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
C# SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Go SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
Java SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
PHP SDK включает средство запуска инструментов, но оно не поддерживает `compaction_control` на стороне клиента. Вместо этого используйте [серверное сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold): оно работает со средством запуска инструментов, если передать правку `compact_20260112` в параметре `context_management` запроса.
```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 tags.
PROMPT
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
### Подсказка для резюме по умолчанию
Встроенная подсказка для резюме поручает Claude создать структурированное резюме для продолжения, включающее:
1. **Обзор задачи:** основной запрос пользователя, критерии успеха и ограничения.
2. **Текущее состояние:** что выполнено, какие файлы изменены и какие артефакты созданы.
3. **Важные открытия:** технические ограничения, принятые решения, устранённые ошибки и неудачные подходы.
4. **Следующие шаги:** конкретные необходимые действия, блокирующие факторы и порядок приоритетов.
5. **Контекст для сохранения:** предпочтения пользователя, предметно-ориентированные детали и взятые обязательства.
Эта структура позволяет Claude эффективно возобновлять работу, не теряя важного контекста и не повторяя ошибок.
```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 tags.
```
### Ограничения
#### Инструменты на стороне сервера
Компактизация требует особого внимания при использовании инструментов на стороне сервера, таких как [веб-поиск](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).
При использовании инструментов на стороне сервера 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 повторно выполнит вызов инструмента после возобновления с резюме, если он всё ещё нужен.
### Мониторинг компактизации
Понимание того, когда срабатывает компактизация, помогает настраивать пороги и проверять ожидаемое поведение.
Компактизация выполняется на стороне клиента во вспомогательных функциях `tool_runner` SDK, поэтому у неё нет прямого HTTP-эквивалента. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic.
CLI не включает вспомогательную функцию `tool_runner`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction), которая выполняет компактизацию на серверах Anthropic без интеграции на стороне SDK.
В версии v1.0 и новее tool runner в Python SDK не поддерживает `compaction_control`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction).
`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;
}
```
Tool runner в C# SDK не поддерживает `compaction_control`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction).
Tool runner в Go SDK не поддерживает `compaction_control`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction).
Tool runner в Java SDK не поддерживает `compaction_control`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction).
Tool runner в PHP SDK не поддерживает `compaction_control`. Вместо этого используйте [компактизацию на стороне сервера](https://platform.claude.com/docs/ru/build-with-claude/compaction).
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
```
### Когда использовать компактизацию
**Подходящие сценарии использования:**
* Длительные агентные задачи, обрабатывающие множество файлов или источников данных
* Исследовательские рабочие процессы, накапливающие большие объёмы информации
* Многошаговые задачи с чётким, измеримым прогрессом
* Задачи, создающие артефакты (файлы, отчёты), которые сохраняются вне разговора
**Менее подходящие сценарии использования:**
* Задачи, требующие точного воспроизведения деталей начала разговора
* Рабочие процессы, интенсивно использующие инструменты на стороне сервера
* Задачи, которым необходимо поддерживать точное состояние множества переменных
## Следующие шаги
Управляйте длинными разговорами с помощью компактизации на стороне сервера — рекомендуемой стратегии для большинства сценариев использования.
Снижайте затраты и задержку за счёт кэширования префиксов подсказок и узнайте, как редактирование контекста взаимодействует с кэшем.