MessagesManajemen konteks

Compaction

Pemadatan konteks sisi server untuk mengelola percakapan panjang yang mendekati batas jendela konteks.

Fitur ini memenuhi syarat untuk Zero Data Retention (ZDR). Ketika organisasi Anda memiliki pengaturan ZDR, data yang dikirim melalui fitur ini tidak disimpan setelah respons API dikembalikan.

"Compaction" (pemadatan) sisi server adalah strategi yang direkomendasikan untuk mengelola konteks dalam percakapan yang berjalan lama dan alur kerja agentik. Fitur ini menangani manajemen konteks secara otomatis, tanpa kode peringkasan sisi klien.

Compaction memperpanjang panjang konteks efektif untuk percakapan dan tugas yang berjalan lama dengan secara otomatis meringkas konteks yang lebih lama ketika mendekati batas jendela konteks. Fitur ini juga menjaga konteks aktif tetap kecil: seiring percakapan bertambah panjang, kualitas respons menurun, sehingga compaction menggantikan konten yang lebih lama dengan ringkasan yang padat.

Untuk pemahaman lebih dalam tentang mengapa konteks panjang mengalami penurunan kualitas dan bagaimana compaction membantu, lihat Effective context engineering.

Fitur ini ideal untuk:

Percakapan multi-giliran berbasis chat di mana Anda ingin pengguna menggunakan satu chat untuk jangka waktu yang lama
Prompt berorientasi tugas yang memerlukan banyak pekerjaan lanjutan (sering kali penggunaan alat) yang mungkin melebihi jendela konteks

Compaction masih dalam versi beta. Sertakan beta header compact-2026-01-12 dalam permintaan API Anda untuk menggunakan fitur ini.

Model yang didukung

Compaction didukung pada model-model berikut:

Claude Fable 5 (claude-fable-5)
Claude Mythos 5 (claude-mythos-5)
Claude Mythos Preview (claude-mythos-preview)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)

Cara kerja compaction

Ketika compaction diaktifkan, Claude secara otomatis meringkas percakapan Anda ketika mencapai ambang batas token yang dikonfigurasi. API akan:

Mendeteksi ketika token input mencapai ambang batas pemicu yang Anda tentukan.
Menghasilkan ringkasan dari percakapan saat ini.
Membuat blok compaction yang berisi ringkasan tersebut.
Melanjutkan respons dengan konteks yang telah dipadatkan.

Pada permintaan berikutnya, tambahkan respons ke pesan Anda. API secara otomatis menghapus semua blok konten sebelum blok compaction, melanjutkan percakapan dari ringkasan.

Alur compaction: ketika token input mencapai pemicu, Claude menulis ringkasan ke dalam blok compaction dan melanjutkan

Penggunaan dasar

Aktifkan compaction dengan menambahkan strategi compact_20260112 ke context_management.edits dalam permintaan Messages API Anda.

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-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)

# Tambahkan respons (termasuk blok pemadatan apa pun) untuk melanjutkan percakapan
messages.append({"role": "assistant", "content": response.content})

Parameter

Parameter	Tipe	Default	Deskripsi
`type`	string	Wajib	Harus berupa `"compact_20260112"`
`trigger`	object	`{"type": "input_tokens", "value": 150000}`	Kapan compaction dipicu. `input_tokens` adalah satu-satunya tipe pemicu yang didukung. `value` harus minimal 50.000 token.
`pause_after_compaction`	boolean	`false`	Apakah akan berhenti sejenak setelah menghasilkan ringkasan compaction
`instructions`	string	`null`	Prompt peringkasan kustom. Sepenuhnya menggantikan prompt default jika disediakan.

Konfigurasi pemicu

Konfigurasikan kapan compaction dipicu menggunakan parameter trigger:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": 150000},
            }
        ]
    },
)

Instruksi peringkasan kustom

Prompt peringkasan default bervariasi menurut model. Setiap default menginstruksikan Claude untuk menulis ringkasan di dalam tag <summary></summary> dengan informasi yang diperlukan untuk melanjutkan tugas di jendela konteks berikutnya. Sebagai contoh, beberapa model menggunakan prompt berikut:

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 <summary></summary> block.

Anda dapat memberikan instruksi kustom melalui parameter instructions. Instruksi kustom tidak melengkapi prompt default. Instruksi tersebut menggantikannya sepenuhnya:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "instructions": "Focus on preserving code snippets, variable names, and technical decisions.",
            }
        ]
    },
)

Berhenti sejenak setelah compaction

Gunakan pause_after_compaction untuk menjeda API setelah menghasilkan ringkasan compaction. Ini memungkinkan Anda menambahkan blok konten tambahan (seperti mempertahankan pesan terbaru atau pesan berorientasi instruksi tertentu) sebelum API melanjutkan dengan respons.

Ketika diaktifkan, API mengembalikan pesan dengan stop reason compaction setelah menghasilkan blok compaction:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [{"type": "compact_20260112", "pause_after_compaction": True}]
    },
)

# Periksa apakah pemadatan memicu jeda
if response.stop_reason == "compaction":
    # Respons hanya berisi blok pemadatan
    messages.append({"role": "assistant", "content": response.content})

    # Lanjutkan permintaan
    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model="claude-opus-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={"edits": [{"type": "compact_20260112"}]},
    )

Menerapkan anggaran token total

Ketika model mengerjakan tugas panjang dengan banyak iterasi penggunaan alat, konsumsi token total dapat meningkat secara signifikan. Anda dapat menggabungkan pause_after_compaction dengan penghitung compaction untuk memperkirakan penggunaan kumulatif dan menyelesaikan tugas dengan baik setelah anggaran tercapai.

Contoh ini hanya muncul dalam bahasa SDK: nilainya terletak pada logika pelacakan anggaran di sekitar permintaan. Permintaan mentahnya menggabungkan trigger dari Konfigurasi pemicu dengan pause_after_compaction dari Berhenti sejenak setelah compaction.

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-4-8",
    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})

    # Estimasi total token yang dikonsumsi; minta penutupan jika melebihi anggaran
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append(
            {
                "role": "user",
                "content": "Please wrap up your current work and summarize the final state.",
            }
        )

Bekerja dengan blok compaction

Ketika compaction dipicu, API mengembalikan blok compaction di awal respons asisten.

Percakapan yang berjalan lama mungkin menghasilkan beberapa compaction. Blok compaction terakhir mencerminkan keadaan akhir prompt, menggantikan konten sebelumnya dengan ringkasan yang dihasilkan.

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..."
    }
  ]
}

Mengirim kembali blok compaction

Anda harus mengirim kembali blok compaction ke API pada permintaan berikutnya untuk melanjutkan percakapan dengan prompt yang telah dipersingkat. Pendekatan paling sederhana adalah menambahkan seluruh konten respons ke pesan Anda:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)
# Setelah menerima respons dengan blok pemadatan
messages.append({"role": "assistant", "content": response.content})

# Lanjutkan percakapan
messages.append({"role": "user", "content": "Now add error handling"})

response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)

Ketika API menerima blok compaction, semua blok konten sebelumnya diabaikan. Anda dapat:

Menyimpan pesan asli dalam daftar Anda dan membiarkan API menangani penghapusan konten yang telah dipadatkan
Secara manual menghapus pesan yang telah dipadatkan dan hanya menyertakan blok compaction dan seterusnya

Streaming

Blok compaction di-stream secara berbeda dari blok teks. Anda menerima event content_block_start, diikuti oleh satu content_block_delta dengan konten ringkasan lengkap (tanpa streaming perantara), dan kemudian event content_block_stop.

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]

with client.beta.messages.stream(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
) as stream:
    for event in stream:
        if event.type == "content_block_start":
            if event.content_block.type == "compaction":
                print("Compaction started...")
            elif event.content_block.type == "text":
                print("Text response started...")

        elif event.type == "content_block_delta":
            if event.delta.type == "compaction_delta":
                print(f"Compaction complete: {len(event.delta.content or '')} chars")
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

    # Dapatkan pesan akhir yang terakumulasi
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Caching prompt

Compaction bekerja dengan baik bersama caching prompt. Anda dapat menambahkan breakpoint cache_control pada blok compaction untuk meng-cache konten yang telah diringkas.

{
  "role": "assistant",
  "content": [
    {
      "type": "compaction",
      "content": "[summary text]",
      "cache_control": { "type": "ephemeral" }
    },
    {
      "type": "text",
      "text": "Based on our conversation..."
    }
  ]
}

Memaksimalkan cache hit dengan prompt sistem

Ketika compaction terjadi, ringkasan menjadi konten baru yang perlu ditulis ke cache. Tanpa breakpoint cache tambahan, hal ini juga akan membatalkan prompt sistem yang telah di-cache, sehingga perlu di-cache ulang bersama dengan ringkasan compaction.

Untuk memaksimalkan tingkat cache hit, tambahkan breakpoint cache_control di akhir prompt sistem Anda. Ini menjaga prompt sistem tetap di-cache secara terpisah dari percakapan, sehingga ketika compaction terjadi:

Cache prompt sistem tetap valid dan dibaca dari cache
Hanya ringkasan compaction yang perlu ditulis sebagai entri cache baru

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    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"}]},
)

Ini menjaga prompt sistem yang panjang tetap di-cache di sepanjang beberapa peristiwa compaction selama percakapan.

Memahami penggunaan

Compaction memerlukan langkah sampling tambahan, yang berkontribusi pada batas laju dan penagihan. API mengembalikan informasi penggunaan terperinci dalam respons:

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
      }
    ]
  }
}

Array iterations menunjukkan penggunaan untuk setiap iterasi sampling. Ketika compaction terjadi, Anda akan melihat iterasi compaction diikuti oleh iterasi message utama. input_tokens dan output_tokens tingkat atas sama persis dengan iterasi message dalam contoh ini karena hanya ada satu iterasi non-compaction. Jumlah token iterasi terakhir mencerminkan ukuran konteks efektif setelah compaction.

input_tokens dan output_tokens tingkat atas tidak menyertakan penggunaan iterasi compaction. Keduanya mencerminkan jumlah dari semua iterasi non-compaction. Untuk menghitung total token yang dikonsumsi dan ditagih untuk sebuah permintaan, jumlahkan semua entri dalam array usage.iterations.

Jika sebelumnya Anda mengandalkan usage.input_tokens dan usage.output_tokens untuk pelacakan biaya atau audit, Anda perlu memperbarui logika pelacakan Anda untuk mengagregasi di seluruh usage.iterations ketika compaction diaktifkan. Dengan beta compaction diaktifkan, setiap respons menyertakan usage.iterations, bahkan jika tidak ada compaction yang terjadi. Entri compaction hanya muncul ketika compaction baru dipicu selama permintaan. Menerapkan kembali blok compaction sebelumnya tidak menimbulkan biaya compaction tambahan, dan field penggunaan tingkat atas tetap akurat dalam kasus tersebut.

Menggabungkan dengan fitur lain

Alat server

Saat menggunakan alat server (seperti pencarian web), pemicu compaction diperiksa di awal setiap iterasi sampling. Compaction mungkin terjadi beberapa kali dalam satu permintaan tergantung pada ambang batas pemicu Anda dan jumlah output yang dihasilkan.

Penghitungan token

Endpoint penghitungan token (/v1/messages/count_tokens) menerapkan blok compaction yang sudah ada dalam prompt Anda tetapi tidak memicu compaction baru. Gunakan endpoint ini untuk memeriksa jumlah token efektif Anda setelah compaction sebelumnya:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
count_response = client.beta.messages.count_tokens(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    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}")

Contoh

Berikut adalah contoh lengkap percakapan yang berjalan lama dengan compaction:

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-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={
            "edits": [
                {
                    "type": "compact_20260112",
                    "trigger": {"type": "input_tokens", "value": 100000},
                }
            ]
        },
    )

    # Tambahkan respons (blok pemadatan otomatis disertakan)
    messages.append({"role": "assistant", "content": response.content})

    # Kembalikan konten teks
    return next(block.text for block in response.content if block.type == "text")


# Jalankan percakapan panjang
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"))
# Terus panggil chat() selama percakapan masih diperlukan

Berikut adalah contoh yang menggunakan pause_after_compaction untuk mempertahankan pertukaran sebelumnya dan pesan pengguna saat ini (total tiga pesan) secara verbatim alih-alih meringkasnya:

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-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={
            "edits": [
                {
                    "type": "compact_20260112",
                    "trigger": {"type": "input_tokens", "value": 100000},
                    "pause_after_compaction": True,
                }
            ]
        },
    )

    # Periksa apakah pemadatan terjadi dan dijeda
    if response.stop_reason == "compaction":
        # Ambil blok pemadatan dari respons
        compaction_block = response.content[0]

        # Pertahankan pertukaran sebelumnya + pesan pengguna saat ini (3 pesan)
        # dengan menyertakannya setelah blok pemadatan
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

        # Bangun daftar pesan baru: pemadatan + pesan yang dipertahankan
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Lanjutkan permintaan dengan konteks yang dipadatkan + pesan yang dipertahankan
        response = client.beta.messages.create(
            betas=["compact-2026-01-12"],
            model="claude-opus-4-8",
            max_tokens=4096,
            messages=messages_after_compaction,
            context_management={"edits": [{"type": "compact_20260112"}]},
        )

        # Perbarui daftar pesan kita untuk mencerminkan pemadatan
        messages.clear()
        messages.extend(messages_after_compaction)

    # Tambahkan respons akhir
    messages.append({"role": "assistant", "content": response.content})

    # Kembalikan konten teks
    return next(block.text for block in response.content if block.type == "text")


# Jalankan percakapan panjang
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"))
# Terus panggil chat() selama percakapan masih membutuhkannya

Batasan saat ini

Model yang sama untuk peringkasan: Model yang ditentukan dalam permintaan Anda digunakan untuk peringkasan. Tidak ada opsi untuk menggunakan model yang berbeda (misalnya, yang lebih murah) untuk ringkasan.
Compaction mungkin gagal ketika alat didefinisikan: Ketika permintaan Anda menyertakan tools, model terkadang memanggil alat selama langkah peringkasan internal alih-alih menulis ringkasan. Ketika ini terjadi, respons berisi blok compaction dengan content: null. Untuk mencegah hal ini, atur instructions ke prompt yang secara eksplisit memberi tahu model untuk tidak memanggil alat, misalnya:
```
Summarize the transcript inside <summary></summary> 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.
```

Langkah selanjutnya

Pengeditan konteks

Kelola konteks percakapan secara otomatis seiring pertumbuhannya dengan pengeditan konteks.

Jendela konteks

Pelajari tentang ukuran jendela konteks dan strategi pengelolaannya.

Cookbook pemadatan memori sesi

Jelajahi implementasi praktis yang mengelola percakapan yang berjalan lama dengan pemadatan memori sesi instan menggunakan background threading dan caching prompt.

Was this page helpful?

MessagesManajemen konteks

Compaction

Pemadatan konteks sisi server untuk mengelola percakapan panjang yang mendekati batas jendela konteks.

Fitur ini memenuhi syarat untuk Zero Data Retention (ZDR). Ketika organisasi Anda memiliki pengaturan ZDR, data yang dikirim melalui fitur ini tidak disimpan setelah respons API dikembalikan.

Untuk pemahaman lebih dalam tentang mengapa konteks panjang mengalami penurunan kualitas dan bagaimana compaction membantu, lihat Effective context engineering.

Fitur ini ideal untuk:

Percakapan multi-giliran berbasis chat di mana Anda ingin pengguna menggunakan satu chat untuk jangka waktu yang lama
Prompt berorientasi tugas yang memerlukan banyak pekerjaan lanjutan (sering kali penggunaan alat) yang mungkin melebihi jendela konteks

Compaction masih dalam versi beta. Sertakan beta header compact-2026-01-12 dalam permintaan API Anda untuk menggunakan fitur ini.

Model yang didukung

Compaction didukung pada model-model berikut:

Claude Fable 5 (claude-fable-5)
Claude Mythos 5 (claude-mythos-5)
Claude Mythos Preview (claude-mythos-preview)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)

Cara kerja compaction

Ketika compaction diaktifkan, Claude secara otomatis meringkas percakapan Anda ketika mencapai ambang batas token yang dikonfigurasi. API akan:

Mendeteksi ketika token input mencapai ambang batas pemicu yang Anda tentukan.
Menghasilkan ringkasan dari percakapan saat ini.
Membuat blok compaction yang berisi ringkasan tersebut.
Melanjutkan respons dengan konteks yang telah dipadatkan.

Pada permintaan berikutnya, tambahkan respons ke pesan Anda. API secara otomatis menghapus semua blok konten sebelum blok compaction, melanjutkan percakapan dari ringkasan.

Penggunaan dasar

Aktifkan compaction dengan menambahkan strategi compact_20260112 ke context_management.edits dalam permintaan Messages API Anda.

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-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)

# Tambahkan respons (termasuk blok pemadatan apa pun) untuk melanjutkan percakapan
messages.append({"role": "assistant", "content": response.content})

Parameter

Parameter	Tipe	Default	Deskripsi
`type`	string	Wajib	Harus berupa `"compact_20260112"`
`trigger`	object	`{"type": "input_tokens", "value": 150000}`	Kapan compaction dipicu. `input_tokens` adalah satu-satunya tipe pemicu yang didukung. `value` harus minimal 50.000 token.
`pause_after_compaction`	boolean	`false`	Apakah akan berhenti sejenak setelah menghasilkan ringkasan compaction
`instructions`	string	`null`	Prompt peringkasan kustom. Sepenuhnya menggantikan prompt default jika disediakan.

Konfigurasi pemicu

Konfigurasikan kapan compaction dipicu menggunakan parameter trigger:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": 150000},
            }
        ]
    },
)

Instruksi peringkasan kustom

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 <summary></summary> block.

Anda dapat memberikan instruksi kustom melalui parameter instructions. Instruksi kustom tidak melengkapi prompt default. Instruksi tersebut menggantikannya sepenuhnya:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [
            {
                "type": "compact_20260112",
                "instructions": "Focus on preserving code snippets, variable names, and technical decisions.",
            }
        ]
    },
)

Berhenti sejenak setelah compaction

Ketika diaktifkan, API mengembalikan pesan dengan stop reason compaction setelah menghasilkan blok compaction:

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={
        "edits": [{"type": "compact_20260112", "pause_after_compaction": True}]
    },
)

# Periksa apakah pemadatan memicu jeda
if response.stop_reason == "compaction":
    # Respons hanya berisi blok pemadatan
    messages.append({"role": "assistant", "content": response.content})

    # Lanjutkan permintaan
    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model="claude-opus-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={"edits": [{"type": "compact_20260112"}]},
    )

Menerapkan anggaran token total

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-4-8",
    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})

    # Estimasi total token yang dikonsumsi; minta penutupan jika melebihi anggaran
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append(
            {
                "role": "user",
                "content": "Please wrap up your current work and summarize the final state.",
            }
        )

Bekerja dengan blok compaction

Ketika compaction dipicu, API mengembalikan blok compaction di awal respons asisten.

Percakapan yang berjalan lama mungkin menghasilkan beberapa compaction. Blok compaction terakhir mencerminkan keadaan akhir prompt, menggantikan konten sebelumnya dengan ringkasan yang dihasilkan.

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..."
    }
  ]
}

Mengirim kembali blok compaction

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)
# Setelah menerima respons dengan blok pemadatan
messages.append({"role": "assistant", "content": response.content})

# Lanjutkan percakapan
messages.append({"role": "user", "content": "Now add error handling"})

response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
)

Ketika API menerima blok compaction, semua blok konten sebelumnya diabaikan. Anda dapat:

Menyimpan pesan asli dalam daftar Anda dan membiarkan API menangani penghapusan konten yang telah dipadatkan
Secara manual menghapus pesan yang telah dipadatkan dan hanya menyertakan blok compaction dan seterusnya

Streaming

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]

with client.beta.messages.stream(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=messages,
    context_management={"edits": [{"type": "compact_20260112"}]},
) as stream:
    for event in stream:
        if event.type == "content_block_start":
            if event.content_block.type == "compaction":
                print("Compaction started...")
            elif event.content_block.type == "text":
                print("Text response started...")

        elif event.type == "content_block_delta":
            if event.delta.type == "compaction_delta":
                print(f"Compaction complete: {len(event.delta.content or '')} chars")
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

    # Dapatkan pesan akhir yang terakumulasi
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Caching prompt

Compaction bekerja dengan baik bersama caching prompt. Anda dapat menambahkan breakpoint cache_control pada blok compaction untuk meng-cache konten yang telah diringkas.

{
  "role": "assistant",
  "content": [
    {
      "type": "compaction",
      "content": "[summary text]",
      "cache_control": { "type": "ephemeral" }
    },
    {
      "type": "text",
      "text": "Based on our conversation..."
    }
  ]
}

Memaksimalkan cache hit dengan prompt sistem

Cache prompt sistem tetap valid dan dibaca dari cache
Hanya ringkasan compaction yang perlu ditulis sebagai entri cache baru

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    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"}]},
)

Ini menjaga prompt sistem yang panjang tetap di-cache di sepanjang beberapa peristiwa compaction selama percakapan.

Memahami penggunaan

Compaction memerlukan langkah sampling tambahan, yang berkontribusi pada batas laju dan penagihan. API mengembalikan informasi penggunaan terperinci dalam respons:

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
      }
    ]
  }
}

Menggabungkan dengan fitur lain

Alat server

Penghitungan token

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
count_response = client.beta.messages.count_tokens(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-8",
    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}")

Contoh

Berikut adalah contoh lengkap percakapan yang berjalan lama dengan compaction:

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-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={
            "edits": [
                {
                    "type": "compact_20260112",
                    "trigger": {"type": "input_tokens", "value": 100000},
                }
            ]
        },
    )

    # Tambahkan respons (blok pemadatan otomatis disertakan)
    messages.append({"role": "assistant", "content": response.content})

    # Kembalikan konten teks
    return next(block.text for block in response.content if block.type == "text")


# Jalankan percakapan panjang
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"))
# Terus panggil chat() selama percakapan masih diperlukan

Berikut adalah contoh yang menggunakan pause_after_compaction untuk mempertahankan pertukaran sebelumnya dan pesan pengguna saat ini (total tiga pesan) secara verbatim alih-alih meringkasnya:

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-4-8",
        max_tokens=4096,
        messages=messages,
        context_management={
            "edits": [
                {
                    "type": "compact_20260112",
                    "trigger": {"type": "input_tokens", "value": 100000},
                    "pause_after_compaction": True,
                }
            ]
        },
    )

    # Periksa apakah pemadatan terjadi dan dijeda
    if response.stop_reason == "compaction":
        # Ambil blok pemadatan dari respons
        compaction_block = response.content[0]

        # Pertahankan pertukaran sebelumnya + pesan pengguna saat ini (3 pesan)
        # dengan menyertakannya setelah blok pemadatan
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

        # Bangun daftar pesan baru: pemadatan + pesan yang dipertahankan
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Lanjutkan permintaan dengan konteks yang dipadatkan + pesan yang dipertahankan
        response = client.beta.messages.create(
            betas=["compact-2026-01-12"],
            model="claude-opus-4-8",
            max_tokens=4096,
            messages=messages_after_compaction,
            context_management={"edits": [{"type": "compact_20260112"}]},
        )

        # Perbarui daftar pesan kita untuk mencerminkan pemadatan
        messages.clear()
        messages.extend(messages_after_compaction)

    # Tambahkan respons akhir
    messages.append({"role": "assistant", "content": response.content})

    # Kembalikan konten teks
    return next(block.text for block in response.content if block.type == "text")


# Jalankan percakapan panjang
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"))
# Terus panggil chat() selama percakapan masih membutuhkannya

Batasan saat ini

Model yang sama untuk peringkasan: Model yang ditentukan dalam permintaan Anda digunakan untuk peringkasan. Tidak ada opsi untuk menggunakan model yang berbeda (misalnya, yang lebih murah) untuk ringkasan.
Compaction mungkin gagal ketika alat didefinisikan: Ketika permintaan Anda menyertakan tools, model terkadang memanggil alat selama langkah peringkasan internal alih-alih menulis ringkasan. Ketika ini terjadi, respons berisi blok compaction dengan content: null. Untuk mencegah hal ini, atur instructions ke prompt yang secara eksplisit memberi tahu model untuk tidak memanggil alat, misalnya:
```
Summarize the transcript inside <summary></summary> 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.
```

Langkah selanjutnya

Pengeditan konteks

Kelola konteks percakapan secara otomatis seiring pertumbuhannya dengan pengeditan konteks.

Jendela konteks

Pelajari tentang ukuran jendela konteks dan strategi pengelolaannya.

Cookbook pemadatan memori sesi

Jelajahi implementasi praktis yang mengelola percakapan yang berjalan lama dengan pemadatan memori sesi instan menggunakan background threading dan caching prompt.

Was this page helpful?

Model yang didukung

Cara kerja compaction

Penggunaan dasar

Parameter

Konfigurasi pemicu

Instruksi peringkasan kustom

Berhenti sejenak setelah compaction

Menerapkan anggaran token total

Bekerja dengan blok compaction

Mengirim kembali blok compaction

Streaming

Caching prompt

Memaksimalkan cache hit dengan prompt sistem

Memahami penggunaan

Menggabungkan dengan fitur lain

Alat server

Penghitungan token

Contoh

Batasan saat ini

Langkah selanjutnya

Model yang didukung

Cara kerja compaction

Penggunaan dasar

Parameter

Konfigurasi pemicu

Instruksi peringkasan kustom

Berhenti sejenak setelah compaction

Menerapkan anggaran token total

Bekerja dengan blok compaction

Mengirim kembali blok compaction

Streaming

Caching prompt

Memaksimalkan cache hit dengan prompt sistem

Memahami penggunaan

Menggabungkan dengan fitur lain

Alat server

Penghitungan token

Contoh

Batasan saat ini

Langkah selanjutnya

Model yang didukung

Cara kerja compaction

Penggunaan dasar

Parameter

Konfigurasi pemicu

Instruksi peringkasan kustom

Berhenti sejenak setelah compaction

Menerapkan anggaran token total

Bekerja dengan blok compaction

Mengirim kembali blok compaction

Streaming

Caching prompt

Memaksimalkan cache hit dengan prompt sistem

Memahami penggunaan

Menggabungkan dengan fitur lain

Alat server

Penghitungan token

Contoh

Batasan saat ini

Langkah selanjutnya

Model yang didukung

Cara kerja compaction

Penggunaan dasar

Parameter

Konfigurasi pemicu

Instruksi peringkasan kustom

Berhenti sejenak setelah compaction

Menerapkan anggaran token total

Bekerja dengan blok compaction

Mengirim kembali blok compaction

Streaming

Caching prompt

Memaksimalkan cache hit dengan prompt sistem

Memahami penggunaan

Menggabungkan dengan fitur lain

Alat server

Penghitungan token

Contoh

Batasan saat ini

Langkah selanjutnya