NachrichtenKontextverwaltung

Compaction

Serverseitige Kontext-Compaction zur Verwaltung langer Konversationen, die sich den Grenzen des Kontextfensters nähern.

Diese Funktion ist für Zero Data Retention (ZDR) qualifiziert. Wenn deine Organisation eine ZDR-Vereinbarung hat, werden Daten, die über diese Funktion gesendet werden, nicht gespeichert, nachdem die API-Antwort zurückgegeben wurde.

Serverseitige Compaction ist die empfohlene Strategie zur Kontextverwaltung in lang laufenden Konversationen und agentischen Workflows. Sie übernimmt die Kontextverwaltung automatisch mit minimalem Integrationsaufwand.

„Compaction" (Verdichtung) erweitert die effektive Kontextlänge für lang laufende Konversationen und Aufgaben, indem älterer Kontext automatisch zusammengefasst wird, wenn sich die Konversation dem Limit des Kontextfensters nähert. Dabei geht es nicht nur darum, unter einer Token-Obergrenze zu bleiben. Je länger Konversationen werden, desto schwerer fällt es Modellen, den Fokus über den gesamten Verlauf hinweg zu behalten. Compaction hält den aktiven Kontext fokussiert und performant, indem veraltete Inhalte durch prägnante Zusammenfassungen ersetzt werden.

Einen tieferen Einblick, warum lange Kontexte an Qualität verlieren und wie Compaction hilft, findest du unter Effective context engineering.

Dies ist ideal für:

Chat-basierte Konversationen mit mehreren Turns, bei denen Nutzer einen Chat über einen langen Zeitraum verwenden sollen
Aufgabenorientierte Prompts, die viel Folgearbeit erfordern (oft Tool-Nutzung) und das Kontextfenster überschreiten könnten

Compaction befindet sich in der Beta-Phase. Füge den Beta-Header compact-2026-01-12 in deine API-Anfragen ein, um dieses Feature zu nutzen.

Unterstützte Modelle

Compaction wird von den folgenden Modellen unterstützt:

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 4.6 (claude-sonnet-4-6)

So funktioniert Compaction

Wenn Compaction aktiviert ist, fasst Claude deine Konversation automatisch zusammen, sobald sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:

Erkennt, wenn die Input-Token deinen angegebenen Trigger-Schwellenwert überschreiten.
Generiert eine Zusammenfassung der aktuellen Konversation.
Erstellt einen compaction-Block, der die Zusammenfassung enthält.
Setzt die Antwort mit dem verdichteten Kontext fort.

Bei nachfolgenden Anfragen hängst du die Antwort an deine Nachrichten an. Die API verwirft automatisch alle Nachrichtenblöcke vor dem compaction-Block und setzt die Konversation ab der Zusammenfassung fort.

Flussdiagramm, das den Compaction-Prozess zeigt: Wenn die Input-Token den Trigger-Schwellenwert überschreiten, generiert Claude eine Zusammenfassung in einem Compaction-Block und setzt die Antwort mit dem verdichteten Kontext fort

Grundlegende Verwendung

Aktiviere Compaction, indem du die Strategie compact_20260112 zu context_management.edits in deiner Messages-API-Anfrage hinzufügst.

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

# Hänge die Antwort (einschließlich eines etwaigen Kompaktierungsblocks) an, um die Konversation fortzusetzen
messages.append({"role": "assistant", "content": response.content})

Parameter

Parameter	Typ	Standard	Beschreibung
`type`	string	Erforderlich	Muss `"compact_20260112"` sein
`trigger`	object	150.000 Token	Wann Compaction ausgelöst werden soll. Muss mindestens 50.000 Token betragen.
`pause_after_compaction`	boolean	`false`	Ob nach dem Generieren der Compaction-Zusammenfassung pausiert werden soll
`instructions`	string	`null`	Benutzerdefinierter Zusammenfassungs-Prompt. Ersetzt den Standard-Prompt vollständig, wenn angegeben.

Trigger-Konfiguration

Konfiguriere mit dem Parameter trigger, wann Compaction ausgelöst wird:

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

Benutzerdefinierte Zusammenfassungsanweisungen

Standardmäßig verwendet Compaction den folgenden Zusammenfassungs-Prompt:

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.

Du kannst über den Parameter instructions benutzerdefinierte Anweisungen angeben, um diesen Prompt vollständig zu ersetzen. Benutzerdefinierte Anweisungen ergänzen den Standard nicht; sie ersetzen ihn vollständig:

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

Pausieren nach Compaction

Verwende pause_after_compaction, um die API nach dem Generieren der Compaction-Zusammenfassung zu pausieren. Dadurch kannst du zusätzliche Content-Blöcke hinzufügen (etwa um aktuelle Nachrichten oder bestimmte anweisungsorientierte Nachrichten zu erhalten), bevor die API mit der Antwort fortfährt.

Wenn aktiviert, gibt die API nach dem Generieren des Compaction-Blocks eine Nachricht mit dem stop_reason compaction zurück:

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

# Prüfe, ob die Kompaktierung eine Pause ausgelöst hat
if response.stop_reason == "compaction":
    # Die Antwort enthält nur den Kompaktierungsblock
    messages.append({"role": "assistant", "content": response.content})

    # Setze die Anfrage fort
    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"}]},
    )

Durchsetzen eines Gesamt-Token-Budgets

Wenn ein Modell an langen Aufgaben mit vielen Tool-Nutzungs-Iterationen arbeitet, kann der gesamte Token-Verbrauch erheblich ansteigen. Du kannst pause_after_compaction mit einem Compaction-Zähler kombinieren, um den kumulativen Verbrauch abzuschätzen und die Aufgabe sauber abzuschließen, sobald ein Budget erreicht ist:

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

    # Schätze die insgesamt verbrauchten Token; fordere zum Abschluss auf, wenn Budget überschritten
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append(
            {
                "role": "user",
                "content": "Please wrap up your current work and summarize the final state.",
            }
        )

Arbeiten mit Compaction-Blöcken

Wenn Compaction ausgelöst wird, gibt die API einen compaction-Block am Anfang der Assistant-Antwort zurück.

Eine lang laufende Konversation kann zu mehreren Compactions führen. Der letzte Compaction-Block spiegelt den finalen Zustand des Prompts wider und ersetzt den Inhalt davor durch die generierte Zusammenfassung.

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-Blöcke zurückgeben

Du musst den compaction-Block bei nachfolgenden Anfragen an die API zurückgeben, um die Konversation mit dem gekürzten Prompt fortzusetzen. Der einfachste Ansatz ist, den gesamten Antwortinhalt an deine Nachrichten anzuhängen:

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"}]},
)
# Nach Erhalt einer Antwort mit einem Compaction-Block
messages.append({"role": "assistant", "content": response.content})

# Setze die Konversation fort
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"}]},
)

Wenn die API einen compaction-Block empfängt, werden alle Content-Blöcke davor ignoriert. Du kannst entweder:

Die ursprünglichen Nachrichten in deiner Liste belassen und die API das Entfernen des verdichteten Inhalts übernehmen lassen
Die verdichteten Nachrichten manuell verwerfen und nur den Compaction-Block und alles danach einschließen

Streaming

Beim Streaming von Antworten mit aktivierter Compaction erhältst du ein content_block_start-Event, wenn die Compaction beginnt. Der Compaction-Block wird anders gestreamt als Textblöcke. Du erhältst ein content_block_start-Event, gefolgt von einem einzelnen content_block_delta mit dem vollständigen Zusammenfassungsinhalt (kein zwischenzeitliches Streaming) und dann ein content_block_stop-Event.

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)

    # Hole die finale akkumulierte Nachricht
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Prompt-Caching

Compaction funktioniert gut mit Prompt-Caching. Du kannst einen cache_control-Breakpoint auf Compaction-Blöcken hinzufügen, um den zusammengefassten Inhalt zu cachen. Der ursprüngliche verdichtete Inhalt wird ignoriert.

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

Cache-Treffer mit System-Prompts maximieren

Wenn Compaction stattfindet, wird die Zusammenfassung zu neuem Inhalt, der in den Cache geschrieben werden muss. Ohne zusätzliche Cache-Breakpoints würde dies auch jeden gecachten System-Prompt invalidieren, sodass dieser zusammen mit der Compaction-Zusammenfassung neu gecacht werden müsste.

Um die Cache-Trefferquote zu maximieren, füge einen cache_control-Breakpoint am Ende deines System-Prompts hinzu. Dadurch bleibt der System-Prompt getrennt von der Konversation gecacht, sodass bei einer Compaction:

Der System-Prompt-Cache gültig bleibt und aus dem Cache gelesen wird
Nur die Compaction-Zusammenfassung als neuer Cache-Eintrag geschrieben werden muss

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

Dieser Ansatz ist besonders vorteilhaft für lange System-Prompts, da sie auch über mehrere Compaction-Ereignisse hinweg während einer Konversation gecacht bleiben.

Usage verstehen

Compaction erfordert einen zusätzlichen Sampling-Schritt, der zu Ratenlimits und Abrechnung beiträgt. Die API gibt detaillierte Usage-Informationen in der Antwort zurück:

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

Das iterations-Array zeigt die Usage für jede Sampling-Iteration. Wenn Compaction stattfindet, siehst du eine compaction-Iteration gefolgt von der Haupt-message-Iteration. Die input_tokens und output_tokens auf oberster Ebene stimmen in diesem Beispiel exakt mit der message-Iteration überein, da es nur eine Nicht-Compaction-Iteration gibt. Die Token-Zahlen der letzten Iteration spiegeln die effektive Kontextgröße nach der Compaction wider.

Die input_tokens und output_tokens auf oberster Ebene enthalten nicht die Usage der Compaction-Iteration. Sie spiegeln die Summe aller Nicht-Compaction-Iterationen wider. Um die insgesamt verbrauchten und abgerechneten Token für eine Anfrage zu berechnen, summiere über alle Einträge im usage.iterations-Array.

Wenn du dich bisher für Kostenverfolgung oder Auditing auf usage.input_tokens und usage.output_tokens verlassen hast, musst du deine Tracking-Logik aktualisieren, um über usage.iterations zu aggregieren, wenn Compaction aktiviert ist. Das iterations-Array wird nur befüllt, wenn während der Anfrage eine neue Compaction ausgelöst wird. Das erneute Anwenden eines vorherigen compaction-Blocks verursacht keine zusätzlichen Compaction-Kosten, und die Usage-Felder auf oberster Ebene bleiben in diesem Fall korrekt.

Kombination mit anderen Features

Server-Tools

Bei der Verwendung von Server-Tools (wie Websuche) wird der Compaction-Trigger zu Beginn jeder Sampling-Iteration geprüft. Compaction kann innerhalb einer einzelnen Anfrage mehrfach auftreten, abhängig von deinem Trigger-Schwellenwert und der Menge der generierten Ausgabe.

Token-Zählung

Der Token-Zählungs-Endpunkt (/v1/messages/count_tokens) wendet vorhandene compaction-Blöcke in deinem Prompt an, löst aber keine neuen Compactions aus. Verwende ihn, um deine effektive Token-Anzahl nach vorherigen Compactions zu prüfen:

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}")

Beispiele

Hier ist ein vollständiges Beispiel einer lang laufenden Konversation mit 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},
                }
            ]
        },
    )

    # Antwort anhängen (Kompaktierungsblöcke werden automatisch eingeschlossen)
    messages.append({"role": "assistant", "content": response.content})

    # Gib den Textinhalt zurück
    return next(block.text for block in response.content if block.type == "text")


# Führe eine lange Konversation aus
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"))
# ... fahre so lange fort wie nötig

Hier ist ein Beispiel, das pause_after_compaction verwendet, um den vorherigen Austausch und die aktuelle Nutzernachricht (insgesamt drei Nachrichten) wörtlich zu erhalten, anstatt sie zusammenzufassen:

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

    # Prüfe, ob eine Komprimierung stattgefunden hat und pausiert wurde
    if response.stop_reason == "compaction":
        # Hole den Komprimierungsblock aus der Antwort
        compaction_block = response.content[0]

        # Bewahre den vorherigen Austausch + aktuelle Benutzernachricht (3 Nachrichten),
        # indem du sie nach dem Komprimierungsblock einfügst
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

        # Erstelle neue Nachrichtenliste: Komprimierung + bewahrte Nachrichten
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Setze die Anfrage mit dem komprimierten Kontext + bewahrten Nachrichten fort
        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"}]},
        )

        # Aktualisiere unsere Nachrichtenliste, um die Komprimierung widerzuspiegeln
        messages.clear()
        messages.extend(messages_after_compaction)

    # Hänge die finale Antwort an
    messages.append({"role": "assistant", "content": response.content})

    # Gib den Textinhalt zurück
    return next(block.text for block in response.content if block.type == "text")


# Führe eine lange Konversation aus
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"))
# ... fahre so lange fort wie nötig

Aktuelle Einschränkungen

Gleiches Modell für die Zusammenfassung: Das in deiner Anfrage angegebene Modell wird für die Zusammenfassung verwendet. Es gibt keine Option, ein anderes (zum Beispiel günstigeres) Modell für die Zusammenfassung zu verwenden.
Compaction kann fehlschlagen, wenn Tools definiert sind: Wenn deine Anfrage tools enthält, ruft das Modell gelegentlich während des internen Zusammenfassungsschritts ein Tool auf, anstatt eine Zusammenfassung zu schreiben. Wenn dies passiert, enthält die Antwort einen compaction-Block mit content: null. Um dies zu verhindern, setze instructions auf einen Prompt, der dem Modell explizit sagt, keine Tools aufzurufen, zum Beispiel:
```
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.
```

Nächste Schritte

Session-Memory-Compaction-Cookbook

Erkunde eine praktische Implementierung, die lang laufende Konversationen mit sofortiger Session-Memory-Compaction unter Verwendung von Background-Threading und Prompt-Caching verwaltet.

Kontextfenster

Erfahre mehr über Kontextfenstergrößen und Verwaltungsstrategien.

Context Editing

Erkunde weitere Strategien zur Verwaltung des Konversationskontexts wie das Löschen von Tool-Ergebnissen und Thinking-Blöcken.

Was this page helpful?

NachrichtenKontextverwaltung

Compaction

Serverseitige Kontext-Compaction zur Verwaltung langer Konversationen, die sich den Grenzen des Kontextfensters nähern.

Einen tieferen Einblick, warum lange Kontexte an Qualität verlieren und wie Compaction hilft, findest du unter Effective context engineering.

Dies ist ideal für:

Chat-basierte Konversationen mit mehreren Turns, bei denen Nutzer einen Chat über einen langen Zeitraum verwenden sollen
Aufgabenorientierte Prompts, die viel Folgearbeit erfordern (oft Tool-Nutzung) und das Kontextfenster überschreiten könnten

Compaction befindet sich in der Beta-Phase. Füge den Beta-Header compact-2026-01-12 in deine API-Anfragen ein, um dieses Feature zu nutzen.

Unterstützte Modelle

Compaction wird von den folgenden Modellen unterstützt:

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 4.6 (claude-sonnet-4-6)

So funktioniert Compaction

Wenn Compaction aktiviert ist, fasst Claude deine Konversation automatisch zusammen, sobald sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:

Erkennt, wenn die Input-Token deinen angegebenen Trigger-Schwellenwert überschreiten.
Generiert eine Zusammenfassung der aktuellen Konversation.
Erstellt einen compaction-Block, der die Zusammenfassung enthält.
Setzt die Antwort mit dem verdichteten Kontext fort.

Grundlegende Verwendung

Aktiviere Compaction, indem du die Strategie compact_20260112 zu context_management.edits in deiner Messages-API-Anfrage hinzufügst.

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

# Hänge die Antwort (einschließlich eines etwaigen Kompaktierungsblocks) an, um die Konversation fortzusetzen
messages.append({"role": "assistant", "content": response.content})

Parameter

Parameter	Typ	Standard	Beschreibung
`type`	string	Erforderlich	Muss `"compact_20260112"` sein
`trigger`	object	150.000 Token	Wann Compaction ausgelöst werden soll. Muss mindestens 50.000 Token betragen.
`pause_after_compaction`	boolean	`false`	Ob nach dem Generieren der Compaction-Zusammenfassung pausiert werden soll
`instructions`	string	`null`	Benutzerdefinierter Zusammenfassungs-Prompt. Ersetzt den Standard-Prompt vollständig, wenn angegeben.

Trigger-Konfiguration

Konfiguriere mit dem Parameter trigger, wann Compaction ausgelöst wird:

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

Benutzerdefinierte Zusammenfassungsanweisungen

Standardmäßig verwendet Compaction den folgenden Zusammenfassungs-Prompt:

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.

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

Pausieren nach Compaction

Wenn aktiviert, gibt die API nach dem Generieren des Compaction-Blocks eine Nachricht mit dem stop_reason compaction zurück:

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

# Prüfe, ob die Kompaktierung eine Pause ausgelöst hat
if response.stop_reason == "compaction":
    # Die Antwort enthält nur den Kompaktierungsblock
    messages.append({"role": "assistant", "content": response.content})

    # Setze die Anfrage fort
    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"}]},
    )

Durchsetzen eines Gesamt-Token-Budgets

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

    # Schätze die insgesamt verbrauchten Token; fordere zum Abschluss auf, wenn Budget überschritten
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append(
            {
                "role": "user",
                "content": "Please wrap up your current work and summarize the final state.",
            }
        )

Arbeiten mit Compaction-Blöcken

Wenn Compaction ausgelöst wird, gibt die API einen compaction-Block am Anfang der Assistant-Antwort zurück.

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-Blöcke zurückgeben

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"}]},
)
# Nach Erhalt einer Antwort mit einem Compaction-Block
messages.append({"role": "assistant", "content": response.content})

# Setze die Konversation fort
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"}]},
)

Wenn die API einen compaction-Block empfängt, werden alle Content-Blöcke davor ignoriert. Du kannst entweder:

Die ursprünglichen Nachrichten in deiner Liste belassen und die API das Entfernen des verdichteten Inhalts übernehmen lassen
Die verdichteten Nachrichten manuell verwerfen und nur den Compaction-Block und alles danach einschließen

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)

    # Hole die finale akkumulierte Nachricht
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Prompt-Caching

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

Cache-Treffer mit System-Prompts maximieren

Der System-Prompt-Cache gültig bleibt und aus dem Cache gelesen wird
Nur die Compaction-Zusammenfassung als neuer Cache-Eintrag geschrieben werden muss

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

Dieser Ansatz ist besonders vorteilhaft für lange System-Prompts, da sie auch über mehrere Compaction-Ereignisse hinweg während einer Konversation gecacht bleiben.

Usage verstehen

Compaction erfordert einen zusätzlichen Sampling-Schritt, der zu Ratenlimits und Abrechnung beiträgt. Die API gibt detaillierte Usage-Informationen in der Antwort zurück:

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

Kombination mit anderen Features

Server-Tools

Token-Zählung

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}")

Beispiele

Hier ist ein vollständiges Beispiel einer lang laufenden Konversation mit 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},
                }
            ]
        },
    )

    # Antwort anhängen (Kompaktierungsblöcke werden automatisch eingeschlossen)
    messages.append({"role": "assistant", "content": response.content})

    # Gib den Textinhalt zurück
    return next(block.text for block in response.content if block.type == "text")


# Führe eine lange Konversation aus
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"))
# ... fahre so lange fort wie nötig

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

    # Prüfe, ob eine Komprimierung stattgefunden hat und pausiert wurde
    if response.stop_reason == "compaction":
        # Hole den Komprimierungsblock aus der Antwort
        compaction_block = response.content[0]

        # Bewahre den vorherigen Austausch + aktuelle Benutzernachricht (3 Nachrichten),
        # indem du sie nach dem Komprimierungsblock einfügst
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

        # Erstelle neue Nachrichtenliste: Komprimierung + bewahrte Nachrichten
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Setze die Anfrage mit dem komprimierten Kontext + bewahrten Nachrichten fort
        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"}]},
        )

        # Aktualisiere unsere Nachrichtenliste, um die Komprimierung widerzuspiegeln
        messages.clear()
        messages.extend(messages_after_compaction)

    # Hänge die finale Antwort an
    messages.append({"role": "assistant", "content": response.content})

    # Gib den Textinhalt zurück
    return next(block.text for block in response.content if block.type == "text")


# Führe eine lange Konversation aus
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"))
# ... fahre so lange fort wie nötig

Aktuelle Einschränkungen

Gleiches Modell für die Zusammenfassung: Das in deiner Anfrage angegebene Modell wird für die Zusammenfassung verwendet. Es gibt keine Option, ein anderes (zum Beispiel günstigeres) Modell für die Zusammenfassung zu verwenden.
Compaction kann fehlschlagen, wenn Tools definiert sind: Wenn deine Anfrage tools enthält, ruft das Modell gelegentlich während des internen Zusammenfassungsschritts ein Tool auf, anstatt eine Zusammenfassung zu schreiben. Wenn dies passiert, enthält die Antwort einen compaction-Block mit content: null. Um dies zu verhindern, setze instructions auf einen Prompt, der dem Modell explizit sagt, keine Tools aufzurufen, zum Beispiel:
```
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.
```

Nächste Schritte

Session-Memory-Compaction-Cookbook

Erkunde eine praktische Implementierung, die lang laufende Konversationen mit sofortiger Session-Memory-Compaction unter Verwendung von Background-Threading und Prompt-Caching verwaltet.

Kontextfenster

Erfahre mehr über Kontextfenstergrößen und Verwaltungsstrategien.

Context Editing

Erkunde weitere Strategien zur Verwaltung des Konversationskontexts wie das Löschen von Tool-Ergebnissen und Thinking-Blöcken.

Was this page helpful?

Unterstützte Modelle

So funktioniert Compaction

Grundlegende Verwendung

Parameter

Trigger-Konfiguration

Benutzerdefinierte Zusammenfassungsanweisungen

Pausieren nach Compaction

Durchsetzen eines Gesamt-Token-Budgets

Arbeiten mit Compaction-Blöcken

Compaction-Blöcke zurückgeben

Streaming

Prompt-Caching

Cache-Treffer mit System-Prompts maximieren

Usage verstehen

Kombination mit anderen Features

Server-Tools

Token-Zählung

Beispiele

Aktuelle Einschränkungen

Nächste Schritte

Unterstützte Modelle

So funktioniert Compaction

Grundlegende Verwendung

Parameter

Trigger-Konfiguration

Benutzerdefinierte Zusammenfassungsanweisungen

Pausieren nach Compaction

Durchsetzen eines Gesamt-Token-Budgets

Arbeiten mit Compaction-Blöcken

Compaction-Blöcke zurückgeben

Streaming

Prompt-Caching

Cache-Treffer mit System-Prompts maximieren

Usage verstehen

Kombination mit anderen Features

Server-Tools

Token-Zählung

Beispiele

Aktuelle Einschränkungen

Nächste Schritte

Unterstützte Modelle

So funktioniert Compaction

Grundlegende Verwendung

Parameter

Trigger-Konfiguration

Benutzerdefinierte Zusammenfassungsanweisungen

Pausieren nach Compaction

Durchsetzen eines Gesamt-Token-Budgets

Arbeiten mit Compaction-Blöcken

Compaction-Blöcke zurückgeben

Streaming

Prompt-Caching

Cache-Treffer mit System-Prompts maximieren

Usage verstehen

Kombination mit anderen Features

Server-Tools

Token-Zählung

Beispiele

Aktuelle Einschränkungen

Nächste Schritte

Unterstützte Modelle

So funktioniert Compaction

Grundlegende Verwendung

Parameter

Trigger-Konfiguration

Benutzerdefinierte Zusammenfassungsanweisungen

Pausieren nach Compaction

Durchsetzen eines Gesamt-Token-Budgets

Arbeiten mit Compaction-Blöcken

Compaction-Blöcke zurückgeben

Streaming

Prompt-Caching

Cache-Treffer mit System-Prompts maximieren

Usage verstehen

Kombination mit anderen Features

Server-Tools

Token-Zählung

Beispiele

Aktuelle Einschränkungen

Nächste Schritte