Context Compression

Resumen

Context compression (compresión de contexto) es el proceso de reducir el volumen de documentos recuperados antes de pasarlos al LLM para generación. En lugar de enviar todos los fragmentos recuperados, el sistema filtra, resume o extrae solo la información relevante.

Esto es útil porque los sistemas RAG suelen recuperar más contexto del necesario. Enviar todo al LLM desperdicia tokens (costo), diluye la atención del modelo en contenido irrelevante (calidad), y puede exceder el límite de contexto (fallo).

Alcance y supuestos

Este paquete cubre técnicas de compresión de contexto: extracción selectiva, resumen por LLM, filtrado por relevancia, y truncamiento estructurado.

No cubre cuantización ni compresión a nivel de modelo, optimización de KV-cache, ni estrategias de chunking. Asume que entiendes RAG, chunking, retrieval y el concepto de ventana de contexto de los LLMs.

Modelo mental

Piensa en preparar un informe ejecutivo para tu jefe. Tienes 50 páginas de documentos. No le pasas las 50 páginas; seleccionas los 3 párrafos realmente relevantes y, si es necesario, escribes un resumen de una página.

La compresión de contexto hace exactamente eso con los documentos recuperados: destila la información útil y descarta el ruido, maximizando el valor de cada token en el contexto final.

Uso práctico

Usa compresión de contexto cuando:

• ✅ Recuperas más documentos de los que caben en el contexto del LLM.
• ✅ Los fragmentos recuperados contienen información redundante o irrelevante.
• ✅ Quieres reducir costos de inferencia (menos tokens de entrada = menor costo).
• ❌ Recuperas pocos documentos y ya son relevantes y concisos.
• ❌ La latencia extra del paso de compresión no se justifica para tu caso.

Ejemplo trabajado: compresión por extracción selectiva

Un modelo de relevancia puntúa cada fragmento y solo los mejores pasan al LLM:

interface RetrievedChunk {
  id: string;
  text: string;
  relevanceScore: number;
}

async function compressContext(
  chunks: RetrievedChunk[],
  query: string,
  maxTokens: number
): Promise<string> {
  // Método 1: filtrado por relevancia
  const scored = await Promise.all(
    chunks.map(async (chunk) => {
      const score = await relevanceModel.score(query, chunk.text);
      return { ...chunk, relevanceScore: score };
    })
  );

  // Ordenar por relevancia y filtrar por token budget
  const ranked = scored.sort((a, b) => b.relevanceScore - a.relevanceScore);
  let context = "";
  let tokenCount = 0;

  for (const chunk of ranked) {
    const tokens = estimateTokens(chunk.text);
    if (tokenCount + tokens > maxTokens) break;
    context += chunk.text + "\n\n";
    tokenCount += tokens;
  }

  // Método 2 (opcional): si los fragmentos son largos, resumir cada uno
  // antes de añadirlos al contexto final
  if (chunks.length > 10 && context.length > 0) {
    context = await llm.complete({
      prompt: `Resume la siguiente información de manera concisa, manteniendo los datos clave necesarios para responder esta pregunta: "${query}"\n\n${context.slice(0, 10000)}`,
    });
  }

  return context;
}

La compresión reduce tokens de entrada, mejora la relación señal/ruido, y baja costos. El precio es una llamada extra de relevancia o resumen.

Evidencia

• Cohere, Context compression and retrieval cubre técnicas para comprimir y optimizar el contexto recuperado antes de la generación.
• LlamaIndex documentation, Chunking Strategies describe cómo el tamaño de chunk afecta la compresión y la calidad de recuperación.