Construa memória para agentes LLM mais eficientes

O que é e por que usar

Agentes baseados em modelos de linguagem (LLMs) são ferramentas poderosas para automação, mas enfrentam uma limitação crítica: a falta de memória de longo prazo. Em uma conversa ou execução de tarefas, cada interação é tratada como um evento isolado. Isso significa que, se um agente precisa lembrar de uma preferência do usuário, de um dado coletado em uma etapa anterior ou do histórico de uma decisão, ele simplesmente não consegue — a menos que você construa essa memória manualmente.

Construir memória para agentes LLM significa criar um sistema de armazenamento e recuperação de informações relevantes que persistem entre sessões. Em vez de depender apenas do contexto limitado do prompt (que geralmente cabe de 4k a 32k tokens), você pode usar bancos de dados vetoriais, armazenamento em nuvem ou até mesmo um simples arquivo JSON para registrar o que é importante. O resultado é um agente que “aprende” com o tempo, oferecendo respostas mais contextuais, personalizadas e eficientes.

No contexto de automação com n8n, isso é particularmente útil. Você pode criar workflows que não apenas executam tarefas, mas também mantêm um registro do que foi feito, das preferências do usuário e dos resultados anteriores. Isso elimina a necessidade de repetir informações em cada interação e permite que o agente tome decisões mais inteligentes baseadas em dados históricos.

Pré-requisitos

Antes de começar, você precisará ter acesso ou conhecimento básico sobre os seguintes itens:

• Conta no n8n (self-hosted ou n8n.cloud) com permissão para criar workflows e usar nós HTTP Request e de banco de dados.
• Chave de API de um LLM (OpenAI, Anthropic, ou outro provedor compatível com n8n).
• Conceitos básicos de JSON para estruturar os dados de memória.
• Um banco de dados ou serviço de armazenamento (pode ser SQLite, PostgreSQL, Supabase, ou até mesmo um arquivo .json em um serviço como Google Drive ou Dropbox). Para este tutorial, usaremos o Supabase por ser gratuito e fácil de configurar.
• Noção de embeddings (opcional, mas recomendado para buscas semânticas). Se quiser implementar busca por similaridade, precisará de um serviço de embeddings como o da OpenAI ou do Cohere.

Exemplo Prático: Assistente de Suporte que Lembra de Clientes

Cenário concreto: Imagine que você gerencia um pequeno e-commerce e recebe dezenas de mensagens de suporte por dia. Cada cliente entra em contato com dúvidas sobre pedidos, trocas ou prazos. Sem memória, seu agente LLM trataria cada mensagem como se fosse a primeira, ignorando todo o histórico de interações anteriores. Isso gera frustração, repetição de perguntas e perda de tempo.

O que será automatizado: Vamos construir um workflow no n8n que, ao receber uma mensagem de um cliente (via webhook, e-mail ou formulário), consulta um banco de dados de memória para recuperar o histórico completo daquele cliente. O LLM então usa esse contexto para responder de forma personalizada, evitando perguntas redundantes e oferecendo um atendimento mais fluido.

Resultado esperado: O agente responde com base no que já foi discutido. Por exemplo, se o cliente já informou o número do pedido em uma interação anterior, o agente não pergunta novamente. Em vez disso, ele diz: “Olá novamente! Vi que seu pedido #12345 está em trânsito. Como posso ajudar com ele hoje?” O tempo de resolução cai drasticamente e a satisfação do cliente aumenta.

Configuração Passo a Passo

Passo 1: Estruturar o Banco de Memória

Primeiro, crie uma tabela no Supabase (ou outro banco) para armazenar as interações. A estrutura sugerida é:

-- SQL para criar a tabela de memória
CREATE TABLE memory (
  id SERIAL PRIMARY KEY,
  user_id TEXT NOT NULL,
  session_id TEXT,
  role TEXT NOT NULL, -- 'user' ou 'assistant'
  content TEXT NOT NULL,
  timestamp TIMESTAMP DEFAULT NOW(),
  metadata JSONB -- para tags, categorias, etc.
);

-- Índice para busca rápida por user_id
CREATE INDEX idx_user_id ON memory (user_id);

Essa tabela guarda cada mensagem trocada com o agente, associada a um user_id (pode ser e-mail, ID do cliente ou qualquer identificador único).

Passo 2: Criar o Workflow no n8n

No n8n, crie um novo workflow com os seguintes nós:

1. Webhook Node (trigger) — Recebe a mensagem do cliente via POST. Configure o método como POST e o path como /chat. O corpo da requisição deve conter user_id e message.
2. HTTP Request Node — Conecta ao Supabase para buscar o histórico do cliente. Use a API REST do Supabase. Exemplo de configuração:
   • Method: GET
   • URL: https://seuprojeto.supabase.co/rest/v1/memory?user_id=eq.{{ $json.user_id }}&order=timestamp.asc
   • Headers: Adicione apikey e Authorization: Bearer com sua chave de serviço do Supabase.
3. Function Node — Processa o histórico retornado. Transforma os registros em um array de mensagens no formato esperado pelo LLM (ex: [{role: "user", content: "..."}, {role: "assistant", content: "..."}]).
4. OpenAI Node (ou outro LLM) — Envia o histórico + a nova mensagem para o modelo. Configure:
   • Model: gpt-3.5-turbo ou gpt-4
   • Messages: Use a saída do Function Node + a mensagem atual.
   • System Prompt: Defina o comportamento do agente (ex: “Você é um assistente de suporte educado e eficiente.”)
5. HTTP Request Node (segundo) — Salva a nova interação no Supabase. Envie um POST para a mesma tabela com user_id, role: "user", content: {{ mensagem }} e depois outro POST com a resposta do LLM como role: "assistant".
6. Respond to Webhook Node — Devolve a resposta do LLM para o cliente.

Passo 3: Configurar o Fluxo de Dados

Aqui está um exemplo de como o JSON de configuração do workflow pode se parecer (simplificado):

{
  "name": "Agente com Memória",
  "nodes": [
    {
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "/chat",
        "responseMode": "responseNode"
      }
    },
    {
      "name": "Buscar Histórico",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "method": "GET",
        "url": "https://seuprojeto.supabase.co/rest/v1/memory?user_id=eq.{{ $json.user_id }}&order=timestamp.asc",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {"name": "apikey", "value": "SUA_CHAVE"},
            {"name": "Authorization", "value": "Bearer SUA_CHAVE"}
          ]
        }
      }
    },
    {
      "name": "Processar Histórico",
      "type": "n8n-nodes-base.function",
      "parameters": {
        "functionCode": "const history = $input.all().map(item => ({role: item.json.role, content: item.json.content})); return history;"
      }
    },
    {
      "name": "LLM",
      "type": "n8n-nodes-base.openAi",
      "parameters": {
        "model": "gpt-3.5-turbo",
        "messages": {
          "values": [
            {"role": "system", "content": "Você é um assistente de suporte."},
            {"role": "user", "content": "={{ $json.message }}"}
          ]
        }
      }
    }
  ]
}

Dicas e Variações

• Use sumarização para históricos longos: Se o histórico for muito extenso (centenas de mensagens), crie um nó Function que resume as interações mais antigas antes de enviar ao LLM. Isso economiza tokens e mantém a performance.
• Adicione metadados para filtragem: Na coluna metadata do banco, armazene tags como “pedido”, “reclamação”, “urgente”. Isso permite que o agente busque apenas interações relevantes para o contexto atual.
• Implemente busca semântica: Em vez de buscar todo o histórico, use embeddings para encontrar as mensagens mais similares à pergunta atual. No n8n, você pode usar o nó “Embeddings” da OpenAI e armazenar os vetores no Supabase com a extensão pgvector.
• Expire memórias antigas: Configure um cron job no n8n (por exemplo, a cada 30 dias) para deletar registros com timestamp superior a 90 dias. Isso mantém o banco leve e evita que o agente use informações desatualizadas.
• Personalize por sessão: Se o mesmo usuário tiver múltiplas sessões (ex: chat no site e e-mail), use o session_id para separar contextos. Assim, o agente não mistura conversas diferentes.

Erros Comuns e Como Evitá-los

• Enviar o histórico inteiro sem limite de tokens: O LLM tem um limite de contexto. Se o histórico for muito longo, a resposta pode ser truncada ou o custo dispara. Solução: limite o número de mensagens recuperadas (ex: últimas 20) ou use sumarização.
• Esquecer de salvar a resposta do LLM: Se você só salva a mensagem do usuário, o histórico fica incompleto. Sempre registre tanto a pergunta quanto a resposta para manter o contexto bidirecional.
• Não tratar erros de banco de dados: Se o Supabase estiver fora do ar, o workflow quebra. Adicione um nó “Error Trigger” ou um “IF” para verificar se a resposta HTTP foi bem-sucedida. Em caso de falha, use um fallback (ex: responder sem histórico).
• Ignorar a privacidade dos dados: Armazenar conversas de clientes exige cuidado. Use criptografia nos dados sensíveis e garanta que o user_id não seja um dado pessoal identificável (prefira IDs internos).
• Usar o mesmo contexto para todos os usuários: Se você não filtrar por user_id, o agente pode confundir informações de clientes diferentes. Sempre inclua o filtro na consulta ao banco.

Próximos Passos

Agora que você tem um agente com memória funcional, o próximo passo é refinar e expandir o sistema. Aqui estão três ações concretas:

1. Implemente a busca semântica: Substitua a busca linear por uma consulta vetorial usando pgvector no Supabase e o nó de embeddings do n8n. Isso permite que o agente encontre informações relevantes mesmo que o cliente use palavras diferentes.
2. Crie um dashboard de monitoramento: Use um nó “HTTP Request” para enviar métricas (número de interações, tempo médio de resposta, tópicos mais comuns) para um serviço como Google Sheets ou um banco analítico. Isso ajuda a identificar gargalos.
3. Adicione um mecanismo de feedback: Após cada resposta, peça que o cliente avalie (positivo/negativo) e armazene isso no banco. Use esses dados para ajustar o prompt do sistema ou treinar um modelo fino.

Construir memória para agentes LLM não é apenas um exercício técnico — é a diferença entre um assistente genérico e um que realmente entende o contexto do usuário. Comece com o exemplo acima, teste com dados reais e ajuste conforme sua necessidade. A automação inteligente começa com a capacidade de lembrar.