Sumarização Antes da Chamada: Condensando Documentos Longos para Claude

Quando um documento é muito longo, muito desfocado ou reutilizado em vários prompts, a solução não é enviá-lo inteiro para o seu modelo mais forte a cada vez.

É condensá-lo uma vez com um modelo barato e, em seguida, enviar a versão condensada para o modelo que faz o trabalho real.

Isso adiciona uma chamada de API extra, mas essa chamada é barata, então o custo líquido é menor sempre que o documento é longo ou reutilizado em vários prompts.

A técnica é mais valiosa para material de referência lido muitas vezes: um arquivo de log grande, um longo tópico de suporte, um contrato extenso ou um changelog grande.

Esta página mostra como construir uma etapa de sumarização com o SDK Python anthropic, quando vale a pena e onde pode dar errado.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

import anthropic
 
client = anthropic.Anthropic()
 
def summarize(document: str, focus: str = "") -> str:
    instruction = f"Resuma este documento em menos de 200 palavras."
    if focus:
        instruction += f" Concentre-se especialmente em: {focus}."
 
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=300,
        messages=[{"role": "user", "content": f"{instruction}\n\n{document}"}],
    )
    return response.content[0].text

Quando usar isso:

• O documento de origem é longo o suficiente para que enviá-lo na íntegra para um modelo forte seja caro em cada chamada.
• O mesmo documento será referenciado em vários prompts, portanto, o custo da sumarização é pago uma vez.
• Você precisa da essência de um documento, não de todos os detalhes exatos (contratos e textos legais são uma exceção, veja Armadilhas).
• Um modelo barato e rápido está disponível em sua linha para fazer a etapa de condensação.

Exemplo de Trabalho

import anthropic
 
client = anthropic.Anthropic()
 
 
def summarize(document: str, focus: str = "", max_words: int = 200) -> str:
    """Condense um documento longo com um modelo barato."""
    instruction = f"Resuma este documento em menos de {max_words} palavras."
    if focus:
        instruction += f" Concentre-se especialmente em: {focus}."
 
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=400,
        messages=[{"role": "user", "content": f"{instruction}\n\n{document}"}],
    )
    return response.content[0].text
 
 
def answer_with_summary(summary: str, question: str) -> str:
    """Envie o resumo condensado, não o documento original, para o modelo mais forte."""
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"Com base neste resumo de um tópico de suporte, responda à pergunta.\n\n"
                        f"Resumo:\n{summary}\n\nPergunta: {question}",
        }],
    )
    return response.content[0].text
 
 
with open("support_thread.txt") as f:
    long_thread = f.read()  # 8.000 palavras de mensagens de ida e volta
 
condensed = summarize(long_thread, focus="qual é o problema não resolvido do cliente")
answer = answer_with_summary(condensed, "O que ainda não foi resolvido para este cliente?")
print(answer)

O que isso demonstra:

• summarize é executado no Haiku 4.5, o nível mais barato, já que condensar texto não requer raciocínio profundo.
• answer_with_summary é executado no Sonnet 5, o modelo que realmente faz o raciocínio em que o usuário se importa, mas ele só vê o texto condensado.
• O parâmetro focus direciona o resumo para o que a pergunta downstream precisa, em vez de produzir um resumo genérico que pode omitir o detalhe relevante.
• Separar as duas funções facilita o cache ou a reutilização de condensed em várias perguntas downstream sobre o mesmo tópico.

Mergulho Profundo

Como Funciona

• O trabalho do modelo barato é estreito: comprimir texto preservando as informações que uma tarefa downstream precisa, não responder à pergunta real.
• Como a sumarização é uma tarefa mais simples do que o raciocínio aberto, um nível de modelo rápido e barato geralmente é suficiente para isso.
• O resumo, uma vez produzido, pode ser armazenado em cache ou guardado para que seja reutilizado em todas as perguntas futuras sobre esse documento, amortizando ainda mais o custo da sumarização.
• O custo de ponta a ponta é: uma chamada de sumarização barata, paga uma vez por documento, mais muitas chamadas baratas para o modelo forte usando o resumo curto em vez do original longo.

Quando a Sumarização Vale a Pena

Notas Python

# Armazene o resumo em cache para que perguntas repetidas sobre o mesmo documento não
# re-executem a chamada de sumarização.
_summary_cache: dict[str, str] = {}
 
def cached_summarize(doc_id: str, document: str, focus: str = "") -> str:
    key = f"{doc_id}:{focus}"
    if key not in _summary_cache:
        _summary_cache[key] = summarize(document, focus=focus)
    return _summary_cache[key]

Um simples dicionário em memória é suficiente para um único processo; um sistema de produção apoiaria isso com um cache persistente indexado pelo hash do documento e foco.

Armadilhas

• Sumarizar o detalhe que a tarefa downstream realmente precisava. Um resumo genérico pode omitir o único número ou cláusula que importava. Correção: passe um parâmetro focus que diga ao sumarizador o que preservar e considere um comprimento de resumo maior para documentos de alto risco.
• Sumarizar texto legal, médico ou numérico preciso. A compressão é inerentemente com perdas, e a redação exata ou figuras exatas podem importar nesses domínios. Correção: para documentos onde a precisão é inegociável, pule a sumarização e use o prompt de contexto mínimo para extrair a seção relevante exata em vez disso.
• Re-sumarizar o mesmo documento em cada chamada. Isso descarta todo o benefício de custo da técnica. Correção: armazene o resumo em cache por identidade do documento, como mostrado no exemplo de Notas Python acima.
• Usar um modelo muito fraco para produzir um resumo coerente. Um modelo extremamente barato ou pequeno pode produzir um resumo confuso ou que perde o ponto completamente. Correção: valide a qualidade do resumo com alguns documentos conhecidos antes de confiar em um determinado nível de modelo para esta etapa; suba um nível se a qualidade não estiver lá.
• Encadear resumos de resumos sem verificar o desvio. Resumir repetidamente um documento já resumido agrava a perda de informação. Correção: sempre resuma da fonte original, não de um resumo anterior, quando a fonte ainda estiver disponível.

Alternativas

FAQs

Relacionados

• Como a Engenharia de Contexto Reduz o Gasto de Tokens - onde a sumarização se encaixa entre as outras técnicas de redução de contexto.
• Noções Básicas de Engenharia de Prompt e Contexto - exemplos práticos de medição de economia de tokens.
• Cortando Contexto: Grafos de Dependência em Vez de Repositórios Completos - a alternativa baseada em extração para sumarização de código.
• Lista de Verificação de Segmentação de Modelos - critérios para escolher qual modelo lida com a etapa de sumarização.
• Deterioração do Contexto: Por Que Mais Tokens Não Significam Melhores Respostas - por que um resumo focado também pode melhorar a qualidade da resposta.

Versões da Pilha: Escrito contra a linha de modelos Claude atual a partir de ~junho de 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (o padrão), e Claude Haiku 4.5 - e o SDK oficial anthropic para Python (última versão 0.x). Nomes de modelos, preços e versões de SDK mudam rapidamente - verifique os detalhes atuais em platform.claude.com/docs antes de confiar neles.