--- title: 토큰 임계값 기반 압축 url: https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold description: 대화가 설정한 토큰 임계값에 도달하면 일반 요청 안에서 API가 이전 컨텍스트를 자동으로 요약하도록 합니다. featureMetadata: status: beta betaHeader: compact-2026-01-12 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-1 - claude-mythos-5-1 - claude-fable-5 - claude-mythos-5 - claude-mythos-preview - claude-opus-5-5 - claude-opus-5 - claude-opus-4-8 - claude-opus-4-7 - claude-opus-4-6 - claude-sonnet-5-5 - claude-sonnet-5 - claude-sonnet-4-6 - claude-haiku-5-5 supportedPlatforms: Claude API: beta Claude Platform on AWS: beta Amazon Bedrock: beta Google Cloud: beta Microsoft Foundry: beta --- "Threshold compaction"(임계값 압축)은 자동 방식의 "compaction"(압축)입니다. 일반 요청에 토큰 임계값을 설정하면, 임계값에 도달했을 때 API가 요청 도중에 이전 컨텍스트를 요약합니다. 이 방식은 요약이 작성되는 시점을 직접 결정하는 온디맨드 압축과 함께 지원됩니다([온디맨드 압축](https://platform.claude.com/docs/ko/build-with-claude/compaction-on-demand) 참조). 둘 중 어떤 방식을 사용할지 선택하려면 [압축 방식 선택하기](https://platform.claude.com/docs/ko/build-with-claude/compaction#choose-how-to-compact)을 참조하세요. 압축은 "context window"(컨텍스트 윈도우) 한도에 가까워질 때 이전 컨텍스트를 자동으로 요약하여, 장기 실행 대화 및 작업의 유효 컨텍스트 길이를 확장합니다. 또한 활성 컨텍스트를 작게 유지합니다. 대화가 길어질수록 응답 품질이 저하되므로, 압축은 이전 콘텐츠를 간결한 요약으로 대체합니다. 긴 컨텍스트에서 품질이 저하되는 이유와 압축이 어떻게 도움이 되는지 자세히 알아보려면 [효과적인 컨텍스트 엔지니어링](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)을 참조하세요. 이 기능은 다음과 같은 경우에 이상적입니다: * 사용자가 하나의 채팅을 오랜 기간 사용하기를 원하는 채팅 기반 멀티턴 대화 * 컨텍스트 윈도우를 초과할 수 있는 많은 후속 작업(주로 "tool use"(도구 사용))이 필요한 작업 지향 프롬프트 ## 압축 작동 방식 압축이 활성화되면, Claude는 대화가 구성된 토큰 임계값에 도달할 때 자동으로 대화를 요약합니다. API는 다음을 수행합니다: 1. 입력 토큰이 지정한 트리거 임계값에 도달하는 시점을 감지합니다. 2. 현재 대화의 요약을 생성합니다. 3. 요약을 포함하는 `compaction` 블록을 생성합니다. 4. 압축된 컨텍스트로 응답을 계속합니다. 후속 요청에서는 응답을 메시지에 추가하세요. API는 `compaction` 블록 이전의 모든 콘텐츠 블록을 자동으로 삭제하고, 요약에서부터 대화를 이어갑니다. ![Compaction flow(압축 흐름): 입력 토큰이 trigger(트리거)에 도달하면 Claude가 compaction 블록에 요약을 작성하고 계속 진행합니다](https://platform.claude.com/docs/ko/images/compaction-flow.svg) ## 기본 사용법 Messages API 요청의 `context_management.edits`에 `compact_20260112` 전략을 추가하여 압축을 활성화하세요. ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a website" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a website context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Help me build a website"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) # 대화를 이어가려면 응답(compaction 블록 포함)을 추가하세요 messages.append({"role": "assistant", "content": response.content}) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Help me build a website" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112" } ] } }); // 대화를 이어가려면 응답(compaction 블록 포함)을 추가하세요 messages.push({ role: "assistant", content: response.content }); ``` ```csharp C# AnthropicClient client = new(); var messages = new List { new() { Role = Role.User, Content = "Help me build a website" } }; var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; var response = await client.Beta.Messages.Create(parameters); // 대화를 이어가려면 응답(compaction 블록 포함)을 추가하세요 messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a website")), } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } // 대화를 이어가려면 응답(compaction 블록 포함)을 추가하세요 messages = append(messages, response.ToParam()) fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a website") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // 대화를 이어가려면 응답(compaction 블록 포함)을 추가하세요 // 다음 요청의 messages에 포함하는 방식으로 추가합니다 System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [ ['role' => 'user', 'content' => 'Help me build a website'] ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); // 대화를 계속하려면 응답(compaction 블록 포함)을 추가하세요 $messages[] = ['role' => 'assistant', 'content' => $response->content]; echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new messages = [ { role: "user", content: "Help me build a website" } ] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) # 대화를 계속하려면 응답(compaction 블록 포함)을 추가하세요 messages << { role: "assistant", content: response.content } puts response ``` ## 매개변수 | 매개변수 | 타입 | 기본값 | 설명 | | ------------------------ | ------- | ------------------------------------------- | ---------------------------------------------------------------------------------- | | `type` | string | 필수 | `"compact_20260112"`이어야 합니다 | | `trigger` | object | `{"type": "input_tokens", "value": 150000}` | 압축을 트리거할 시점입니다. `input_tokens`가 유일하게 지원되는 트리거 타입입니다. `value`는 최소 50,000 토큰이어야 합니다. | | `pause_after_compaction` | boolean | `false` | 압축 요약을 생성한 후 일시 중지할지 여부 | | `instructions` | string | `null` | 사용자 지정 요약 프롬프트입니다. 제공되면 기본 프롬프트를 완전히 대체합니다. | ### 트리거 구성 `trigger` 매개변수를 사용하여 압축이 트리거되는 시점을 구성하세요: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 150000 } } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 150000 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 150000}, } ] }, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 150000 } } ] } }); ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(150000) }] } }; var message = await client.Beta.Messages.Create(parameters); Console.WriteLine(message); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 150000}, }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(150000L) .build()) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $message = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => [ 'type' => 'input_tokens', 'value' => 150000 ] ] ] ] ); echo $message; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 150000 } } ] } ) puts response ``` ### 사용자 지정 요약 지침 기본 요약 프롬프트는 모델에 따라 다릅니다. 각 기본 프롬프트는 향후 컨텍스트 윈도우에서 작업을 계속하는 데 필요한 정보를 담아 `

` 태그 안에 요약을 작성하도록 Claude에게 지시합니다. 예를 들어, 일부 모델은 다음 프롬프트를 사용합니다: ```text wrap You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a

block. ``` `instructions` 매개변수를 통해 사용자 지정 지침을 제공할 수 있습니다. 사용자 지정 지침은 기본 프롬프트를 보완하지 않습니다. 기본 프롬프트를 완전히 대체합니다: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "instructions": "Focus on preserving code snippets, variable names, and technical decisions." } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 instructions: >- Focus on preserving code snippets, variable names, and technical decisions. YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "instructions": "Focus on preserving code snippets, variable names, and technical decisions.", } ] }, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", instructions: "Focus on preserving code snippets, variable names, and technical decisions." } ] } }); ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = [ new BetaMessageParam { Role = Role.User, Content = "Help me build a Python web scraper" }, new BetaMessageParam { Role = Role.Assistant, Content = "I'll help you build a web scraper..." }, new BetaMessageParam { Role = Role.User, Content = "Add support for JavaScript-rendered pages" } ], ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Instructions = "Focus on preserving code snippets, variable names, and technical decisions." }] } }; var message = await client.Beta.Messages.Create(parameters); Console.WriteLine(message); ``` ```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("Help me build a Python web scraper")), {Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("I'll help you build a web scraper...")}}, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Add support for JavaScript-rendered pages")), }, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Instructions: anthropic.String("Focus on preserving code snippets, variable names, and technical decisions."), }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a Python web scraper") .addAssistantMessage("I'll help you build a web scraper...") .addUserMessage("Add support for JavaScript-rendered pages") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .instructions("Focus on preserving code snippets, variable names, and technical decisions.") .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $response = $client->beta->messages->create( maxTokens: 4096, messages: [ ['role' => 'user', 'content' => 'Help me build a Python web scraper'], ['role' => 'assistant', 'content' => "I'll help you build a web scraper..."], ['role' => 'user', 'content' => 'Add support for JavaScript-rendered pages'] ], model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'instructions' => 'Focus on preserving code snippets, variable names, and technical decisions.' ] ] ] ); echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: [ { role: "user", content: "Help me build a Python web scraper" }, { role: "assistant", content: "I'll help you build a web scraper..." }, { role: "user", content: "Add support for JavaScript-rendered pages" } ], context_management: { edits: [ { type: "compact_20260112", instructions: "Focus on preserving code snippets, variable names, and technical decisions." } ] } ) puts response ``` Claude 5.1 이상 모델에서는 사용자 지정 `instructions`가 포함된 요청이 보이는 대화만을 기반으로 요약합니다. 이전 thinking 블록은 요약기의 입력에 포함되지 않습니다. ### 압축 후 일시 중지 `pause_after_compaction`을 사용하면 압축 요약을 생성한 후 API를 일시 중지할 수 있습니다. 이를 통해 API가 응답을 계속하기 전에 추가 콘텐츠 블록(예: 최근 메시지 보존 또는 특정 지침 중심 메시지)을 추가할 수 있습니다. 이 옵션이 활성화되면, API는 compaction 블록을 생성한 후 `compaction` 중지 사유와 함께 메시지를 반환합니다: ```bash cURL # pause_after_compaction은 compaction(압축) 요약 직후에 응답을 중지하므로 # 계속하기 전에 메시지를 조정할 수 있습니다. 계속(continue) # 단계는 일회성 셸 명령으로 옮기기 어렵습니다. 전체 일시 중지 후 계속 흐름은 # SDK 탭을 참조하세요. 단일 일시 중지 요청: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "pause_after_compaction": true } ] } }' ``` ```bash CLI # pause_after_compaction은 compaction 요약 직후 응답을 중지하므로 # 계속하기 전에 메시지를 조정할 수 있습니다. 계속하기 단계는 # 일회성 CLI 명령으로 옮기기 어려우므로 SDK 탭에서 # 전체 일시 중지 및 계속 흐름을 참조하세요. 일시 중지된 단일 요청: ant beta:messages create --beta compact-2026-01-12 --format jsonl <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 pause_after_compaction: true YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [{"type": "compact_20260112", "pause_after_compaction": True}] }, ) # compaction(압축)으로 인해 일시 중지가 발생했는지 확인합니다 if response.stop_reason == "compaction": # 응답에 compaction 블록만 포함되어 있습니다 messages.append({"role": "assistant", "content": response.content}) # 요청을 계속 진행합니다 response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; let response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", pause_after_compaction: true } ] } }); // compaction(압축)으로 인해 일시 중지가 발생했는지 확인합니다 if (response.stop_reason === "compaction") { // 응답에 compaction 블록만 포함되어 있습니다 messages.push({ role: "assistant", content: response.content }); // 요청을 계속합니다 response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [{ type: "compact_20260112" }] } }); } ``` ```csharp C# var client = new AnthropicClient(); var messages = new List { new() { Role = Role.User, Content = "Hello, Claude" } }; var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { PauseAfterCompaction = true }] } }; var response = await client.Beta.Messages.Create(parameters); if (response.StopReason == BetaStopReason.Compaction) { messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); parameters = new() { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; response = await client.Beta.Messages.Create(parameters); } Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ PauseAfterCompaction: anthropic.Bool(true), }}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { messages = append(messages, response.ToParam()) response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaStopReason; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Help me build a website") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // compaction(압축)으로 인해 일시 중지되었는지 확인합니다 if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { // compaction 블록을 추가하고 요청을 계속합니다 // 이는 압축된 컨텍스트로 새 요청을 구성하는 방식으로 수행합니다 MessageCreateParams continueParams = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Help me build a website") .addMessage(response) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); response = client.beta().messages().create(continueParams); } System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $messages[] = [ 'role' => 'assistant', 'content' => $response->content ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); } echo $response; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", pause_after_compaction: true } ] } ) if response.stop_reason == :compaction messages << { role: "assistant", content: response.content } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) end puts response ``` #### 총 토큰 예산 적용 모델이 많은 도구 사용 반복을 포함하는 긴 작업을 수행할 때, 총 토큰 소비량이 크게 증가할 수 있습니다. `pause_after_compaction`을 압축 카운터와 결합하여 누적 사용량을 추정하고, 예산에 도달하면 작업을 원활하게 마무리할 수 있습니다. 이 예제는 SDK 언어로만 제공됩니다. 이 예제의 핵심은 요청을 둘러싼 예산 추적 로직에 있기 때문입니다. 원시 요청은 [트리거 구성](https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold#trigger-configuration)의 `trigger`와 [압축 후 일시 중지](https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold#pausing-after-compaction)의 `pause_after_compaction`을 결합합니다. ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] TRIGGER_THRESHOLD = 100_000 TOTAL_TOKEN_BUDGET = 3_000_000 n_compactions = 0 response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": TRIGGER_THRESHOLD}, "pause_after_compaction": True, } ] }, ) if response.stop_reason == "compaction": n_compactions += 1 messages.append({"role": "assistant", "content": response.content}) # 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리하도록 프롬프트합니다 if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET: messages.append( { "role": "user", "content": "Please wrap up your current work and summarize the final state.", } ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const TRIGGER_THRESHOLD = 100_000; const TOTAL_TOKEN_BUDGET = 3_000_000; let compactionCount = 0; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD }, pause_after_compaction: true } ] } }); if (response.stop_reason === "compaction") { compactionCount += 1; messages.push({ role: "assistant", content: response.content }); // 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리하도록 프롬프트합니다 if (compactionCount * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET) { messages.push({ role: "user", content: "Please wrap up your current work and summarize the final state." }); } } ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello, Claude" }]; const int TriggerThreshold = 100_000; const int TotalTokenBudget = 3_000_000; int compactionCount = 0; var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(TriggerThreshold), PauseAfterCompaction = true }] } }); if (response.StopReason == BetaStopReason.Compaction) { compactionCount += 1; messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(b => new BetaContentBlockParam(b.Json)).ToList() }); // 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리를 요청합니다 if (compactionCount * TriggerThreshold >= TotalTokenBudget) { messages.Add(new() { Role = Role.User, Content = "Please wrap up your current work and summarize the final state." }); } } Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} const triggerThreshold = 100_000 const totalTokenBudget = 3_000_000 compactionCount := 0 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: triggerThreshold}, PauseAfterCompaction: anthropic.Bool(true), }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { compactionCount++ messages = append(messages, response.ToParam()) // 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리하도록 프롬프트합니다 if compactionCount*triggerThreshold >= totalTokenBudget { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Please wrap up your current work and summarize the final state."))) } } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; import com.anthropic.models.beta.messages.BetaStopReason; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); long triggerThreshold = 100_000; long totalTokenBudget = 3_000_000; int compactionCount = 0; List messages = new ArrayList<>(); messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content("Hello, Claude") .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(triggerThreshold) .build()) .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { compactionCount += 1; messages.add(response.toParam()); // 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리하도록 프롬프트합니다 if (compactionCount * triggerThreshold >= totalTokenBudget) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content("Please wrap up your current work and summarize the final state.") .build()); } } System.out.println(response); ``` ```php PHP $client = new Client(); $triggerThreshold = 100_000; $totalTokenBudget = 3_000_000; $compactionCount = 0; $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => $triggerThreshold], 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $compactionCount += 1; $messages[] = ['role' => 'assistant', 'content' => $response->content]; // 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리를 요청합니다 if ($compactionCount * $triggerThreshold >= $totalTokenBudget) { $messages[] = [ 'role' => 'user', 'content' => 'Please wrap up your current work and summarize the final state.' ]; } } ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] TRIGGER_THRESHOLD = 100_000 TOTAL_TOKEN_BUDGET = 3_000_000 compaction_count = 0 response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD }, pause_after_compaction: true } ] } ) if response.stop_reason == :compaction compaction_count += 1 messages << { role: "assistant", content: response.content } # 소비된 총 토큰 수를 추정하고, 예산을 초과하면 마무리를 요청합니다 if compaction_count * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET messages << { role: "user", content: "Please wrap up your current work and summarize the final state." } end end ``` ## 압축 블록 다루기 압축이 트리거되면, API는 어시스턴트 응답의 시작 부분에 `compaction` 블록을 반환합니다. 장기 실행 대화에서는 여러 번의 압축이 발생할 수 있습니다. 마지막 compaction 블록은 프롬프트의 최종 상태를 반영하며, 그 이전의 콘텐츠를 생성된 요약으로 대체합니다. ```json Output { "content": [ { "type": "compaction", "content": "Summary of the conversation: The user requested help building a web scraper..." }, { "type": "text", "text": "Based on our conversation so far..." } ] } ``` ### 압축 블록 다시 전달하기 단축된 프롬프트로 대화를 계속하려면 후속 요청에서 `compaction` 블록을 API에 다시 전달해야 합니다. 가장 간단한 방법은 전체 응답 콘텐츠를 메시지에 추가하는 것입니다: ```bash cURL # "compaction"(압축) 블록을 포함한 응답 콘텐츠는 다음 요청의 # assistant 턴으로 API에 다시 전달되어야 합니다. 이 메시지 목록 관리는 # 일회성 셸 명령으로는 적합하지 않으므로, 전체 흐름은 CLI 및 SDK # 탭을 참조하세요. 첫 번째 요청: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create \ --beta compact-2026-01-12 \ --transform content \ --format jsonl <<'YAML' > content.json model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML # compaction 블록이 포함된 응답을 받은 후, 이를 assistant 턴으로 # 추가하고 대화를 계속합니다 ant beta:messages create --beta compact-2026-01-12 < { new() { Role = Role.User, Content = "Help me build a web scraper" } }; var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); messages.Add(new BetaMessageParam { Role = Role.User, Content = "Now add error handling" }); var nextResponse = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); Console.WriteLine(nextResponse); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a web scraper")), } compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = append(messages, response.ToParam()) messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add error handling"))) nextResponse, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(nextResponse) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // 첫 번째 요청 BetaMessage response = client.beta().messages().create( MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a web scraper") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build()); // compaction(압축) 블록이 포함된 응답을 받은 후에는 전체 // 콘텐츠(compaction 블록 포함)를 추가하고 대화를 계속합니다 BetaMessage nextResponse = client.beta().messages().create( MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a web scraper") .addMessage(response) .addUserMessage("Now add error handling") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build()); System.out.println(nextResponse); ``` ```php PHP $client = new Client(); $messages = [ ['role' => 'user', 'content' => 'Help me build a web scraper'] ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); $messages[] = ['role' => 'assistant', 'content' => $response->content]; $messages[] = ['role' => 'user', 'content' => 'Now add error handling']; $nextResponse = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); echo json_encode($nextResponse, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new messages = [ { role: "user", content: "Help me build a web scraper" } ] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) messages << { role: "assistant", content: response.content } messages << { role: "user", content: "Now add error handling" } next_response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) puts next_response.content ``` Python에서는 이 페이지의 샘플처럼 `client.beta.messages`를 사용하세요. `client.messages`를 호출하고 블록을 직접 직렬화하는 경우, 일반 `model_dump()`는 `compaction` 블록에 `text: null`과 `citations: null`을 추가합니다. 그러면 API는 400 오류(`Extra inputs are not permitted`)와 함께 요청을 거부합니다. 대신 `to_dict()` 또는 `model_dump(exclude_none=True)`를 사용하세요. [요약에서 이어서 진행하기](https://platform.claude.com/docs/ko/build-with-claude/compaction-on-demand#continue-from-the-summary)에서도 온디맨드 압축에 대해 동일한 조언을 제공합니다. API가 `compaction` 블록을 받으면, 그 이전의 모든 콘텐츠 블록은 무시됩니다. 다음 중 하나를 선택할 수 있습니다: * 원본 메시지를 목록에 유지하고 API가 압축된 콘텐츠 제거를 처리하도록 합니다 * 압축된 메시지를 수동으로 삭제하고 compaction 블록부터만 포함합니다 Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5에서는 `compaction` 블록 이전의 thinking 블록이 이어서 전달되지 않으므로, 요약이 모델이 가진 이전 작업의 전부입니다. 직접 `instructions`를 작성하는 경우 요약에 반드시 유지해야 할 내용을 모델에 알려 주세요. [압축 요약에서 보존할 내용을 모델에 알려 주기](https://platform.claude.com/docs/ko/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries)를 참조하세요. ### 스트리밍 compaction 블록은 텍스트 블록과 다르게 스트리밍됩니다. `content_block_start` 이벤트를 받은 다음, 전체 요약 콘텐츠가 담긴 단일 `content_block_delta`(중간 스트리밍 없음)를 받고, 이어서 `content_block_stop` 이벤트를 받습니다. ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "stream": true, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create \ --stream \ --beta compact-2026-01-12 \ --format jsonl <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] with client.beta.messages.stream( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) as stream: for event in stream: match event.type: case "content_block_start": block = event.content_block match block.type: case "compaction": print("Compaction started...") case "text": print("Text response started...") case "content_block_delta": delta = event.delta match delta.type: case "compaction_delta": print(f"Compaction complete: {len(delta.content or '')} chars") case "text_delta": print(delta.text, end="", flush=True) # 최종 누적된 메시지를 가져옵니다 message = stream.get_final_message() messages.append({"role": "assistant", "content": message.content}) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const stream = await client.beta.messages.stream({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [{ type: "compact_20260112" }] } }); for await (const event of stream) { switch (event.type) { case "content_block_start": switch (event.content_block.type) { case "compaction": console.log("Compaction started..."); break; case "text": console.log("Text response started..."); break; } break; case "content_block_delta": switch (event.delta.type) { case "compaction_delta": console.log(`Compaction complete: ${event.delta.content?.length ?? 0} chars`); break; case "text_delta": process.stdout.write(event.delta.text); break; } break; } } // 최종 누적된 메시지를 가져옵니다 const message = await stream.finalMessage(); messages.push({ role: "assistant", content: message.content }); ``` ```csharp C# var client = new AnthropicClient(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; await foreach (var streamEvent in client.Beta.Messages.CreateStreaming(parameters)) { if (streamEvent.TryPickContentBlockStart(out var startEvent)) { if (startEvent.ContentBlock.TryPickBetaCompaction(out _)) { Console.WriteLine("Compaction started..."); } else if (startEvent.ContentBlock.TryPickBetaText(out _)) { Console.WriteLine("Text response started..."); } } else if (streamEvent.TryPickContentBlockDelta(out var deltaEvent)) { if (deltaEvent.Delta.TryPickCompaction(out var compactionDelta)) { Console.WriteLine($"Compaction complete: {compactionDelta.Content?.Length ?? 0} chars"); } else if (deltaEvent.Delta.TryPickText(out var textDelta)) { Console.Write(textDelta.Text); } } } ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) for stream.Next() { event := stream.Current() switch eventVariant := event.AsAny().(type) { case anthropic.BetaRawContentBlockStartEvent: switch eventVariant.ContentBlock.AsAny().(type) { case anthropic.BetaCompactionBlock: fmt.Println("Compaction started...") case anthropic.BetaTextBlock: fmt.Println("Text response started...") } case anthropic.BetaRawContentBlockDeltaEvent: switch deltaVariant := eventVariant.Delta.AsAny().(type) { case anthropic.BetaCompactionContentBlockDelta: fmt.Printf("Compaction complete: %d chars\n", len(deltaVariant.Content)) case anthropic.BetaTextDelta: fmt.Print(deltaVariant.Text) } } } if err := stream.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); try (var streamResponse = client.beta().messages().createStreaming(params)) { streamResponse.stream().forEach(event -> { event.contentBlockStart().ifPresent(startEvent -> { startEvent.contentBlock().compaction().ifPresent(c -> System.out.println("Compaction started...") ); startEvent.contentBlock().text().ifPresent(t -> System.out.println("Text response started...") ); }); event.contentBlockDelta().ifPresent(deltaEvent -> { deltaEvent.delta().compaction().ifPresent(cd -> System.out.println("Compaction complete: " + cd.content().map(String::length).orElse(0) + " chars") ); deltaEvent.delta().text().ifPresent(td -> System.out.print(td.text()) ); }); }); } ``` ```php PHP use Anthropic\Beta\Messages\BetaCompactionBlock; use Anthropic\Beta\Messages\BetaCompactionContentBlockDelta; use Anthropic\Beta\Messages\BetaRawContentBlockDeltaEvent; use Anthropic\Beta\Messages\BetaRawContentBlockStartEvent; use Anthropic\Beta\Messages\BetaTextBlock; use Anthropic\Beta\Messages\BetaTextDelta; $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $stream = $client->beta->messages->createStream( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); foreach ($stream as $event) { switch (true) { case $event instanceof BetaRawContentBlockStartEvent: switch (true) { case $event->contentBlock instanceof BetaCompactionBlock: echo "Compaction started...\n"; break; case $event->contentBlock instanceof BetaTextBlock: echo "Text response started...\n"; break; } break; case $event instanceof BetaRawContentBlockDeltaEvent: switch (true) { case $event->delta instanceof BetaCompactionContentBlockDelta: echo "Compaction complete: " . strlen($event->delta->content ?? '') . " chars\n"; break; case $event->delta instanceof BetaTextDelta: echo $event->delta->text; break; } break; } } ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] stream = client.beta.messages.stream( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) stream.each do |event| case event when Anthropic::Models::BetaRawContentBlockStartEvent case event.content_block when Anthropic::Models::BetaCompactionBlock puts "Compaction started..." when Anthropic::Models::BetaTextBlock puts "Text response started..." end when Anthropic::Models::BetaRawContentBlockDeltaEvent delta = event.delta case delta when Anthropic::Models::BetaCompactionContentBlockDelta puts "Compaction complete: #{(delta.content || "").length} chars" when Anthropic::Models::BetaTextDelta print delta.text end end end ``` ### 프롬프트 캐싱 압축은 [프롬프트 캐싱](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching)과 함께 잘 작동합니다. compaction 블록에 `cache_control` 중단점을 추가하여 요약된 콘텐츠를 캐시할 수 있습니다. ```json { "role": "assistant", "content": [ { "type": "compaction", "content": "[summary text]", "cache_control": { "type": "ephemeral" } }, { "type": "text", "text": "Based on our conversation..." } ] } ``` #### 시스템 프롬프트로 캐시 적중 극대화하기 압축이 발생하면, 요약은 캐시에 기록되어야 하는 새로운 콘텐츠가 됩니다. 추가 캐시 중단점이 없으면, 이로 인해 캐시된 시스템 프롬프트도 무효화되어 압축 요약과 함께 다시 캐시해야 합니다. 캐시 적중률을 극대화하려면 시스템 프롬프트 끝에 `cache_control` 중단점을 추가하세요. 이렇게 하면 시스템 프롬프트가 대화와 별도로 캐시되므로, 압축이 발생할 때: * 시스템 프롬프트 캐시는 유효한 상태로 유지되며 캐시에서 읽힙니다 * 압축 요약만 새 캐시 항목으로 기록하면 됩니다 ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "system": [ { "type": "text", "text": "You are a helpful coding assistant...", "cache_control": { "type": "ephemeral" } } ], "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 system: - type: text text: You are a helpful coding assistant... cache_control: type: ephemeral messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, system=[ { "type": "text", "text": "You are a helpful coding assistant...", "cache_control": { "type": "ephemeral" }, # Cache the system prompt separately } ], messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, system: [ { type: "text", text: "You are a helpful coding assistant...", cache_control: { type: "ephemeral" } // Cache the system prompt separately } ], messages, context_management: { edits: [{ type: "compact_20260112" }] } }); ``` ```csharp C# var client = new AnthropicClient(); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, System = new List { new() { Text = "You are a helpful coding assistant...", CacheControl = new BetaCacheControlEphemeral() } }, Messages = [new() { Role = Role.User, Content = "Hello, Claude" }], ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; 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, System: []anthropic.BetaTextBlockParam{ { Text: "You are a helpful coding assistant...", CacheControl: anthropic.NewBetaCacheControlEphemeralParam(), }, }, Messages: []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaCacheControlEphemeral; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .systemOfBetaTextBlockParams(List.of( BetaTextBlockParam.builder() .text("You are a helpful coding assistant...") .cacheControl(BetaCacheControlEphemeral.builder().build()) .build() )) .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $response = $client->beta->messages->create( maxTokens: 4096, messages: [['role' => 'user', 'content' => 'Hello, Claude']], model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], system: [ [ 'type' => 'text', 'text' => 'You are a helpful coding assistant...', 'cache_control' => [ 'type' => 'ephemeral' ] ] ], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, system: [ { type: "text", text: "You are a helpful coding assistant...", cache_control: { type: "ephemeral" } } ], messages: [{ role: "user", content: "Hello, Claude" }], context_management: { edits: [{ type: "compact_20260112" }] } ) puts response ``` 이렇게 하면 대화 전반에 걸쳐 여러 번의 압축 이벤트가 발생해도 긴 시스템 프롬프트가 캐시된 상태로 유지됩니다. ## 사용량 이해하기 압축에는 추가 샘플링 단계가 필요하며, 이는 "rate limit"(속도 제한) 및 청구에 반영됩니다. API는 응답에서 자세한 사용량 정보를 반환합니다: ```json Output { "usage": { "input_tokens": 23000, "output_tokens": 1000, "iterations": [ { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 }, { "type": "message", "input_tokens": 23000, "output_tokens": 1000 } ] } } ``` `iterations` 배열은 각 샘플링 반복의 사용량을 보여줍니다. 압축이 발생하면 `compaction` 반복 다음에 주요 `message` 반복이 표시됩니다. 이 예제에서는 압축이 아닌 반복이 하나뿐이므로 최상위 `input_tokens`와 `output_tokens`가 `message` 반복과 정확히 일치합니다. 마지막 반복의 토큰 수는 압축 후의 유효 컨텍스트 크기를 반영합니다. 최상위 `input_tokens`와 `output_tokens`에는 압축 반복 사용량이 포함되지 않습니다. 이 값들은 압축이 아닌 모든 반복의 합계를 반영합니다. 요청에 대해 소비되고 청구된 총 토큰을 계산하려면 `usage.iterations` 배열의 모든 항목을 합산하세요. 이전에 비용 추적이나 감사를 위해 `usage.input_tokens`와 `usage.output_tokens`에 의존했다면, 압축이 활성화된 경우 `usage.iterations` 전체를 집계하도록 추적 로직을 업데이트해야 합니다. 압축 베타가 활성화되면 압축이 발생하지 않았더라도 모든 응답에 `usage.iterations`가 포함됩니다. `compaction` 항목은 요청 중에 새로운 압축이 트리거된 경우에만 나타납니다. 이전 `compaction` 블록을 다시 적용하는 데에는 추가 압축 비용이 발생하지 않으며, 이 경우 최상위 사용량 필드는 정확하게 유지됩니다. ## 다른 기능과 결합하기 ### 서버 도구 서버 도구(예: 웹 검색)를 사용할 때, 압축 트리거는 각 샘플링 반복의 시작 시점에 확인됩니다. 트리거 임계값과 생성된 출력량에 따라 단일 요청 내에서 압축이 여러 번 발생할 수 있습니다. ### 토큰 카운팅 토큰 카운팅 엔드포인트(`/v1/messages/count_tokens`)는 프롬프트에 있는 기존 `compaction` 블록을 적용하지만 새로운 압축을 트리거하지는 않습니다. 이전 압축 이후의 유효 토큰 수를 확인하는 데 사용하세요: ```bash cURL curl https://api.anthropic.com/v1/messages/count_tokens \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI CURRENT=$(ant beta:messages count-tokens \ --beta compact-2026-01-12 \ --transform input_tokens \ --raw-output <<'YAML' model: claude-opus-5-5 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ) ORIGINAL=$(ant beta:messages count-tokens \ --beta compact-2026-01-12 \ --transform context_management.original_input_tokens \ --raw-output <<'YAML' model: claude-opus-5-5 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ) printf 'Current tokens: %s\n' "$CURRENT" printf 'Original tokens: %s\n' "$ORIGINAL" ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] count_response = client.beta.messages.count_tokens( betas=["compact-2026-01-12"], model="claude-opus-5-5", messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) print(f"Current tokens: {count_response.input_tokens}") print(f"Original tokens: {count_response.context_management.original_input_tokens}") ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Summarize the key points of our conversation so far." } ]; const countResponse = await client.beta.messages.countTokens({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", messages, context_management: { edits: [{ type: "compact_20260112" }] } }); console.log(`Current tokens: ${countResponse.input_tokens}`); console.log(`Original tokens: ${countResponse.context_management!.original_input_tokens}`); ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var countParams = new MessageCountTokensParams { Model = Model.ClaudeOpus5_5, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] }, Betas = ["compact-2026-01-12"] }; var countResponse = await client.Beta.Messages.CountTokens(countParams); Console.WriteLine($"Current tokens: {countResponse.InputTokens}"); Console.WriteLine($"Original tokens: {countResponse.ContextManagement?.OriginalInputTokens}"); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} countResponse, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{ Model: anthropic.ModelClaudeOpus5_5, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Printf("Current tokens: %d\n", countResponse.InputTokens) fmt.Printf("Original tokens: %d\n", countResponse.ContextManagement.OriginalInputTokens) ``` ```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.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCountTokensParams params = MessageCountTokensParams.builder() .model(Model.CLAUDE_OPUS_5_5) .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .addBeta("compact-2026-01-12") .build(); BetaMessageTokensCount countResponse = client.beta().messages().countTokens(params); System.out.println("Current tokens: " + countResponse.inputTokens()); System.out.println("Original tokens: " + countResponse.contextManagement().get().originalInputTokens()); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $countResponse = $client->beta->messages->countTokens( messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); echo "Current tokens: " . $countResponse->inputTokens . "\n"; echo "Original tokens: " . $countResponse->contextManagement->originalInputTokens . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] count_response = client.beta.messages.count_tokens( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) puts "Current tokens: #{count_response.input_tokens}" puts "Original tokens: #{count_response.context_management.original_input_tokens}" ``` ## 예제 다음은 압축을 사용하는 장기 실행 대화의 전체 예제입니다: ```bash cURL # curl은 개별 요청을 보내므로 messages 배열은 # 호출하는 스크립트에서 관리하세요. 전체 chat() 루프는 SDK 탭을 참조하세요. 단일 턴 # 요청 형식: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a Python web scraper" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 100000 } } ] } }' ``` ```bash CLI # CLI는 개별 턴을 처리하므로 messages 배열은 # 호출하는 스크립트에서 관리하세요. 전체 chat() 루프는 SDK 탭을 참조하세요. 단일 턴 # 요청 형식: ant beta:messages create \ --beta compact-2026-01-12 \ --transform 'content.#(type=="text").text' \ --raw-output <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a Python web scraper context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 100000 YAML ``` ```python Python client = anthropic.Anthropic() messages: list[dict] = [] def chat(user_message: str) -> str: messages.append({"role": "user", "content": user_message}) response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 100000}, } ] }, ) # 응답을 추가합니다(compaction 블록은 자동으로 포함됩니다) messages.append({"role": "assistant", "content": response.content}) # 텍스트 콘텐츠를 반환합니다 return next(block.text for block in response.content if block.type == "text") # 긴 대화를 실행합니다 print(chat("Help me build a Python web scraper")) print(chat("Add support for JavaScript-rendered pages")) print(chat("Now add rate limiting and error handling")) # 대화에 필요한 만큼 chat()을 계속 호출합니다 ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = []; async function chat(userMessage: string): Promise { messages.push({ role: "user", content: userMessage }); const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 } } ] } }); // 응답을 추가합니다(compaction 블록은 자동으로 포함됩니다) messages.push({ role: "assistant", content: response.content }); // 텍스트 콘텐츠를 반환합니다 const textBlock = response.content.find((block) => block.type === "text"); return textBlock?.text ?? ""; } // 긴 대화를 실행합니다 console.log(await chat("Help me build a Python web scraper")); console.log(await chat("Add support for JavaScript-rendered pages")); console.log(await chat("Now add rate limiting and error handling")); // 대화에 필요한 만큼 chat()을 계속 호출합니다 ``` ```csharp C# AnthropicClient client = new(); List messages = new(); Console.WriteLine(await Chat(client, messages, "Help me build a Python web scraper")); Console.WriteLine(await Chat(client, messages, "Add support for JavaScript-rendered pages")); Console.WriteLine(await Chat(client, messages, "Now add rate limiting and error handling")); static async Task Chat(AnthropicClient client, List messages, string userMessage) { messages.Add(new() { Role = Role.User, Content = userMessage }); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(100000) }] } }; var response = await client.Beta.Messages.Create(parameters); messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); return response.Content .Select(block => block.Value) .OfType() .Select(tb => tb.Text) .FirstOrDefault() ?? ""; } ``` ```go Go package main import ( "context" "fmt" "log" "github.com/anthropics/anthropic-sdk-go" ) var ( client = anthropic.NewClient() messages []anthropic.BetaMessageParam ) func chat(userMessage string) string { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage))) response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000}, }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = append(messages, response.ToParam()) for _, block := range response.Content { if variant, ok := block.AsAny().(anthropic.BetaTextBlock); ok { return variant.Text } } return "" } func main() { fmt.Println(chat("Help me build a Python web scraper")) fmt.Println(chat("Add support for JavaScript-rendered pages")) fmt.Println(chat("Now add rate limiting and error handling")) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; // ... private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv(); private static final List messages = new ArrayList<>(); public static void main(String[] args) { System.out.println(chat("Help me build a Python web scraper")); System.out.println(chat("Add support for JavaScript-rendered pages")); System.out.println(chat("Now add rate limiting and error handling")); } private static String chat(String userMessage) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content(userMessage) .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(100000L) .build()) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // 응답을 추가합니다(compaction 블록은 자동으로 포함됩니다) messages.add(response.toParam()); return response.content().stream() .filter(block -> block.text().isPresent()) .map(block -> block.text().get().text()) .findFirst() .orElse(""); } ``` ```php PHP $client = new Client(); $messages = []; function chat($client, &$messages, $userMessage) { $messages[] = ['role' => 'user', 'content' => $userMessage]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => 100000] ] ] ] ); $messages[] = ['role' => 'assistant', 'content' => $response->content]; foreach ($response->content as $block) { if ($block->type === 'text') { return $block->text; } } return ''; } echo chat($client, $messages, "Help me build a Python web scraper") . "\n"; echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n"; echo chat($client, $messages, "Now add rate limiting and error handling") . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [] def chat(client, messages, user_message) messages << { role: "user", content: user_message } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 } } ] } ) messages << { role: "assistant", content: response.content } response.content.find { |block| block.type == :text }&.text || "" end puts chat(client, messages, "Help me build a Python web scraper") puts chat(client, messages, "Add support for JavaScript-rendered pages") puts chat(client, messages, "Now add rate limiting and error handling") ``` Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5에서는 압축 블록 뒤에 다시 삽입하는 모든 어시스턴트 턴에서 `thinking` 및 `redacted_thinking` 블록을 제거하거나, `thinking-binding-controls-2026-08-01` [베타 헤더](https://platform.claude.com/docs/ko/api/beta-headers)와 함께 `thinking.block_binding.prefix_mismatch_behavior: "drop_block"`을 전송하세요. 이러한 블록은 전체 기록이 존재할 때 생성되었으므로 더 이상 [대화 검사](https://platform.claude.com/docs/ko/build-with-claude/thinking#preserved-in-conversation)를 통과하지 못합니다. 검사가 적용되는 경우 후속 요청은 400 오류와 함께 거부됩니다. 보존된 텍스트 및 도구 블록은 그대로 두어도 됩니다. 이전 턴을 다시 삽입하지 않고 API가 모든 것을 요약하도록 하면 이 문제를 피할 수 있습니다. Claude Sonnet 5.5에서 `block_binding`은 `thinking: {"type": "adaptive"}`에서만 작동합니다. `between_tools`를 사용하는 경우에는 대신 블록을 제거하세요. Claude Haiku 5.5에서 `block_binding`은 `thinking: {"type": "adaptive"}`에서만 작동하므로, `thinking: {"type": "disabled"}`를 사용하는 경우에는 대신 블록을 제거하세요. 다음은 `pause_after_compaction`을 사용하여 이전 교환과 현재 사용자 메시지(총 세 개의 메시지)를 요약하는 대신 보존하는 예제입니다. 이 예제는 해당 메시지의 텍스트 및 도구 블록을 변경하지 않고 유지하며, 보존된 어시스턴트 턴에서 `thinking` 및 `redacted_thinking` 블록을 제거하고, 남은 것이 없으면 해당 턴을 제거합니다: ```bash cURL # curl은 개별 요청을 보내므로 messages 배열은 호출하는 # 스크립트에서 관리하세요. 일시 중지 및 보존 처리를 포함한 전체 chat() 루프는 # SDK 탭을 참조하세요. 단일 턴 요청 형태: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a Python web scraper" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 100000 }, "pause_after_compaction": true } ] } }' ``` ```bash CLI # CLI는 개별 턴을 처리하므로 messages 배열은 # 호출하는 스크립트에서 유지하세요. 일시 중지 및 보존 처리를 포함한 전체 chat() 루프는 SDK 탭을 참조하세요. # 단일 턴 요청 형식: ant beta:messages create \ --beta compact-2026-01-12 \ --transform 'content.#(type=="text").text' \ --raw-output <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a Python web scraper context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 100000 pause_after_compaction: true YAML ``` ```python Python from typing import Any client = anthropic.Anthropic() messages: list[dict[str, Any]] = [] def chat(user_message: str) -> str: messages.append({"role": "user", "content": user_message}) response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 100000}, "pause_after_compaction": True, } ] }, ) # compaction이 발생하여 일시 중지되었는지 확인합니다 if response.stop_reason == "compaction": # 응답에서 compaction 블록을 가져옵니다 compaction_block = response.content[0] # 이전 교환 + 현재 사용자 메시지(메시지 3개)를 보존합니다 # compaction 블록 뒤에 포함하되, thinking 블록은 제외합니다. # 콘텐츠가 남지 않은 assistant 턴은 삭제됩니다 preserved_messages = [ { **message, "content": [ block for block in message["content"] if block.type not in ("thinking", "redacted_thinking") ], } if message["role"] == "assistant" else message for message in messages[-3:] ] preserved_messages = [m for m in preserved_messages if m["content"]] # 새 메시지 목록 구성: compaction + 보존된 메시지 new_assistant_content = [compaction_block] messages_after_compaction = [ {"role": "assistant", "content": new_assistant_content} ] + preserved_messages # 압축된 컨텍스트 + 보존된 메시지로 요청을 계속합니다 response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages_after_compaction, context_management={"edits": [{"type": "compact_20260112"}]}, ) # compaction을 반영하도록 메시지 목록을 업데이트합니다 messages.clear() messages.extend(messages_after_compaction) # 최종 응답을 추가합니다 messages.append({"role": "assistant", "content": response.content}) # 텍스트 콘텐츠를 반환합니다 return next(block.text for block in response.content if block.type == "text") # 긴 대화를 실행합니다 print(chat("Help me build a Python web scraper")) print(chat("Add support for JavaScript-rendered pages")) print(chat("Now add rate limiting and error handling")) # 대화에 필요한 만큼 chat()을 계속 호출합니다 ``` ```typescript TypeScript const client = new Anthropic(); let messages: Anthropic.Beta.Messages.BetaMessageParam[] = []; async function chat(userMessage: string): Promise { messages.push({ role: "user", content: userMessage }); let response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 }, pause_after_compaction: true } ] } }); // compaction이 발생하여 일시 중지되었는지 확인합니다 if (response.stop_reason === "compaction") { // 응답에서 compaction 블록을 가져옵니다 const compactionBlock = response.content[0]; // 이전 교환과 현재 사용자 메시지(3개 메시지)를 보존합니다 // compaction 블록 뒤에 포함하되, thinking 블록은 제외합니다. // 콘텐츠가 남지 않은 assistant 턴은 삭제됩니다 const preservedMessages = messages .slice(-3) .map((message) => message.role === "assistant" && Array.isArray(message.content) ? { ...message, content: message.content.filter( (block) => block.type !== "thinking" && block.type !== "redacted_thinking" ) } : message ) .filter((message) => message.content.length > 0); // 새 메시지 목록 구성: compaction + 보존된 메시지 const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "assistant", content: [compactionBlock] }, ...preservedMessages ]; // 압축된 컨텍스트와 보존된 메시지로 요청을 계속합니다 response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messagesAfterCompaction, context_management: { edits: [{ type: "compact_20260112" }] } }); // compaction을 반영하도록 메시지 목록을 업데이트합니다 messages = messagesAfterCompaction; } // 최종 응답을 추가합니다 messages.push({ role: "assistant", content: response.content }); // 텍스트 콘텐츠를 반환합니다 const textBlock = response.content.find((block) => block.type === "text"); return textBlock?.text ?? ""; } // 긴 대화를 실행합니다 console.log(await chat("Help me build a Python web scraper")); console.log(await chat("Add support for JavaScript-rendered pages")); console.log(await chat("Now add rate limiting and error handling")); // 대화에 필요한 만큼 chat()을 계속 호출합니다 ``` ```csharp C# AnthropicClient client = new(); List messages = new(); Console.WriteLine(await Chat("Help me build a Python web scraper")); Console.WriteLine(await Chat("Add support for JavaScript-rendered pages")); Console.WriteLine(await Chat("Now add rate limiting and error handling")); async Task Chat(string userMessage) { messages.Add(new() { Role = Role.User, Content = userMessage }); var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(100000), PauseAfterCompaction = true }] } }); if (response.StopReason == BetaStopReason.Compaction) { if (!response.Content[0].TryPickCompaction(out _)) throw new InvalidOperationException("Expected compaction block"); // 이전 대화 교환과 현재 사용자 메시지(메시지 3개)를 보존하되, // thinking 블록은 제외합니다. 비어 있게 된 assistant 턴은 삭제됩니다 var preserved = messages .Skip(Math.Max(0, messages.Count - 3)) .Select(message => message.Content.TryPickBetaContentBlockParams(out var blocks) ? new BetaMessageParam { Role = message.Role, Content = blocks .Where(block => block.Type.GetString() is not ("thinking" or "redacted_thinking")) .ToList() } : message) .Where(message => !message.Content.TryPickBetaContentBlockParams(out var blocks) || blocks.Count > 0) .ToList(); var messagesAfterCompaction = new List { new() { Role = Role.Assistant, Content = new List { new BetaContentBlockParam(response.Content[0].Json) } } }; messagesAfterCompaction.AddRange(preserved); response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messagesAfterCompaction, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); messages = messagesAfterCompaction; } messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); return response.Content .Select(block => block.Value) .OfType() .Select(tb => tb.Text) .FirstOrDefault() ?? ""; } ``` ```go Go package main import ( "context" "fmt" "log" "github.com/anthropics/anthropic-sdk-go" ) var ( client = anthropic.NewClient() messages []anthropic.BetaMessageParam ) func chat(userMessage string) string { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage))) compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000}, PauseAfterCompaction: anthropic.Bool(true), }}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { compactionParam := response.Content[0].ToParam() // 이전 대화 교환과 현재 사용자 메시지(메시지 3개)를 보존하되, // thinking 블록은 제외합니다. 비어 있게 된 assistant 턴은 삭제됩니다 var preserved []anthropic.BetaMessageParam for _, message := range messages[max(0, len(messages)-3):] { var content []anthropic.BetaContentBlockParamUnion for _, block := range message.Content { if block.OfThinking == nil && block.OfRedactedThinking == nil { content = append(content, block) } } if len(content) == 0 { continue } message.Content = content preserved = append(preserved, message) } messagesAfterCompaction := []anthropic.BetaMessageParam{ {Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{compactionParam}}, } messagesAfterCompaction = append(messagesAfterCompaction, preserved...) response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messagesAfterCompaction, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = messagesAfterCompaction } messages = append(messages, response.ToParam()) for _, block := range response.Content { if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok { return textBlock.Text } } return "" } func main() { fmt.Println(chat("Help me build a Python web scraper")) fmt.Println(chat("Add support for JavaScript-rendered pages")) fmt.Println(chat("Now add rate limiting and error handling")) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; import com.anthropic.models.beta.messages.BetaStopReason; // ... private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv(); private static final List messages = new ArrayList<>(); public static String chat(String userMessage) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content(userMessage) .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(100000L) .build()) .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // compaction이 발생하여 일시 중지되었는지 확인합니다 if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { // 이전 교환과 현재 사용자 메시지(메시지 3개)를 보존하되, // thinking 블록은 제외합니다. 비어 있게 된 assistant 턴은 삭제됩니다 List preservedMessages = new ArrayList<>(); for (BetaMessageParam message : messages.subList(Math.max(0, messages.size() - 3), messages.size())) { if (message.content().isBetaContentBlockParams()) { message = message.toBuilder() .contentOfBetaContentBlockParams(message.content().asBetaContentBlockParams().stream() .filter(block -> !block.isThinking() && !block.isRedactedThinking()) .toList()) .build(); if (message.content().asBetaContentBlockParams().isEmpty()) { continue; } } preservedMessages.add(message); } // 새 메시지 목록 구성: compaction + 보존된 메시지 List messagesAfterCompaction = new ArrayList<>(); messagesAfterCompaction.add(response.toParam()); messagesAfterCompaction.addAll(preservedMessages); // 압축된 컨텍스트와 보존된 메시지로 요청을 계속합니다 MessageCreateParams continueParams = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messagesAfterCompaction) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); response = client.beta().messages().create(continueParams); // compaction을 반영하도록 메시지 목록을 업데이트합니다 messages.clear(); messages.addAll(messagesAfterCompaction); } // 최종 응답을 추가합니다 messages.add(response.toParam()); return response.content().stream() .filter(block -> block.text().isPresent()) .map(block -> block.text().get().text()) .findFirst() .orElse(""); } public static void main(String[] args) { System.out.println(chat("Help me build a Python web scraper")); System.out.println(chat("Add support for JavaScript-rendered pages")); System.out.println(chat("Now add rate limiting and error handling")); } ``` ```php PHP $client = new Client(); $messages = []; function chat($client, &$messages, $userMessage) { $messages[] = ['role' => 'user', 'content' => $userMessage]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => 100000], 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $compactionBlock = $response->content[0]; // 이전 교환과 현재 사용자 메시지(메시지 3개)를 유지하되, // thinking 블록은 제외합니다. 비어 있게 된 assistant 턴은 삭제됩니다 $preserved = array_values(array_filter(array_map( fn($message) => $message['role'] === 'assistant' ? array_merge($message, ['content' => array_values(array_filter( $message['content'], fn($block) => !in_array($block->type, ['thinking', 'redacted_thinking'], true) ))]) : $message, array_slice($messages, -3) ), fn($message) => $message['content'] !== [])); $messagesAfterCompaction = array_merge( [['role' => 'assistant', 'content' => [$compactionBlock]]], $preserved ); $response = $client->beta->messages->create( maxTokens: 4096, messages: $messagesAfterCompaction, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); $messages = $messagesAfterCompaction; } $messages[] = ['role' => 'assistant', 'content' => $response->content]; foreach ($response->content as $block) { if ($block->type === 'text') { return $block->text; } } return ''; } echo chat($client, $messages, "Help me build a Python web scraper") . "\n"; echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n"; echo chat($client, $messages, "Now add rate limiting and error handling") . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [] def chat(client, messages, user_message) messages << { role: "user", content: user_message } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 }, pause_after_compaction: true } ] } ) if response.stop_reason == :compaction compaction_block = response.content[0] # 이전 대화와 현재 사용자 메시지(메시지 3개)를 유지하되, # thinking 블록은 제외합니다. 비어 있게 된 assistant 턴은 삭제됩니다 preserved = messages.last(3).map do |message| next message unless message[:role] == "assistant" message.merge(content: message[:content].reject { |block| %i[thinking redacted_thinking].include?(block.type) }) end.reject { |message| message[:content].empty? } messages_after_compaction = [ { role: "assistant", content: [compaction_block] } ] + preserved response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages_after_compaction, context_management: { edits: [{ type: "compact_20260112" }] } ) messages.clear messages.concat(messages_after_compaction) end messages << { role: "assistant", content: response.content } response.content.find { |block| block.type == :text }&.text || "" end puts chat(client, messages, "Help me build a Python web scraper") puts chat(client, messages, "Add support for JavaScript-rendered pages") puts chat(client, messages, "Now add rate limiting and error handling") ``` ## 현재 제한 사항 * **요약에 동일한 모델 사용:** 요청에 지정된 모델이 요약에 사용됩니다. 요약에 다른(예: 더 저렴한) 모델을 사용하는 옵션은 없습니다. * **도구가 정의된 경우 압축이 실패할 수 있음:** 요청에 `tools`가 포함된 경우, 모델이 내부 요약 단계에서 요약을 작성하는 대신 간혹 도구를 호출합니다. 이 경우 응답에 `content: null`인 `compaction` 블록이 포함됩니다. 이를 방지하려면 [`instructions`](https://platform.claude.com/docs/ko/build-with-claude/compaction-threshold#custom-summarization-instructions)를 모델에 도구를 호출하지 말라고 명시적으로 지시하는 프롬프트로 설정하세요. 예: ```text wrap Summarize the transcript inside

tags. Include relevant information in the summary for continuing the task in the next context window. Do not call any tools while writing this summary; respond with text only. ``` ## 다음 단계 컨텍스트 편집을 사용하여 대화가 길어짐에 따라 대화 컨텍스트를 자동으로 관리하세요. 컨텍스트 윈도우 크기와 관리 전략에 대해 알아보세요. 백그라운드 스레딩과 프롬프트 캐싱을 활용한 즉각적인 세션 메모리 압축으로 장기 실행 대화를 관리하는 실용적인 구현을 살펴보세요.