Compresión del contexto
Reduzca el contexto a lo verdaderamente importante.
Compresión del contexto es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
Por qué comprimir el contexto
Los fragmentos recuperados contienen ruido: un fragmento relevante puede consistir principalmente en texto genérico y contener una sola oración esencial. La compresión de contexto reduce el texto recuperado a lo que realmente responde a la consulta antes de enviarlo al generador.
Los beneficios se acumulan: menor coste de tokens, menor latencia, menos elementos distractores y alivio de la pérdida en el centro al reducir el contexto que el modelo debe recorrer.
def compress(query, chunks):
# Goal: keep only spans that bear on the query,
# dropping boilerplate, navigation, and off-topic sentences.
return [extract_relevant(query, c) for c in chunks]Extractiva frente a abstr activa
La compresión extractiva selecciona fragmentos textuales literales (oraciones, pasajes) relevantes para la consulta, preservando la redacción exacta y la procedencia. La compresión abstr activa parafrasea o resume, logrando una mayor compresión, pero con riesgo de pérdida de información y de introducir errores.
Para RAG factual con citas, prefiera la compresión extractiva para mantener las afirmaciones vinculadas a la fuente; use la abstr activa solo cuando pueda verificar la fidelidad.
def extractive(query, chunk):
sents = split_sentences(chunk.text)
scored = [(s, relevance(query, s)) for s in sents]
kept = [s for s, r in scored if r > TAU]
return ' '.join(kept) or top1(scored) # never return emptyFiltrado a nivel de oración
Una técnica ligera y robusta consiste en puntuar cada oración de cada fragmento según su relación con la consulta mediante un cross-encoder pequeño o la similitud entre embeddings, y descartar las oraciones con puntuación baja. Así se conservan las oraciones de mayor valor y se elimina el contenido de relleno.
Mantenga un contexto mínimo por fragmento para no eliminar la oración contigua que aporta significado al hecho.
def sentence_filter(query, chunk, keep_ratio=0.4):
sents = split_sentences(chunk.text)
scores = embed_sim_batch(query, sents)
n_keep = max(1, int(len(sents) * keep_ratio))
idx = sorted(range(len(sents)), key=lambda i: -scores[i])[:n_keep]
return ' '.join(sents[i] for i in sorted(idx)) # keep original orderCompresión contextual basada en LLM
Un LLM puede comprimir cada fragmento: indíquele que extraiga únicamente las partes de un pasaje relevantes para la consulta y que devuelva el fragmento recortado literalmente o un marcador vacío si nada es relevante.
Este es el patrón de LangChain ContextualCompressionRetriever. Es más preciso que los filtros basados en embeddings, pero añade una llamada al LLM por fragmento; por eso, resérvelo para pipelines de alta importancia o procéselo por lotes.
def llm_compress(query, chunk):
prompt = (
'Extract ONLY sentences from the passage relevant to the query. '
'If none are relevant, output NONE. Do not paraphrase.\n'
'Query: ' + query + '\nPassage: ' + chunk.text
)
out = llm(prompt, temperature=0).strip()
return None if out == 'NONE' else outPoda a nivel de token (LLMLingua)
Métodos como LLMLingua comprimen a nivel de token mediante un modelo pequeño que estima la cantidad de información de cada token y descarta los tokens con poca información. Pueden lograr grandes tasas de compresión y conservar al mismo tiempo la señal que necesita el modelo grande.
La desventaja es que el texto comprimido resulta menos legible para las personas, por lo que este enfoque es adecuado para contexto destinado exclusivamente a máquinas, no para mostrarlo al usuario.
def token_prune(context, target_ratio=0.3):
# small LM estimates per-token information (perplexity-based);
# drop the least informative tokens down to target_ratio length
scores = small_lm_token_importance(context)
return keep_top_fraction(context, scores, target_ratio)Dependiente de la consulta frente a independiente
La compresión dependiente de la consulta conserva lo relevante para esta consulta y produce el contexto más ajustado, pero debe ejecutarse en cada solicitud. La compresión independiente de la consulta (resúmenes de fragmentos precalculados) es más económica durante la solicitud, pero no puede centrarse en la pregunta concreta.
Un enfoque híbrido almacena sin conexión versiones condensadas de los fragmentos y aplica en línea un recorte ligero dependiente de la consulta.
# Offline: precompute a dense summary per chunk (query-agnostic)
chunk.summary = summarize(chunk.text)
# Online: query-aware trim over summaries (cheap) then verify on full
ctx = [sentence_filter(query, Chunk(c.summary)) for c in top_chunks]Protección contra la pérdida de información
Una compresión agresiva puede eliminar la única cláusula importante. Protéjase con una comprobación de recuperación: verifique que el contexto comprimido siga implicando la respuesta o conserve una alternativa con el fragmento sin comprimir cuando el compresor devuelva una cantidad de texto sospechosamente pequeña.
No permita que la compresión deje vacío un fragmento al que el re-ranker haya asignado una alta relevancia; eso indica un fallo del compresor, no irrelevancia.
def safe_compress(query, chunk):
out = llm_compress(query, chunk)
if out is None and chunk.rerank_score > 0.7:
return chunk.text # trust re-ranker over compressor
return out or chunk.textConservación de la procedencia
La compresión debe conservar intacta la atribución de la fuente. Etiquete cada fragmento conservado con el ID de su fragmento y de su documento para que el generador pueda citarlo. Si elimina los metadatos al comprimir, perderá la verificabilidad y la capacidad de detectar alucinaciones.
Transporte los ID por el pipeline como campos estructurados, nunca como texto libre que la compresión pueda eliminar.
def compress_with_ids(query, chunks):
out = []
for c in chunks:
span = safe_compress(query, c)
out.append({'id': c.id, 'doc': c.meta['doc_id'], 'text': span})
return out # generator cites id; provenance preservedLa compresión y el presupuesto de tokens
La compresión permite recuperar más candidatos para maximizar la recuperación y mantener pequeño el prompt final. Establezca un presupuesto de tokens para la ventana de contexto y empaquete de forma voraz los fragmentos comprimidos de mayor valor hasta alcanzar dicho presupuesto.
Esto desacopla la cantidad que recupera de la cantidad que gasta en la generación, un factor clave de eficiencia.
def pack(spans, budget_tokens, tok):
spans = sorted(spans, key=lambda s: -s['score'])
used, packed = 0, []
for s in spans:
t = tok(s['text'])
if used + t > budget_tokens:
continue
packed.append(s); used += t
return packedMedición de la calidad de la compresión
Realice un seguimiento de tres cifras: la tasa de compresión (tokens ahorrados), la precisión de las respuestas (si se mantuvo la calidad) y la fidelidad (si el compresor evitó alterar los hechos). El objetivo es obtener la mayor tasa posible sin modificar la precisión de las respuestas.
Pruebe distintos niveles de agresividad de compresión y elija el punto de Pareto que cumpla su objetivo de coste sin pérdida de calidad.
def eval_compression(eval_set, levels):
return {
lvl: {
'ratio': mean_ratio(eval_set, lvl),
'acc': answer_accuracy(eval_set, lvl),
'faith': faithfulness(eval_set, lvl),
} for lvl in levels
}Un pipeline consciente de la compresión
De principio a fin: recupere ampliamente, reordene, comprima cada fragmento restante (de forma extractiva o mediante un LLM) conservando la procedencia, evite el recorte excesivo, empaquete el contenido según un presupuesto de tokens y genere la respuesta con citas.
La compresión es la capa que hace asequible la recuperación con alta capacidad de recuperación y mantiene al generador centrado en lo importante.
def pipeline(query):
top = rerank(query, hybrid_retrieve(query, 50))[:12]
spans = compress_with_ids(query, top)
spans = [s for s in spans if s['text']]
packed = pack(spans, budget_tokens=2000, tok=count_tokens)
return generate_with_citations(query, packed)Comprobación rápida
Elija el enfoque de compresión adecuado para un sistema RAG factual con citas.
Resumen
Conclusiones principales:
- La compresión reduce los fragmentos recuperados al contenido relevante para la consulta, disminuyendo el coste, la latencia y los elementos distractores.
- Para RAG factual con citas, prefiera la compresión extractiva (literal y rastreable) a la abstr activa; la poda a nivel de token es adecuada para contexto destinado exclusivamente a máquinas.
- La compresión dependiente de la consulta es la más precisa, pero debe ejecutarse en cada solicitud; combínela con resúmenes sin conexión para mejorar la eficiencia.
- Protéjase contra la pérdida de información y conserve la procedencia de los fragmentos y documentos para las citas.
- Use la compresión para recuperar ampliamente y mantener pequeños los prompts; ajústela para maximizar la tasa sin perder precisión en las respuestas.
Preguntas frecuentes
¿La lección «Compresión del contexto» es gratis?
Sí — el texto completo de «Compresión del contexto» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «Compresión del contexto»?
Reduzca el contexto a lo verdaderamente importante. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Compresión del contexto»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Más allá del RAG ingenuo
- Reordenación de fragmentos recuperados
- Compresión del contexto
- Reescritura de consultas y HyDE