← Voltar

Engenharia de Contexto: Como otimizar a memória e o desempenho dos seus Agents de IA

15 de out. de 2025 • Equipe DoubleChat
Engenharia de Contexto: Como otimizar a memória e o desempenho dos seus Agents de IA

A engenharia de contexto (context engineering) é a disciplina de estruturar, priorizar e gerenciar informações fornecidas a LLMs para maximizar precisão, eficiência e confiabilidade. Neste guia, você aprenderá técnicas práticas para otimizar o contexto dos seus agents.

Por que Context Engineering importa?

Modelos de linguagem têm limites de contexto (ex.: 200K tokens no Claude 3.5 Sonnet). A forma como você estrutura e fornece informações impacta diretamente:

  • Precisão: Contexto relevante melhora respostas
  • Custo: Tokens desnecessários aumentam custos
  • Latência: Menos contexto = respostas mais rápidas
  • Confiabilidade: Contexto bem estruturado reduz alucinações

Princípios fundamentais

1. Relevância sobre volume

Não envie tudo que você tem. Priorize informações essenciais para a tarefa atual.

Ruim:

Histórico completo dos últimos 3 meses (200 mensagens)
Perfil completo do cliente
Todas as políticas da empresa

Bom:

Últimas 5 interações relevantes
Nome, preferências e status atual do cliente
Políticas específicas ao caso (ex.: política de troca)

2. Estruturação hierárquica

Organize informações do mais importante para o menos importante.

[CONTEXTO CRÍTICO]
Cliente: João Silva (VIP, cliente há 3 anos)
Situação: Pedido #1234 atrasado há 5 dias
Status atual: Transportadora reportou extravio

[CONTEXTO SECUNDÁRIO]
Histórico: 12 pedidos anteriores, sem problemas
Preferências: Prefere contato via WhatsApp

[CONTEXTO COMPLEMENTAR]
Última compra: R$ 450,00 em eletrônicos
Programa de fidelidade: Nível Gold

3. Formatação clara e consistente

Use formatação padronizada para facilitar o parsing pelo modelo.

## Dados do Cliente
- Nome: Maria Santos
- Tipo: Business
- Desde: 2022-03-15
- Tickets abertos: 0

## Ticket Atual
- ID: #5678
- Assunto: Dúvida sobre integração API
- Prioridade: Alta
- SLA: Vence em 2h30min

## Contexto Técnico
- Stack: Node.js 18, TypeScript
- Endpoint: POST /api/v2/webhooks
- Erro: 401 Unauthorized

Técnicas práticas de otimização

1. Janela deslizante (Sliding Window)

Para conversas longas, mantenha apenas as N mensagens mais recentes + resumo do histórico anterior.

interface ContextWindow {
  summary: string; // Resumo das mensagens antigas
  recentMessages: Message[]; // Últimas 10-20 mensagens
  relevantFacts: string[]; // Fatos importantes extraídos
}

// Exemplo
const context = {
  summary: "Cliente solicitou alteração de plano há 3 dias. Aprovado pela gerência ontem.",
  recentMessages: [...últimas10Mensagens],
  relevantFacts: [
    "Cliente autorizou débito automático",
    "Plano novo: Business Pro",
    "Data de ativação: 2025-10-20"
  ]
}

2. Recuperação semântica (Semantic Retrieval)

Em vez de enviar toda a base de conhecimento, busque apenas documentos relevantes.

// RAG (Retrieval-Augmented Generation)
async function buildContext(userQuery: string) {
  // 1. Buscar documentos relevantes
  const relevantDocs = await vectorDB.search(userQuery, {
    limit: 3,
    minScore: 0.7
  });
  
  // 2. Formatar contexto
  return {
    query: userQuery,
    knowledge: relevantDocs.map(doc => ({
      title: doc.title,
      content: doc.content,
      source: doc.url
    }))
  };
}

3. Compressão inteligente

Resuma informações repetitivas ou volumosas.

Antes (3000 tokens):

Pedido #1001: Status: entregue, Data: 01/08/2025, Valor: R$ 120,00, Produtos: [Livro A, Livro B]
Pedido #1002: Status: entregue, Data: 15/08/2025, Valor: R$ 85,00, Produtos: [Livro C]
Pedido #1003: Status: entregue, Data: 02/09/2025, Valor: R$ 200,00, Produtos: [Livro D, Livro E, Livro F]
[... mais 20 pedidos ...]

Depois (200 tokens):

Histórico de pedidos (23 total, R$ 3.450,00):
- Todos entregues com sucesso
- Frequência: ~2-3 por mês
- Ticket médio: R$ 150,00
- Categoria principal: Livros (95%)
- Último pedido: #1023 em 10/10/2025

4. Contexto lazy-loaded

Carregue informações adicionais apenas quando necessário.

// Contexto inicial (mínimo)
const initialContext = {
  customer: { id, name, tier },
  currentIssue: { summary, category }
};

// Se o agent precisar de mais dados, ele pode usar ferramentas
const tools = [
  {
    name: "getFullCustomerHistory",
    description: "Busca histórico completo do cliente (use apenas se necessário)",
    parameters: { customerId: string }
  },
  {
    name: "searchKnowledgeBase",
    description: "Busca na base de conhecimento",
    parameters: { query: string, maxResults: number }
  }
];

Padrões de contexto por tipo de agent

Agent de Atendimento (SAC)

[PRIORIDADE ALTA]
- Cliente: nome, tier, tickets abertos
- Problema atual: descrição, categoria, urgência
- Histórico recente: últimas 3 interações

[PRIORIDADE MÉDIA]
- Pedidos recentes: últimos 2-3
- Preferências: canal, horário, idioma

[PRIORIDADE BAIXA]
- Estatísticas gerais: tempo como cliente, NPS

Agent de Vendas (SDR)

[PRIORIDADE ALTA]
- Lead: nome, empresa, cargo, origem
- Interesse: produto/solução específica
- Qualificação: budget, timeline, autoridade

[PRIORIDADE MÉDIA]
- Empresa: segmento, tamanho, localização
- Histórico: interações anteriores, materiais baixados

[PRIORIDADE BAIXA]
- Dados demográficos adicionais

Agent Técnico (Dev/Suporte)

[PRIORIDADE ALTA]
- Problema: erro específico, mensagem, contexto
- Ambiente: versões, configurações relevantes
- Tentativas: o que já foi testado

[PRIORIDADE MÉDIA]
- Stack: tecnologias, dependências
- Logs: últimos 50 linhas relevantes

[PRIORIDADE BAIXA]
- Documentação completa
- Histórico de issues similares

Métricas para avaliar qualidade do contexto

1. Eficiência de tokens

Token Efficiency = Tokens relevantes usados / Total de tokens enviados

Objetivo: > 70%

2. Taxa de recuperação correta

Retrieval Accuracy = Respostas corretas usando contexto / Total de respostas

Objetivo: > 90%

3. Latência por contexto

Latency per 1K tokens = Tempo de resposta / (Tokens de contexto / 1000)

Objetivo: < 500ms por 1K tokens

4. Custo por interação

Cost per interaction = (Input tokens × price_in + Output tokens × price_out)

Objetivo: definido por caso de uso

Checklist de Context Engineering

  • Identificar informações essenciais: liste o mínimo necessário para cada tipo de tarefa
  • Estruturar hierarquicamente: organize por prioridade/relevância
  • Implementar retrieval semântico: use RAG para bases de conhecimento grandes
  • Configurar janela deslizante: defina quantas mensagens manter em conversas longas
  • Comprimir dados repetitivos: resuma históricos e listas extensas
  • Usar lazy loading: carregue contexto adicional sob demanda
  • Medir e otimizar: monitore métricas de eficiência e custo
  • A/B test: compare diferentes estratégias de contexto

Ferramentas e bibliotecas úteis

Vector Databases (para RAG)

  • Pinecone: gerenciado, fácil de começar
  • Weaviate: open-source, rico em features
  • Chroma: leve, ideal para protótipos

Processamento de contexto

// Exemplo: Limitar tokens de contexto
import { encode } from 'gpt-tokenizer';

function truncateContext(text: string, maxTokens: number): string {
  const tokens = encode(text);
  if (tokens.length <= maxTokens) return text;
  
  // Truncar e decodificar
  const truncated = tokens.slice(0, maxTokens);
  return decode(truncated) + "... [contexto truncado]";
}

// Exemplo: Priorização de contexto
interface ContextBlock {
  content: string;
  priority: 'high' | 'medium' | 'low';
  tokens: number;
}

function buildPrioritizedContext(
  blocks: ContextBlock[],
  maxTokens: number
): string {
  const sorted = blocks.sort((a, b) => {
    const priorities = { high: 3, medium: 2, low: 1 };
    return priorities[b.priority] - priorities[a.priority];
  });
  
  let total = 0;
  const selected: string[] = [];
  
  for (const block of sorted) {
    if (total + block.tokens <= maxTokens) {
      selected.push(block.content);
      total += block.tokens;
    } else {
      break;
    }
  }
  
  return selected.join('\n\n');
}

Exemplo completo: Agent de suporte com contexto otimizado

interface OptimizedSupportAgent {
  async handleTicket(ticketId: string) {
    // 1. Carregar contexto mínimo
    const ticket = await db.tickets.findById(ticketId);
    const customer = await db.customers.findById(ticket.customerId, {
      fields: ['id', 'name', 'tier', 'language']
    });
    
    // 2. Buscar conhecimento relevante
    const relevantDocs = await vectorDB.search(ticket.description, {
      limit: 3
    });
    
    // 3. Carregar histórico recente (não tudo!)
    const recentHistory = await db.interactions.find({
      customerId: customer.id,
      limit: 5,
      orderBy: 'createdAt DESC'
    });
    
    // 4. Construir contexto estruturado
    const context = `
[TICKET ATUAL]
ID: ${ticket.id}
Assunto: ${ticket.subject}
Categoria: ${ticket.category}
Prioridade: ${ticket.priority}

[CLIENTE]
Nome: ${customer.name}
Tier: ${customer.tier}
Idioma: ${customer.language}

[CONHECIMENTO RELEVANTE]
${relevantDocs.map(doc => `
- ${doc.title}
  ${doc.content.substring(0, 200)}...
  Fonte: ${doc.url}
`).join('\n')}

[HISTÓRICO RECENTE]
${recentHistory.map(h => `
- ${h.date}: ${h.summary}
`).join('\n')}
`;
    
    // 5. Ferramentas para contexto adicional (se necessário)
    const tools = [
      {
        name: 'getOrderDetails',
        description: 'Busca detalhes de um pedido específico',
        parameters: { orderId: 'string' }
      },
      {
        name: 'searchFullHistory',
        description: 'Busca no histórico completo (use com parcimônia)',
        parameters: { query: 'string', limit: 'number' }
      }
    ];
    
    return { context, tools };
  }
}

Anti-padrões comuns (evite!)

❌ Dump de dados não estruturados

Aqui está tudo sobre o cliente: {JSON.stringify(allCustomerData)}

❌ Contexto duplicado

Cliente: João
Nome do cliente: João
O cliente se chama João

❌ Informações desatualizadas

Status do pedido: em processamento
[na verdade já foi entregue há 2 dias]

❌ Contexto sem hierarquia

Tudo no mesmo nível, sem priorização clara

Conclusão

Context engineering é crucial para agents eficientes e confiáveis. Lembre-se:

  1. Menos é mais: priorize relevância sobre volume
  2. Estruture bem: hierarquia e formatação importam
  3. Seja dinâmico: ajuste o contexto conforme a necessidade
  4. Meça sempre: otimize com base em dados

Comece implementando janela deslizante e retrieval semântico nos seus agents. Os ganhos em custo, latência e qualidade serão imediatos.

Próximo post: Vamos explorar técnicas avançadas de RAG (Retrieval-Augmented Generation) e como implementar busca híbrida (keyword + semantic) para maximizar a precisão dos seus agents.