요청 시 컴팩션

ant beta:messages create --beta compact-2026-09-04 <<'YAML'
model: claude-opus-5-5
# max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
max_tokens: 4096
messages:
  - role: user
    content: I am building a recipe app. Help me name the main entities in the data model.
  - role: assistant
    content: Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.
  - role: user
    content: Good. Now suggest field names for Recipe.
compaction:
  type: summarize
YAML

from anthropic.types.beta import BetaMessageParam

client = anthropic.Anthropic()

history: list[BetaMessageParam] = [
    {
        "role": "user",
        "content": "I am building a recipe app. Help me name the main entities in the data model.",
    },
    {
        "role": "assistant",
        "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.",
    },
    {"role": "user", "content": "Good. Now suggest field names for Recipe."},
]

response = client.beta.messages.create(
    model="claude-opus-5-5",
    # max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
    max_tokens=4096,
    betas=["compact-2026-09-04"],
    messages=history,
    compaction={"type": "summarize"},
)
print(f"Stop reason: {response.stop_reason}")

const client = new Anthropic();

const history: Anthropic.Beta.Messages.BetaMessageParam[] = [
  {
    role: "user",
    content: "I am building a recipe app. Help me name the main entities in the data model."
  },
  {
    role: "assistant",
    content:
      "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
  },
  { role: "user", content: "Good. Now suggest field names for Recipe." }
];

const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  // max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
  max_tokens: 4096,
  betas: ["compact-2026-09-04"],
  messages: history,
  compaction: { type: "summarize" }
});
console.log(`Stop reason: ${response.stop_reason}`);

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;

AnthropicClient client = new();

List<BetaMessageParam> history =
[
    new()
    {
        Role = Role.User,
        Content = "I am building a recipe app. Help me name the main entities in the data model.",
    },
    new()
    {
        Role = Role.Assistant,
        Content = "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.",
    },
    new() { Role = Role.User, Content = "Good. Now suggest field names for Recipe." },
];

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    // max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
    MaxTokens = 4096,
    Betas = [AnthropicBeta.Compact2026_09_04],
    Messages = history,
    Compaction = new BetaCompactionConfig(), // type defaults to "summarize"
});

Console.WriteLine($"Stop reason: {response.StopReason?.Raw()}");

client := anthropic.NewClient()

history := []anthropic.BetaMessageParam{
	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("I am building a recipe app. Help me name the main entities in the data model.")),
	{
		Role:    anthropic.BetaMessageParamRoleAssistant,
		Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.")},
	},
	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Good. Now suggest field names for Recipe.")),
}

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model: anthropic.ModelClaudeOpus5_5,
	// max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
	MaxTokens: 4096,
	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
	Messages:  history,
	Compaction: anthropic.BetaCompactionConfigUnionParam{
		OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println("Stop reason:", response.StopReason)

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaCompactionConfig;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    var client = AnthropicOkHttpClient.fromEnv();

    var params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        // max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
        .maxTokens(4096)
        .addBeta(AnthropicBeta.COMPACT_2026_09_04)
        .addUserMessage("I am building a recipe app. Help me name the main entities in the data model.")
        .addAssistantMessage("Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.")
        .addUserMessage("Good. Now suggest field names for Recipe.")
        .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
        .build();

    var response = client.beta().messages().create(params);
    response.stopReason().ifPresent(reason -> IO.println("Stop reason: " + reason));
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaCompactionConfig;
use Anthropic\Beta\Messages\BetaMessageParam;
use Anthropic\Beta\Messages\BetaMessageParam\Role;

$client = new Client();

$history = [
    BetaMessageParam::with(
        role: Role::USER,
        content: 'I am building a recipe app. Help me name the main entities in the data model.',
    ),
    BetaMessageParam::with(
        role: Role::ASSISTANT,
        content: 'Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe.',
    ),
    BetaMessageParam::with(role: Role::USER, content: 'Good. Now suggest field names for Recipe.'),
];

$response = $client->beta->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    // max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
    maxTokens: 4096,
    betas: [AnthropicBeta::COMPACT_2026_09_04],
    messages: $history,
    compaction: BetaCompactionConfig::with(), // type defaults to 'summarize'
);

echo "Stop reason: {$response->stopReason}", PHP_EOL;

client = Anthropic::Client.new

history = [
  {
    role: "user",
    content: "I am building a recipe app. Help me name the main entities in the data model."
  },
  {
    role: "assistant",
    content: "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
  },
  { role: "user", content: "Good. Now suggest field names for Recipe." }
]

response = client.beta.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  # max_tokens caps the whole call, including any thinking, so allow several thousand tokens.
  max_tokens: 4096,
  betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
  messages: history,
  compaction: { type: "summarize" }
)
puts "Stop reason: #{response.stop_reason}"

client = anthropic.Anthropic()

Set this near your real input budget. It is low here so a short conversation compacts.

COMPACT_AT_TOKENS = 2500 SYSTEM = "You help design a recipe app's data model. Keep answers short."

QUESTIONS = [ "What are the main entities in the data model?", "Which fields should Recipe have?", "Which fields should Ingredient have?", "Which fields should RecipeIngredient have?", "Which fields should Step have?", "Which indexes should these tables have?", "Which fields should be required?", "Which fields should have default values?", ]

history: list[BetaMessageParam] = [] for turn, question in enumerate(QUESTIONS, start=1): history.append({"role": "user", "content": question}) response = client.beta.messages.create( model="claude-opus-5-5", max_tokens=8192, system=SYSTEM, betas=["compact-2026-09-04"], messages=history, ) history.append({"role": "assistant", "content": response.content})

  # The next request sends this reply too, so count it.
  conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
  if conversation_tokens > COMPACT_AT_TOKENS and turn < len(QUESTIONS):
      summary = client.beta.messages.create(
          model="claude-opus-5-5",
          max_tokens=4096,
          system=SYSTEM,
          betas=["compact-2026-09-04"],
          messages=history,
          compaction={"type": "summarize"},
      )
      if summary.stop_reason == "compaction":
          history = [{"role": "assistant", "content": summary.content}]
          print(f"Compacted before turn {turn + 1}")

```typescript TypeScript
const client = new Anthropic();

// Set this near your real input budget. It is low here so a short conversation compacts.
const compactAtTokens = 2500;
const systemPrompt = "You help design a recipe app's data model. Keep answers short.";

const questions = [
  "What are the main entities in the data model?",
  "Which fields should Recipe have?",
  "Which fields should Ingredient have?",
  "Which fields should RecipeIngredient have?",
  "Which fields should Step have?",
  "Which indexes should these tables have?",
  "Which fields should be required?",
  "Which fields should have default values?"
];

let history: Anthropic.Beta.Messages.BetaMessageParam[] = [];
for (const [index, question] of questions.entries()) {
  const turn = index + 1;
  history.push({ role: "user", content: question });
  const response = await client.beta.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 8192,
    system: systemPrompt,
    betas: ["compact-2026-09-04"],
    messages: history
  });
  history.push({ role: "assistant", content: response.content });

  // The next request sends this reply too, so count it.
  const conversationTokens = response.usage.input_tokens + response.usage.output_tokens;
  if (conversationTokens > compactAtTokens && turn < questions.length) {
    const summary = await client.beta.messages.create({
      model: "claude-opus-5-5",
      max_tokens: 4096,
      system: systemPrompt,
      betas: ["compact-2026-09-04"],
      messages: history,
      compaction: { type: "summarize" }
    });
    if (summary.stop_reason === "compaction") {
      history = [{ role: "assistant", content: summary.content }];
      console.log(`Compacted before turn ${turn + 1}`);
    }
  }
}

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Model = Anthropic.Models.Messages.Model;

AnthropicClient client = new();

// Set this near your real input budget. It is low here so a short conversation compacts.
const int CompactAtTokens = 2500;
const string SystemPrompt = "You help design a recipe app's data model. Keep answers short.";

string[] questions =
[
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?",
];

List<BetaMessageParam> history = [];
foreach (var (index, question) in questions.Index())
{
    var turn = index + 1;
    history.Add(new() { Role = Role.User, Content = question });
    var response = await client.Beta.Messages.Create(new MessageCreateParams
    {
        Model = Model.ClaudeOpus5_5,
        MaxTokens = 8192,
        System = SystemPrompt,
        Betas = [AnthropicBeta.Compact2026_09_04],
        Messages = history,
    });
    history.Add(new()
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
    });

    // The next request sends this reply too, so count it.
    var conversationTokens = response.Usage.InputTokens + response.Usage.OutputTokens;
    if (conversationTokens > CompactAtTokens && turn < questions.Length)
    {
        var summary = await client.Beta.Messages.Create(new MessageCreateParams
        {
            Model = Model.ClaudeOpus5_5,
            MaxTokens = 4096,
            System = SystemPrompt,
            Betas = [AnthropicBeta.Compact2026_09_04],
            Messages = history,
            Compaction = new BetaCompactionConfig(), // type defaults to "summarize"
        });
        if (summary.StopReason == BetaStopReason.Compaction)
        {
            history =
            [
                new()
                {
                    Role = Role.Assistant,
                    Content = summary.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
                },
            ];
            Console.WriteLine($"Compacted before turn {turn + 1}");
        }
    }
}

ctx := context.Background()
client := anthropic.NewClient()

// Set this near your real input budget. It is low here so a short conversation compacts.
const compactAtTokens = 2500
system := []anthropic.BetaTextBlockParam{{Text: "You help design a recipe app's data model. Keep answers short."}}

questions := []string{
	"What are the main entities in the data model?",
	"Which fields should Recipe have?",
	"Which fields should Ingredient have?",
	"Which fields should RecipeIngredient have?",
	"Which fields should Step have?",
	"Which indexes should these tables have?",
	"Which fields should be required?",
	"Which fields should have default values?",
}

var history []anthropic.BetaMessageParam
for i, question := range questions {
	turn := i + 1
	history = append(history, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(question)))
	response, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
		Model:     anthropic.ModelClaudeOpus5_5,
		MaxTokens: 8192,
		System:    system,
		Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
		Messages:  history,
	})
	if err != nil {
		log.Fatal(err)
	}
	history = append(history, response.ToParam())

	// The next request sends this reply too, so count it.
	conversationTokens := response.Usage.InputTokens + response.Usage.OutputTokens
	if conversationTokens > compactAtTokens && turn < len(questions) {
		summary, err := client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
			Model:     anthropic.ModelClaudeOpus5_5,
			MaxTokens: 4096,
			System:    system,
			Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaCompact2026_09_04},
			Messages:  history,
			Compaction: anthropic.BetaCompactionConfigUnionParam{
				OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
			},
		})
		if err != nil {
			log.Fatal(err)
		}
		if summary.StopReason == anthropic.BetaStopReasonCompaction {
			history = []anthropic.BetaMessageParam{summary.ToParam()}
			fmt.Printf("Compacted before turn %d\n", turn+1)
		}
	}
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaCompactionConfig;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.MessageCreateParams;

// Set this near your real input budget. It is low here so a short conversation compacts.
static final long COMPACT_AT_TOKENS = 2500;
static final String SYSTEM = "You help design a recipe app's data model. Keep answers short.";

void main() {
    var client = AnthropicOkHttpClient.fromEnv();

    var questions = List.of(
        "What are the main entities in the data model?",
        "Which fields should Recipe have?",
        "Which fields should Ingredient have?",
        "Which fields should RecipeIngredient have?",
        "Which fields should Step have?",
        "Which indexes should these tables have?",
        "Which fields should be required?",
        "Which fields should have default values?"
    );

    var history = new ArrayList<BetaMessageParam>();
    for (int turn = 1; turn <= questions.size(); turn++) {
        history.add(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.USER)
            .content(questions.get(turn - 1))
            .build());
        var params = MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_5_5)
            .maxTokens(8192)
            .system(SYSTEM)
            .addBeta(AnthropicBeta.COMPACT_2026_09_04)
            .messages(history)
            .build();
        var response = client.beta().messages().create(params);
        history.add(response.toParam());

        // The next request sends this reply too, so count it.
        long conversationTokens = response.usage().inputTokens() + response.usage().outputTokens();
        if (conversationTokens > COMPACT_AT_TOKENS && turn < questions.size()) {
            var summaryParams = MessageCreateParams.builder()
                .model(Model.CLAUDE_OPUS_5_5)
                .maxTokens(4096)
                .system(SYSTEM)
                .addBeta(AnthropicBeta.COMPACT_2026_09_04)
                .messages(history)
                .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
                .build();
            var summary = client.beta().messages().create(summaryParams);
            if (summary.stopReason().map(BetaStopReason.COMPACTION::equals).orElse(false)) {
                history.clear();
                history.add(summary.toParam());
                IO.println("Compacted before turn " + (turn + 1));
            }
        }
    }
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaCompactionConfig;
use Anthropic\Beta\Messages\BetaMessageParam;
use Anthropic\Beta\Messages\BetaMessageParam\Role;
use Anthropic\Beta\Messages\BetaStopReason;

$client = new Client();

// Set this near your real input budget. It is low here so a short conversation compacts.
const COMPACT_AT_TOKENS = 2500;
const SYSTEM = "You help design a recipe app's data model. Keep answers short.";

$questions = [
    'What are the main entities in the data model?',
    'Which fields should Recipe have?',
    'Which fields should Ingredient have?',
    'Which fields should RecipeIngredient have?',
    'Which fields should Step have?',
    'Which indexes should these tables have?',
    'Which fields should be required?',
    'Which fields should have default values?',
];

$history = [];
foreach ($questions as $index => $question) {
    $turn = $index + 1;
    $history[] = BetaMessageParam::with(role: Role::USER, content: $question);
    $response = $client->beta->messages->create(
        model: Model::CLAUDE_OPUS_5_5,
        maxTokens: 8192,
        system: SYSTEM,
        betas: [AnthropicBeta::COMPACT_2026_09_04],
        messages: $history,
    );
    $history[] = BetaMessageParam::with(role: Role::ASSISTANT, content: $response->content);

    // The next request sends this reply too, so count it.
    $conversationTokens = $response->usage->inputTokens + $response->usage->outputTokens;
    if ($conversationTokens > COMPACT_AT_TOKENS && $turn < count($questions)) {
        $summary = $client->beta->messages->create(
            model: Model::CLAUDE_OPUS_5_5,
            maxTokens: 4096,
            system: SYSTEM,
            betas: [AnthropicBeta::COMPACT_2026_09_04],
            messages: $history,
            compaction: new BetaCompactionConfig(), // type defaults to 'summarize'
        );
        if ($summary->stopReason === BetaStopReason::COMPACTION->value) {
            $history = [BetaMessageParam::with(role: Role::ASSISTANT, content: $summary->content)];
            printf("Compacted before turn %d\n", $turn + 1);
        }
    }
}

client = Anthropic::Client.new

# Set this near your real input budget. It is low here so a short conversation compacts.
COMPACT_AT_TOKENS = 2500
SYSTEM = "You help design a recipe app's data model. Keep answers short."

questions = [
  "What are the main entities in the data model?",
  "Which fields should Recipe have?",
  "Which fields should Ingredient have?",
  "Which fields should RecipeIngredient have?",
  "Which fields should Step have?",
  "Which indexes should these tables have?",
  "Which fields should be required?",
  "Which fields should have default values?"
]

history = []
questions.each.with_index(1) do |question, turn|
  history << { role: "user", content: question }
  response = client.beta.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 8192,
    system_: SYSTEM,
    betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
    messages: history
  )
  history << { role: "assistant", content: response.content }

  # The next request sends this reply too, so count it.
  conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
  if conversation_tokens > COMPACT_AT_TOKENS && turn < questions.length
    summary = client.beta.messages.create(
      model: Anthropic::Model::CLAUDE_OPUS_5_5,
      max_tokens: 4096,
      system_: SYSTEM,
      betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
      messages: history,
      compaction: { type: "summarize" }
    )
    if summary.stop_reason == :compaction
      history = [{ role: "assistant", content: summary.content }]
      puts "Compacted before turn #{turn + 1}"
    end
  end
end