백그라운드 컴팩션

import anthropic from anthropic.types.beta import BetaMessage, BetaMessageParam

client = anthropic.Anthropic() executor = ThreadPoolExecutor(max_workers=1)

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?", ]

def swap_in(history: list[BetaMessageParam], summary: BetaMessage, sent: int) -> None: if summary.stop_reason == "compaction": # Replace exactly the messages the compaction request held. # Later turns stay after the block. history[:sent] = [{"role": "assistant", "content": summary.content}] print(f"Swapped {sent} messages")

history: list[BetaMessageParam] = [] pending: Future[BetaMessage] | None = None sent = 0 for turn, question in enumerate(QUESTIONS, start=1): if pending is not None and pending.done(): swap_in(history, pending.result(), sent) pending = None

  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)
      and pending is None
  ):
      sent = len(history)
      pending = executor.submit(
          client.beta.messages.create,
          model="claude-opus-5-5",
          max_tokens=4096,
          system=SYSTEM,
          betas=["compact-2026-09-04"],
          messages=history.copy(),
          compaction={"type": "summarize"},
      )

Swap in a summary that is still on its way before you save

or continue the conversation.

if pending is not None: swap_in(history, pending.result(), sent) executor.shutdown()

```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?"
];

function swapIn(
  history: Anthropic.Beta.Messages.BetaMessageParam[],
  summary: Anthropic.Beta.Messages.BetaMessage,
  sent: number
): Anthropic.Beta.Messages.BetaMessageParam[] {
  if (summary.stop_reason !== "compaction") {
    return history;
  }
  console.log(`Swapped ${sent} messages`);
  // Replace exactly the messages the compaction request held. Later turns stay after the block.
  return [{ role: "assistant", content: summary.content }, ...history.slice(sent)];
}

let history: Anthropic.Beta.Messages.BetaMessageParam[] = [];
let pending: Promise<Anthropic.Beta.Messages.BetaMessage> | undefined;
let settled = false;
let sent = 0;
for (const [index, question] of questions.entries()) {
  const turn = index + 1;
  if (pending && settled) {
    history = swapIn(history, await pending, sent);
    pending = undefined;
    settled = false;
  }

  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 && !pending) {
    sent = history.length;
    pending = client.beta.messages.create({
      model: "claude-opus-5-5",
      max_tokens: 4096,
      system: systemPrompt,
      betas: ["compact-2026-09-04"],
      messages: [...history],
      compaction: { type: "summarize" }
    });
    // Mark the request settled either way. Awaiting it then returns the summary or throws.
    const markSettled = () => {
      settled = true;
    };
    pending.then(markSettled, markSettled);
  }
}

// Swap in a summary that is still on its way before you save or continue the conversation.
if (pending) {
  history = swapIn(history, await pending, sent);
}

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?",
];

static List<BetaMessageParam> SwapIn(List<BetaMessageParam> history, BetaMessage summary, int sent)
{
    if (summary.StopReason != BetaStopReason.Compaction)
    {
        return history;
    }
    Console.WriteLine($"Swapped {sent} messages");
    // Replace exactly the messages the compaction request held. Later turns stay after the block.
    return
    [
        new()
        {
            Role = Role.Assistant,
            Content = summary.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
        },
        .. history[sent..],
    ];
}

List<BetaMessageParam> history = [];
Task<BetaMessage>? pending = null;
var sent = 0;
foreach (var (index, question) in questions.Index())
{
    var turn = index + 1;
    if (pending is { IsCompleted: true })
    {
        history = SwapIn(history, await pending, sent);
        pending = null;
    }

    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 && pending is null)
    {
        sent = history.Count;
        pending = 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"
        });
    }
}

// Swap in a summary that is still on its way before you save or continue the conversation.
if (pending is not null)
{
    history = SwapIn(history, await pending, sent);
}

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
var pending chan *anthropic.BetaMessage
var sent int
swapIn := func(summary *anthropic.BetaMessage) {
	if summary.StopReason != anthropic.BetaStopReasonCompaction {
		return
	}
	fmt.Printf("Swapped %d messages\n", sent)
	// Replace exactly the messages the compaction request held. Later turns stay after the block.
	history = slices.Replace(history, 0, sent, summary.ToParam())
}

for i, question := range questions {
	turn := i + 1
	// Receiving from a nil channel never succeeds, so this skips when nothing is pending.
	select {
	case summary := <-pending:
		swapIn(summary)
		pending = nil
	default:
	}

	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) && pending == nil {
		sent = len(history)
		pending = make(chan *anthropic.BetaMessage, 1)
		go func(messages []anthropic.BetaMessageParam, result chan<- *anthropic.BetaMessage) {
			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:  messages,
				Compaction: anthropic.BetaCompactionConfigUnionParam{
					OfSummarize: &anthropic.BetaSummarizeCompactionParam{},
				},
			})
			if err != nil {
				log.Fatal(err)
			}
			result <- summary
		}(slices.Clone(history), pending)
	}
}

// Swap in a summary that is still on its way before you save or continue the conversation.
if pending != nil {
	swapIn(<-pending)
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaCompactionConfig;
import com.anthropic.models.beta.messages.BetaMessage;
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 swapIn(List<BetaMessageParam> history, BetaMessage summary, int sent) {
    if (!summary.stopReason().map(BetaStopReason.COMPACTION::equals).orElse(false)) {
        return;
    }
    IO.println("Swapped " + sent + " messages");
    // Replace exactly the messages the compaction request held. Later turns stay after the block.
    history.subList(0, sent).clear();
    history.addFirst(summary.toParam());
}

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>();
    CompletableFuture<BetaMessage> pending = null;
    int sent = 0;
    for (int turn = 1; turn <= questions.size(); turn++) {
        if (pending != null && pending.isDone()) {
            swapIn(history, pending.join(), sent);
            pending = null;
        }

        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() && pending == null) {
            sent = history.size();
            var summaryParams = MessageCreateParams.builder()
                .model(Model.CLAUDE_OPUS_5_5)
                .maxTokens(4096)
                .system(SYSTEM)
                .addBeta(AnthropicBeta.COMPACT_2026_09_04)
                .messages(List.copyOf(history))
                .compaction(BetaCompactionConfig.builder().build()) // type defaults to "summarize"
                .build();
            pending = client.async().beta().messages().create(summaryParams);
        }
    }

    // Swap in a summary that is still on its way before you save or continue the conversation.
    if (pending != null) {
        swapIn(history, pending.join(), sent);
    }
    client.close();
}

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?"
]

def swap_in(history, summary, sent)
  return history unless summary.stop_reason == :compaction

  puts "Swapped #{sent} messages"
  # Replace exactly the messages the compaction request held. Later turns stay after the block.
  [{ role: "assistant", content: summary.content }, *history[sent..]]
end

history = []
pending = nil
sent = 0
questions.each.with_index(1) do |question, turn|
  if pending && !pending.alive?
    history = swap_in(history, pending.value, sent)
    pending = nil
  end

  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 && pending.nil?
    sent = history.length
    pending = Thread.new(history.dup) do |snapshot|
      client.beta.messages.create(
        model: Anthropic::Model::CLAUDE_OPUS_5_5,
        max_tokens: 4096,
        system_: SYSTEM,
        betas: [Anthropic::AnthropicBeta::COMPACT_2026_09_04],
        messages: snapshot,
        compaction: { type: "summarize" }
      )
    end
  end
end

# Swap in a summary that is still on its way before you save or continue the conversation.
history = swap_in(history, pending.value, sent) if pending