Compactación que conserva los turnos recientes

La "keep-tail compaction" (compactación que conserva la cola) mantiene los últimos turnos de una conversación palabra por palabra después del resumen. Cambia dos cosas en el bucle de compactación: qué mensajes van en la solicitud de compactación y qué envías después del bloque. Todo lo que se indica en Continuar a partir del resumen se aplica sin cambios.

Elige qué turnos conservar

Ningún parámetro define qué turnos se conservan. Tú eliges un "cut point" (punto de corte) en tu historial: los mensajes anteriores a él van en la solicitud de compactación, y los mensajes a partir de él se conservan.

Los turnos conservados vuelven a Claude con su longitud completa, así que cuanto más conserves, menos espacio libera la compactación.

Coloca el corte donde no quede ninguna llamada a herramienta abierta, con cada llamada a herramienta y su resultado del mismo lado. Si los mensajes que envías terminan en un turno assistant cuya llamada a herramienta aún no tiene resultado, la API rechaza la solicitud de compactación.

Compacta los turnos más antiguos y envía el resto después del bloque

Para conservar una cola de turnos recientes palabra por palabra, deja esos turnos fuera de la solicitud de compactación. La API resume todos los mensajes que recibe, así que envía solo los turnos más antiguos y luego coloca el bloque delante de los turnos que conservaste.

Envía los turnos conservados exactamente como están en tu historial, incluidos los bloques de pensamiento. Ambas solicitudes llevan el encabezado beta, como en Solicitar un resumen.

En el siguiente ejemplo, el historial contiene dos turnos y el corte conserva el segundo. La solicitud de compactación lleva el primer turno:

{
  "model": "claude-opus-5-5",
  "max_tokens": 4096,
  "messages": [
    {
      "role": "user",
      "content": "I am building a recipe app. Help me name the main entities in the data model."
    },
    {
      "role": "assistant",
      "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
    }
  ],
  "compaction": { "type": "summarize" }
}

La siguiente solicitud envía primero el bloque devuelto, luego el turno conservado exactamente como estaba y después el nuevo mensaje user. Continuar a partir del resumen muestra una solicitud que comienza con un bloque.

El siguiente programa es el bucle de Compactar en un bucle, modificado para conservar los dos últimos turnos. Las líneas resaltadas muestran en qué se diferencia del bucle.

from anthropic.types.beta import BetaMessageParam

client = anthropic.Anthropic()

# Ajusta esto cerca de tu presupuesto real de entrada. Aquí es bajo para que una conversación corta se compacte.
COMPACT_AT_TOKENS = 2500
SYSTEM = "You help design a recipe app's data model. Keep answers short."
KEEP_TURNS = 2

QUESTIONS = [
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?",
]

history: list[BetaMessageParam] = []
for turn, question in enumerate(QUESTIONS, start=1):
    history.append({"role": "user", "content": question})
    response = client.beta.messages.create(
        model="claude-opus-5-5",
        max_tokens=8192,
        system=SYSTEM,
        betas=["compact-2026-09-04"],
        messages=history,
    )
    history.append({"role": "assistant", "content": response.content})

    # La siguiente solicitud también envía esta respuesta, así que cuéntala.
    conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
    if conversation_tokens > COMPACT_AT_TOKENS and KEEP_TURNS < turn < len(QUESTIONS):
        # Un turno es un mensaje del usuario y una respuesta del asistente,
        # así que los turnos conservados empiezan con un mensaje del usuario.
        split = -2 * KEEP_TURNS
        older, recent = history[:split], history[split:]
        summary = client.beta.messages.create(
            model="claude-opus-5-5",
            max_tokens=4096,
            system=SYSTEM,
            betas=["compact-2026-09-04"],
            messages=older,
            compaction={"type": "summarize"},
        )
        if summary.stop_reason == "compaction":
            history = [{"role": "assistant", "content": summary.content}, *recent]
            print(f"Kept {len(recent) // 2} turns after the block")

• Elegir el corte: El programa conserva los dos últimos turnos, donde un turno es un mensaje user y la respuesta a él. Divide el historial a cuatro mensajes del final, de modo que los turnos conservados comienzan con un mensaje user.
• Decidir cuándo compactar: La comprobación de tamaño también exige que la conversación tenga más turnos de los que conserva el programa, para que la parte más antigua nunca esté vacía.
• La solicitud de compactación: Donde el bucle envía todo el historial, esta versión envía solo los mensajes más antiguos.
• El intercambio: Donde el bucle reemplaza todo el historial con el mensaje devuelto, el nuevo historial de esta versión es el mensaje devuelto seguido de los turnos conservados.

La comprobación de stop_reason y todas las solicitudes posteriores al intercambio no cambian respecto al bucle.

Mantén válido el pensamiento en los turnos conservados

Si devuelves bloques de pensamiento en un modelo con pensamiento preservado, el pensamiento de los turnos conservados sigue siendo válido solo mientras se cumplan las condiciones para el pensamiento conservado, y una de ellas limita dónde puede caer el corte.

El corte del programa, entre una respuesta y el siguiente mensaje user, cumple esa condición. También la cumple un corte al final de una solicitud que ya hiciste: compacta exactamente los messages de esa solicitud y conserva todo lo que tu historial haya acumulado desde entonces.

Compatibility