O que é janela de contexto e por que ela importa

Toda conversa com um modelo de linguagem acontece dentro de uma fronteira invisível: a janela de contexto. Ela determina quanto texto o modelo consegue "ler" de uma só vez e, na prática, define o que ele é capaz de lembrar dentro de uma interação. Entender esse limite é o que separa quem usa a IA na sorte de quem projeta sistemas confiáveis com ela. Para quem constrói aplicações com IA, a janela deixa de ser curiosidade técnica e vira a principal variável de engenharia: ela governa custo, velocidade e qualidade ao mesmo tempo.

O que é a janela de contexto

A janela de contexto é a quantidade máxima de tokens que o modelo processa em uma única passada — somando o que você envia (entrada) e o que ele gera (saída). Se você ainda não tem clareza sobre o que é um token, vale ler antes O que são tokens em IA? Tokenização explicada, porque toda a contagem de contexto é feita em tokens, nunca em palavras ou caracteres.

Pense na janela como a "mesa de trabalho" do modelo. Tudo que está sobre a mesa pode ser consultado a qualquer momento. O que não cabe na mesa simplesmente não existe para ele naquele instante. Não há gaveta, não há arquivo de fundo: o que saiu da janela some.

[ system prompt ] + [ histórico da conversa ] + [ sua mensagem ] + [ resposta gerada ]
└──────────────────────── tudo isso soma na janela ────────────────────────┘
                              (medido em tokens)

Um detalhe importante: a janela é compartilhada entre entrada e saída. Se um modelo tem janela de 8 mil tokens e você gasta 7.500 com o prompt, sobram apenas 500 para a resposta. É um erro comum entupir a entrada e depois reclamar que a resposta veio cortada — o modelo não tinha espaço para escrever mais. Por isso, ao planejar uma chamada, você precisa reservar um orçamento explícito para a saída.

Tamanhos típicos e o que cabe neles

Os tamanhos de janela evoluíram muito rápido. Para ter uma noção concreta de capacidade:

Uma regra mental útil: 1.000 tokens ≈ 750 palavras em inglês (um pouco menos em português). Então uma janela de 128 mil tokens equivale a algo em torno de um livro de tamanho considerável. Mas atenção — cabe não significa que será usado bem, e voltaremos a esse ponto.

Vale também ter referências numéricas para o dia a dia. Uma página de texto corrido tem por volta de 500 palavras, ou cerca de 650 tokens. Um artigo de blog médio fica entre 1.500 e 3.000 tokens. Um contrato de dez páginas pode passar de 6.000 tokens. E código costuma ser mais "denso" em tokens do que prosa, porque símbolos, indentação e nomes de variáveis fragmentam bastante a tokenização. Em português, palavras com acentuação e flexões tendem a gerar mais tokens que seus equivalentes em inglês, então a mesma janela "rende menos" para nós.

Por que o limite existe

O limite não é arbitrário nem preguiça de engenharia. Ele nasce do coração da arquitetura dos modelos: o mecanismo de atenção. Em um Transformer clássico, cada token "presta atenção" em todos os outros tokens da janela. Isso significa que o custo de computação cresce quadraticamente com o tamanho do contexto: dobrar a janela tende a quadruplicar o trabalho.

A ideia da atenção foi introduzida por Vaswani, Shazeer, Parmar, Uszkoreit et al. (2017) no artigo que apresentou a arquitetura Transformer. O ponto central é que, para cada token, o modelo calcula uma relação com todos os demais — formando uma matriz de tamanho n × n, onde n é o número de tokens. É essa matriz que explode quando o contexto cresce: com 1.000 tokens são 1 milhão de relações; com 100 mil tokens, são 10 bilhões.

Esse comportamento se conecta diretamente com as leis de escala estudadas por Kaplan, McCandlish, Henighan, Brown et al. (2020), que mostraram como desempenho, dados e custo computacional se relacionam de forma previsível. Janelas maiores exigem mais memória e mais processamento, e isso aparece tanto na lentidão quanto no preço da chamada. Por isso, ampliar a janela de um modelo nunca é "de graça" — é uma decisão de engenharia com custo concreto de hardware.

Janela cheia: custo e latência

Como tudo dentro da janela é processado, quanto mais contexto você manda, mais caro e mais lento fica. Dois efeitos práticos:

Por isso, "usar a janela inteira só porque ela é grande" costuma ser um antipadrão. O objetivo é colocar o contexto certo, não o máximo de contexto.

Há ainda um efeito de custo que pega muita gente de surpresa em chats longos: o crescimento acumulado. Em uma conversa de 20 turnos, o turno 20 não envia só a sua última pergunta — ele reenvia todo o histórico anterior. Isso significa que os primeiros tokens da conversa acabam sendo processados (e pagos) dezenas de vezes ao longo da sessão. O custo total de uma conversa cresce de forma quase quadrática com o número de turnos, não linear. Uma mitigação cada vez mais comum é o cache de prompt, em que o provedor guarda o processamento de um prefixo estável (como um system prompt longo) e o reaproveita nas chamadas seguintes, reduzindo custo e latência da parte repetida.

O mito da memória infinita

Um equívoco comum é tratar a janela como memória permanente. Ela não é. O modelo não lembra de nada entre chamadas independentes. A ilusão de memória em um chat existe porque a aplicação reenvia todo o histórico anterior a cada nova mensagem. Quando esse histórico ultrapassa a janela, as mensagens mais antigas são cortadas — e o modelo passa a agir como se elas nunca tivessem existido.

Foi justamente a capacidade de aprender a partir do que está dentro da janela, sem treinar de novo, que Brown, Mann, Ryder, Subbiah, Kaplan et al. (2020) popularizaram como aprendizado in-context: você ensina a tarefa colocando exemplos no próprio prompt. Mas isso só funciona enquanto os exemplos couberem na janela.

Para dar uma memória que persiste além da janela, é preciso uma estratégia externa, e a mais usada é justamente buscar informação relevante sob demanda — o que nos leva ao RAG.

Vale destacar a diferença entre dois conceitos que iniciantes costumam misturar. Parâmetros (os "pesos" do modelo) guardam o conhecimento aprendido no treino — eles não mudam quando você conversa. A janela de contexto é a memória de curtíssimo prazo, válida só para aquela passada. Conhecimento do treino é como o que você decorou na escola; o contexto é como o post-it que você cola no monitor para a tarefa de agora. Ambos são úteis, mas funcionam de formas completamente diferentes.

"Lost in the middle": cabe não é o mesmo que é usado bem

Mesmo com janelas enormes, há um detalhe incômodo: os modelos não tratam todas as posições da janela com a mesma atenção. Há uma tendência observada de lembrar melhor do começo e do fim do contexto e "perder" informações no meio. Em um documento longo, um dado crucial enterrado no parágrafo central pode acabar ignorado.

Esse fenômeno foi documentado de forma sistemática por Liu, Lin, Hewitt, Paranjape et al. (2024), em um estudo que mostrou como a precisão de recuperação de informação cai quando o dado relevante está no meio de um contexto longo, formando uma curva em "U" — alto desempenho nas extremidades e queda no centro.

Isso tem implicações de design diretas:

Uma técnica prática para testar se o seu modelo sofre desse efeito é o teste de "agulha no palheiro" (needle in a haystack): você esconde uma frase específica em algum ponto de um contexto longo e pede ao modelo para recuperá-la, variando a posição. Se a precisão despenca quando a agulha está no meio, você sabe que precisa reorganizar como monta o contexto.

Janela maior não substitui boa engenharia de contexto

A tentação é achar que janelas gigantes resolvem tudo. Na prática, decidir o que entra, em que ordem e em que formato virou uma disciplina própria, abordada em Engenharia de contexto: o novo prompt engineering. O trabalho deixou de ser só "escrever um bom prompt" e passou a ser "montar o melhor contexto possível dentro do orçamento de tokens".

Algumas táticas centrais dessa montagem:

Tudo isso pressupõe entender o que é um LLM (Large Language Model) e como ele consome contexto — a janela é o recurso escasso que você está administrando.

Um padrão prático de orçamento de tokens

Uma forma concreta de organizar a cabeça é dividir a janela em fatias com orçamentos explícitos. Por exemplo, para uma janela de 32 mil tokens:

system prompt + instruções fixas .......  2.000 tokens
contexto recuperado (RAG) ..............  8.000 tokens
histórico resumido da conversa .........  4.000 tokens
mensagem atual do usuário ..............  2.000 tokens
margem reservada para a resposta .......  4.000 tokens
folga de segurança .....................  12.000 tokens

Definir esses limites por antecedência evita o cenário em que um histórico inchado expulsa o contexto recuperado mais importante. Quando uma fatia estoura, você sabe exatamente qual delas comprimir primeiro — em geral, o histórico antigo, que é o candidato natural a ser resumido.

RAG: a saída quando o contexto não cabe

Quando a informação relevante é maior que qualquer janela — uma base de conhecimento, a documentação inteira de um produto, milhares de tickets — a resposta não é uma janela ainda maior, e sim buscar dinamicamente só o que importa. Essa é a ideia central por trás do RAG na prática: um sistema de busca seleciona os trechos mais pertinentes e os injeta na janela no momento da pergunta. Assim você simula uma memória praticamente ilimitada sem pagar para processar tudo a cada chamada.

Há ainda um benefício de confiabilidade: trazer fontes concretas para dentro da janela tende a reduzir respostas inventadas, um problema que detalhamos em O que é alucinação em IA e como reduzi-la.

O RAG e a janela grande não são rivais, e sim aliados. Em muitos sistemas modernos, o RAG faz a primeira filtragem (escolhe os 20 documentos mais promissores entre milhões) e a janela grande acomoda esse conjunto com folga, deixando o próprio modelo fazer o raciocínio fino sobre eles. A regra de ouro continua valendo: filtre antes, raciocine depois — nunca terceirize toda a seleção para o "joga tudo na janela".

Erros comuns ao lidar com a janela

Alguns tropeços aparecem repetidamente em projetos reais:

Perguntas frequentes

Janela de contexto é a mesma coisa que memória do modelo? Não. A janela é memória de curtíssimo prazo, válida apenas para a passada atual. O conhecimento durável fica nos parâmetros, fixados no treino. Para memória que persiste entre sessões, você precisa de armazenamento externo e de uma estratégia de recuperação como o RAG.

Se a janela é grande, posso parar de me preocupar com tokens? Não. Janela grande resolve o problema de "não caber", mas não o de custo, latência e do efeito "lost in the middle". Continua valendo selecionar o contexto certo.

Por que minha resposta veio cortada no meio? Quase sempre porque a soma de entrada e saída atingiu o limite da janela, ou porque você definiu um limite de tokens de saída baixo demais. Verifique quanto da janela o prompt consumiu e reserve espaço para a resposta.

Português gasta mais tokens que inglês? Em geral sim, por conta de acentuação, flexões e da forma como o tokenizador foi treinado. Na prática, a mesma janela acomoda um pouco menos de conteúdo em português do que em inglês.

Conclusão

A janela de contexto é o limite fundamental dentro do qual toda interação com um LLM acontece — medida em tokens, restrita pelo custo quadrático da atenção e frequentemente confundida com memória permanente, que ela não é. Janelas maiores são úteis, mas trazem custo, latência e a armadilha de informações esquecidas no meio. O verdadeiro ganho vem de administrar bem esse espaço: selecionar o contexto certo, posicioná-lo com cuidado, reservar orçamento para a saída e usar técnicas como RAG para ir além do que a janela comporta. Dominar esse recurso escasso é uma das habilidades mais práticas de quem constrói com IA.

Referências