Estourou o limite de tokens do ChatGPT: por que a IA esquece e como resolver

Você explicou tudo pra IA. O contexto do projeto, as regras do código, o tom da resposta. Vinte mensagens depois, ela esqueceu o que vocês tinham combinado e começou a inventar de novo. A primeira reação é achar que o modelo "burrou". Não é burrice. É a janela de contexto fazendo exatamente o que ela faz.

Esse é um dos erros mais comuns de quem usa IA pra valer: conversa longa, documento gigante, e de repente a resposta despenca de qualidade. Quase sempre a culpa é a mesma — você estourou o limite de tokens do ChatGPT (ou do Claude, ou de qualquer LLM), e o modelo simplesmente não enxerga mais o começo.

Neste post você vai entender, pela dor, o que é a janela de contexto, por que o chat "esquece", e as quatro estratégias que resolvem isso em produção: resumo, RAG, chunking e memória externa.

TL;DR

• O que é: o limite de tokens (a "janela de contexto") é o total de texto que o modelo consegue ler de uma vez. Estourou, ele descarta o começo.
• Por que a IA esquece: chat não tem memória mágica. Cada turno reenvia o histórico inteiro. Quando não cabe mais, os tokens mais antigos caem — geralmente em ordem de chegada (FIFO).
• Stack mental: tokenização, janela de contexto, atenção (self-attention), recuperação (RAG), memória externa.
• Como resolver: resumir o histórico, recuperar só o trecho relevante (RAG + chunking), e guardar fatos importantes numa memória fora da janela.

O que é o limite de tokens (e por que ele existe)

Modelo de linguagem não lê palavra. Lê token — pedaços de texto. Um token é, em média, uns 4 caracteres, ou aproximadamente 0,75 palavra em inglês (guia de janelas de contexto). "Beer and Code" vira uns 4 ou 5 tokens. Esse post inteiro, alguns milhares.

A janela de contexto é o teto de tokens que o modelo processa numa única requisição. E tem um detalhe que muita gente ignora: esse teto conta entrada e saída juntas. Seu prompt, o histórico da conversa, os documentos que você colou, e a resposta que o modelo vai gerar — tudo divide o mesmo orçamento. A documentação da Anthropic chama isso direto de "memória de trabalho" do modelo (Context windows).

Por que existe esse limite? Por causa de como o transformer funciona. O mecanismo de atenção (self-attention) faz cada token "olhar" para todos os outros da sequência. Isso quer dizer que o custo computacional cresce de forma quadrática: dobrar o tamanho do contexto quase quadruplica a conta na camada de atenção (análise de limitações). Janela infinita não é só caro. É matematicamente caro.

Por que a IA "esquece" o começo da conversa

Aqui mora o mal-entendido. Você sente o chat como uma conversa contínua, com memória. Tecnicamente, não é nada disso.

A cada mensagem nova, a interface reenvia o histórico inteiro pro modelo. Toda vez. O modelo não "lembra" do turno 3 — ele relê o turno 3, porque ele foi reempacotado junto no turno 20. Não existe estado guardado entre as chamadas. Existe um texto cada vez maior sendo reenviado.

E o texto cresce de forma linear a cada turno. Uma hora ele não cabe mais na janela. O que acontece então?

Em interfaces de chat, a janela de contexto costuma funcionar num sistema rolante de "primeiro a entrar, primeiro a sair".

Isso está na própria documentação da Anthropic. FIFO puro. Sem ranking inteligente, sem sumarização automática por padrão: os tokens mais antigos são simplesmente descartados pra abrir espaço pros novos. As suas instruções iniciais — aquelas que você caprichou no começo — são exatamente as primeiras a cair.

Esse é o "esquecimento". Não é o modelo ficando confuso. É o começo da conversa literalmente deixando de existir na entrada que ele recebe. Ele não esqueceu. Ele nunca recebeu.

Quanto cabe, afinal?

A pergunta óbvia: qual o tamanho da janela? Depende do modelo, e em 2026 o leque é enorme.

Fonte: comparativo de janelas por modelo e docs da Anthropic.

Parece que o problema acabou, né? Se cabe 1 milhão de tokens, quem se importa com estourar? Calma. Janela grande resolve menos do que vende.

O problema não é só estourar — é o "lost in the middle"

Tem uma armadilha pior que o limite duro. Mesmo quando o texto cabe na janela, a qualidade cai conforme você enche.

A própria Anthropic dá nome ao fenômeno: context rot. Conforme o número de tokens cresce, a precisão e o recall do modelo degradam (Context windows). E tem o efeito "perdido no meio" (lost in the middle): informação enfiada no meio de um contexto gigante tende a ser ignorada, enquanto o que está no início e no fim recebe mais atenção.

Traduzindo pro seu dia a dia: colar um PDF de 300 páginas no prompt e perguntar sobre um detalhe da página 150 é pedir pra ser ignorado. O dado está na janela. Mas o modelo não consegue puxá-lo direito no meio de tanto ruído.

Por isso "curar" o que entra no contexto importa mais do que quanto espaço você tem. Contexto não é depósito. É bancada de trabalho. Bancada lotada não te deixa mais produtivo — te deixa perdido.

Como resolver na prática

Quatro estratégias. Não são exclusivas — em produção, você combina.

1. Resumir o histórico (sumarização / compaction)

A ideia mais direta: antes de estourar, comprima o que já passou. Em vez de reenviar 50 turnos crus, você reenvia um resumo dos 45 mais antigos + os 5 recentes na íntegra.

Isso pode ser manual ("resuma o que decidimos até aqui") ou automático. A Anthropic, por exemplo, oferece compaction — sumarização server-side que condensa as partes antigas da conversa automaticamente, permitindo conversas longas além do limite com pouca integração (Managing context). O trade-off é honesto: resumo perde detalhe. Você troca precisão por sobrevivência.

2. Recuperar só o relevante (RAG)

A virada de chave. Em vez de jogar tudo no contexto e torcer, você guarda o conhecimento fora do modelo e busca só o pedaço que importa pra cada pergunta.

Isso é RAG (Retrieval-Augmented Generation): você indexa seus documentos como embeddings num banco vetorial, e na hora da pergunta recupera os 3 ou 4 trechos mais semelhantes — e só esses entram no prompt. (RAG não é bala de prata pra todo caso — a gente já destrinchou quando RAG resolve e quando fine-tuning ou contexto resolvem melhor.)

Pergunta do usuário
        │
        ▼
  Busca semântica  ──►  Banco vetorial (todos os docs)
        │
        ▼
  Top 3 trechos relevantes  ──►  Prompt enxuto  ──►  LLM

Em vez de 300 páginas, o modelo recebe os 2 parágrafos que respondem a pergunta. Janela folgada, sem lost in the middle, custo menor. É a diferença entre dar a biblioteca inteira pro modelo ou entregar a página certa aberta.

3. Chunking bem feito

RAG só funciona se a recuperação for boa. E recuperação boa começa no chunking: como você corta os documentos antes de indexar.

Cortar a cada N tokens no braço é o jeito errado — você racha uma frase no meio e o trecho perde sentido. O caminho é chunking semântico, com sobreposição entre os pedaços pra não perder contexto na fronteira, e metadados (título do documento, nome da seção) embutidos em cada chunk (técnicas de gestão de contexto). Chunk ruim recupera lixo. Lixo recuperado vira resposta ruim. Garbage in, garbage out — agora com embeddings.

4. Memória externa

Resumo e RAG resolvem o documento. Falta o fato persistente: o nome do cliente, a decisão de arquitetura, a preferência do usuário. Coisas que precisam sobreviver entre sessões.

A solução é uma camada de memória fora da janela. O agente lê e escreve fatos num armazenamento próprio e consulta quando precisa — sem carregar tudo no contexto o tempo todo. A Anthropic lançou um memory tool baseado em arquivos exatamente pra isso, combinado com context editing que limpa resultados de ferramenta obsoletos. Os números internos deles: as duas técnicas juntas deram +39% de desempenho em tarefas complexas multi-step, e o context editing sozinho cortou 84% do consumo de tokens numa tarefa de busca web (Context management).

Repara no padrão das quatro: nenhuma tenta fazer a janela crescer. Todas decidem, com critério, o que não colocar nela. Isso é engenharia de contexto — decidir o que entra no prompt e o que fica de fora. E é o que separa o protótipo que funciona na demo do produto que aguenta uma conversa real.

FAQ rápido

"Estourou o limite de tokens" — o que faço agora? Curto prazo: comece uma conversa nova e cole um resumo do que importa. Médio prazo: pare de despejar tudo no chat. Estruture o conhecimento fora do modelo (RAG) e traga só o relevante por pergunta.

Janela de 1M token não resolve de vez? Não. Resolve o estouro, não o context rot. Encher 1M de tokens degrada precisão e custa caro (lembra do custo quadrático da atenção). Janela grande é folga, não desculpa pra jogar tudo dentro.

Por que a IA esquece mesmo eu não tendo conversado tanto? Documentos colados, respostas longas e instruções de sistema também consomem tokens. Entrada e saída dividem a mesma janela. Você pode estourar em poucas mensagens se cada uma for densa.

RAG é só pra quem tem muito documento? Não. RAG é pra qualquer caso em que o conhecimento não cabe (ou não deveria caber) no prompt toda vez. Inclusive memória de usuário e histórico de suporte.

Conclusão

O chat não esquece por burrice. Esquece porque a janela de contexto é um espaço finito que reenvia o histórico inteiro a cada turno e descarta o começo quando não cabe mais — e perde precisão muito antes disso, no context rot. Entender isso muda a forma como você usa IA: o jogo não é caber mais texto, é decidir o que entra.

As quatro saídas — resumo, RAG, chunking e memória — têm uma coisa em comum: são decisões de arquitetura, não de prompt. Você não conserta limite de contexto escrevendo um prompt mais bonito. Conserta projetando o sistema que alimenta o modelo. É exatamente esse tipo de decisão — o que recuperar, o que resumir, o que guardar na memória, como montar o pipeline — que a gente coloca na mesa, com código rodando, no Workshop Arquitetando Soluções de IA: como arquitetar software de verdade com agentes, sem cair no hype do "prompt mágico".

Porque no fim das contas, IA em produção nunca foi sobre o prompt. É sobre contexto, recuperação, memória e limite do modelo. O resto é demo.