Gestion du contexte

Compaction

Compaction de contexte côté serveur pour gérer les longues conversations qui approchent les limites de la fenêtre de contexte.

La compaction côté serveur est la stratégie recommandée pour gérer le contexte dans les conversations longues et les flux de travail d'agent. Elle gère automatiquement la gestion du contexte avec un travail d'intégration minimal.

La compaction étend la longueur effective du contexte pour les conversations et tâches longues en résumant automatiquement le contexte plus ancien lorsque vous approchez de la limite de la fenêtre de contexte. C'est idéal pour :

Les conversations multi-tours basées sur le chat où vous voulez que les utilisateurs utilisent un chat pendant une longue période
Les invites orientées vers les tâches qui nécessitent beaucoup de travail de suivi (souvent l'utilisation d'outils) qui peuvent dépasser la fenêtre de contexte de 200K

La compaction est actuellement en version bêta. Incluez l'en-tête bêta compact-2026-01-12 dans vos demandes d'API pour utiliser cette fonctionnalité.

Modèles supportés

La compaction est supportée sur les modèles suivants :

Claude Opus 4.6 (claude-opus-4-6)

Comment fonctionne la compaction

Lorsque la compaction est activée, Claude résume automatiquement votre conversation lorsqu'elle approche du seuil de jetons configuré. L'API :

Détecte quand les jetons d'entrée dépassent votre seuil de déclenchement spécifié.
Génère un résumé de la conversation actuelle.
Crée un bloc compaction contenant le résumé.
Continue la réponse avec le contexte compacté.

Sur les demandes suivantes, ajoutez la réponse à vos messages. L'API supprime automatiquement tous les blocs de messages avant le bloc compaction, continuant la conversation à partir du résumé.

Utilisation de base

Activez la compaction en ajoutant la stratégie compact_20260112 à context_management.edits dans votre demande Messages API.

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "anthropic-beta: compact-2026-01-12" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-opus-4-6",
    "max_tokens": 4096,
    "messages": [
        {
            "role": "user",
            "content": "Help me build a website"
        }
    ],
    "context_management": {
        "edits": [
            {
                "type": "compact_20260112"
            }
        ]
    }
}'

Paramètres

Paramètre	Type	Par défaut	Description
`type`	string	Requis	Doit être `"compact_20260112"`
`trigger`	object	150 000 jetons	Quand déclencher la compaction. Doit être au moins 50 000 jetons.
`pause_after_compaction`	boolean	`false`	S'il faut faire une pause après la génération du résumé de compaction
`instructions`	string	`null`	Invite de résumé personnalisée. Remplace complètement l'invite par défaut lorsqu'elle est fournie.

Configuration du déclenchement

Configurez quand la compaction se déclenche en utilisant le paramètre trigger :

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

Instructions de résumé personnalisées

Par défaut, la compaction utilise l'invite de résumé suivante :

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.

Vous pouvez fournir des instructions personnalisées via le paramètre instructions pour remplacer complètement cette invite. Les instructions personnalisées ne complètent pas la valeur par défaut ; elles la remplacent complètement :

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

Pause après compaction

Utilisez pause_after_compaction pour mettre en pause l'API après la génération du résumé de compaction. Cela vous permet d'ajouter des blocs de contenu supplémentaires (comme la préservation des messages récents ou des messages spécifiques orientés vers les instructions) avant que l'API ne continue avec la réponse.

Lorsqu'elle est activée, l'API retourne un message avec la raison d'arrêt compaction après la génération du bloc de compaction :

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

# Check if compaction triggered a pause
if response.stop_reason == "compaction":
    # Response contains only the compaction block
    messages.append({"role": "assistant", "content": response.content})

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

Application d'un budget de jetons total

Lorsqu'un modèle travaille sur des tâches longues avec de nombreuses itérations d'utilisation d'outils, la consommation totale de jetons peut augmenter considérablement. Vous pouvez combiner pause_after_compaction avec un compteur de compaction pour estimer l'utilisation cumulative et terminer gracieusement la tâche une fois qu'un budget est atteint :

Python

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

    # Estimate total tokens consumed; prompt wrap-up if over budget
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append({
            "role": "user",
            "content": "Please wrap up your current work and summarize the final state.",
        })

Travailler avec les blocs de compaction

Lorsque la compaction est déclenchée, l'API retourne un bloc compaction au début de la réponse de l'assistant.

Une conversation longue peut résulter en plusieurs compactions. Le dernier bloc de compaction reflète l'état final de l'invite, remplaçant le contenu antérieur par le résumé généré.

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

Retourner les blocs de compaction

Vous devez retourner le bloc compaction à l'API sur les demandes suivantes pour continuer la conversation avec l'invite raccourcie. L'approche la plus simple est d'ajouter tout le contenu de la réponse à vos messages :

# After receiving a response with a compaction block
messages.append({"role": "assistant", "content": response.content})

# Continue the conversation
messages.append({"role": "user", "content": "Now add error handling"})

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

Lorsque l'API reçoit un bloc compaction, tous les blocs de contenu avant celui-ci sont ignorés. Vous pouvez soit :

Conserver les messages originaux dans votre liste et laisser l'API gérer la suppression du contenu compacté
Supprimer manuellement les messages compactés et inclure uniquement le bloc de compaction en avant

Streaming

Lors du streaming des réponses avec la compaction activée, vous recevrez un événement content_block_start lorsque la compaction commence. Le bloc de compaction se diffuse différemment des blocs de texte. Vous recevrez un événement content_block_start, suivi d'un seul content_block_delta avec le contenu du résumé complet (pas de streaming intermédiaire), puis un événement content_block_stop.

import anthropic

client = anthropic.Anthropic()

with client.beta.messages.stream(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-6",
    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)} chars")
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

    # Get the final accumulated message
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Mise en cache des invites

Vous pouvez ajouter un point d'arrêt cache_control sur les blocs de compaction, qui met en cache l'invite système complète ainsi que le contenu résumé. Le contenu compacté original est ignoré.

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

Comprendre l'utilisation

La compaction nécessite une étape d'échantillonnage supplémentaire, qui contribue aux limites de débit et à la facturation. L'API retourne des informations d'utilisation détaillées dans la réponse :

{
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 1234,
    "iterations": [
      {
        "type": "compaction",
        "input_tokens": 180000,
        "output_tokens": 3500
      },
      {
        "type": "message",
        "input_tokens": 23000,
        "output_tokens": 1000
      }
    ]
  }
}

Le tableau iterations affiche l'utilisation pour chaque itération d'échantillonnage. Lorsque la compaction se produit, vous verrez une itération compaction suivie de l'itération message principale. Les comptages de jetons de l'itération finale reflètent la taille effective du contexte après compaction.

Les input_tokens et output_tokens de niveau supérieur n'incluent pas l'utilisation de l'itération de compaction—ils reflètent la somme de toutes les itérations non-compaction. Pour calculer le total des jetons consommés et facturés pour une demande, additionnez tous les éléments du tableau usage.iterations.

Si vous aviez précédemment compté sur usage.input_tokens et usage.output_tokens pour le suivi des coûts ou l'audit, vous devrez mettre à jour votre logique de suivi pour agréger les usage.iterations lorsque la compaction est activée. Le tableau iterations n'est rempli que lorsqu'une nouvelle compaction est déclenchée pendant la demande. La réapplication d'un bloc compaction précédent n'entraîne aucun coût de compaction supplémentaire, et les champs d'utilisation de niveau supérieur restent précis dans ce cas.

Combinaison avec d'autres fonctionnalités

Outils serveur

Lors de l'utilisation d'outils serveur (comme la recherche web), le déclenchement de la compaction est vérifié au début de chaque itération d'échantillonnage. La compaction peut se produire plusieurs fois dans une seule demande selon votre seuil de déclenchement et la quantité de sortie générée.

Comptage des jetons

Le point de terminaison de comptage des jetons (/v1/messages/count_tokens) applique les blocs compaction existants dans votre invite mais ne déclenche pas de nouvelles compactions. Utilisez-le pour vérifier votre comptage de jetons effectif après les compactions précédentes :

count_response = client.beta.messages.count_tokens(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-6",
    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}")

Exemples

Voici un exemple complet d'une conversation longue avec compaction :

import anthropic

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

    # Append response (compaction blocks are automatically included)
    messages.append({"role": "assistant", "content": response.content})

    # Return the text content
    return next(
        block.text for block in response.content if block.type == "text"
    )

# Run a long conversation
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"))
# ... continue as long as needed

Voici un exemple qui utilise pause_after_compaction pour préserver les deux derniers messages (un tour utilisateur + un tour assistant) textuellement au lieu de les résumer :

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

    # Check if compaction occurred and paused
    if response.stop_reason == "compaction":
        # Get the compaction block from the response
        compaction_block = response.content[0]

        # Preserve the last 2 messages (1 user + 1 assistant turn)
        # by including them after the compaction block
        preserved_messages = messages[-2:] if len(messages) >= 2 else messages

        # Build new message list: compaction + preserved messages
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Continue the request with the compacted context + preserved messages
        response = client.beta.messages.create(
            betas=["compact-2026-01-12"],
            model="claude-opus-4-6",
            max_tokens=4096,
            messages=messages_after_compaction,
            context_management={
                "edits": [{"type": "compact_20260112"}]
            }
        )

        # Update our message list to reflect the compaction
        messages.clear()
        messages.extend(messages_after_compaction)

    # Append the final response
    messages.append({"role": "assistant", "content": response.content})

    # Return the text content
    return next(
        block.text for block in response.content if block.type == "text"
    )

# Run a long conversation
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"))
# ... continue as long as needed

Limitations actuelles

Même modèle pour la résumé : Le modèle spécifié dans votre demande est utilisé pour la résumé. Il n'y a pas d'option pour utiliser un modèle différent (par exemple, moins cher) pour le résumé.

Prochaines étapes

Livre de recettes de compaction

Explorez des exemples pratiques et des implémentations dans le livre de recettes.

Fenêtres de contexte

Découvrez les tailles de fenêtre de contexte et les stratégies de gestion.

Édition de contexte

Explorez d'autres stratégies pour gérer le contexte de conversation comme l'effacement des résultats d'outils et l'effacement des blocs de réflexion.

Was this page helpful?

Gestion du contexte

Compaction

Compaction de contexte côté serveur pour gérer les longues conversations qui approchent les limites de la fenêtre de contexte.

Les conversations multi-tours basées sur le chat où vous voulez que les utilisateurs utilisent un chat pendant une longue période
Les invites orientées vers les tâches qui nécessitent beaucoup de travail de suivi (souvent l'utilisation d'outils) qui peuvent dépasser la fenêtre de contexte de 200K

La compaction est actuellement en version bêta. Incluez l'en-tête bêta compact-2026-01-12 dans vos demandes d'API pour utiliser cette fonctionnalité.

Modèles supportés

La compaction est supportée sur les modèles suivants :

Claude Opus 4.6 (claude-opus-4-6)

Comment fonctionne la compaction

Lorsque la compaction est activée, Claude résume automatiquement votre conversation lorsqu'elle approche du seuil de jetons configuré. L'API :

Détecte quand les jetons d'entrée dépassent votre seuil de déclenchement spécifié.
Génère un résumé de la conversation actuelle.
Crée un bloc compaction contenant le résumé.
Continue la réponse avec le contexte compacté.

Utilisation de base

Activez la compaction en ajoutant la stratégie compact_20260112 à context_management.edits dans votre demande Messages API.

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "anthropic-beta: compact-2026-01-12" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-opus-4-6",
    "max_tokens": 4096,
    "messages": [
        {
            "role": "user",
            "content": "Help me build a website"
        }
    ],
    "context_management": {
        "edits": [
            {
                "type": "compact_20260112"
            }
        ]
    }
}'

Paramètres

Paramètre	Type	Par défaut	Description
`type`	string	Requis	Doit être `"compact_20260112"`
`trigger`	object	150 000 jetons	Quand déclencher la compaction. Doit être au moins 50 000 jetons.
`pause_after_compaction`	boolean	`false`	S'il faut faire une pause après la génération du résumé de compaction
`instructions`	string	`null`	Invite de résumé personnalisée. Remplace complètement l'invite par défaut lorsqu'elle est fournie.

Configuration du déclenchement

Configurez quand la compaction se déclenche en utilisant le paramètre trigger :

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

Instructions de résumé personnalisées

Par défaut, la compaction utilise l'invite de résumé suivante :

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.

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

Pause après compaction

Lorsqu'elle est activée, l'API retourne un message avec la raison d'arrêt compaction après la génération du bloc de compaction :

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

# Check if compaction triggered a pause
if response.stop_reason == "compaction":
    # Response contains only the compaction block
    messages.append({"role": "assistant", "content": response.content})

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

Application d'un budget de jetons total

Python

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

    # Estimate total tokens consumed; prompt wrap-up if over budget
    if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
        messages.append({
            "role": "user",
            "content": "Please wrap up your current work and summarize the final state.",
        })

Travailler avec les blocs de compaction

Lorsque la compaction est déclenchée, l'API retourne un bloc compaction au début de la réponse de l'assistant.

Une conversation longue peut résulter en plusieurs compactions. Le dernier bloc de compaction reflète l'état final de l'invite, remplaçant le contenu antérieur par le résumé généré.

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

Retourner les blocs de compaction

# After receiving a response with a compaction block
messages.append({"role": "assistant", "content": response.content})

# Continue the conversation
messages.append({"role": "user", "content": "Now add error handling"})

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

Lorsque l'API reçoit un bloc compaction, tous les blocs de contenu avant celui-ci sont ignorés. Vous pouvez soit :

Conserver les messages originaux dans votre liste et laisser l'API gérer la suppression du contenu compacté
Supprimer manuellement les messages compactés et inclure uniquement le bloc de compaction en avant

Streaming

import anthropic

client = anthropic.Anthropic()

with client.beta.messages.stream(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-6",
    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)} chars")
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

    # Get the final accumulated message
    message = stream.get_final_message()
    messages.append({"role": "assistant", "content": message.content})

Mise en cache des invites

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

Comprendre l'utilisation

{
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 1234,
    "iterations": [
      {
        "type": "compaction",
        "input_tokens": 180000,
        "output_tokens": 3500
      },
      {
        "type": "message",
        "input_tokens": 23000,
        "output_tokens": 1000
      }
    ]
  }
}

Combinaison avec d'autres fonctionnalités

Outils serveur

Comptage des jetons

count_response = client.beta.messages.count_tokens(
    betas=["compact-2026-01-12"],
    model="claude-opus-4-6",
    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}")

Exemples

Voici un exemple complet d'une conversation longue avec compaction :

import anthropic

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

    # Append response (compaction blocks are automatically included)
    messages.append({"role": "assistant", "content": response.content})

    # Return the text content
    return next(
        block.text for block in response.content if block.type == "text"
    )

# Run a long conversation
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"))
# ... continue as long as needed

Voici un exemple qui utilise pause_after_compaction pour préserver les deux derniers messages (un tour utilisateur + un tour assistant) textuellement au lieu de les résumer :

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

    # Check if compaction occurred and paused
    if response.stop_reason == "compaction":
        # Get the compaction block from the response
        compaction_block = response.content[0]

        # Preserve the last 2 messages (1 user + 1 assistant turn)
        # by including them after the compaction block
        preserved_messages = messages[-2:] if len(messages) >= 2 else messages

        # Build new message list: compaction + preserved messages
        new_assistant_content = [compaction_block]
        messages_after_compaction = [
            {"role": "assistant", "content": new_assistant_content}
        ] + preserved_messages

        # Continue the request with the compacted context + preserved messages
        response = client.beta.messages.create(
            betas=["compact-2026-01-12"],
            model="claude-opus-4-6",
            max_tokens=4096,
            messages=messages_after_compaction,
            context_management={
                "edits": [{"type": "compact_20260112"}]
            }
        )

        # Update our message list to reflect the compaction
        messages.clear()
        messages.extend(messages_after_compaction)

    # Append the final response
    messages.append({"role": "assistant", "content": response.content})

    # Return the text content
    return next(
        block.text for block in response.content if block.type == "text"
    )

# Run a long conversation
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"))
# ... continue as long as needed

Limitations actuelles

Même modèle pour la résumé : Le modèle spécifié dans votre demande est utilisé pour la résumé. Il n'y a pas d'option pour utiliser un modèle différent (par exemple, moins cher) pour le résumé.

Prochaines étapes

Livre de recettes de compaction

Explorez des exemples pratiques et des implémentations dans le livre de recettes.

Fenêtres de contexte

Découvrez les tailles de fenêtre de contexte et les stratégies de gestion.

Édition de contexte

Explorez d'autres stratégies pour gérer le contexte de conversation comme l'effacement des résultats d'outils et l'effacement des blocs de réflexion.

Was this page helpful?