Mem0 MCP

Se integra con Mem0.ai para proporcionar capacidades de memoria persistente para LLMs, compatible con almacenamiento en la nube, Supabase y local.

GitHub

Prueba este MCPPatrocinado

Documentación

Servidor MCP @pinkpixel/mem0-mcp ✨

Un servidor de Protocolo de Contexto de Modelo (MCP) que se integra con Mem0.ai para proporcionar capacidades de memoria persistente para LLMs. Permite que los agentes de IA almacenen y recuperen información entre sesiones.

Este servidor utiliza el SDK de Node.js mem0ai para su funcionalidad principal.

Características 🧠

Herramientas Modernizadas y Avanzadas (v0.8.0)

add_memory: Almacena una memoria a partir de contenido de texto o arreglos de mensajes estructurados.
- Entradas: content (cadena) o messages (arreglo de objetos de rol/contenido), userId (cadena), runId / sessionId (cadena), agentId (cadena), appId (cadena), metadata (objeto), infer (booleano), customInstructions (cadena), waitForCompletion (booleano, predeterminado: true), timeoutMs (número, predeterminado: 15000)
- Comportamiento: Las adiciones de Cloud V3 son asíncronas. De forma predeterminada, esta herramienta consulta la cola en segundo plano hasta que se completa. Pase waitForCompletion: false para obtener el eventId inmediatamente.
search_memories: Busca memorias utilizando filtros híbridos semánticos y BM25.
- Entradas: query (cadena), userId (cadena), runId / sessionId (cadena), agentId (cadena), appId (cadena), filters (objeto), threshold (número), topK (número), rerank (booleano), referenceDate (cadena)
- Comportamiento: Anida automáticamente las variables de alcance dentro del bloque V3 filters para evitar errores de validación de la API.
search_memory: Alias compatible con versiones anteriores para search_memories.
list_memories: Listado paginado de registros de memoria con alcance por identificadores.
- Entradas: userId (cadena), runId / sessionId (cadena), agentId (cadena), appId (cadena), filters (objeto), page (número), pageSize (número)
get_memory: Recupera un único registro de memoria por su ID.
- Entradas: memoryId (cadena)
update_memory: Modifica el texto o los metadatos de una memoria existente.
- Entradas: memoryId (cadena), text (cadena), metadata (objeto)
delete_memory: Elimina un registro de memoria específico por ID.
- Entradas: memoryId (cadena)
get_memory_history: Recupera el rastro de auditoría de las revisiones de memoria (solo nube).
- Entradas: memoryId (cadena)
get_memory_capabilities: Expone la matriz de características y los indicadores de soporte del modo de almacenamiento backend activo.
- Entradas: Ninguna
batch_update_memories: Realiza actualizaciones masivas de contenidos de texto para múltiples memorias (solo nube).
- Entradas: updates (arreglo de objetos { memoryId: string, text: string })
batch_delete_memories: Realiza eliminaciones masivas de múltiples memorias.
- Entradas: memoryIds (arreglo de cadenas), confirm (booleano, debe ser true para ejecutar)
rate_memory: Envía evaluación de retroalimentación de calidad para un registro de memoria (solo nube).
- Entradas: memoryId (cadena), feedback (cadena: positive, negative, very_negative), reason (cadena, opcional)
get_memory_event: Recupera manualmente los detalles de un trabajo de evento en segundo plano específico (solo nube).
- Entradas: eventId (cadena)
list_memory_events: Lista los registros de historial de eventos de procesamiento de memoria en segundo plano (solo nube).
- Entradas: page (número), pageSize (número)
create_memory_export: Inicia un trabajo de consulta de exportación de memoria asíncrona (solo nube).
- Entradas: schema (objeto), filters (objeto, opcional), exportInstructions (cadena, opcional)
get_memory_export: Recupera el estado y los metadatos de descarga de un trabajo de exportación de memoria (solo nube).
- Entradas: exportId (cadena)

Requisitos Previos 🔑

Este servidor admite tres modos de almacenamiento:

Modo de Almacenamiento en la Nube ☁️ (Recomendado para producción)
- Requiere una clave de API de Mem0 (proporcionada como variable de entorno MEM0_API_KEY)
- Las memorias se almacenan de forma persistente en los servidores en la nube de Mem0
- No se necesita base de datos local
- Soporte completo de características con filtrado y búsqueda avanzados
Modo de Almacenamiento Supabase 🗄️ (Recomendado para autoalojamiento)
- Requiere credenciales de Supabase (variables de entorno SUPABASE_URL y SUPABASE_KEY)
- Requiere clave de API de OpenAI (variable de entorno OPENAI_API_KEY) para incrustaciones
- Las memorias se almacenan de forma persistente en su base de datos de Supabase
- Nivel gratuito disponible, opción autoalojable
- Requiere configuración inicial de la base de datos (migraciones SQL proporcionadas a continuación)
Modo de Almacenamiento Local 💾 (Solo desarrollo/pruebas)
- Requiere una clave de API de OpenAI (proporcionada como variable de entorno OPENAI_API_KEY)
- Las memorias se almacenan en una base de datos vectorial en memoria (no persistente por defecto)
- Los datos se pierden cuando el servidor se reinicia a menos que se configure para almacenamiento persistente

Instalación y Configuración ⚙️

Puede ejecutar este servidor de tres maneras principales:

Instalación a través de Smithery

Para instalar Mem0 Memory Server para Claude Desktop automáticamente a través de Smithery:

npx -y @smithery/cli install @pinkpixel-dev/mem0-mcp-server --client claude

1. Instalación Global (Recomendada para uso frecuente)

Instale el paquete globalmente y use el comando mem0-mcp:

npm install -g @pinkpixel/mem0-mcp

Después de la instalación global, puede ejecutar el servidor directamente:

mem0-mcp

Configure su cliente MCP para usar el comando global:

Configuración de Almacenamiento en la Nube (Instalación Global)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "mem0-mcp",
      "args": [],
      "env": {
        "MEM0_API_KEY": "YOUR_MEM0_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Supabase (Instalación Global)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "mem0-mcp",
      "args": [],
      "env": {
        "SUPABASE_URL": "YOUR_SUPABASE_PROJECT_URL",
        "SUPABASE_KEY": "YOUR_SUPABASE_ANON_KEY",
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Local (Instalación Global)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "mem0-mcp",
      "args": [],
      "env": {
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123"
      }
    }
  }
}

2. Usando `npx` (Recomendado para uso ocasional)

Configure su cliente MCP (por ejemplo, Claude Desktop, Cursor, Cline, Roo Code, etc.) para ejecutar el servidor usando npx:

Configuración de Almacenamiento en la Nube (npx)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@pinkpixel/mem0-mcp"
      ],
      "env": {
        "MEM0_API_KEY": "YOUR_MEM0_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Supabase (npx)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@pinkpixel/mem0-mcp"
      ],
      "env": {
        "SUPABASE_URL": "YOUR_SUPABASE_PROJECT_URL",
        "SUPABASE_KEY": "YOUR_SUPABASE_ANON_KEY",
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Local (npx)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@pinkpixel/mem0-mcp"
      ],
      "env": {
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123"
      }
    }
  }
}

3. Ejecución desde Repositorio Clonado

Nota: Este método requiere que primero clone el repositorio con git.

Clone el repositorio, instale las dependencias y compile el servidor:

git clone https://github.com/pinkpixel-dev/mem0-mcp
cd mem0-mcp
npm install
npm run build

Luego, configure su cliente MCP para ejecutar el script compilado directamente usando node:

Configuración de Almacenamiento en la Nube (Repositorio Clonado)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "node",
      "args": [
        "/absolute/path/to/mem0-mcp/build/index.js"
      ],
      "env": {
        "MEM0_API_KEY": "YOUR_MEM0_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Supabase (Repositorio Clonado)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "node",
      "args": [
        "/absolute/path/to/mem0-mcp/build/index.js"
      ],
      "env": {
        "SUPABASE_URL": "YOUR_SUPABASE_PROJECT_URL",
        "SUPABASE_KEY": "YOUR_SUPABASE_ANON_KEY",
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "DEFAULT_AGENT_ID": "your-agent-id",
        "DEFAULT_APP_ID": "your-app-id"
      }
    }
  }
}

Configuración de Almacenamiento Local (Repositorio Clonado)

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "node",
      "args": [
        "/absolute/path/to/mem0-mcp/build/index.js"
      ],
      "env": {
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123"
      },
      "disabled": false,
      "alwaysAllow": [
        "add_memory",
        "search_memory",
        "delete_memory"
      ]
    }
  }
}

Notas Importantes:

Reemplace /absolute/path/to/mem0-mcp/ con la ruta absoluta real a su repositorio clonado
Use el archivo build/index.js, no el archivo src/index.ts
El servidor MCP requiere stdout limpio para la comunicación del protocolo: cualquier biblioteca o código que escriba en stdout puede interferir con el protocolo

Configuración de Supabase 🗄️

Si elige usar el modo de almacenamiento de Supabase, deberá configurar su base de datos de Supabase con la tabla requerida.

1. Crear un Proyecto de Supabase

Vaya a supabase.com y cree un nuevo proyecto
Anote la URL de su proyecto y la clave anónima en la configuración del proyecto

2. Ejecutar Migraciones SQL

Ejecute estos comandos SQL en su Editor SQL de Supabase:

-- Enable the vector extension
create extension if not exists vector;

-- Create the memories table
create table if not exists memories (
  id text primary key,
  embedding vector(1536),
  metadata jsonb,
  created_at timestamp with time zone default timezone('utc', now()),
  updated_at timestamp with time zone default timezone('utc', now())
);

-- Create the vector similarity search function
create or replace function match_vectors(
  query_embedding vector(1536),
  match_count int,
  filter jsonb default '{}'::jsonb
)
returns table (
  id text,
  similarity float,
  metadata jsonb
)
language plpgsql
as $$
begin
  return query
  select
    t.id::text,
    1 - (t.embedding <=> query_embedding) as similarity,
    t.metadata
  from memories t
  where case
    when filter::text = '{}'::text then true
    else t.metadata @> filter
  end
  order by t.embedding <=> query_embedding
  limit match_count;
end;
$$;

-- Create the memory_history table for history tracking
create table if not exists memory_history (
  id text primary key,
  memory_id text not null,
  previous_value text,
  new_value text,
  action text not null,
  created_at timestamp with time zone default timezone('utc', now()),
  updated_at timestamp with time zone,
  is_deleted integer default 0
);

3. Establecer Variables de Entorno

Agregue estas a su configuración de MCP:

SUPABASE_URL: La URL de su proyecto de Supabase (por ejemplo, https://your-project.supabase.co)
SUPABASE_KEY: Su clave anónima de Supabase
OPENAI_API_KEY: Su clave de API de OpenAI (para incrustaciones)

Beneficios del Modo Supabase

✅ Almacenamiento Persistente - Los datos sobreviven a los reinicios del servidor ✅ Nivel Gratuito Disponible - Nivel gratuito generoso para desarrollo ✅ Autoalojable - Puede ejecutar su propia instancia de Supabase ✅ Escalable - Crece con sus necesidades ✅ Acceso SQL - Acceso directo a la base de datos para consultas avanzadas ✅ Características en Tiempo Real - Suscripciones en tiempo real integradas

Configuración de Parámetros 🎯

Entendiendo los Parámetros de Mem0

El servidor utiliza cuatro parámetros clave para organizar y delimitar las memorias:

userId - Identifica al usuario (requerido)
agentId - Identifica el LLM/agente que realiza la llamada a la herramienta (opcional)
appId - Identifica el proyecto/aplicación del usuario - ¡esto controla el alcance del proyecto! (opcional)
sessionId - Identifica la sesión de conversación (se asigna a run_id en Mem0) (opcional)

Respaldo de Variables de Entorno 🔄

El servidor MCP admite respaldos de variables de entorno para la identificación del usuario y la configuración del proyecto:

DEFAULT_USER_ID: ID de usuario de respaldo cuando no se proporciona en las llamadas a herramientas
DEFAULT_AGENT_ID: ID de agente de respaldo para identificar el LLM/agente
DEFAULT_APP_ID: ID de aplicación de respaldo para el alcance del proyecto

Orden de Prioridad (¡Importante!)

Parámetros de Herramienta (mayor prioridad) - Valores proporcionados por el LLM en las llamadas a herramientas
Variables de Entorno (respaldo) - Valores de su configuración de MCP

Comportamiento de Ejemplo:

// Your MCP config
"env": {
  "DEFAULT_USER_ID": "john-doe",
  "DEFAULT_AGENT_ID": "my-assistant",
  "DEFAULT_APP_ID": "my-project"
}

Si el LLM proporciona parámetros:

{
  "tool": "add_memory",
  "arguments": {
    "content": "Remember this",
    "userId": "session-123",        // ← Overrides DEFAULT_USER_ID
    "agentId": "different-agent",   // ← Overrides DEFAULT_AGENT_ID
    "appId": "special-project"      // ← Overrides DEFAULT_APP_ID
    // sessionId omitted           // ← No fallback, will be undefined
  }
}

Resultado: Usa session-123, different-agent y special-project

Si el LLM omite parámetros:

{
  "tool": "add_memory",
  "arguments": {
    "content": "Remember this"
    // All IDs omitted - uses environment variables
  }
}

Resultado: Usa john-doe, my-assistant y my-project

Controlando el Comportamiento del LLM

Para asegurar que se usen sus variables de entorno, instruya a su LLM:

"Use el ID de usuario predeterminado configurado en el entorno"
"No especifique los parámetros userId, agentId o appId"
"Deje que el servidor use los valores predeterminados configurados"

Recomendación de Prompt del Sistema

Para mejores resultados, incluya instrucciones en su prompt del sistema como:

When creating memories, use:
- agentId: "my-assistant"
- appId: "my-project"
- sessionId: "current-conversation-id"

Ejemplo de configuración usando DEFAULT_USER_ID:

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@pinkpixel/mem0-mcp"
      ],
      "env": {
        "MEM0_API_KEY": "YOUR_MEM0_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123",
        "ORG_ID": "your-org-id",
        "PROJECT_ID": "your-project-id"
      }
    }
  }
}

O cuando se ejecuta directamente con node:

git clone https://github.com/pinkpixel-dev/mem0-mcp
cd mem0-mcp
npm install
npm run build

{
  "mcpServers": {
    "mem0-mcp": {
      "command": "node",
      "args": [
        "path/to/mem0-mcp/build/index.js"
      ],
      "env": {
        "OPENAI_API_KEY": "YOUR_OPENAI_API_KEY_HERE",
        "DEFAULT_USER_ID": "user123"
      }
    }
  }
}

Comparación de Modos de Almacenamiento 🔄

Almacenamiento en la Nube (API de Mem0) ☁️

Persistente por defecto - Sus memorias permanecen disponibles entre sesiones y reinicios del servidor
No se requiere base de datos local - Todos los datos se almacenan en los servidores de Mem0
Mayor calidad de recuperación - Utiliza los algoritmos de búsqueda optimizados de Mem0
Campos adicionales - Admite los parámetros agent_id y threshold
Totalmente gestionado - Sin configuración ni mantenimiento requeridos
Requiere - Una clave de API de Mem0

Almacenamiento Supabase 🗄️

Almacenamiento persistente - Los datos se almacenan en su base de datos PostgreSQL de Supabase
Nivel gratuito disponible - Nivel gratuito generoso para desarrollo y proyectos pequeños
Autoalojable - Puede ejecutar su propia instancia de Supabase para control total
Acceso SQL - Acceso directo a la base de datos para consultas avanzadas y análisis
Escalable - Crece con sus necesidades, desde el nivel gratuito hasta empresarial
Búsqueda vectorial - Utiliza la extensión pgvector para búsqueda de similitud eficiente
Características en tiempo real - Suscripciones en tiempo real y webhooks integrados
Requiere - Configuración del proyecto de Supabase y clave de API de OpenAI para incrustaciones

Almacenamiento Local (API de OpenAI) 💾

En memoria por defecto - Los datos se almacenan solo en RAM y no son persistentes a largo plazo. Aunque puede ocurrir algo de almacenamiento en caché, no debe confiar en esto para almacenamiento permanente.
Riesgo de pérdida de datos - Los datos de memoria se perderán al reiniciar el servidor, reiniciar el sistema o si el proceso se termina
Recomendado para - Desarrollo, pruebas o uso temporal solamente
Para almacenamiento persistente - Use las opciones de Almacenamiento en la Nube o Supabase si necesita memoria a largo plazo confiable
Usa incrustaciones de OpenAI - Para funcionalidad de búsqueda vectorial
Autocontenido - Todos los datos permanecen en su máquina
Requiere - Una clave de API de OpenAI

Desarrollo 💻

Clona el repositorio e instala las dependencias:

git clone https://github.com/pinkpixel-dev/mem0-mcp
cd mem0-mcp
npm install

Compila el servidor:

npm run build

Para desarrollo con reconstrucción automática al cambiar archivos:

npm run watch

Depuración 🐞

Dado que los servidores MCP se comunican a través de stdio, la depuración puede ser un desafío. Aquí hay algunos enfoques:

Usa el Inspector MCP: Esta herramienta puede monitorear la comunicación del protocolo MCP:

npm run inspector

Registro en consola: Al agregar registros de consola, usa siempre console.error() en lugar de console.log() para evitar interferir con el protocolo MCP
Archivos de entorno: Usa un archivo .env para el desarrollo local y simplificar la configuración de claves de API y otras opciones de configuración

Notas Técnicas de Implementación 🔧

1. Adiciones Asíncronas de la Plataforma V3 y Sondeo

La adición de Mem0 Cloud V3 es una tarea asíncrona en segundo plano. Al llamar a add_memory, el servidor envía la solicitud a /v3/memories/add/ y recibe un eventId.

Sondeo Síncrono (Predeterminado): El servidor consulta el endpoint de estado del evento (/v1/event/{id}/) cada 500 ms hasta un máximo de timeoutMs (predeterminado 15000 ms) hasta que el estado se convierta en SUCCEEDED o FAILED. Una vez resuelto, devuelve el resultado final.
Ejecución Asíncrona: Pasa "waitForCompletion": false para omitir el sondeo. El servidor devolverá inmediatamente el eventId y un estado PENDING.

2. Normalización de Filtros V3 Anidados

Los endpoints de búsqueda y listado de Mem0 Cloud V3 rechazan los IDs de alcance de nivel superior (user_id, agent_id, app_id, run_id) y devuelven un error HTTP 400. V3 requiere estos campos dentro del objeto anidado filters. Para evitar romper las configuraciones de los clientes, este servidor normaliza automáticamente las variables de alcance de nivel superior (userId, agentId, appId, runId/sessionId) y las fusiona en el objeto anidado filters internamente antes de enviar la solicitud a la API.

3. Control de Capacidades

Diferentes backends admiten diferentes conjuntos de funciones. Llama a get_memory_capabilities para obtener una matriz de capacidades estructurada del backend activo.

Modo Cloud: Admite completamente todas las funciones (apiVersion: "v3", eventos asíncronos, listados, historiales de auditoría, consultas lógicas).
Modos Supabase / Local: Interfaces vectoriales estándar V1. Las herramientas específicas de la nube no compatibles (como get_memory_history o list_memories) fallarán de manera controlada con mensajes claros de función no disponible.

4. Registro y Estabilidad del Protocolo

Los servidores MCP se comunican usando JSON-RPC a través de stdout. Cualquier registro de biblioteca inesperado impreso en stdout corromperá el canal del protocolo y provocará fallos en los clientes. Este servidor anula los métodos de salida predeterminados de console (como console.log) para redirigir o silenciar el registro estándar, asegurando una comunicación stdio limpia.

Hecho con 💖 por Pink Pixel