Tu memoria dentro de cada herramienta de IA

Un solo comando da a Claude Code, Claude Desktop, Cursor o cualquier host MCP una memoria a largo plazo respaldada por tu cuenta WOS. Sin código de integración: el agente recibe nueve herramientas de memoria y decide cuándo usarlas.

Instalación

Claude Code, una línea (crea antes una clave en la consola):

claude mcp add wontopos --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp
# pick which store it remembers into (optional): add --env WONTOPOS_USER_ID=my-project

# ~/.cursor/mcp.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# .vscode/mcp.json
{ "servers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# ~/.codeium/windsurf/mcp_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

# Claude Desktop and any other MCP host
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to Cursor →  ·  Add to VS Code →

Env opcional: WONTOPOS_USER_ID fija el store por defecto, WONTOPOS_MODEL el motor, WONTOPOS_BASE_URL otro host de la API. WONTOPOS_READ_ONLY=1 cambia a solo lectura (solo recall/búsqueda/listado).

Antes de compartir un store

• Usa una clave dedicada. Las claves llevan su workspace: una clave solo para MCP acota lo que las herramientas conectadas pueden tocar, y puedes rotarla en la consola sin tocar las claves de tu app.
• Modo solo lectura. WONTOPOS_READ_ONLY=1 no registra ninguna herramienta de escritura: el agente puede recordar, buscar, listar memorias, ejecutar engramas y leer estadísticas, pero no guardar, actualizar, olvidar ni borrar. Ideal para agentes que deben consultar la memoria, no poseerla.
• Mantén la confirmación de herramientas activada. Los hosts MCP preguntan antes de ejecutar herramientas por defecto: déjala activa sobre todo para forget, porque los borrados se comparten entre todas las herramientas del store.
• Todo lo guardado lo puede recordar cualquier herramienta con la clave. Nunca guardes secretos - claves de API, contraseñas - como memorias.
• Las memorias recordadas son datos, no instrucciones. Las descripciones de las herramientas se lo dicen explícitamente al agente. Aun así, no guardes texto de terceros no confiable en un store que un agente autónomo obedece.
• Los borrados también se comparten. Un forget o delete_all desde una herramienta borra para todas.
• "me" es el agente que escribe en el store. Si varios agentes comparten uno, sus voces "me" se mezclan. Da a cada agente su propio store (WONTOPOS_USER_ID) para identidades separadas.
• Paga una sola cuenta. Todas las herramientas conectadas consumen el mismo saldo y límite de tasa.

Luego, solo habla

Cosas que puedes decir

• "Este repo usa pnpm, recuérdalo" → remember lo guarda; la siguiente sesión ya lo sabe.
• "¿Qué formato de error acordamos la semana pasada?" → recall trae la decisión de vuelta al contexto.
• "En realidad, la fecha límite pasó al viernes" → el agente ve que contradice lo que recordó y llama a update para corregir esa memoria en el sitio.
• "Eso está mal, olvídalo" → el agente encuentra el id y llama a forget; tu host pide confirmación antes.
• "¿Qué recuerdas de mí?" → list_memories recorre todo lo guardado, para que el agente responda o ponga orden.

No hay nada especial que decir: son frases normales, no comandos. El agente lee la descripción de cada herramienta y elige solo.

Las nueve herramientas

• recall - Contexto en una llamada: turnos recientes más memorias relevantes. Su descripción indica al agente llamarla primero cuando importe el contexto pasado.
• remember - Guarda un hecho o decisión duradera. speaker: "me" marca las palabras del propio agente; un nombre registrado, quién lo dijo.
• search - Búsqueda semántica, con un filtro speaker por persona — y filters para acotarla por FECHA o tema ("¿qué decidimos en junio?"), el único eje que el significado por sí solo no puede acotar.
• update - Sustituye una memoria cuyo hecho cambió, conservando el rastro en vez de borrarlo.
• forget - Borra una memoria por id.
• list_memories - Recorre todo lo almacenado, para responder "¿qué recuerdas de mí?" o hacer limpieza.
• engram - Ejecuta una tubería multisalto integrada (deep_recall, timeline, gather) cuando una sola búsqueda no basta.
• stats - Cuánto hay en un almacén: útil antes de una limpieza y para confirmar que una escritura llegó.
• create_store - Los stores son explícitos: uno por usuario final, proyecto o agente.

¿SDK o MCP?

• El SDK va dentro de una app que tú escribes. Tu código decide exactamente cuándo guardar y qué recordar: determinista, tipado, versionado. ¿Construyes un producto? SDK.
• MCP se enchufa a una herramienta de IA que no escribiste tú. El agente decide cuándo usar la memoria, guiado por las descripciones - cero código. Para Claude Code, Claude Desktop, Cursor o dar memoria a un asistente ya hecho.

Debajo, la misma API y los mismos stores: una app hecha con el SDK y una sesión de Claude Code por MCP comparten una memoria. Se elige por superficie, no uno u otro.

Una memoria a través de todas las herramientas

La memoria pertenece a la cuenta, no a la herramienta. El mismo store escrito desde ChatGPT (Actions más la spec OpenAPI) se recuerda en Claude Code y en tus propios agentes, y al revés: una conversación empezada en una herramienta continúa en otra.

Y como es un solo store, puedes salir de Claude Code y seguir hablando donde construyes: un agente del SDK con la misma clave y store recuerda todo lo que Claude Code acaba de aprender, y lo que guarde tu agente, Claude Code lo recuerda en la siguiente sesión.

MCP: memoria para herramientas de IA

El núcleo de WOS es la API y los SDK. El servidor MCP es un complemento encima: la misma memoria, enchufada a herramientas que no construiste tú - Claude Code, Claude Desktop, Cursor.

Una línea de instalación da al agente nueve herramientas de memoria que usa por su cuenta. Y como la memoria vive en tu cuenta, lo que escribe una herramienta lo recuerdan todas las demás, incluidos los agentes que construyas con el SDK.

Qué puedes hacer con esto

• Un Claude Code que recuerda tu proyecto. Decisiones, fixes, preferencias: recuperados en la siguiente sesión sin re-explicar nada.
• Empieza en ChatGPT, continúa en Claude. Mismo store, misma memoria: la conversación cruza herramientas en vez de reiniciarse.
• Tu propio agente sigue en el circuito. Lo que aprende Claude Code, un agente del SDK lo recuerda - y lo que guarda tu agente, Claude Code lo recuerda de vuelta.

Funciona en Claude Code, Claude Desktop, Cursor, Windsurf y cualquier host MCP. ChatGPT llega a la misma memoria vía Actions más la spec OpenAPI.

Instalación

claude mcp add wontopos --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp

El agente recibe nueve herramientas - recall · remember · search · update · forget · list_memories · engram · stats · create_store - cada una descrita para que sepa por sí solo cuándo usarlas.

Abrir la página de desarrollador →

Claude Code

La vía principal: un comando en tu terminal y cada sesión empieza con memoria.

1. Crea una clave de API en la consola. La clave lleva su workspace: una clave = un espacio de memoria.
2. Registra el servidor. --scope user lo hace disponible en todos los proyectos; sin él, solo lo ve el proyecto actual.
3. Compruébalo: ejecuta /mcp dentro de Claude Code; wontopos debe aparecer con nueve herramientas.
4. Hazlo automático: una línea en tu CLAUDE.md - "cuando importe el contexto pasado, llama primero a wontopos recall" - y cada sesión empieza con memoria sin pedirlo.

claude mcp add wontopos --scope user \
  --env WONTOPOS_API_KEY=wos-live-... -- npx -y wontopos-mcp
# pick a store (optional): add --env WONTOPOS_USER_ID=my-project

Claude Desktop

Añade el bloque de abajo a claude_desktop_config.json (Ajustes → Developer → Edit Config), reinicia la app y aparecen las nueve herramientas. Nota: claude.ai en web y móvil necesita un servidor MCP remoto, que WOS aún no ofrece; la app de escritorio es la vía soportada.

# claude_desktop_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Cursor

Añade el bloque de abajo a ~/.cursor/mcp.json, o pulsa el botón de un clic, y reinicia Cursor. El agente toma las nueve herramientas.

# ~/.cursor/mcp.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to Cursor →

VS Code

VS Code (modo agente de Copilot) lee los servidores MCP de .vscode/mcp.json del proyecto: añade el bloque de abajo o pulsa el botón de un clic.

# .vscode/mcp.json
{ "servers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

Add to VS Code →

Windsurf

Windsurf (Cascade) lee ~/.codeium/windsurf/mcp_config.json: añade el bloque de abajo y recarga; aparecen las mismas nueve herramientas.

# ~/.codeium/windsurf/mcp_config.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }

ChatGPT

Los conectores MCP de ChatGPT solo aceptan servidores remotos, así que la vía soportada hoy es un GPT personalizado con una Action: crea un GPT, añade una Action, pega la URL de la spec OpenAPI de abajo y configura tu clave como cabecera de auth. Ese GPT llamará a la misma memoria que tus demás herramientas.

# GPT → Configure → Actions → Import from URL
https://api.wontopos.com/openapi.json
# Authentication: API Key · Header name: X-API-Key

Mismo store, misma memoria: lo que ChatGPT guarda por la Action, Claude Code lo recuerda por MCP, y al revés.

Gemini CLI

Gemini CLI lee los servidores MCP de ~/.gemini/settings.json: añade el bloque de abajo, reinicia la CLI y las mismas nueve herramientas aparecen también ahí.

# ~/.gemini/settings.json
{ "mcpServers": {
    "wontopos": {
      "command": "npx",
      "args": ["-y", "wontopos-mcp"],
      "env": { "WONTOPOS_API_KEY": "wos-live-...",
               "WONTOPOS_USER_ID": "my-project" }
    } } }