Ir al contenido principal
Español— Elegir un idioma
Menú

Compactación: comprimir conversaciones largas

Lección 11 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. El problema de las conversaciones largas
  2. Dos estrategias que debes conocer
  3. Verificar que la compactación merece la pena
  4. Puntos clave

El problema de las conversaciones largas

Cada mensaje añadido a una conversación incrementa el número de tokens enviados a la API. Una conversación de 50 turnos puede alcanzar fácilmente los 30 000 tokens de entrada, lo que dispara tanto la latencia como el coste. El problema es insidioso: el primer turno de un asistente de soporte cuesta unos pocos cientos de tokens, mientras que el trigésimo turno cuesta varios miles, aunque el usuario esté haciendo exactamente el mismo tipo de pregunta. Pagas cada vez más por un servicio idéntico y el usuario espera cada vez más la respuesta.

La compactación resuelve esto comprimiendo el historial sin perder información esencial. Consiste en resumir los intercambios antiguos para reducir el recuento de tokens manteniendo el contexto necesario. En lugar de enviar todo el historial, envías un resumen de los intercambios pasados más los mensajes recientes. El modelo sigue sabiendo que el nombre del cliente es Dupont, que tiene un pedido en disputa y que ya le ofreciste un reembolso, sin tener que releer los cuarenta mensajes que establecieron esos hechos.

El mecanismo

La siguiente función aplica esta lógica en su forma más simple: estima el volumen, no hace nada hasta que se supera el umbral y luego divide el historial en dos partes. Los mensajes antiguos van al resumen; los más recientes permanecen intactos.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Compacta el historial cuando supera el umbral."""

    # Estimar recuento de tokens (aproximación)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # No es necesario compactar

    # Dividir: mensajes antiguos vs recientes
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Resumir mensajes antiguos
    old_text = "\n".join(
        f"{m['role']}: {m['content']}" for m in old_messages
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            "Resume esta conversación de forma concisa. "
            "Mantén la información factual clave, las decisiones tomadas "
            "y el contexto necesario para entender lo que sigue.\n\n"
            f"{old_text}"
        ),
        max_output_tokens=500,
    )

    # Reconstruir historial compactado
    summary_message = {
        "role": "system",
        "content": f"Resumen de la conversación anterior:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Dos detalles merecen tu atención. El prompt de resumen solicita explícitamente las decisiones tomadas, porque un resumen que solo retiene temas hace que el modelo pierda la memoria de sus propios compromisos. Y max_output_tokens=500 limita el resumen: sin este límite, el resumen crecería en cada compactación y acabarías con el mismo problema que intentabas eliminar.

Dos estrategias que debes conocer

Ventana deslizante con resumen

La siguiente clase industrializa el principio. Mantiene un único resumen que reescribe en cada compactación integrando nuevos intercambios, mientras conserva una ventana de mensajes en bruto. El contexto enviado a la API consta siempre de tres bloques: el prompt del sistema, el resumen acumulativo y la ventana reciente.

class CompactedConversation:
    """Gestiona una conversación con compactación automática."""

    def __init__(
        self,
        system_prompt: str,
        compaction_threshold: int = 8_000,
        window_size: int = 8,
    ):
        self.system_prompt = system_prompt
        self.threshold = compaction_threshold
        self.window_size = window_size
        self.summary: str | None = None
        self.messages: list[dict] = []

    def build_context(self) -> list[dict]:
        """Construye el contexto para enviar a la API."""
        context = [{"role": "system", "content": self.system_prompt}]

        if self.summary:
            context.append({
                "role": "system",
                "content": f"Contexto anterior: {self.summary}",
            })

        context.extend(self.messages[-self.window_size:])
        return context

    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})
        self._check_compaction()

    def _check_compaction(self):
        tokens = sum(len(m["content"]) // 4 for m in self.messages)
        if tokens > self.threshold:
            self._compact()

    def _compact(self):
        old_messages = self.messages[:-self.window_size]
        if not old_messages:
            return

        text = "\n".join(
            f"{m['role']}: {m['content']}" for m in old_messages
        )

        existing_context = f"Resumen existente: {self.summary}\n\n" if self.summary else ""

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                f"{existing_context}"
                f"Nuevos intercambios para integrar en el resumen:\n{text}\n\n"
                "Genera un resumen actualizado, conciso y factual."
            ),
            max_output_tokens=400,
        )

        self.summary = response.output_text
        self.messages = self.messages[-self.window_size:]

Observa que _compact reinyecta el resumen existente en el prompt antes de los nuevos intercambios. Esto evita la amnesia progresiva: sin esta reinyección, cada compactación borraría todo lo que la anterior había retenido.

Compactación selectiva

El resumen es destructivo y algunos contenidos no sobreviven a la reformulación. Un fragmento de código, una respuesta JSON de una API o una tabla de cifras pierde su utilidad en cuanto se parafrasea. La compactación selectiva ordena, por tanto, los mensajes antiguos antes de resumir: los que contienen código o datos estructurados pasan intactos, mientras que solo se comprime el texto conversacional.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Compacta manteniendo intactos los mensajes estructurados."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Mantener mensajes que contengan código o datos
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Resumir solo el texto conversacional
    summary = ""
    if to_summarize:
        text = "\n".join(f"{m['role']}: {m['content']}" for m in to_summarize)
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Resume estos intercambios en 3 frases:\n{text}",
            max_output_tokens=200,
        )
        summary = response.output_text

    result = []
    if summary:
        result.append({
            "role": "system",
            "content": f"Resumen de los intercambios: {summary}",
        })
    result.extend(to_keep)
    result.extend(recent_messages)
    return result

El criterio de ordenación usado aquí —presencia de tres acentos graves o una llave de apertura— es intencionadamente rudimentario. Adáptalo a lo que tus herramientas producen realmente: para un asistente que gestiona referencias de casos, quizás quieras preservar cualquier mensaje que contenga un ID de cliente.

Verificar que la compactación merece la pena

Una compactación mal calibrada cuesta una llamada extra a la API sin ganancia notable, o comprime de forma tan agresiva que el modelo pierde el hilo y hace preguntas ya resueltas. Por eso, mide la ratio antes de fijar tus umbrales definitivos, usando una muestra de conversaciones reales.

def compaction_ratio(
    before: list[dict],
    after: list[dict],
) -> dict:
    tokens_before = sum(len(m["content"]) // 4 for m in before)
    tokens_after = sum(len(m["content"]) // 4 for m in after)
    reduction = 1 - (tokens_after / tokens_before) if tokens_before else 0

    return {
        "tokens_before": tokens_before,
        "tokens_after": tokens_after,
        "reduction": f"{reduction:.0%}",
        "messages_before": len(before),
        "messages_after": len(after),
    }

Toma una docena de transcripciones de tu entorno de producción, pásalas por la compactación y lee los resúmenes producidos: si no puedes reanudar la conversación basándote solo en el resumen, tu umbral es demasiado bajo o tu prompt de resumen es demasiado vago.

Puntos clave

  • La compactación reduce los tokens resumiendo los mensajes antiguos
  • Mantén siempre intactos los mensajes más recientes (ventana deslizante)
  • Preserva los mensajes que contengan código o datos estructurados
  • Reinyecta el resumen existente en cada nueva compactación para evitar la amnesia progresiva
  • Mide la ratio de compresión para calibrar tus umbrales