MessagesKontextverwaltung

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, ohne clientseitigen Zusammenfassungscode.

„Compaction" (Verdichtung) erweitert die effektive Kontextlänge für lang laufende Konversationen und Aufgaben, indem älterer Kontext automatisch zusammengefasst wird, wenn sich die Grenze des Kontextfensters nähert. Sie hält außerdem den aktiven Kontext klein: Wenn eine Konversation wächst, nimmt die Antwortqualität ab, daher ersetzt Compaction ältere Inhalte durch eine prägnante Zusammenfassung.

Für einen tieferen Einblick, warum lange Kontexte an Qualität verlieren und wie Compaction hilft, siehe 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 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)

Wie Compaction funktioniert

Wenn Compaction aktiviert ist, fasst Claude deine Konversation automatisch zusammen, sobald sie den konfigurierten Token-Schwellenwert erreicht. Die API:

Erkennt, wenn die Input-Token deinen angegebenen Trigger-Schwellenwert erreichen.
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 Content-Blöcke vor dem compaction-Block und setzt die Konversation ab der Zusammenfassung fort.

Compaction-Ablauf: Wenn die Input-Token den Trigger erreichen, schreibt Claude eine Zusammenfassung in einen Compaction-Block und fährt 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	`{"type": "input_tokens", "value": 150000}`	Wann Compaction ausgelöst werden soll. `input_tokens` ist der einzige unterstützte Trigger-Typ. `value` 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

Der Standard-Zusammenfassungs-Prompt variiert je nach Modell. Jeder Standard-Prompt weist Claude an, eine Zusammenfassung innerhalb von <summary></summary>-Tags zu schreiben, die die Informationen enthält, die benötigt werden, um die Aufgabe in einem zukünftigen Kontextfenster fortzusetzen. Einige Modelle verwenden beispielsweise den folgenden 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 benutzerdefinierte Anweisungen über den Parameter instructions bereitstellen. Benutzerdefinierte Anweisungen ergänzen den Standard-Prompt 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. Dies ermöglicht es dir, zusätzliche Content-Blöcke hinzuzufü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":
    # Antwort enthält nur den Kompaktierungs-Block
    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 elegant abzuschließen, sobald ein Budget erreicht ist.

Dieses Beispiel erscheint nur in den SDK-Sprachen: Sein Wert liegt in der Budget-Tracking-Logik rund um die Anfrage. Die rohe Anfrage kombiniert den trigger aus Trigger-Konfiguration mit pause_after_compaction aus Pausieren nach 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})

    # Schätze die insgesamt verbrauchten Token; fordere zum Abschluss auf, wenn das Budget überschritten ist
    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 Kompaktierungsblock
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 behalten und die API das Entfernen des verdichteten Inhalts übernehmen lassen
Die verdichteten Nachrichten manuell verwerfen und nur den Compaction-Block und alles danach einbeziehen

Streaming

Der Compaction-Block wird anders gestreamt als Text-Blö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.

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

Dadurch bleiben lange System-Prompts über mehrere Compaction-Ereignisse hinweg während einer Konversation gecacht.

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 auftritt, 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-Zählungen 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. Mit aktivierter Compaction-Beta enthält jede Antwort usage.iterations, auch wenn keine Compaction stattgefunden hat. Ein compaction-Eintrag erscheint nur, 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 überprü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 überprü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"))
# Rufe chat() so lange auf, wie die Konversation es erfordert

Hier ist ein Beispiel, das pause_after_compaction verwendet, um den vorherigen Austausch und die aktuelle Benutzernachricht (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 Kompaktierung stattgefunden hat und pausiert wurde
    if response.stop_reason == "compaction":
        # Hole den Kompaktierungsblock aus der Antwort
        compaction_block = response.content[0]

        # Bewahre den vorherigen Austausch + aktuelle Benutzernachricht (3 Nachrichten)
        # indem sie nach dem Kompaktierungsblock eingefügt werden
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

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

        # Setze die Anfrage mit dem kompaktierten 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 Kompaktierung 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"))
# Rufe chat() so lange auf, wie die Konversation es erfordert

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 auftritt, 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

Context Editing

Verwalte den Konversationskontext automatisch, während er wächst, mit Context Editing.

Kontextfenster

Erfahre mehr über Kontextfenstergrößen und Verwaltungsstrategien.

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.

Was this page helpful?

MessagesKontextverwaltung

Compaction

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

Für einen tieferen Einblick, warum lange Kontexte an Qualität verlieren und wie Compaction hilft, siehe 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 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)

Wie Compaction funktioniert

Wenn Compaction aktiviert ist, fasst Claude deine Konversation automatisch zusammen, sobald sie den konfigurierten Token-Schwellenwert erreicht. Die API:

Erkennt, wenn die Input-Token deinen angegebenen Trigger-Schwellenwert erreichen.
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	`{"type": "input_tokens", "value": 150000}`	Wann Compaction ausgelöst werden soll. `input_tokens` ist der einzige unterstützte Trigger-Typ. `value` 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

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 benutzerdefinierte Anweisungen über den Parameter instructions bereitstellen. Benutzerdefinierte Anweisungen ergänzen den Standard-Prompt 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

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":
    # Antwort enthält nur den Kompaktierungs-Block
    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

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 das Budget überschritten ist
    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 Kompaktierungsblock
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 behalten und die API das Entfernen des verdichteten Inhalts übernehmen lassen
Die verdichteten Nachrichten manuell verwerfen und nur den Compaction-Block und alles danach einbeziehen

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

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

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

Dadurch bleiben lange System-Prompts über mehrere Compaction-Ereignisse hinweg während einer Konversation gecacht.

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"))
# Rufe chat() so lange auf, wie die Konversation es erfordert

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 Kompaktierung stattgefunden hat und pausiert wurde
    if response.stop_reason == "compaction":
        # Hole den Kompaktierungsblock aus der Antwort
        compaction_block = response.content[0]

        # Bewahre den vorherigen Austausch + aktuelle Benutzernachricht (3 Nachrichten)
        # indem sie nach dem Kompaktierungsblock eingefügt werden
        preserved_messages = messages[-3:] if len(messages) >= 3 else messages

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

        # Setze die Anfrage mit dem kompaktierten 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 Kompaktierung 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"))
# Rufe chat() so lange auf, wie die Konversation es erfordert

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 auftritt, 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

Context Editing

Verwalte den Konversationskontext automatisch, während er wächst, mit Context Editing.

Kontextfenster

Erfahre mehr über Kontextfenstergrößen und Verwaltungsstrategien.

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.

Was this page helpful?

Unterstützte Modelle

Wie Compaction funktioniert

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

Wie Compaction funktioniert

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

Wie Compaction funktioniert

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

Wie Compaction funktioniert

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