Como gerenciar janelas de contexto pequenas em LLMs: 3 estratégias práticas com Python

Por que janelas de contexto pequenas podem ser uma vantagem

A indústria de IA desenvolveu uma obsessão por modelos capazes de ingerir contextos gigantes — um livro inteiro em um único prompt. Mas, na prática, janelas enormes trazem limitações reais: custos de API crescentes, tempos de resposta inaceitáveis e o problema do “lost in the middle”, em que o modelo ignora informações enterradas no meio de um prompt gigante. Trabalhar com janelas pequenas, porém bem gerenciadas, costuma produzir resultados superiores: menos latência, menos custo e um modelo forçado a se concentrar no que realmente importa.

Neste guia, você vai aprender três estratégias práticas para gerenciar janelas de contexto curtas em modelos de linguagem, com exemplos em Python para duas delas.

Estratégia 1: Truncamento por janela deslizante (sliding window)

A janela deslizante é a estratégia mais simples e mais usada. Em vez de enviar todo o histórico da conversa ao modelo, o contexto é tratado como uma fila FIFO (primeiro a entrar, primeiro a sair): conforme novas mensagens chegam, as mais antigas são descartadas. A única decisão é definir o tamanho da janela e equilibrar retenção de contexto com controle de custo e latência.

A principal vantagem é o controle absoluto e previsível sobre o uso de tokens: o número máximo de interações processadas por vez permanece fixo.

class SlidingWindowMemory:
    def __init__(self, max_turns=3):
        # Mantém apenas os últimos `max_turns` da conversa
        self.max_turns = max_turns
        self.history = []

    def add_interaction(self, user_text, ai_text):
        self.history.append({"user": user_text, "ai": ai_text})
        # Lógica da janela: descarta os turnos mais antigos se o limite for excedido
        if len(self.history) > self.max_turns:
            self.history = self.history[-self.max_turns:]

    def build_prompt(self, new_query):
        prompt = "System: Responda de forma concisa com base no contexto recente.\n\n"
        for turn in self.history:
            prompt += f"User: {turn['user']}\nAI: {turn['ai']}\n"
        prompt += f"User: {new_query}\nAI:"
        return prompt

O ponto fraco é óbvio: memória de longo prazo é perdida. Se a conversa exige lembrar de algo dito há muitos turnos, a janela deslizante sozinha não resolve — por isso ela costuma ser combinada com as outras estratégias abaixo.

Estratégia 2: Orçamento de tokens + RAG

Sistemas de RAG (Retrieval-Augmented Generation) complementam o LLM com um mecanismo que recupera documentos externos e enriquece o prompt com contexto relevante. Com janelas pequenas, o orçamento de tokens divide o contexto em zonas com limites rígidos — por exemplo, 20% para instruções de sistema, 20% para o histórico de chat e 60% para dados recuperados. Isso evita que documentos grandes esgotem o prompt e mantém apenas a informação mais relevante.

def build_budgeted_prompt(system_prompt, retrieved_chunks, user_query, max_words=50):
    # Custo fixo dos elementos obrigatórios
    base_words = len(system_prompt.split()) + len(user_query.split())
    current_words = base_words
    included_chunks = []

    for chunk in retrieved_chunks:
        chunk_words = len(chunk.split())
        # Só adiciona o trecho se couber no orçamento
        if current_words + chunk_words <= max_words:
            included_chunks.append(chunk)
            current_words += chunk_words
        else:
            print(f"Orçamento atingido! Deixou de fora {len(retrieved_chunks) - len(included_chunks)} trechos.")
            break

    context_str = "\n---\n".join(included_chunks)
    return f"{system_prompt}\n\nContexto:\n{context_str}\n\nUser: {user_query}"

Uma heurística útil para tornar o orçamento mais realista: considere que 1 palavra equivale, em média, a 1,3 tokens.

Estratégia 3: Técnicas avançadas

• Resumos rotativos (rolling summaries): um LLM auxiliar condensa o histórico antigo em um parágrafo compacto. Preserva memória de longo prazo sem inchar o prompt, mas exige chamadas extras de API.
• Compressão de prompt: um algoritmo remove palavras de preenchimento, dados redundantes e stop words antes de alimentar o modelo. Reduz latência drasticamente, mas pode apagar nuances valiosas se aplicado com agressividade demais.
• Mascaramento de observações: oculta ruído estrutural antigo (como consultas de banco de dados em sistemas de agentes ou logs intermediários de execução de código), mantendo a lógica central intacta. Muito usado em agentes autônomos.

Conclusão prática

Janelas de contexto pequenas não devem ser vistas como limitação, e sim como recurso arquitetural para evitar custo e latência excessivos. Combinar janela deslizante com orçamento de tokens e, quando necessário, resumos rotativos, entrega soluções mais rápidas e baratas sem sacrificar a precisão.