Gerenciamento da Janela de Contexto

Estratégias para gerenciar janelas de contexto de LLMs, incluindo sumarização, corte, roteamento e prevenção de "apodrecimento" do contexto.

Capacidades

• engenharia-de-contexto
• sumarizacao-de-contexto
• corte-de-contexto
• roteamento-de-contexto
• contagem-de-tokens
• priorizacao-de-contexto

Pré-requisitos

• Conhecimento: Fundamentos de LLM, Noções básicas de tokenização, Engenharia de prompts
• Habilidades recomendadas: engenharia-de-prompts

Escopo

• Não cobre: Detalhes de implementação de RAG, Ajuste fino de modelos, Modelos de embedding
• Limites: Foco em otimização de contexto, Cobre estratégias, não implementações específicas

Ecossistema

Ferramentas_primárias

• tiktoken - Tokenizador da OpenAI para contagem de tokens
• LangChain - Framework com utilitários de gerenciamento de contexto
• Claude API - Mais de 200 mil de contexto com suporte a cache

Padrões

Estratégia de Contexto em Camadas

Diferentes estratégias baseadas no tamanho do contexto

Quando usar: Construindo qualquer sistema de conversação multi-turno

interface ContextTier {
    maxTokens: number;
    strategy: 'full' | 'summarize' | 'rag';
    model: string;
}

const TIERS: ContextTier[] = [
    { maxTokens: 8000, strategy: 'full', model: 'claude-3-haiku' },
    { maxTokens: 32000, strategy: 'full', model: 'claude-3-5-sonnet' },
    { maxTokens: 100000, strategy: 'summarize', model: 'claude-3-5-sonnet' },
    { maxTokens: Infinity, strategy: 'rag', model: 'claude-3-5-sonnet' }
];

async function selectStrategy(messages: Message[]): ContextTier {
    const tokens = await countTokens(messages);

    for (const tier of TIERS) {
        if (tokens <= tier.maxTokens) {
            return tier;
        }
    }
    return TIERS[TIERS.length - 1];
}

async function prepareContext(messages: Message[]): PreparedContext {
    const tier = await selectStrategy(messages);

    switch (tier.strategy) {
        case 'full':
            return { messages, model: tier.model };

        case 'summarize':
            const summary = await summarizeOldMessages(messages);
            return { messages: [summary, ...recentMessages(messages)], model: tier.model };

        case 'rag':
            const relevant = await retrieveRelevant(messages);
            return { messages: [...relevant, ...recentMessages(messages)], model: tier.model };
    }
}

Otimização da Posição Serial

Coloque conteúdo importante no início e no fim

Quando usar: Construindo prompts com contexto significativo

// LLMs weight beginning and end more heavily
// Structure prompts to leverage this

function buildOptimalPrompt(components: {
    systemPrompt: string;
    criticalContext: string;
    conversationHistory: Message[];
    currentQuery: string;
}): string {
    // START: System instructions (always first)
    const parts = [components.systemPrompt];

    // CRITICAL CONTEXT: Right after system (high primacy)
    if (components.criticalContext) {
        parts.push(`## Key Context\n${components.criticalContext}`);
    }

    // MIDDLE: Conversation history (lower weight)
    // Summarize if long, keep recent messages full
    const history = components.conversationHistory;
    if (history.length > 10) {
        const oldSummary = summarize(history.slice(0, -5));
        const recent = history.slice(-5);
        parts.push(`## Earlier Conversation (Summary)\n${oldSummary}`);
        parts.push(`## Recent Messages\n${formatMessages(recent)}`);
    } else {
        parts.push(`## Conversation\n${formatMessages(history)}`);
    }

    // END: Current query (high recency)
    // Restate critical requirements here
    parts.push(`## Current Request\n${components.currentQuery}`);

    // FINAL: Reminder of key constraints
    parts.push(`Remember: ${extractKeyConstraints(components.systemPrompt)}`);

    return parts.join('\n\n');
}

Sumarização Inteligente

Resuma por importância, não apenas por recência

Quando usar: Contexto excede o tamanho ideal

interface MessageWithMetadata extends Message {
    importance: number;  // Pontuação de 0 a 1
    hasCriticalInfo: boolean;  // Preferências do usuário, decisões
    referenced: boolean;  // Foi referenciado depois?
}

async function smartSummarize(
    messages: MessageWithMetadata[],
    targetTokens: number
): Message[] {
    // Ordena por importância, preserva a ordem para pontuações empatadas
    const sorted = [...messages].sort((a, b) =>
        (b.importance + (b.hasCriticalInfo ? 0.5 : 0) + (b.referenced ? 0.3 : 0)) -
        (a.importance + (a.hasCriticalInfo ? 0.5 : 0) + (a.referenced ? 0.3 : 0))
    );


…