AI Prompt Engineering · Aula

Compressão de contexto

Reduza o contexto ao que realmente importa.

Compressão de contexto é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Por que comprimir o contexto

Os trechos recuperados são ruidosos: um trecho relevante pode ser, em sua maior parte, texto padrão, com uma única frase essencial. A compressão de contexto reduz o texto recuperado ao que de fato responde à consulta antes de ele chegar ao gerador.

Os benefícios se acumulam: menor custo de unidades de texto, latência reduzida, menos distratores e alívio do efeito de perda no meio, ao reduzir o contexto que o modelo precisa percorrer.

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]

Extrativa versus abstrativa

A compressão extrativa seleciona trechos literais (frases, passagens) relevantes para a consulta, preservando a redação exata e a proveniência. A compressão abstrativa reformula ou resume, alcançando uma compressão maior, mas com risco de perda de informação e introdução de erros.

Para RAG factual com citações, prefira a abordagem extrativa para manter as afirmações rastreáveis até a fonte; use a abstrativa apenas quando for possível verificar a fidelidade.

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 empty

Filtragem no nível das frases

Uma técnica leve e robusta: pontue cada frase de cada trecho em relação à consulta usando um pequeno codificador cruzado ou a similaridade entre representações vetoriais, e descarte as frases com pontuação baixa. Isso preserva as frases de maior valor e elimina o conteúdo de preenchimento.

Mantenha um contexto mínimo por trecho para evitar remover a frase ao redor que dá significado ao fato.

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 order

Compressão contextual baseada em LLM

Um LLM pode comprimir cada trecho: solicite que extraia apenas as partes de uma passagem relevantes para a consulta, retornando o trecho com cortes literais ou um marcador vazio caso nada seja relevante.

Esse é o padrão ContextualCompressionRetriever do LangChain. Ele é mais preciso que os filtros baseados em representações vetoriais, mas adiciona uma chamada ao LLM por trecho; portanto, reserve-o para pipelines de alta criticidade ou processe os trechos em lote.

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 out

Poda no nível das unidades de texto (LLMLingua)

Métodos como LLMLingua comprimem no nível das unidades de texto usando um modelo pequeno para estimar a informatividade de cada unidade e descartar as que contêm pouca informação. Eles podem alcançar grandes taxas de compressão preservando o sinal de que o modelo maior precisa.

A desvantagem é que o texto comprimido se torna menos legível para as pessoas; portanto, essa abordagem é adequada para contextos usados apenas por máquinas, não para exibição ao usuário.

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)

Orientada pela consulta versus independente da consulta

A compressão orientada pela consulta mantém o que é relevante para esta consulta e produz o contexto mais enxuto, mas precisa ser executada a cada solicitação. A compressão independente da consulta (com resumos de trechos pré-calculados) é mais barata no momento da solicitação, mas não consegue se concentrar na pergunta específica.

Uma abordagem híbrida armazena previamente versões condensadas dos trechos e aplica uma leve redução orientada pela consulta durante a solicitação.

# 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]

Proteção contra perda de informação

Uma compressão agressiva pode excluir a única cláusula importante. Proteja-se com uma verificação de cobertura: confirme que o contexto comprimido ainda permite inferir a resposta ou mantenha uma alternativa de reserva para o trecho sem compressão quando o compressor retornar uma quantidade suspeitamente pequena de conteúdo.

Nunca permita que a compressão reduza a vazio um trecho que o reclassificador avaliou como altamente relevante; isso indica uma falha do compressor, não falta de relevância.

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.text

Preservação da proveniência

A compressão deve manter intacta a atribuição da fonte. Marque cada trecho preservado com seu trecho de origem e o ID do documento para que o gerador possa citá-lo. Se os metadados forem removidos durante a compressão, você perderá a verificabilidade e a capacidade de detectar alucinações.

Mantenha os campos de ID no pipeline como campos estruturados, nunca como texto livre que a compressão possa remover.

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 preserved

Compressão e orçamento de unidades de texto

A compressão permite recuperar mais candidatos para aumentar a cobertura sem deixar grande a instrução final. Defina um orçamento de unidades de texto para a janela de contexto e agrupe avidamente os trechos comprimidos de maior valor até atingir esse orçamento.

Isso dissocia a quantidade recuperada da quantidade gasta na geração, um importante recurso de eficiência.

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 packed

Medição da qualidade da compressão

Acompanhe três números: taxa de compressão (unidades economizadas), precisão da resposta (a qualidade foi mantida?) e fidelidade (o compressor evitou alterar os fatos?). O objetivo é alcançar a maior taxa sem alterar a precisão da resposta.

Teste diferentes níveis de agressividade da compressão e escolha o ponto da fronteira de Pareto que atenda à sua meta de custo sem perda de qualidade.

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
    }

Um pipeline consciente da compressão

De ponta a ponta: recupere amplamente, reclassifique, comprima cada trecho restante (de forma extrativa ou baseada em LLM) preservando a proveniência, proteja-se contra cortes excessivos, agrupe os trechos dentro de um orçamento de unidades de texto e gere com citações.

A compressão é a camada que torna a recuperação com alta cobertura acessível e mantém o gerador concentrado no que importa.

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)

Verificação rápida

Escolha a abordagem de compressão correta para um sistema RAG factual com citações.

Recapitulação

Principais conclusões:

A compressão reduz os trechos recuperados ao conteúdo relevante para a consulta, diminuindo custos, latência e distratores.
Prefira a abordagem extrativa (literal e rastreável) à abstrativa para RAG factual com citações; a poda no nível das unidades de texto é adequada para contextos usados apenas por máquinas.
A compressão orientada pela consulta é a mais enxuta, mas precisa ser executada a cada solicitação; combine-a com resumos previamente gerados para ganhar eficiência.
Proteja-se contra a perda de informação e preserve a proveniência dos trechos e documentos para as citações.
Use a compressão para recuperar amplamente e ainda manter as instruções pequenas; ajuste-a para maximizar a taxa sem perder precisão da resposta.

Perguntas Frequentes

A aula “Compressão de contexto” é grátis?

Sim — o texto completo de “Compressão de contexto” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Compressão de contexto”?

Reduza o contexto ao que realmente importa. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Compressão de contexto”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para AI Prompt Engineering