Blog

Como Adicionar Memória Persistente ao Seu Agente de IA (Para Lembrar de Ontem)

Ashley Innocent

Ashley Innocent

19 março 2026

Como Adicionar Memória Persistente ao Seu Agente de IA (Para Lembrar de Ontem)

TL;DR

Adicione memória persistente a agentes de IA em 4 etapas: (1) Configure um servidor de memória MCP com as ferramentas remember, recall, search e rollback, (2) Adicione instruções de memória aos prompts do agente, (3) Configure ~/.claude/settings.json para Claude Code ou .cursor/mcp.json para Cursor, (4) Use padrões de memória para registro de decisões, transferências de agente e pontos de verificação de sessão. Agentes retêm contexto entre sessões — chega de copiar e colar conversas anteriores.

Resolva o problema “Não lembro de ontem”. Adicione memória persistente a agentes de IA usando o protocolo MCP, e eles se lembrarão de decisões, entregáveis e contexto de sessões anteriores.

Você conhece a rotina:

Day 1: "Build the user authentication system"
Agent: [Builds JWT auth, creates users table, implements refresh tokens]

Day 2: "Continue from yesterday"
Agent: "I don't have context from previous sessions. Can you paste what we did?"

Você copia e cola a conversa anterior. O agente lê 2000 linhas de contexto. Ambos perdem 15 minutos para se atualizar.

Memória persistente resolve isso. Com a memória MCP (Model Context Protocol), os agentes armazenam decisões automaticamente e as recuperam quando necessário. Sem copiar e colar. Sem re-explicações.

Neste tutorial, você configurará a memória MCP para agentes de IA. Você aprenderá como armazenar decisões de sessões do Arquiteto de Backend, recuperar contexto ao mudar para o Otimizador de Banco de Dados e entregar resultados ao Desenvolvedor Frontend — tudo sem perder o contexto. Os mesmos padrões de memória funcionam se você estiver construindo APIs com integração Apidog ou gerenciando sprints de desenvolvimento de vários dias.

botão

O Que É Memória MCP?

A memória MCP permite que agentes de IA armazenem e recuperem informações entre sessões. Pense nela como um caderno compartilhado onde os agentes podem escrever e ler.

Quatro ferramentas alimentam a memória MCP:

Ferramenta Propósito Exemplo
remember Armazenar informações com tags Salvar “tabela de usuários com UUID, bcrypt”
recall Pesquisar por palavra-chave ou tag Encontrar “decisões de auth”
rollback Restaurar para um estado anterior Desfazer alterações de esquema ruins
search Encontrar entre sessões “O que o Arquiteto de Backend decidiu?” 
┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  Agente de IA   │         │  Servidor        │         │  Armazenamento│
│  (Claude Code)  │◄───────►│  de Memória MCP  │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

Passo 1: Configure um Servidor de Memória MCP

Você precisa de um servidor MCP que exponha ferramentas de memória. Existem várias implementações de código aberto.

Opção A: Use um servidor de memória hospedado

npm install -g @example/mcp-memory-server

Opção B: Execute um servidor local simples

Crie memory-server.js:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const MEMORY_FILE = path.join(process.env.HOME, ".mcp-memory", "memories.json");

const server = new McpServer({
  name: "memory",
  version: "1.0.0"
});

// Ensure memory file exists
async function initMemory() {
  await fs.mkdir(path.dirname(MEMORY_FILE), { recursive: true });
  try {
    await fs.access(MEMORY_FILE);
  } catch {
    await fs.writeFile(MEMORY_FILE, JSON.stringify([]));
  }
}

// Tool: remember
server.tool(
  "remember",
  {
    content: z.string().describe("Information to store"),
    tags: z.array(z.string()).describe("Tags for retrieval (e.g., ['backend', 'auth'])"),
    agent: z.string().optional().describe("Agent name for tagging")
  },
  async ({ content, tags, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const memory = {
      id: Date.now().toString(),
      content,
      tags,
      agent,
      timestamp: new Date().toISOString()
    };
    memories.push(memory);
    await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2));
    return { content: [{ type: "text", text: `Stored memory with tags: ${tags.join(", ")}` }] };
  }
);

// Tool: recall
server.tool(
  "recall",
  {
    query: z.string().describe("Search query or tag to find"),
    agent: z.string().optional().describe("Filter by agent name")
  },
  async ({ query, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories.filter(m => {
      const matchesQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
                          m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()));
      const matchesAgent = !agent || m.agent === agent;
      return matchesQuery && matchesAgent;
    });
    return {
      content: [{
        type: "text",
        text: results.length === 0
          ? "No memories found"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Tags to search for"),
    limit: z.number().optional().default(10)
  },
  async ({ tags, limit }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories
      .filter(m => tags.some(t => m.tags.includes(t)))
      .slice(0, limit);
    return {
      content: [{
        type: "text",
        text: results.map(m => `[${m.agent || "unknown"}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: rollback
server.tool(
  "rollback",
  {
    agent: z.string().describe("Agent name to rollback"),
    timestamp: z.string().describe("Rollback to this timestamp")
  },
  async ({ agent, timestamp }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const rolledBack = memories.filter(m =>
      m.agent !== agent || new Date(m.timestamp) <= new Date(timestamp)
    );
    await fs.writeFile(MEMORY_FILE, JSON.stringify(rolledBack, null, 2));
    return {
      content: [{
        type: "text",
        text: `Rolled back ${agent} to ${timestamp}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Execute o servidor:

node memory-server.js

Passo 2: Adicione Instruções de Memória a Qualquer Agente

Você não precisa modificar os arquivos do agente. Adicione instruções de memória em seu prompt:

Você tem acesso às ferramentas de memória MCP: remember, recall, search, rollback.

Siga estes protocolos de memória:

**Ao iniciar uma sessão:**
1. Recupere o contexto: recall(query="ecommerce-api", agent="Backend Architect")
2. Revise os itens pendentes da última sessão

**Ao concluir o trabalho:**
1. Lembre-se dos entregáveis com tags:
   - remember(content="Criada tabela de usuários com chave primária UUID, hash de senha bcrypt, autenticação JWT com tokens de atualização", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Inclua as decisões tomadas e os itens pendentes

**Ao transferir para outro agente:**
1. Deixe o contexto para o agente receptor:
   - remember(content="Endpoints da API: /auth/login, /auth/register, /products, /orders. Fluxo de autenticação: token de acesso JWT (15min) + token de atualização (7 dias). Problema conhecido: limitação de taxa ainda não implementada", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Quando algo falha:**
1. Procure pelo último estado funcional conhecido
2. Use rollback para restaurar

Exemplo em ação:

Você: "Ative o modo Arquiteto de Backend. Projete o sistema de usuário para nossa API de e-commerce."

[Agente projeta o sistema, cria esquema, implementa autenticação]

Agente: "Sistema de usuário completo. Armazenando memória..."
→ Chama: remember("tabela de usuários com UUID, bcrypt, JWT + tokens de atualização", tags: ["ecommerce-api", "auth", "database"])

[Sessão termina]

[Dia seguinte]

Você: "Continue de ontem"

Agente: "Recuperando contexto..."
→ Chama: recall(query="ecommerce-api")
→ Retorna: "tabela de usuários com UUID, bcrypt, JWT + tokens de atualização"

Agente: "Ontem eu projetei a tabela de usuários com chaves primárias UUID, implementei hash de senha bcrypt e configurei a autenticação JWT com tokens de atualização. Próximo passo: esquema do catálogo de produtos. Pronto para continuar."

Passo 3: Configurar para Claude Code

Adicione o servidor de memória à sua configuração MCP:

Edite ~/.claude/settings.json:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/your-username"
      }
    }
  }
}

Reinicie o Claude Code. As ferramentas de memória agora devem estar disponíveis.

Teste:

Use a ferramenta remember para armazenar: "Memória de teste para projeto de e-commerce"
Tags: ["test", "ecommerce-api"]

Use a ferramenta recall para encontrar memórias sobre "test"

Passo 4: Configurar para Cursor

Crie .cursor/mcp.json em seu projeto:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"]
    }
  }
}

Teste:

@memory remember "Iniciando projeto de API de e-commerce com PostgreSQL"
Tags: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Padrões de Memória para Fluxos de Trabalho Reais

Padrão 1: Registro de Decisões

Toda vez que você tomar uma decisão técnica, registre-a:

remember({
  content: "Escolheu PostgreSQL em vez de MySQL para: (1) suporte JSONB para atributos de produto flexíveis, (2) melhor busca de texto completo, (3) suporte nativo a UUID",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Mais tarde, quando alguém perguntar “Por que PostgreSQL?”:

recall(query="decisão PostgreSQL MySQL")

Padrão 2: Transferências de Agente

Ao trocar de agente, deixe uma nota de transferência:

remember({
  content: "Backend completo. Endpoints: POST /auth/login, POST /auth/register, GET /products, POST /orders. Autenticação: JWT 15min acesso + 7 dias refresh. Pendente: limitação de taxa, verificação de e-mail. Frontend precisa: formulário de login, lista de produtos, carrinho, checkout.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

O Desenvolvedor Frontend começa com:

recall(query="transferência", agent="Backend Architect")

Padrão 3: Pontos de Verificação da Sessão

No final de cada sessão de trabalho:

remember({
  content: "Sessão completa. Concluído: tabela de usuários, endpoints de autenticação, esquema de produto. Próxima sessão: sistema de pedidos, webhook de pagamento. Bloqueadores: aguardando chaves da API Stripe.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Retomar a próxima sessão:

recall(query="checkpoint sessão-1")

Padrão 4: Rastreamento de Bugs

Quando você encontrar um bug:

remember({
  content: "BUG: Token de atualização não expira após logout. Token armazenado em memória, não persistido. Correção: mover para Redis com TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Revisor de Código",
  severity: "high"
})

Procure por bugs mais tarde:

search(tags=["bug", "ecommerce-api"])

Solução de Problemas

Memória não persistindo:

Muitos resultados na recuperação:

Arquivo de memória crescendo muito:

O Que Você Construiu

Componente Propósito
Servidor de Memória MCP Armazena/recupera informações entre sessões
Ferramenta remember Registra decisões, entregáveis, transferências
Ferramenta recall Encontra contexto de sessões anteriores
Ferramenta search Consulta por tags em todas as memórias
Ferramenta rollback Restaura para um estado anterior quando necessário
Padrões de memória Registro de decisões, transferências, pontos de verificação, rastreamento de bugs

Próximos Passos

Estenda o servidor de memória:

Construa memória de equipe:

Integre com ferramentas:

Solução de Problemas Comuns

Memória não persistindo entre sessões:

Recall retorna resultados vazios:

Arquivo de memória crescendo demais:

Servidor falha ao iniciar:

Múltiplos agentes sobrescrevendo as memórias uns dos outros:

Considerações de Segurança do Servidor de Memória

Armazenamento de Chaves de API:Se o seu servidor de memória armazena dados sensíveis (chaves de API, senhas), implemente criptografia:

import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.MEMORY_ENCRYPTION_KEY;
const ALGORITHM = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY), iv);
  const encrypted = cipher.update(text, 'utf8', 'hex');
  return {
    encryptedData: encrypted + cipher.final('hex'),
    iv: iv.toString('hex'),
    authTag: cipher.getAuthTag().toString('hex')
  };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY),
    Buffer.from(encrypted.iv, 'hex')
  );
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  return decipher.update(encrypted.encryptedData, 'hex', 'utf8') + decipher.final('utf8');
}

Controle de Acesso:Para servidores de memória de equipe, adicione autenticação:

Seus agentes de IA agora têm memória persistente. Eles lembram de ontem. Eles recuperam decisões. Eles transferem contexto sem copiar e colar.

Chega de “Não tenho contexto de sessões anteriores.” Chega de re-explicar. Chega de tempo desperdiçado.

Esse é o poder da memória MCP: dê aos seus agentes um caderno compartilhado, e observe-os se tornarem realmente úteis em projetos de vários dias.

botão

Perguntas Frequentes

O que é memória MCP?A memória MCP é uma implementação de protocolo que permite aos agentes de IA armazenar e recuperar informações entre sessões. Pense nela como um caderno compartilhado onde os agentes podem escrever e ler, persistindo o contexto além de conversas únicas.

Como configuro memória persistente para Claude Code?Instale um servidor de memória MCP, depois adicione-o a ~/.claude/settings.json com o comando e caminho do servidor. Reinicie o Claude Code e as ferramentas de memória (remember, recall, search, rollback) se tornarão disponíveis.

Quais agentes de IA suportam memória MCP?Qualquer agente rodando em clientes compatíveis com MCP (Claude Code, Cursor, Windsurf) pode usar ferramentas de memória. Você não precisa modificar os arquivos do agente — apenas adicione instruções de memória aos seus prompts.

Quais são os melhores padrões de memória para transferências de agente?Use remember com tags como ["transferência", "nome-do-projeto"] para deixar contexto para o próximo agente. Inclua o trabalho concluído, itens pendentes e problemas conhecidos. O agente receptor chama recall(query="transferência") para recuperá-lo.

Quanto de memória os servidores MCP podem armazenar?Depende da implementação. O servidor de referência usa um arquivo JSON que cresce indefinidamente. Servidores de produção devem adicionar políticas de expiração, arquivamento automático ou backends de banco de dados para uso em larga escala.

As equipes podem compartilhar um servidor de memória central?Sim. Execute o servidor de memória em uma máquina compartilhada ou instância na nuvem, configure os clientes de todos os membros da equipe para se conectarem a ele e marque as memórias por projeto e desenvolvedor para recuperação organizada.

E se a recuperação de memória retornar muitos resultados?Adicione tags mais específicas ao armazenar memórias. Filtre por nome do agente em suas consultas de recuperação. Use frases exatas entre aspas. Considere implementar pesquisa semântica com embeddings para uma recuperação mais inteligente.

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar