Blog

Cómo Añadir Memoria Persistente a Agentes de IA para Recordar el Pasado

Ashley Innocent

Ashley Innocent

19 March 2026

Cómo Añadir Memoria Persistente a Agentes de IA para Recordar el Pasado

Apidog para empresas

Despliegue local

SSO & RBAC

Conforme con SOC 2

Explorar Apidog Enterprise

En resumen

Añade memoria persistente a los agentes de IA en 4 pasos: (1) Configura un servidor de memoria MCP con las herramientas remember, recall, search y rollback, (2) Añade instrucciones de memoria a los prompts del agente, (3) Configura ~/.claude/settings.json para Claude Code o .cursor/mcp.json para Cursor, (4) Usa patrones de memoria para el registro de decisiones, traspasos entre agentes y puntos de control de sesión. Los agentes retienen el contexto entre sesiones, sin más copiar y pegar conversaciones anteriores.

Resuelve el problema de "no recuerdo lo de ayer". Añade memoria persistente a los agentes de IA utilizando el protocolo MCP, y recordarán decisiones, entregables y contexto de sesiones anteriores.

Ya conoces la dinámica:

Día 1: "Construir el sistema de autenticación de usuarios"
Agente: [Construye la autenticación JWT, crea la tabla de usuarios, implementa tokens de actualización]

Día 2: "Continuar desde ayer"
Agente: "No tengo contexto de sesiones anteriores. ¿Puedes pegar lo que hicimos?"

Copias y pegas la conversación anterior. El agente lee 2000 líneas de contexto. Ambos perdéis 15 minutos poniéndoos al día.

La memoria persistente soluciona esto. Con la memoria MCP (Model Context Protocol), los agentes almacenan decisiones automáticamente y las recuperan cuando es necesario. Sin copiar y pegar. Sin volver a explicar.

En este tutorial, configurarás la memoria MCP para agentes de IA. Aprenderás a almacenar decisiones de sesiones de Backend Architect, recordar contexto al cambiar a Database Optimizer y traspasar entregables a Frontend Developer, todo sin perder contexto. Los mismos patrones de memoria funcionan tanto si estás construyendo APIs con integración Apidog como si gestionas sprints de desarrollo de varios días.

botón

¿Qué es la memoria MCP?

La memoria MCP permite a los agentes de IA almacenar y recuperar información entre sesiones. Piensa en ella como un cuaderno compartido en el que los agentes pueden escribir y leer.

Cuatro herramientas impulsan la memoria MCP:

Herramienta Propósito Ejemplo
remember Almacenar información con etiquetas Guardar "tabla de usuarios con UUID, bcrypt"
recall Buscar por palabra clave o etiqueta Encontrar "decisiones de auth"
rollback Restaurar a un estado anterior Deshacer cambios de esquema erróneos
search Buscar entre sesiones "¿Qué decidió el arquitecto de backend?" 
┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  Agente de IA   │         │  Memoria MCP     │         │  Almacenam. │
│  (Claude Code)  │◄───────►│  Servidor        │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  E/S    └─────────────┘

Paso 1: Configurar un servidor de memoria MCP

Necesitas un servidor MCP que exponga herramientas de memoria. Existen varias implementaciones de código abierto.

Opción A: Usar un servidor de memoria alojado

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

Opción B: Ejecutar un servidor local simple

Crea 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);

Ejecuta el servidor:

node memory-server.js

Paso 2: Añadir instrucciones de memoria a cualquier agente

No necesitas modificar los archivos del agente. Añade instrucciones de memoria en tu prompt:

Tienes acceso a las herramientas de memoria MCP: remember, recall, search, rollback.

Sigue estos protocolos de memoria:

**Cuando inicies una sesión:**
1. Recordar contexto: recall(query="ecommerce-api", agent="Backend Architect")
2. Revisar los elementos pendientes de la última sesión

**Cuando completes el trabajo:**
1. Recordar entregables con etiquetas:
   - remember(content="Creada tabla de usuarios con clave primaria UUID, hashing de contraseña bcrypt, autenticación JWT con tokens de actualización", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Incluir decisiones tomadas y elementos pendientes

**Al traspasar a otro agente:**
1. Dejar contexto para el agente receptor:
   - remember(content="Endpoints de API: /auth/login, /auth/register, /products, /orders. Flujo de autenticación: token de acceso JWT (15min) + token de actualización (7 días). Problema conocido: la limitación de velocidad aún no está implementada", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Cuando algo falle:**
1. Buscar el último estado bueno conocido
2. Usar rollback para restaurar

Ejemplo en acción:

Tú: "Activa el modo Arquitecto de Backend. Diseña el sistema de usuarios para nuestra API de comercio electrónico."

[El agente diseña el sistema, crea el esquema, implementa la autenticación]

Agente: "Sistema de usuarios completado. Almacenando memoria..."
→ Llama a: remember("tabla de usuarios con UUID, bcrypt, JWT + tokens de actualización", tags: ["ecommerce-api", "auth", "database"])

[La sesión termina]

[Al día siguiente]

Tú: "Continuar desde ayer"

Agente: "Recuperando contexto..."
→ Llama a: recall(query="ecommerce-api")
→ Devuelve: "tabla de usuarios con UUID, bcrypt, JWT + tokens de actualización"

Agente: "Ayer diseñé la tabla de usuarios con claves primarias UUID, implementé el hashing de contraseñas bcrypt y configuré la autenticación JWT con tokens de actualización. Siguiente paso: esquema de catálogo de productos. Listo para continuar."

Paso 3: Configurar para Claude Code

Añade el servidor de memoria a tu configuración MCP:

Edita ~/.claude/settings.json:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/tu-nombre-de-usuario"
      }
    }
  }
}

Reinicia Claude Code. Las herramientas de memoria deberían estar disponibles ahora.

Pruébalo:

Usa la herramienta remember para almacenar: "Memoria de prueba para el proyecto de comercio electrónico"
Tags: ["test", "ecommerce-api"]

Usa la herramienta recall para encontrar memorias sobre "test"

Paso 4: Configurar para Cursor

Crea .cursor/mcp.json en tu proyecto:

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

Pruébalo:

@memory remember "Iniciando proyecto de API de comercio electrónico con PostgreSQL"
Tags: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Patrones de memoria para flujos de trabajo reales

Patrón 1: Registro de decisiones

Cada vez que tomes una decisión técnica, regístrala:

remember({
  content: "Se eligió PostgreSQL sobre MySQL por: (1) soporte JSONB para atributos de producto flexibles, (2) mejor búsqueda de texto completo, (3) soporte nativo de UUID",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Más tarde, cuando alguien pregunte "¿Por qué PostgreSQL?":

recall(query="PostgreSQL MySQL decision")

Patrón 2: Traspasos entre agentes

Al cambiar de agente, deja una nota de traspaso:

remember({
  content: "Backend completado. Endpoints: POST /auth/login, POST /auth/register, GET /products, POST /orders. Auth: acceso JWT 15min + actualización 7 días. Pendiente: limitación de velocidad, verificación de email. Necesidades de Frontend: formulario de login, lista de productos, carrito, checkout.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Frontend Developer comienza con:

recall(query="handoff", agent="Backend Architect")

Patrón 3: Puntos de control de sesión

Al final de cada sesión de trabajo:

remember({
  content: "Sesión completada. Hecho: tabla de usuarios, endpoints de autenticación, esquema de producto. Siguiente sesión: sistema de pedidos, webhook de pago. Bloqueantes: esperando claves API de Stripe.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Reanudar la siguiente sesión:

recall(query="checkpoint session-1")

Patrón 4: Seguimiento de errores

Cuando encuentres un error:

remember({
  content: "BUG: El token de actualización no expira después del logout. Token almacenado en memoria, no persistido. Solución: mover a Redis con TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Buscar errores más tarde:

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

Resolución de problemas

La memoria no persiste:

Demasiados resultados al recuperar:

El archivo de memoria crece demasiado:

Lo que construiste

Componente Propósito
Servidor de memoria MCP Almacena/recupera información entre sesiones
Herramienta remember Registra decisiones, entregables, traspasos
Herramienta recall Encuentra contexto de sesiones anteriores
Herramienta search Consulta por etiquetas en todas las memorias
Herramienta rollback Restaura a un estado anterior cuando sea necesario
Patrones de memoria Registro de decisiones, traspasos, puntos de control, seguimiento de errores

Próximos pasos

Extender el servidor de memoria:

Construir memoria de equipo:

Integrar con herramientas:

Resolución de problemas comunes

La memoria no persiste entre sesiones:

La recuperación devuelve resultados vacíos:

El archivo de memoria crece demasiado:

El servidor no se inicia:

Múltiples agentes sobrescribiendo las memorias de otros:

Consideraciones de seguridad del servidor de memoria

Almacenamiento de claves API: Si tu servidor de memoria almacena datos sensibles (claves API, contraseñas), implementa cifrado:

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');
}

Control de acceso: Para servidores de memoria de equipo, añade autenticación:

Tus agentes de IA ahora tienen memoria persistente. Recuerdan lo de ayer. Recuperan decisiones. Traspasan contexto sin copiar y pegar.

No más "no tengo contexto de sesiones anteriores". No más volver a explicar. No más tiempo perdido.

Ese es el poder de la memoria MCP: dale a tus agentes un cuaderno compartido y observa cómo se vuelven realmente útiles en proyectos de varios días.

botón

Preguntas frecuentes

¿Qué es la memoria MCP? La memoria MCP es una implementación de protocolo que permite a los agentes de IA almacenar y recuperar información entre sesiones. Piensa en ella como un cuaderno compartido en el que los agentes pueden escribir y leer, persistiendo el contexto más allá de las conversaciones individuales.

¿Cómo configuro la memoria persistente para Claude Code? Instala un servidor de memoria MCP y luego añádelo a ~/.claude/settings.json con el comando y la ruta del servidor. Reinicia Claude Code y las herramientas de memoria (remember, recall, search, rollback) estarán disponibles.

¿Qué agentes de IA son compatibles con la memoria MCP? Cualquier agente que se ejecute en clientes compatibles con MCP (Claude Code, Cursor, Windsurf) puede usar las herramientas de memoria. No necesitas modificar los archivos del agente, simplemente añade instrucciones de memoria a tus prompts.

¿Cuáles son los mejores patrones de memoria para los traspasos entre agentes? Usa remember con etiquetas como ["handoff", "nombre-del-proyecto"] para dejar contexto al siguiente agente. Incluye el trabajo completado, los elementos pendientes y los problemas conocidos. El agente receptor llama a recall(query="handoff") para recuperarlo.

¿Cuánta memoria pueden almacenar los servidores MCP? Depende de la implementación. El servidor de referencia utiliza un archivo JSON que crece indefinidamente. Los servidores de producción deberían añadir políticas de expiración, autoarchivo o backends de base de datos para un uso a gran escala.

¿Pueden los equipos compartir un servidor de memoria central? Sí. Ejecuta el servidor de memoria en una máquina compartida o instancia en la nube, configura los clientes de todos los miembros del equipo para que se conecten a él y etiqueta las memorias por proyecto y desarrollador para una recuperación organizada.

¿Qué pasa si la recuperación de memoria devuelve demasiados resultados? Añade etiquetas más específicas al almacenar memorias. Filtra por nombre de agente en tus consultas de recuperación. Usa frases exactas entre comillas. Considera implementar la búsqueda semántica con embeddings para una recuperación más inteligente.

Practica el diseño de API en Apidog

Descubre una forma más fácil de construir y usar APIs

Registrarse gratisDescargar