Janela de Contexto em IA: Como Funciona e Como Aproveitar
A janela de contexto define quanto texto um modelo consegue ver de uma vez — e tem mais nuances do que parece. Conheça os limites por modelo em 2026, o problema lost-in-the-middle, RAG, chunking e como medir antes de enviar.
Por Vitor Morais
Fundador do MochaLabz ·
Conte tokens antes de enviar para a IA
Estime o tamanho do seu prompt para GPT, Claude e Gemini — evita erros de limite e custos surpresa.
Contar tokens →A janela de contexto (context window) é o número máximo de tokens que um modelo de linguagem consegue processar em uma única chamada — somando o prompt enviado, o histórico da conversa, anexos e a resposta gerada. É uma propriedade fixa de cada modelo, e entendê-la bem é essencial para qualquer aplicação séria de IA: chatbots, assistentes de código, análise de documentos, RAG.
O que é a janela de contexto na prática
Quando você manda uma mensagem para um LLM, o modelo não recebe a string crua. O texto é tokenizado (quebrado em pedaços numéricos), e cada token consome uma posição da janela. A janela é o “espaço de memória de trabalho” do modelo: tudo o que cabe ali, ele “vê”. O que está fora, simplesmente não existe para aquela chamada.
Para entender melhor o que é um token, veja o que são tokens em IA. A regra rápida em português: 1 token ≈ 0,7 palavra (português é mais “caro” em tokens que inglês por causa de acentos e palavras compostas).
Janelas dos principais modelos em 2026
A corrida por contextos maiores foi feroz nos últimos dois anos. Em 2022 a média era 4k–8k. Hoje, modelos premium chegam a 1–2 milhões de tokens:
| Critério | Janela total | Equivalente em palavras |
|---|---|---|
| Gemini 2.5 Pro | 2 000 000 tokens | ~1,5 milhão |
| Claude Opus 4.7 (1M) | 1 000 000 tokens | ~750 mil |
| GPT-5 | 1 000 000 tokens | ~750 mil |
| Claude Sonnet 4.6 | 200 000 tokens | ~150 mil |
| GPT-4o | 128 000 tokens | ~96 mil |
| Llama 4 Long-context | 256 000 tokens | ~190 mil |
| Mistral Large 2 | 128 000 tokens | ~96 mil |
| Modelos locais 7–13B típicos | 8 000–32 000 tokens | ~6–24 mil |
Output também conta
A janela é compartilhada entre input e output. Em GPT-5 com 1M tokens, se você usou 980k no input, sobram 20k para resposta. Sempre reserve espaço para o output esperado.
O que entra na janela (e o que muita gente esquece)
Quando você faz uma chamada à API, vários componentes ocupam tokens — não só o último prompt do usuário:
- System prompt: instruções persistentes definidas pela aplicação.
- Histórico da conversa: todos os turnos anteriores (user e assistant).
- Definições de ferramentas (tool calls):schema das funções disponíveis para o modelo.
- Anexos: PDFs, planilhas, imagens convertidas em descrições, áudios transcritos.
- Mensagem atual do usuário.
- Output gerado.
O problema lost-in-the-middle
Pesquisas (Liu et al., 2023; várias replicações em 2024–2026) mostraram um efeito consistente em todos os LLMs grandes: a precisão de recuperar informação cai significativamente quando ela está no meio do contexto, em comparação com o início ou o fim. O efeito persiste mesmo nos modelos com janelas de 1M+.
Por que isso importa
Não basta ter informação dentro da janela — ela precisa estar em posição estratégica. Coloque instruções críticas no início (system prompt) ou no final (logo antes do output esperado). Evite enterrar fatos importantes no meio de um documento longo.
Estratégias para trabalhar dentro do limite
1. RAG (Retrieval-Augmented Generation)
Em vez de enviar um livro inteiro, indexe o conteúdo numa base vetorial (Pinecone, Weaviate, pgvector, Chroma) e recupere apenas os trechos relevantes para a pergunta do usuário. Inclua só esses trechos no prompt:
// Pseudocódigo de fluxo RAG
const trechos = await vectorDB.search(perguntaDoUsuario, { topK: 5 });
const prompt = `
Use APENAS os trechos abaixo para responder.
Se a resposta não estiver nos trechos, diga "não sei".
Trechos:
${trechos.map((t, i) => `[${i + 1}] ${t.texto}`).join('\n\n')}
Pergunta: ${perguntaDoUsuario}
`;
const resposta = await llm.complete(prompt);RAG escala para corpus de qualquer tamanho, controla o que o modelo pode usar como fonte e geralmente é mais preciso que despejar tudo no contexto.
2. Chunking com sobreposição
Para documentos que ainda passam de uma chamada só, divida em chunks com overlap (sobreposição) — assim contextos divididos entre chunks não são perdidos:
function chunkText(text, chunkSize = 1000, overlap = 200) {
const chunks = [];
let start = 0;
while (start < text.length) {
chunks.push(text.slice(start, start + chunkSize));
start += chunkSize - overlap;
}
return chunks;
}
// Boa prática: chunkar por estrutura (parágrafo, seção)
// e não só por contagem fixa de caracteres.3. Sumarização progressiva
Para conversas longas que crescem indefinidamente: a cada N turnos, sumarize os turnos anteriores e mantenha apenas o resumo + as últimas mensagens no contexto. Funciona bem em chatbots de suporte, assistentes de coding e copilotos.
4. Map-reduce de documentos
Para tarefas como “resumir todos esses 100 PDFs”: processe cada um separadamente (map), gere resumos individuais e depois consolide os resumos numa segunda chamada (reduce). Evita estourar contexto e dá controle por documento.
5. Prompt caching
Quando o mesmo grande contexto é reutilizado em várias chamadas (ex: instruções extensas + base de conhecimento fixa), use prompt caching. OpenAI, Anthropic e Google reduzem drasticamente o custo do input cacheado (até 90% off em algumas APIs).
Como contar tokens antes de enviar
Cada provedor tem seu tokenizer:
// OpenAI — tiktoken
import { encoding_for_model } from 'tiktoken';
const enc = encoding_for_model('gpt-5');
const tokens = enc.encode(textoCompleto).length;
if (tokens > 950000) {
console.warn('Próximo do limite!');
}
// Anthropic — beta de count_tokens
import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const { input_tokens } = await client.messages.countTokens({
model: 'claude-opus-4-7',
messages: [{ role: 'user', content: texto }],
});
// Google — Gemini SDK
import { GoogleGenerativeAI } from '@google/generative-ai';
const model = new GoogleGenerativeAI(API_KEY).getGenerativeModel({
model: 'gemini-2.5-pro',
});
const { totalTokens } = await model.countTokens(texto);Custo: a janela tem preço
Toda janela utilizada é cobrada — geralmente por milhão de tokens. Janela maior também significa latência maior:
| Critério | Custo input | Latência típica |
|---|---|---|
| GPT-5 | ~US$ 5–15 | ~5–10s para 100k tokens |
| Claude Opus 4.7 | ~US$ 15 | ~5–15s para 100k tokens |
| Claude Sonnet 4.6 | ~US$ 3 | ~3–8s para 100k tokens |
| Gemini 2.5 Pro | ~US$ 1,25–2,50 | ~5–12s para 100k tokens |
| Llama 4 (auto-hosted) | custo de GPU/hora | Variável |
Reduzir custo sem perder qualidade
Use modelos menores para etapas simples (extrair, classificar, roteirizar) e reserve o modelo grande só para a etapa que realmente precisa de raciocínio. Isso é o padrão cascading: você economiza muito sem sacrificar a qualidade da resposta final. Veja também como economizar tokens no ChatGPT e Claude.
Erros comuns ao trabalhar com contexto
- Despejar PDF inteiro sem necessidade: custa caro e geralmente piora qualidade pelo lost-in-the-middle.
- Esquecer do histórico: chats que crescem silenciosamente eventualmente estouram o limite.
- Ignorar o output: reservar pelo menos 10–20% da janela para a resposta esperada.
- Tokens diferentes em modelos diferentes: 1M tokens no GPT-5 não é igual a 1M no Claude — tokenizers diferentes contam diferente.
- Chunking burro: dividir no meio de uma sentença, sem overlap, quebra contexto e prejudica a busca.
- Não usar prompt caching: em sistemas com instruções longas reutilizadas, é dinheiro jogado fora.
Checklist para sua próxima aplicação de IA
- ✅ Conhece a janela exata do modelo escolhido.
- ✅ Mede tokens do input antes de enviar.
- ✅ Reserva espaço para o output esperado.
- ✅ Coloca instruções críticas no início ou no fim do prompt.
- ✅ Usa RAG quando o corpus é maior que a janela.
- ✅ Chunking respeita estrutura (parágrafos, seções).
- ✅ Tem estratégia para histórico longo (sumarização ou janela deslizante).
- ✅ Considerou prompt caching para conteúdos reutilizados.
- ✅ Usa modelos menores para subtarefas simples.
- ✅ Monitora custo de input por chamada em produção.
Perguntas frequentes
O que é janela de contexto em modelos de linguagem?+
É o número máximo de tokens que o modelo aceita por chamada — somando o que você envia (system prompt, histórico, anexos, pergunta) e o que ele gera de resposta. Se você ultrapassar, a API retorna erro e o modelo simplesmente não processa. A janela é uma propriedade fixa de cada modelo: GPT-5 com 1M tokens, Claude Opus 4.7 com 1M, Gemini 2.5 Pro com 2M.
Quanto texto cabe em 100 mil tokens?+
Em português, 100 mil tokens equivalem a aproximadamente 65–75 mil palavras, ou um livro médio de 250–300 páginas. Em inglês a razão é melhor (1 token ≈ 0,75 palavra). Em código a contagem varia muito: indentação, símbolos e nomes longos consomem mais tokens por linha do que prosa.
Quais são os modelos com maior janela de contexto em 2026?+
Gemini 2.5 Pro lidera com 2 milhões de tokens. Claude Opus 4.7 e GPT-5 oferecem 1 milhão. Modelos open-source como Llama 4 e Mistral Large têm 128k–256k tokens, com versões long-context experimentais chegando a 1M. Para a maioria dos casos práticos, 200k já é mais do que o suficiente.
O que é o problema lost-in-the-middle?+
Pesquisas mostram que LLMs têm desempenho melhor ao recuperar informação que está no início ou no fim do contexto, e desempenho significativamente pior com informação no meio. Mesmo com janelas de 1M+, a precisão cai dramaticamente para informações enterradas em torno do meio do prompt. Por isso, qualidade do contexto importa mais que quantidade.
Janela maior é sempre melhor?+
Não. Janelas maiores aumentam latência (modelo demora mais para processar), custo (cobrança por token de input), e podem reduzir qualidade pelo lost-in-the-middle. A regra prática: envie o mínimo necessário com a informação certa, e prefira RAG (busca + injeção seletiva) a despejar documentos inteiros no prompt.
O que é RAG e quando vale mais que aumentar contexto?+
RAG (Retrieval-Augmented Generation) é a técnica de buscar trechos relevantes em uma base externa (vetorial, lexical ou híbrida) e injetar só esses trechos no prompt. Vale quando você tem corpus muito maior que a janela (manuais, livros, base de conhecimento), quando os dados mudam frequentemente, ou quando precisa controlar quais fontes o modelo usa. RAG é mais barato e geralmente mais preciso que enviar tudo de uma vez.
Como contar tokens antes de enviar?+
Para OpenAI, use a biblioteca tiktoken com o encoder do modelo (cl100k_base para GPT-4 family, o200k_base para GPT-4o em diante). Para Claude, use o tokenizador do SDK Anthropic. Para Gemini, o Google AI SDK expõe count_tokens(). Como aproximação rápida em português: divida número de caracteres por 3,5 para estimar tokens.
O contexto inclui tudo? System prompt, histórico, anexos?+
Sim. Tudo que entra na chamada conta: system prompt, todos os turnos anteriores da conversa, ferramentas disponíveis (tool definitions), anexos (PDFs, imagens convertidas), output esperado e a pergunta atual. Se você tem chat de longa duração, considere sumarização progressiva para evitar estourar o limite.
Continue lendo
O Que São Tokens em IA (2026): Guia Completo para LLMs como GPT e Claude
Tokens explicados: o que são, como a tokenização funciona, custo por token nos principais modelos, como contar antes de enviar e estratégias para reduzir consumo.
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.
Chain-of-Thought Prompting: O Guia Completo (2026) com Exemplos
Chain-of-Thought (CoT) é a técnica de prompt que faz LLMs raciocinarem passo a passo, melhorando acurácia em até 60% em problemas complexos. Aprenda zero-shot, few-shot, Self-Consistency e Tree-of-Thoughts, com exemplos para ChatGPT, Claude e Gemini.
Few-Shot Prompting: Como Ensinar Padrões à IA com Exemplos (2026)
Few-shot prompting é a técnica mais confiável para garantir formato e consistência em saídas de LLMs. Aprenda zero-shot vs one-shot vs few-shot, quantos exemplos usar, combinação com Chain-of-Thought e quando migrar para fine-tuning.