Compaction di latar belakang

"Background compaction" (pemadatan latar belakang), yang sering disebut "async compaction" (pemadatan asinkron), mengubah dua hal dalam loop compaction: permintaan compaction berjalan sementara percakapan berlanjut pada riwayat lengkapnya, dan penukaran menunggu hingga blok tiba. Melanjutkan dari ringkasan dan Menangani ringkasan yang tidak ada atau error berlaku tanpa perubahan.

Cara kerja penukaran sementara pekerjaan berlanjut

Permintaan compaction dan blok yang dikembalikannya sama seperti dalam loop. Riwayat Anda bertambah antara saat permintaan dikirim dan saat hasilnya digunakan, dan "swap" (penukaran) harus membiarkan pertambahan tersebut tetap di tempatnya.

1. Kirim permintaan compaction dengan riwayat Anda sebagaimana adanya, dan catat berapa banyak pesan yang dimuatnya.
2. Selama permintaan tersebut berjalan, teruskan percakapan pada riwayat lengkap. Tambahkan setiap giliran baru, jangan mengedit apa pun yang sudah ada dalam riwayat, dan jangan memulai permintaan compaction lain hingga permintaan ini selesai ditukar atau gagal.
3. Saat respons tiba dengan stop_reason "compaction", hapus tepat pesan-pesan yang Anda kirim dari bagian depan riwayat Anda dan letakkan pesan yang dikembalikan di tempatnya. Setiap giliran yang ditambahkan sejak langkah 1 tetap berada setelahnya.
4. Kirim riwayat yang sudah ditukar pada permintaan pertama setelah blok tiba, sehingga thinking yang dihasilkan selama ringkasan sedang ditulis tetap valid.

Sebagai contoh, jika permintaan compaction memuat pesan 1 hingga 5 dan percakapan bertambah dengan pesan 6 hingga 8 selama permintaan itu berjalan, setelah penukaran riwayat Anda adalah blok tersebut diikuti oleh pesan 6 hingga 8.

Jika respons memiliki stop_reason lain, tidak ada ringkasan yang dihasilkan, dan hal ini dihitung sebagai kegagalan pada langkah 2. Pertahankan riwayat lengkap; Menangani ringkasan yang tidak ada atau error mencantumkan penyebabnya dan apa yang harus dilakukan untuk masing-masing.

Meminta ringkasan di latar belakang

Permintaan compaction dihitung terhadap batas laju Anda seperti permintaan lainnya, dan selama permintaan itu berjalan, aplikasi Anda memiliki dua permintaan yang terbuka sekaligus. Percakapan terus bertambah pada riwayat lengkapnya hingga penukaran, jadi mulailah permintaan compaction selagi "context window" (jendela konteks) masih memiliki ruang untuk giliran-giliran yang tiba sementara itu.

Program berikut adalah loop dari Compaction dalam loop dengan permintaan compaction dipindahkan dari jalur percakapan. Program ini tidak memiliki versi PHP, karena contohnya bergantung pada menjalankan dua permintaan sekaligus. Baris yang disorot menunjukkan di mana program ini berbeda dari loop, dan daftar berikut membahasnya sesuai urutan program menjalankannya.

from concurrent.futures import Future, ThreadPoolExecutor

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

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

# Atur ini mendekati anggaran input Anda yang sebenarnya. Di sini dibuat rendah agar percakapan singkat pun dipadatkan.
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":
        # Ganti tepat pesan-pesan yang dimuat oleh permintaan pemadatan.
        # Giliran berikutnya tetap berada setelah blok tersebut.
        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})

    # Permintaan berikutnya juga mengirim balasan ini, jadi hitung juga.
    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"},
        )

# Pasang ringkasan yang masih dalam proses sebelum Anda menyimpan
# atau melanjutkan percakapan.
if pending is not None:
    swap_in(history, pending.result(), sent)
executor.shutdown()

• Menentukan kapan melakukan compaction: Pemeriksaan ukuran juga mensyaratkan bahwa tidak ada permintaan compaction yang sedang tertunda.
• Memulai permintaan: Di tempat loop menunggu respons compaction, versi ini mencatat berapa banyak pesan yang dimuat riwayat, memulai permintaan pada salinan riwayat dengan alat konkurensi milik masing-masing bahasa, dan melanjutkan ke giliran berikutnya tanpa menunggu.
• Memeriksa hasil: Di awal setiap giliran, program memeriksa apakah permintaan yang tertunda sudah selesai. Jika sudah, program melakukan penukaran sebelum mengirim permintaan untuk giliran tersebut.
• Melakukan penukaran: Di tempat loop mengganti seluruh riwayat dengan pesan yang dikembalikan, fungsi penukaran versi ini hanya mengganti pesan-pesan yang dimuat oleh permintaan, dihitung dari bagian depan, dan mempertahankan semua yang ditambahkan sejak saat itu.
• Mengakhiri loop: Jika permintaan compaction masih tertunda saat loop berakhir, program menunggunya dan melakukan penukaran, sehingga ringkasan yang masih dalam perjalanan tidak hilang sebelum Anda menyimpan atau melanjutkan percakapan.

Pemeriksaan stop_reason tidak berubah dari loop: respons tanpa blok membiarkan riwayat seperti semula. Karena tidak ada lagi yang tertunda, program kemudian dapat memulai permintaan compaction baru.

Menjaga thinking tetap valid selama ringkasan dibuat

Giliran yang tiba selama ringkasan sedang ditulis adalah giliran yang dipertahankan. Jika Anda mengirim kembali blok thinking pada model dengan "preserved thinking" (pemikiran yang dipertahankan), thinking dalam giliran-giliran tersebut tetap valid hanya selama syarat agar thinking yang dipertahankan tetap valid terpenuhi.

Compatibility