Sumarização com IA: Como Resumir Textos Longos com ChatGPT, Claude e Gemini
LLMs transformaram sumarização em problema resolvido — mas só se você souber prompt correto, estratégia para textos longos (chunking, map-reduce, RAG) e como validar qualidade. Veja modelos, prompts, implementação com API e validação automatizada.
Por Vitor Morais
Fundador do MochaLabz ·
Resuma textos automaticamente
Resumo com IA em múltiplos formatos — TL;DR, bullets, executive summary — 100% online.
Usar resumidor →Sumarização com IA deixou de ser problema em aberto em 2023 — LLMs modernos resumem textos com qualidade próxima de editores humanos quando bem orientados. Mas existem nuances que separam um resumo útil de um resumo genérico ou enganoso: escolha do modelo, estrutura do prompt, estratégia para textos maiores que a janela de contexto e validação contra alucinação. Este guia cobre tudo, com prompts prontos, implementação via API e padrões para volume.
Os dois tipos clássicos de sumarização
| Critério | Como funciona | Vantagem | Risco |
|---|---|---|---|
| Extrativa | Seleciona frases literais do texto | Fidelidade total; sem alucinação | Coerência comprometida em textos longos |
| Abstractive | Parafraseia e sintetiza em palavras próprias | Mais legível e conciso | Pode alucinar; adiciona info não presente |
LLMs fazem abstractive por padrão
GPT, Claude, Gemini, Llama — todos produzem resumos abstractive por padrão. Isso melhora legibilidade mas exige atenção a alucinação. Para extrativa pura (útil em jurídico, médico), peça explicitamente no prompt: “Copie frases literais do texto; não parafraseie.”
Escolhendo o modelo certo para sumarização
| Critério | Melhor caso de uso | Custo relativo |
|---|---|---|
| Claude Opus 4.7 | Resumos críticos de textos muito longos (livros, papers) | Alto |
| GPT-5 | Sumarização com raciocínio e análise profunda | Alto |
| Claude Sonnet 4.6 | Padrão para resumos de qualidade em produção | Médio |
| GPT-5-mini | Volume médio, bom equilíbrio | Baixo-médio |
| Claude Haiku 4.5 | Volume alto de resumos simples (e-mails, notícias) | Muito baixo |
| Gemini 2.5 Flash | Resumos com imagens/PDFs (multimodal) | Muito baixo |
| Llama 4 (self-hosted) | Dados sensíveis, sem envio a API externa | Infra própria |
Prompts eficazes para sumarização
Estrutura padrão do prompt
❌ Fraco (gera resumo genérico)
"Resuma isso:"
✅ Bom (específico, acionável)
"Você é [ROLE]. Resuma o texto abaixo em [FORMATO] de no
máximo [TAMANHO] palavras, destacando:
- [ELEMENTO 1]
- [ELEMENTO 2]
- [ELEMENTO 3]
Restrições:
- Mantenha o tom [TOM].
- Não invente informação que não esteja no texto.
- Se algo não estiver claro, diga explicitamente.
Texto:
[CONTEÚDO]"
✅ Ainda melhor (com audiência)
"Você é um editor executivo. Resuma o texto abaixo para um
CEO ocupado em 150 palavras, destacando implicações de
negócio e próximos passos acionáveis. Se há dado
quantitativo, preserve-o. Não repita jargão técnico.
Texto:
[CONTEÚDO]"Quatro elementos que todo prompt deve ter
- Role: “Você é editor experiente”, “Você é analista financeiro”. Ajusta tom e prioridades.
- Formato: TL;DR, bullets, parágrafo, tabela. Define estrutura clara.
- Restrições: tamanho máximo, tom, o que incluir/excluir.
- Audiência: “para um CEO”, “para um desenvolvedor iniciante”. Calibra nível.
Os 6 formatos de resumo mais úteis
| Critério | Tamanho típico | Casos de uso |
|---|---|---|
| TL;DR | 1-3 frases (50-100 palavras) | Lead de artigo, aviso de slack, tweet |
| Bullets | 3-7 bullets (150-300 palavras) | Apresentações, documentação, notas |
| Abstract acadêmico | 1 parágrafo (200-300) | Papers, relatórios científicos |
| Executive summary | 1 página (400-600) | Relatórios corporativos, propostas |
| Narrativo longo | 1000+ palavras | Livros, documentários, reportagens |
| Estruturado (QA) | Perguntas e respostas | FAQ, briefing, onboarding |
Prompts prontos por formato
// TL;DR
"Resuma em 2-3 frases (no máximo 80 palavras). Foco na
mensagem central e na conclusão prática."
// BULLETS
"Resuma em 5 bullets objetivos, cada um de 1-2 linhas.
Ordene do mais ao menos importante. Use verbos de ação."
// ABSTRACT ACADÊMICO
"Resuma como abstract acadêmico em 1 parágrafo de 200 palavras,
cobrindo: (1) problema, (2) método, (3) resultados principais,
(4) conclusão. Sem jargão desnecessário."
// EXECUTIVE SUMMARY
"Resuma como executive summary de 1 página para um diretor ocupado.
Estrutura: situação atual, principal decisão a tomar, opções,
recomendação, impacto financeiro estimado, próximos passos.
Tom direto, sem float corporativo."
// NARRATIVO LONGO
"Resuma em texto fluido de 1000 palavras, organizado em 4-5
seções com subtítulos. Preserve tom e exemplos do original.
Mantenha narrativa cronológica quando aplicável."
// ESTRUTURADO QA
"Extraia do texto as 10 perguntas mais importantes que ele
responde e escreva cada resposta em 2-3 frases, fiel ao
original."Estratégias para textos maiores que a janela
Mesmo com janelas de 1M tokens (GPT-5, Claude), livros inteiros, arquivos de transcrição gigantes e corpus corporativos podem exceder. As duas estratégias principais:
1. Chunking + Map-Reduce
// Fluxo completo
1. CHUNK: divide texto em pedaços de ~30k tokens
(deixando folga para prompt + resposta)
2. MAP: resuma cada chunk separadamente
Para cada chunk_i:
resumo_i = summarize(chunk_i, "Resuma em 500 palavras
mantendo números e fatos-chave")
3. REDUCE: consolide os resumos
resumo_final = summarize(join(resumos), "Com base nestes
resumos parciais, crie um resumo unificado
de 1000 palavras")
// Exemplo para livro
Chunk 1 (cap 1-2, 40 pgs) → Resumo 1 (500 palavras)
Chunk 2 (cap 3-4, 35 pgs) → Resumo 2 (500 palavras)
Chunk 3 (cap 5-6, 45 pgs) → Resumo 3 (500 palavras)
...
Chunk 10 (cap 19-20) → Resumo 10 (500 palavras)
Todos os 10 Resumos → Resumo Final do Livro (1200 palavras)Cuidado com chunk boundaries
Não quebre no meio de sentenças ou ideias. Ideal: quebras por parágrafos, seções, capítulos. Para textos sem estrutura clara, use chunk com overlap de ~10% para evitar perda de contexto na fronteira.
2. RAG (Retrieval-Augmented Generation)
Para corpus que muda pouco mas é consultado muito (manuais, wikis, bases de conhecimento), indexe em vetor e use busca semântica para trazer só trechos relevantes:
// 1. Indexação (uma vez)
const chunks = splitByParagraph(documento);
for (const chunk of chunks) {
const embedding = await openai.embeddings.create({
model: 'text-embedding-3-small',
input: chunk,
});
await db.save({ text: chunk, embedding: embedding.data[0] });
}
// 2. Busca + sumarização (por query)
async function resumirPorTopico(tema: string) {
const query_emb = await openai.embeddings.create({
model: 'text-embedding-3-small',
input: tema,
});
const trechos = await db.searchByEmbedding(query_emb, 10);
return await openai.chat.completions.create({
model: 'gpt-5',
messages: [{
role: 'user',
content: `Com base nos trechos abaixo, escreva um resumo
sobre "${tema}" em 300 palavras:
${trechos.map(t => t.text).join('\n\n---\n\n')}`,
}],
temperature: 0.3,
});
}Implementação completa em Node.js
// Classe base com configuração + validação
import Anthropic from '@anthropic-ai/sdk';
type ResumoStyle = 'tldr' | 'bullets' | 'executive' | 'abstract';
const STYLES: Record<ResumoStyle, { instrucao: string; maxTokens: number }> = {
tldr: { instrucao: 'em 2-3 frases (máximo 80 palavras)', maxTokens: 150 },
bullets: { instrucao: 'em 5 bullets objetivos', maxTokens: 500 },
executive: { instrucao: 'como executive summary para CEO', maxTokens: 800 },
abstract: { instrucao: 'como abstract acadêmico (200 palavras)', maxTokens: 400 },
};
const client = new Anthropic();
export async function resumir(
texto: string,
style: ResumoStyle = 'bullets',
options: { temperature?: number } = {}
): Promise<string> {
const { instrucao, maxTokens } = STYLES[style];
const message = await client.messages.create({
model: 'claude-sonnet-4-6',
max_tokens: maxTokens,
system: 'Você é um editor experiente e factual. Nunca adicione informação que não esteja no texto original.',
messages: [{
role: 'user',
content: `Resuma o texto abaixo ${instrucao}.
Preserve números, datas e nomes próprios mencionados.
Se algo for ambíguo, indique explicitamente.
Texto:
${texto}`,
}],
temperature: options.temperature ?? 0.3,
});
return message.content[0].type === 'text'
? message.content[0].text
: '';
}
// Uso
const resumo = await resumir(artigoLongo, 'bullets');
console.log(resumo);Map-Reduce em Node.js para textos gigantes
function chunkByTokens(texto: string, maxTokens = 30_000): string[] {
const chunks: string[] = [];
const paragrafos = texto.split('\n\n');
let atual = '';
for (const p of paragrafos) {
const candidato = atual + (atual ? '\n\n' : '') + p;
if (estimateTokens(candidato) > maxTokens && atual) {
chunks.push(atual);
atual = p;
} else {
atual = candidato;
}
}
if (atual) chunks.push(atual);
return chunks;
}
function estimateTokens(texto: string): number {
// Aproximação: ~1 token por 4 caracteres em português
return Math.ceil(texto.length / 4);
}
export async function resumirLongo(textoLongo: string): Promise<string> {
const chunks = chunkByTokens(textoLongo, 30_000);
// MAP: resuma cada chunk em paralelo
const resumosParciais = await Promise.all(
chunks.map((c, i) => resumir(
c,
'bullets',
{ temperature: 0.3 }
))
);
// REDUCE: consolide
const concatenado = resumosParciais
.map((r, i) => `Parte ${i + 1}:\n${r}`)
.join('\n\n---\n\n');
return await resumir(
concatenado,
'executive',
{ temperature: 0.2 }
);
}Validando qualidade do resumo
Cinco critérios manuais
- Fidelidade: todas as afirmações estão no texto original? Teste: escolha 3 fatos do resumo e procure no texto.
- Completude: os pontos principais foram cobertos? Teste: pense nas 3 perguntas-chave que o texto responde e veja se o resumo as aborda.
- Concisão: cada frase agrega? Elimine “em conclusão”, “vale ressaltar”, “por fim”.
- Coerência: faz sentido sem ler o original? Dê para alguém que não viu o original e veja se entende.
- Tom: mantém registro (formal/informal, técnico/leigo) apropriado? LLMs tendem a “achatar” o tom original — corrija se importante.
Validação automática com LLM-as-judge
async function avaliarResumo(
original: string,
resumo: string
): Promise<{ score: number; issues: string[] }> {
const prompt = `Avalie o resumo abaixo comparando com o texto original.
TEXTO ORIGINAL:
${original}
RESUMO:
${resumo}
Retorne JSON no formato:
{
"fidelidade": 0-10,
"completude": 0-10,
"concisao": 0-10,
"coerencia": 0-10,
"tom": 0-10,
"score_total": 0-10,
"issues": ["lista de problemas detectados"]
}`;
const response = await client.messages.create({
model: 'claude-sonnet-4-6',
max_tokens: 500,
messages: [{ role: 'user', content: prompt }],
temperature: 0,
});
return JSON.parse(response.content[0].text);
}
// Use para regressão automática em pipeline de sumarização
const avaliacao = await avaliarResumo(original, resumo);
if (avaliacao.score_total < 7) {
console.warn('Resumo de baixa qualidade:', avaliacao.issues);
}Temperatura e factualidade
temperature controla aleatoriedade do output:
| Critério | Valor | Uso |
|---|---|---|
| 0.0 | Mais determinístico | Documentos jurídicos, relatórios financeiros |
| 0.1-0.3 | Baixa variação | Padrão para sumarização factual |
| 0.4-0.6 | Moderada | Resumos com alguma síntese criativa |
| 0.7+ | Alta criatividade | Evite — risco de alucinação alto |
Cuidado com alucinação
Modelos pequenos, temperature alta e prompts ambíguos aumentam risco de alucinação. Para resumos críticos: temperature ≤ 0.3, modelo médio/grande, prompt específico. Valide sempre contra o texto original quando o resumo será usado para decisão real.
Casos de uso reais e prompts específicos
Reuniões (transcrição → ações)
"Você é secretário executivo. A transcrição abaixo é de uma
reunião de 1h. Produza:
1. RESUMO (3 bullets): decisões principais
2. AÇÕES: quem faz o quê, até quando (formato: [Responsável]
faz [tarefa] até [data])
3. BLOQUEADORES: itens não resolvidos que precisam
acompanhamento
4. PRÓXIMA REUNIÃO: data + pauta sugerida
Use só informação da transcrição. Nomes e datas exatos.
TRANSCRIÇÃO:
[...]"Papers acadêmicos → linguagem simples
"Você é professor que traduz pesquisa para público leigo.
Resuma o paper abaixo em 400 palavras, para alguém com
ensino médio:
1. Qual é o problema estudado?
2. Como os pesquisadores fizeram?
3. O que descobriram?
4. Por que isso importa para a vida real?
Evite jargão. Use analogias quando ajudar.
PAPER:
[...]"Threads de e-mail longas → decisão
"A thread abaixo tem 30 mensagens. Extraia:
1. DECISÃO TOMADA (se houver, em 1 frase)
2. PRINCIPAIS POSIÇÕES: quem defendeu o quê (máximo 5)
3. PONTOS NÃO RESOLVIDOS
4. AÇÃO REQUERIDA DE MIM
Seja telegráfico. Preserve nomes.
THREAD:
[...]"Feedback de usuário (reviews)
"Você é analista de produto. Analise as 1000 reviews abaixo e
produza:
1. SENTIMENTO GERAL (% positivo / neutro / negativo)
2. TOP 5 ELOGIOS (temas recorrentes)
3. TOP 5 CRÍTICAS (problemas mais citados)
4. FUNCIONALIDADES PEDIDAS (o que usuários querem)
5. 3 DECISÕES DE PRODUTO que estes dados sugerem
Cite reviews específicas como evidência (número da review).
REVIEWS:
[review 1]
[review 2]
..."Reduzindo custo de sumarização em volume
- Cascata de modelos: resumo inicial com Haiku, revisão final com Sonnet/Opus só nos casos que importam.
- Prompt caching: system prompt e exemplos fixos cacheáveis pelo provider (Anthropic, OpenAI).
- Batch API: para processamento não-interativo (ex: resumir histórico), 50% off em OpenAI e Anthropic.
- Embeddings + busca em vez de tudo no contexto: RAG reduz drasticamente tokens de input.
- Compressão de input: remova HTML, comentários e whitespace antes de enviar.
- max_tokens baixo para o output: força resumo sem divagar.
Veja o guia completo de como economizar tokens no ChatGPT e Claude.
Privacidade e dados sensíveis
Nem tudo pode ir para API externa
Anthropic, OpenAI (via API) e Google Vertex garantem por contrato que dados enviados NÃO treinam modelos. Mas ChatGPT grátis e Claude.ai grátis podem. Para dados pessoais, jurídicos, médicos ou governamentais, use sempre API enterprise ou modelos self-hosted (Llama 4, Mistral Large em infraestrutura privada).
Quando NÃO usar IA para resumir
- Documentos jurídicos críticos: a menor alucinação pode ter consequência legal.
- Exames médicos: idem.
- Decisões irreversíveis: sempre leia o original.
- Textos muito pequenos: se você leria em 2 min, não vale custar 2000 tokens.
- Textos fortemente técnicos de nicho: modelo pode não entender contexto e produzir resumo raso.
Técnicas manuais continuam úteis
Para resumos pessoais (leitura ativa, estudo), técnicas manuais clássicas continuam úteis — Cornell method, SQ3R, mind map. IA acelera volume; técnica manual aprofunda compreensão. Os dois se complementam. Veja técnicas de resumo de texto para abordagens não-IA.
Checklist de sumarização com IA
- ✅ Modelo escolhido pelo caso de uso (não sempre o maior).
- ✅ Prompt com role + formato + restrições + audiência.
- ✅ Temperature 0-0.3 para factualidade.
- ✅ max_tokens calibrado para o formato esperado.
- ✅ Para textos longos: chunking + map-reduce ou RAG.
- ✅ Validação cruzada (5 critérios ou LLM-as-judge).
- ✅ Instrução explícita contra alucinação no system prompt.
- ✅ API enterprise para dados sensíveis (não ChatGPT grátis).
- ✅ Cascata de modelos para reduzir custo em volume.
- ✅ Prompt caching quando reutiliza system prompts.
- ✅ Batch API para processamento assíncrono.
- ✅ Revisão humana em resumos críticos.
Perguntas frequentes
Qual o melhor modelo de IA para sumarização em 2026?+
Claude Sonnet 4.6 e GPT-5 lideram em qualidade de resumo, especialmente para textos longos (janela de 1M tokens). Para custo/benefício, Gemini 2.5 Flash é excelente e muito mais barato. Para resumos simples e em volume, Claude Haiku 4.5 entrega 90% da qualidade a 1/20 do custo. A regra: modelo grande só quando o texto é complexo ou crítico; modelo menor para volume.
Qual a diferença entre sumarização extrativa e abstractive?+
Extrativa seleciona frases/trechos literalmente do texto original (copy-paste inteligente). Abstractive reescreve em palavras próprias, parafraseando e sintetizando. LLMs modernos fazem abstractive por padrão — qualidade superior, mas risco maior de alucinação. Para compliance (jurídico, médico), prefira extrativa; para comunicação geral, abstractive vence.
Qual prompt funciona melhor para resumir?+
Inclua 4 elementos: role ("você é editor experiente"), formato esperado (bullets, TL;DR, narrativo), restrições (tamanho máximo, tom), e contexto da audiência ("para um CEO", "para um desenvolvedor iniciante"). Quanto mais específico, melhor o resumo. Evite apenas "resuma isto" — gera output genérico e inconsistente.
Como resumir textos maiores que a janela de contexto?+
Use chunking + map-reduce: (1) divida o texto em partes menores que caibam na janela com folga, (2) resuma cada chunk individualmente, (3) concatene os resumos e resuma o resultado final. Para livros, divida por capítulos; para transcrições, por intervalo de tempo; para código, por módulo. Alternativamente, use RAG para indexar e só trazer partes relevantes.
O resumo da IA pode inventar informação (alucinação)?+
Sim, e é o maior risco. Modelos menores alucinam mais; temperatura alta aumenta o risco; textos muito longos onde lost-in-the-middle age; prompts ambíguos dão margem. Para reduzir: use temperature 0-0.3, peça citações do texto original, use modelos de reasoning (GPT-5-thinking, Claude Thinking), valide sempre antes de publicar resumos críticos.
Vale a pena usar modelos de reasoning para resumir?+
Para resumos críticos (compliance, jurídico, análise de pesquisa), sim — modelos com reasoning interno (o3, GPT-5-thinking, Claude Thinking) produzem resumos mais fiéis ao original e com menos alucinação. Custam mais e são mais lentos. Para volume de resumos casuais (e-mails, notícias), modelos regulares são suficientes e 5-10× mais baratos.
Como validar se o resumo é bom?+
Cinco critérios: (1) Fidelidade — todas afirmações estão no texto original? (2) Completude — pontos principais cobertos? (3) Concisão — cada frase agrega? (4) Coerência — faz sentido sem ler o original? (5) Tom — mantém registro apropriado? Para volume, use um segundo LLM como "juiz" que compara resumo com original e pontua. Métricas automáticas (ROUGE, BERTScore) ajudam mas não substituem revisão humana em resumos críticos.
É seguro enviar documentos confidenciais para resumir?+
Depende do provider. Anthropic (Claude), OpenAI API (não ChatGPT grátis) e Google Vertex AI garantem por contrato que dados enviados NÃO são usados para treinar modelos. Para dados muito sensíveis (médico, jurídico, governamental), considere modelos self-hosted (Llama 4, Mistral Large em infraestrutura privada) ou ambientes enterprise com cláusulas específicas de privacidade.
Continue lendo
Prompt Engineering (2026): Guia Completo com Técnicas, Templates e Exemplos
Guia definitivo de prompt engineering: role, contexto, exemplos, chain-of-thought, output estruturado, avaliação e templates prontos para ChatGPT, Claude e Gemini.
Como Economizar Tokens no ChatGPT, Claude e Gemini (Guia 2026)
Reduza o custo das APIs de IA em 40–80% sem perder qualidade. 12 técnicas práticas: compressão, prompt caching, modelos em cascata, RAG, batching, sumarização — com estimativas reais.
Janela de Contexto em IA: Guia Completo (2026) com Limites por Modelo
A janela de contexto define quanto texto um LLM consegue processar de uma vez. Conheça os limites de GPT-5, Claude, Gemini e Llama em 2026, lost-in-the-middle, RAG, chunking e prompt caching.
Técnicas de Resumo de Texto (2026): Método Manual, IA e Frameworks Testados
Guia completo de técnicas de resumo: método manual passo a passo, frameworks (BLUF, SCQA, pirâmide invertida, IMRAD), uso prático de IA e avaliação de qualidade.