Janelas de Contexto

O que é uma janela de contexto?

Uma janela de contexto é a quantidade máxima de texto (e outras entradas serializadas, como chamadas de ferramentas) que um modelo de linguagem grande (LLM) consegue considerar de uma vez ao produzir o próximo token. Ela é medida em tokens, não em caracteres ou palavras (veja Tokenização).

A janela de contexto de um modelo normalmente inclui:

Tokens de entrada (mensagens de sistema + desenvolvedor + usuário, documentos que você cola, trechos recuperados, etc.)
Tokens de saída gerados até agora na resposta atual (porque o modelo condiciona nos seus próprios tokens anteriores)

Então, se um modelo tem uma janela de contexto de 32k tokens e você fornece um prompt de 30k tokens, você pode ter espaço apenas para ~2k tokens de saída antes de o modelo atingir o limite.

Janelas de contexto importam porque elas limitam o que o modelo pode “lembrar” dentro de uma única passagem direta (forward pass). Elas não são memória de longo prazo—quando o texto sai da janela, o modelo não consegue mais prestar atenção diretamente nele.

Janelas de contexto estão fortemente conectadas ao aprendizado em contexto (in-context learning) (a capacidade de adaptar o comportamento a partir de exemplos no prompt). Janelas mais longas permitem mais demonstrações, mais documentos de referência e conversas mais longas. Veja Aprendizado em Contexto.

Por que as janelas de contexto são limitadas

A maioria dos LLMs modernos é baseada na Arquitetura Transformer. Duas grandes restrições limitam o comprimento de contexto:

1) O custo computacional e a memória da atenção crescem com o comprimento da sequência

Na autoatenção padrão (self-attention), cada token pode prestar atenção a todos os outros tokens. Para um comprimento de sequência (n), a atenção escala aproximadamente como:

Custo computacional: (O(n^2))
Memória: também grande (especialmente durante o treinamento e, durante a inferência, devido ao cache de chave/valor)

Esse crescimento quadrático fica caro rapidamente. Ir de 8k → 32k tokens pode significar ~16× mais trabalho de atenção no pior caso.

2) Memória na inferência: o cache KV

Durante a geração, Transformers armazenam tensores de cache de chave/valor (KV cache) para cada token anterior, para que o modelo não os recompute a cada etapa. A memória do cache KV cresce aproximadamente de forma linear com o comprimento do contexto:

Mais tokens → cache KV maior → mais memória de GPU por requisição
Cache KV maior → tamanhos de lote menores e menor throughput (o custo de serving aumenta)

3) A informação posicional precisa generalizar para sequências longas

Transformers só são sensíveis à ordem porque injetamos informação posicional. Alguns esquemas de codificação posicional generalizam mal para além dos comprimentos vistos no treinamento. É aqui que entram métodos de contexto longo como RoPE e ALiBi.

“Contexto máximo” vs “contexto efetivo”

Mesmo que um modelo suporte uma janela máxima grande (por exemplo, 128k), o contexto efetivo—a parte que ele usa de forma confiável—pode ser menor dependendo de:

Distribuição de treinamento (com que frequência ele viu sequências longas durante o pré-treinamento)
Arquitetura e codificação posicional
Dificuldade da tarefa (encontrar um detalhe entre muitos é mais difícil)
Efeitos de “perdido no meio” (lost-in-the-middle) (às vezes os modelos focam mais no começo/fim do que no meio)

Por isso, benchmarks de contexto longo frequentemente distinguem:

Ele consegue aceitar 128k tokens?
Ele consegue recuperar de forma confiável uma “agulha” em 80k?

Codificações posicionais e comportamento em contexto longo (visão geral)

Transformers precisam de uma forma de representar as posições dos tokens. Duas abordagens amplamente usadas em LLMs são:

RoPE (Rotary Position Embeddings)
ALiBi (Attention with Linear Biases)

Ambas são projetadas para melhorar o tratamento de posição relativa e podem ajudar na extrapolação de comprimento de contexto (context-length extrapolation) (usar sequências mais longas do que aquelas em que o modelo foi treinado), embora de maneiras diferentes.

RoPE (Rotary Position Embeddings): intuição e implicações

RoPE codifica posição ao rotacionar vetores de consulta e chave de um modo que faz a atenção depender da distância relativa entre tokens.

Intuição em alto nível:

O vetor de consulta/chave de cada token é transformado por uma rotação dependente da posição.
Quando você calcula o produto escalar (q \cdot k), o resultado incorpora naturalmente deslocamentos posicionais relativos.
Isso frequentemente resulta em forte desempenho para modelagem de linguagem e é comum em muitas famílias de LLMs.

Por que RoPE importa para contexto longo:

RoPE tende a funcionar bem dentro dos comprimentos treinados.
Extrapolar muito além do comprimento de treinamento pode degradar, porque as rotações (frequências) efetivamente “dão a volta” (wrap) ou ficam mal calibradas para longas distâncias.
Muitas extensões de contexto longo são essencialmente estratégias de escalonamento de RoPE (RoPE scaling): elas modificam o mapeamento de posição → rotação para que posições mais longas se comportem “como se” fossem mais curtas.

Ideias comuns de extensão de RoPE em alto nível (os nomes variam entre famílias de modelos e artigos):

Escalonamento linear (linear scaling): comprime posições para que 0..128k se mapeie no intervalo de fase originalmente usado para 0..32k.
Sensível a NTK / escalonamento de frequência (NTK-aware / frequency scaling): ajusta bandas de frequência de forma diferente para que a atenção local permaneça precisa enquanto a atenção de longo alcance continue utilizável.
Esquemas híbridos: preservam o comportamento de curto alcance (crítico para sintaxe/código) enquanto estendem a capacidade de longo alcance.

Conclusão prática: em modelos baseados em RoPE, “suporta 128k” frequentemente implica treinamento especial ou escalonamento cuidadoso de RoPE; empurrar ingenuamente para comprimentos maiores pode reduzir a qualidade.

ALiBi: intuição e implicações

ALiBi modifica a atenção ao adicionar um viés dependente da distância às pontuações de atenção.

Intuição em alto nível:

A pontuação de atenção vira:
[ \text{score}(i, j) = q_i \cdot k_j ;+; \text{bias}(|i-j|) ]
O viés é tipicamente linear na distância, com inclinações (slopes) que diferem por cabeça de atenção.
Isso incentiva a atenção a preferir tokens mais próximos, ainda permitindo atenção de longo alcance.

Por que ALiBi importa para contexto longo:

Como ALiBi define uma penalidade simples por distância em vez de usar embeddings posicionais fixos, ele pode generalizar de forma mais natural para comprimentos maiores em tempo de inferência.
Na prática, o desempenho em contexto longo ainda depende de treinamento, dados e implementação, mas ALiBi costuma ser considerado mais “amigável à extrapolação” do que alguns esquemas posicionais absolutos.

Conclusão prática: ALiBi pode facilitar executar em comprimentos maiores, mas não resolve magicamente o custo computacional/de memória da atenção longa.

Outras abordagens para lidar com contexto longo (além de RoPE/ALiBi)

Capacidade de contexto longo não é apenas sobre codificação posicional. Muitos sistemas combinam múltiplas estratégias:

Atenção esparsa ou estruturada

Em vez de atenção completa (n^2), tokens prestam atenção a um subconjunto:

Atenção de janela deslizante (sliding-window attention): cada token presta atenção principalmente a tokens próximos
Tokens globais (global tokens): alguns tokens prestam atenção em tudo (útil para tarefas no nível de documento)
Padrões bloco-esparsos (block-sparse patterns): atenção dentro de blocos mais conexões limitadas entre blocos

Essas técnicas reduzem custo computacional e podem permitir sequências muito mais longas, mas podem perder parte da capacidade de raciocínio global se não forem cuidadosamente projetadas.

Recorrência por segmentos / tokens de memória

Algumas arquiteturas reutilizam representações de segmentos anteriores:

Processam o texto em blocos.
Carregam adiante um estado comprimido ou memória.

Isso pode estender o contexto efetivo sem prestar atenção a todos os tokens de uma vez, mas altera o comportamento do modelo: ele deixa de ser “pura” atenção completa sobre todo o prompt.

Geração aumentada por recuperação (RAG)

Em vez de colocar tudo na janela de contexto, recupere apenas as partes relevantes:

Indexe documentos (busca vetorial ou híbrida)
Recupere os top-k trechos dado o query
Alimente os trechos recuperados no prompt

Isso costuma ser mais custo-efetivo do que contextos extremamente longos e pode reduzir alucinações quando combinado com citações (veja Alucinações e LLMs com Uso de Ferramentas).

Exemplos práticos: trabalhando dentro de uma janela de contexto

Exemplo 1: Orçamento de tokens (prompt + saída)

Suponha que você use um modelo com janela de 16k e queira até 1k tokens de saída. Seu orçamento seguro de entrada pode ser ~14k tokens para deixar espaço para overhead de sistema/ferramentas e variabilidade menor.

Regras práticas:

Reserve explicitamente espaço para saída.
Lembre-se de que esquemas de chamadas de ferramentas, assinaturas de funções e prompts de sistema também consomem tokens.
A contagem de tokens varia por idioma e formatação (código pode tokenizar de forma diferente de prosa).

Exemplo 2: Dividindo um documento longo para Perguntas e Respostas

Se um PDF tem 200k tokens, você não consegue colá-lo em um modelo de 32k. Uma abordagem comum é:

Dividir em blocos (por exemplo, 800–1500 tokens)
Gerar embeddings dos blocos e recuperar os relevantes (RAG), ou
Executar um pipeline de sumarização map-reduce

Aqui está um chunker simplificado (tokenização omitida por brevidade—sistemas reais devem dividir por tokens, não por caracteres):

def chunk_text(text, max_chars=4000, overlap=400):
    chunks = []
    start = 0
    while start < len(text):
        end = min(len(text), start + max_chars)
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # overlap helps preserve boundary context
        if start < 0:
            start = 0
        if end == len(text):
            break
    return chunks

Então você pode montar o prompt apenas com os blocos mais relevantes:

System: You answer questions using ONLY the provided excerpts.
User: Question: What are the termination clauses?

Excerpts:
[1] ...
[2] ...
[3] ...

Answer with citations like [1], [2].

Essa abordagem frequentemente supera despejar uma enorme quantidade de texto em uma janela de contexto longa porque reduz distração e problemas de “perdido no meio”.

Exemplo 3: Conversa com janela deslizante e sumarização periódica

Em sistemas de chat, você pode manter a conversa coerente sem contexto infinito ao:

Manter as últimas N interações literalmente
Manter um estado de resumo (summary state) contínuo
Incluir apenas o resumo + interações recentes no prompt

Estrutura de pseudo-prompt:

System: You are a helpful assistant.
System: Conversation summary (update as needed): ...
User: (recent messages...)
Assistant: (recent assistant replies...)
User: New question...

Isso é um compromisso prático quando contexto longo é caro, e frequentemente melhora a consistência para assistentes implantados em escala.

Trade-offs de comprimento de contexto

Aumentar o comprimento de contexto não é uma “capacidade gratuita”. Isso muda custo, latência e, às vezes, qualidade.

1) Custo e latência

Contexto mais longo geralmente aumenta:

Tempo de prefill (processamento do prompt inicial)
Uso de memória (cache KV)
Custo de serving (menos requisições concorrentes por GPU)

Mesmo que a velocidade de geração por token seja similar, o prefill inicial pode dominar para prompts muito longos.

2) Diluição da atenção e dificuldade de recuperação

Com mais tokens, o modelo precisa selecionar informação relevante de um conjunto maior. Modos de falha comuns:

Perdido no meio: detalhes relevantes no meio são ignorados com mais frequência do que os próximos ao início/fim.
Varredura superficial: o modelo dá respostas genéricas apesar de a informação estar presente.
Interferência: múltiplos trechos similares confundem o modelo.

Mitigações:

Forneça estrutura forte: títulos, IDs, listas com marcadores
Peça citações para forçar fundamentação
Use recuperação para restringir ao texto mais relevante
Coloque as restrições mais importantes perto do fim do prompt (recência ajuda)

3) Injeção de prompt e área de ataque de segurança

Mais contexto frequentemente significa mais texto não confiável (páginas da web, e-mails, documentos). Isso aumenta o risco de:

Injeção de prompt (prompt injection) (“ignore instruções anteriores…” dentro de texto recuperado)
Tentativas de exfiltração de dados
Uso indevido de ferramentas (se o modelo pode chamar ferramentas)

Mitigações incluem:

Separação clara de instruções vs. dados (delimitadores, tags explícitas de “conteúdo não confiável”)
Políticas de uso de ferramentas e sandboxing (veja Mitigações de Segurança e LLMs com Uso de Ferramentas)
Filtros de recuperação e allowlists de fontes

4) Desalinhamentos de treinamento e generalização

Um modelo pode suportar contexto longo na inferência, mas ainda assim performar melhor em comprimentos menores se:

Ele raramente viu sequências longas durante o pré-treinamento
Não houve fine-tuning de contexto longo
A extrapolação da codificação posicional é imperfeita

Por isso, fornecedores frequentemente especificam tanto um comprimento máximo de contexto quanto mostram avaliações de contexto longo.

5) Qualidade da saída vs. tamanho do prompt

Prompts longos podem reduzir alucinações ao fornecer evidências, mas também podem aumentar alucinações se o modelo:

mistura fontes contraditórias,
não consegue localizar o trecho relevante,
ou é pressionado a responder além do que está declarado.

Combinar contexto longo com instruções rígidas de fundamentação e citações costuma ser eficaz (veja Alucinações).

Quando usar contexto longo vs. recuperação ou compressão

Contexto longo é mais valioso quando o modelo precisa de acesso conjunto a muitos detalhes ao mesmo tempo:

Boas situações para contexto longo:

Reescrita do documento inteiro preservando tom e restrições
Análise multi-seção em que referências cruzadas importam
Revisão de código em múltiplos arquivos (até certo ponto; veja Modelos de Código)
Revisão jurídica/contratual com muitas dependências

Melhores situações para recuperação + contexto menor:

Consulta de fatos em um corpus grande (políticas, manuais, bases de conhecimento)
Suporte ao cliente com muitos artigos similares
Perguntas e respostas sobre grandes conjuntos de documentos em que apenas alguns trechos importam

Melhores situações para sumarização/compressão:

Conversas muito longas em que apenas decisões-chave importam
Transcrições de reunião em que você precisa de itens de ação, não do texto literal

Na prática, muitos sistemas de produção combinam:

uma janela de contexto moderada,
recuperação para fundamentação,
e sumarização para estado.

Notas de engenharia: construindo com janelas de contexto

A estratégia de truncamento importa

Se você exceder o limite, algo precisa ser descartado:

Descartar as interações mais antigas (comum em chat)
Descartar os blocos menos relevantes (seleção baseada em recuperação)
Comprimir (resumos, fatos extraídos)

Truncamento ingênuo pode remover restrições críticas (por exemplo, políticas de segurança, preferências do usuário). Mantenha “restrições rígidas” em uma seção de sistema/desenvolvedor fixada, e trate o resto como descartável.

Separe “instrução” de “dados”

Um formato de prompt robusto frequentemente se parece com:

Instruções: curtas, alta prioridade
Contexto/dados: claramente delimitados, tratados como não confiáveis
Tarefa: pergunta explícita e formato de saída requerido

Isso reduz confusão e ajuda a defender contra injeção.

Decodificação não corrige contexto ausente

Configurações de amostragem (temperature/top-p) afetam a variabilidade, mas não restauram contexto descartado. Se o modelo não tiver a informação necessária dentro da janela, ele vai chutar. Veja Estratégias de Decodificação.

Avaliando desempenho em contexto longo

Estilos comuns de avaliação incluem:

Agulha no palheiro (needle-in-a-haystack): esconder um fato-chave na posição 5k/50k/100k e pedir por ele.
Benchmarks de Perguntas e Respostas e sumarização de documentos longos: medir fidelidade e cobertura.
Recuperação multi-hop dentro do contexto: exige conectar partes distantes de um documento.

Um ponto-chave: um modelo pode pontuar bem em aceitar entradas longas, mas ainda performar mal em usar isso de forma confiável.

Resumo

Uma janela de contexto é o orçamento de tokens ao qual um LLM consegue prestar atenção de uma vez, abrangendo tanto a entrada quanto a saída gerada. Ela é limitada pelo escalonamento da atenção em Transformers, pela memória do cache KV e pela generalização da codificação posicional. Métodos de contexto longo como RoPE (com variantes de escalonamento) e ALiBi buscam tornar o tratamento posicional mais robusto em comprimentos grandes, mas contexto mais longo traz trade-offs reais: maior custo e latência, recuperação de informação mais difícil (“perdido no meio”) e uma superfície maior de ataque de segurança. Na prática, capacidade de contexto longo é mais eficaz quando combinada com estruturação forte, orçamento cuidadoso de tokens e técnicas complementares como recuperação e sumarização.