AgentMemory

Capa de memoria nativa de MCP para Claude Code, Cursor, Cline, Continue y otras 16 herramientas de IA. Búsqueda híbrida (BM25 + pgvector + graph), autoalojada en Supabase + Vercel, 100% MIT, sin muro de pago.

GitHub

Prueba este MCPPatrocinado

Documentación

AgentMemory.fyi

Gestor de memoria visual para agentes de IA. Una única fuente de verdad para Claude Code, Cursor, Cline, Continue.

_{* Vista previa alojada en Vercel — inicia sesión con correo o GitHub para probarla. Tus datos permanecen privados para tu cuenta mediante Supabase RLS. Para autoalojamiento o modo solo local, consulta Inicio rápido a continuación.}

Capturas de pantalla

Dashboard

Panel — estadísticas de un vistazo, memorias recientes, desglose por categorías y acciones rápidas

Memory Graph

Grafo de memoria — vista de fuerza dirigida con D3, panel de Detalles de Memoria integrado y Memorias Similares (98% / 97% de coincidencia) ordenadas por distancia vectorial

Export

Exportación — CLAUDE.md, .cursorrules, MemGPT JSON o URL de solo lectura compartible con un clic, con vista previa en vivo y filtros por categoría

100% gratis, para siempre

AgentMemory es de código abierto bajo MIT. Sin muros de pago, sin niveles premium, sin límites.

Gratis para todos — memorias ilimitadas, proyectos ilimitados
Autoalojable — ejecútalo localmente para siempre, sin telemetría, sin bloqueo
Nativo MCP — funciona como servidor de Protocolo de Contexto de Modelo en Claude Desktop, Cursor, Cline, Continue, Windsurf, Roo Code, Kilo Code, Zed, Aider, Goose, Warp, Codex CLI, Gemini CLI, GitHub Copilot CLI, Qwen Code CLI, Google Antigravity, AWS Kiro, Droid, OpenCode, OpenClaw y pi-mono. Consulta Conecta a tu herramienta de IA a continuación.
Visual — vista de grafo de todas las memorias y sus relaciones semánticas
Portátil — importar/exportar a .cursorrules, CLAUDE.md, MemGPT JSON, sesiones de Claude Code .jsonl
Sincronización en la nube opcional — inicia sesión para sincronizar tus memorias entre dispositivos mediante Supabase

Apoya el proyecto

AgentMemory se construye y mantiene en tiempo libre. Si te ahorra tiempo, considera apoyar el desarrollo:

Dona en DonationAlerts — tarjetas, SBP, YooMoney, cripto, más de 100 métodos
Marca el repositorio con estrella — la mejor donación de $0
Reporta errores o solicita funciones
Contribuye con PRs
Corre la voz en Twitter / Reddit / HackerNews

Inicio rápido

Interfaz web (modo solo local)

npm install
npm run dev
# → http://localhost:5173

Funciona sin backend. Las memorias se almacenan en localStorage (navegador) o ~/.agentmemory/ (MCP stdio).

Servidor MCP (stdio, local)

npm run mcp

Se configura en claude_desktop_config.json (el script ejecuta mcp/index.ts mediante tsx — sin paso de compilación):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

9 herramientas: add_memory, search_memories, list_memories, find_similar, delete_memory, list_projects, switch_project, get_project_context, import_jsonl, backfill_embeddings. 3 recursos: agentmemory://rules, agentmemory://graph, agentmemory://projects. 100% gratis, sin claves de licencia.

Conecta a tu herramienta de IA

AgentMemory expone el mismo servidor MCP en dos modos:

stdio local — ejecuta mcp/index.ts mediante tsx; el proceso del agente lo invoca como proceso hijo. Ideal para herramientas de escritorio que tienen acceso al sistema de archivos de tu máquina.
HTTP en la nube — endpoint HTTP transmisible en https://<your-host>/mcp (predeterminado de Vercel). Ideal para herramientas alojadas, clientes web y compartir la misma memoria entre máquinas. El JWT de Supabase del usuario va en Authorization: Bearer <jwt>.

Los fragmentos a continuación asumen que tu clon está en /absolute/path/to/agentmemory. El comando stdio local ejecuta el servidor MCP directamente con tsx — sin necesidad de compilación.

Dos fragmentos de referencia que reutilizarás

// LOCAL — stdio
{
  "command": "npx",
  "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
  "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
}

// CLOUD — HTTP
{
  "url": "https://your-app.vercel.app/mcp",
  "headers": { "Authorization": "Bearer <supabase-jwt>" }
}

Para obtener un JWT de Supabase, inicia sesión en la interfaz web alojada de AgentMemory, luego en DevTools ejecuta JSON.parse(localStorage.getItem('sb-<project>-auth-token') || 'null') y copia access_token. Los JWT duran ~1h; actualiza re-ejecutando el comando después de cada sesión.

Tabla de contenidos

#	Herramienta	Archivo de configuración	Modo
1	Claude Desktop	`claude_desktop_config.json`	stdio / http
2	Cursor	`.cursor/mcp.json`	stdio / http
3	Cline	Barra lateral de Cline → Servidores MCP	stdio / http
4	Continue	`~/.continue/config.yaml`	stdio / http
5	Roo Code	`.roo/mcp.json`	stdio / http
6	Kilo Code	Barra lateral de Kilo → Servidores MCP	stdio / http
7	Windsurf	`~/.codeium/windsurf/mcp_config.json`	stdio / http
8	Zed	`~/.config/zed/settings.json`	stdio / http
9	Aider	bandera `--mcp-server`	stdio
10	Goose	`~/.config/goose/config.yaml`	stdio / http
11	Warp	Warp Drive → Servidores MCP	stdio / http
12	OpenAI Codex CLI	`~/.codex/config.toml`	stdio / http
13	Google Gemini CLI	`~/.gemini/settings.json`	stdio / http
14	GitHub Copilot CLI	`~/.config/github-copilot/mcp.json`	stdio / http
15	Qwen Code CLI	`~/.qwen/settings.json`	stdio / http
16	Google Antigravity	`.antigravity/mcp.json`	stdio / http
17	AWS Kiro	`.kiro/settings/mcp.json`	stdio / http
18	Droid (Factory)	`~/.droid/mcp.json`	stdio / http
19	OpenCode	`opencode.json` / `~/.config/opencode/config.json`	stdio / http
20	OpenClaw y pi-mono	`~/.openclaw/openclaw.json` / `~/.pi/config.json`	stdio / http

1. Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json (mac) · %APPDATA%\Claude\claude_desktop_config.json (win) · ~/.config/Claude/claude_desktop_config.json (linux).

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Reinicia Claude Desktop. El panel de conectores debería mostrar 9 🔧 herramientas y 3 📄 recursos.

2. Cursor

.cursor/mcp.json en tu espacio de trabajo (por proyecto) o ~/.cursor/mcp.json (global).

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Cursor Settings → Features → MCP. Haz clic en Refresh si el servidor no aparece.

3. Cline

Extensión de VSCode. Abre la barra lateral de Cline → ⚙️ Settings → MCP Servers → Configure MCP Servers → edita cline_mcp_settings.json:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" },
      "disabled": false
    }
  }
}

Cline recarga automáticamente el archivo al guardar. Las herramientas de memoria aparecen bajo el ícono 🔧 en el chat.

4. Continue

~/.continue/config.yaml (YAML; Continue 1.0+):

mcpServers:
  - name: agentmemory
    command: npx
    args:
      - tsx
      - /absolute/path/to/agentmemory/mcp/index.ts
    env:
      AGENTMEMORY_HOME: /absolute/path/to/storage

Para modo nube, reemplaza con transport: http + url + headers (consulta documentación de MCP de Continue).

5. Roo Code

.roo/mcp.json en tu espacio de trabajo, o mediante la barra lateral de Roo → MCP → Edit Global MCP:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

6. Kilo Code

Kilo es un fork de OpenCode, así que el mismo esquema funciona. Abre la barra lateral de Kilo → Servidores MCP → Edit Global MCP, o .kilocode/mcp.json en tu espacio de trabajo:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Para modo nube, intercambia la entrada por { "url": "https://...", "headers": { "Authorization": "Bearer ..." } }.

7. Windsurf

~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Windsurf Settings → Cascade → MCP Servers lo muestra después de reiniciar.

8. Zed

~/.config/zed/settings.json (nota: Zed usa context_servers, no mcpServers):

{
  "context_servers": {
    "agentmemory": {
      "command": {
        "path": "npx",
        "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
        "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
      }
    }
  }
}

Para modo nube, usa "settings": { "url": "https://...", "headers": { "Authorization": "Bearer ..." } } en lugar de command. Consulta documentación de servidores de contexto de Zed.

9. Aider

Aider 0.73+ agregó MCP. Pasa el servidor en la línea de comandos (un --mcp-server por servidor):

aider --mcp-server "npx tsx /absolute/path/to/agentmemory/mcp/index.ts AGENTMEMORY_HOME=/path/to/storage"

O en ~/.aider.conf.yml:

mcp-servers: |
  agentmemory: npx tsx /absolute/path/to/agentmemory/mcp/index.ts AGENTMEMORY_HOME=/path/to/storage

Aider lista las herramientas disponibles al inicio; refiérelas en el chat con /tool agentmemory__add_memory ....

10. Goose

~/.config/goose/config.yaml — extensions es el término de Goose para servidores MCP:

extensions:
  agentmemory:
    type: stdio
    cmd: npx
    args: ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"]
    envs:
      AGENTMEMORY_HOME: /absolute/path/to/storage
    enabled: true

Modo nube: establece type: streamable_http, uri: https://your-app.vercel.app/mcp, headers.Authorization: "Bearer <jwt>", envs: {}.

11. Warp

Warp Drive → Settings → AI → Manage MCP Servers → + Add:

Campo	Valor
Nombre	`agentmemory`
Comando	`npx tsx /absolute/path/to/agentmemory/mcp/index.ts`
Env	`AGENTMEMORY_HOME=/absolute/path/to/storage`

Warp también admite ~/.warp/mcp_config.json para sincronización entre máquinas — mismo esquema mcpServers que Claude Desktop.

12. OpenAI Codex CLI

~/.codex/config.toml:

[mcp_servers.agentmemory]
command = "npx"
args = ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"]
env = { AGENTMEMORY_HOME = "/absolute/path/to/storage" }

Para nube, intercambia la tabla por:

[mcp_servers.agentmemory]
url = "https://your-app.vercel.app/mcp"
http_headers = { Authorization = "Bearer <supabase-jwt>" }

Verifica con codex mcp list.

13. Google Gemini CLI

~/.gemini/settings.json:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Confiado por defecto si trust: true está establecido por servidor. Consulta documentación de MCP de Gemini CLI.

14. GitHub Copilot CLI

El nuevo CLI copilot (reemplaza al antiguo gh copilot). ~/.config/github-copilot/mcp.json:

{
  "mcpServers": {
    "agentmemory": {
      "type": "stdio",
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

O en línea en tiempo de ejecución: copilot --additional-mcp-config @/absolute/path/to/config.json. Las herramientas se prefijan automáticamente con agentmemory__ en el chat.

15. Qwen Code CLI

El CLI qwen de Alibaba (Qwen3-Coder). ~/.qwen/settings.json (o ~/.qwen-cli/settings.json dependiendo de la compilación):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

16. Google Antigravity

.antigravity/mcp.json en tu espacio de trabajo (por proyecto) o ~/.antigravity/mcp.json (global):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Modo nube: reemplaza con { "url": "https://your-app.vercel.app/mcp", "headers": { "Authorization": "Bearer <supabase-jwt>" } }. Antigravity recoge el archivo al abrir el espacio de trabajo.

17. AWS Kiro

.kiro/settings/mcp.json en tu espacio de trabajo (por proyecto) o ~/.kiro/settings/mcp.json (global):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Kiro Settings → MCP Servers muestra un botón de actualización si el servidor no está accesible.

18. Droid (Factory)

~/.droid/mcp.json (global) o .factory/mcp.json (por proyecto):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Ejecuta droid mcp list para verificar que se cargó. En TUI, usa @agentmemory para invocar herramientas.

19. OpenCode

opencode.json en la raíz de tu proyecto, o ~/.config/opencode/config.json para global:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "agentmemory": {
      "type": "local",
      "command": ["npx", "tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "environment": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" },
      "enabled": true
    }
  }
}

Para modo nube, cambia a "type": "remote", "url": "https://your-app.vercel.app/mcp", "headers": { "Authorization": "Bearer <supabase-jwt>" }. Refiérete en los prompts con use the agentmemory tool.

20. OpenClaw y pi-mono

Estos son asistentes personales de IA, no IDEs de codificación — aceptan servidores MCP como skills, por lo que AgentMemory se convierte en la memoria a largo plazo del asistente.

OpenClaw — ~/.openclaw/openclaw.json:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Reinicia la puerta de enlace con openclaw gateway restart. En Telegram/WhatsApp/Discord, el asistente ahora tiene memoria persistente entre sesiones — di "recuerda que prefiero el modo oscuro" y se mantiene.

pi-mono (CLI pi de Mario Zechner) — ~/.pi/config.json:

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/agentmemory/mcp/index.ts"],
      "env": { "AGENTMEMORY_HOME": "/absolute/path/to/storage" }
    }
  }
}

Ejecuta pi y pide al agente que search_memories para contexto previo.

Solución de problemas

Síntoma	Solución
`ENOENT` en `mcp/index.ts`	Usa una ruta absoluta; `~` no se expande dentro del JSON
`command not found: tsx`	`npm i -g tsx`, o reemplaza `npx tsx` con `node --import tsx`
Las herramientas nunca aparecen	Reinicia el cliente. Algunos (Cline, Kilo, Roo) necesitan un interruptor de "habilitar" explícito
`401 Unauthorized` en la nube	JWT expirado; vuelve a copiarlo desde DevTools de la interfaz web `localStorage`
`429 Too Many Requests` en la nube	Alcanzó `RATE_LIMIT_PER_HOUR`; espera o retrocede mediante `backfill_embeddings`
`Cannot find module '@modelcontextprotocol/...'`	`npm install` en la raíz del repositorio de agentmemory

Características

Decaimiento de memoria y seguimiento de acceso

Las memorias siguen una curva de decaimiento exponencial (strength = 0.5^(days/30) × importance/5) y reciben un impulso cada vez que se leen. Cada memoria cae en uno de cuatro niveles, mostrados como una insignia de color en la tarjeta:

Nivel	Fuerza	Color	Significado
caliente	≥ 0.70	rojo	Creada recientemente o accedida con frecuencia
templada	≥ 0.40	ámbar	Aún relevante
fría	≥ 0.15	azul	Desvaneciéndose, pero conservada para contexto
muerta	< 0.15	gris	Candidata automática para olvidar

runAutoForget() se ejecuta al iniciar la aplicación y elimina recuerdos que coincidan con: TTL expirado, O (strength < 0.05 AND access_count < 3), O (importance ≤ 2 AND age > 180 days).
MemoryCard llama a touchMemory(id) al montar, incrementando access_count y actualizando last_accessed_at.
Sobrevive en todos los backends: local (zustand), Supabase (columna strength de Postgres + runAutoForget de useAuth).

Búsqueda híbrida (BM25 + Vector + Grafo mediante RRF)

Tres fuentes se fusionan mediante Fusión de rango recíproco (k=60) en src/utils/rrf.ts:

Fuente	Peso	Dónde se ejecuta	Implementación
Vector (coseno)	0.6	Servidor (nube) / local	pgvector + HuggingFace Inference API, 384-dim MiniLM-L6-v2 (gratis, sin tarjeta de crédito)
BM25	0.4	Ambos	Similitud de trigramas pg_trgm (servidor) o índice invertido con stemming de Porter (local)
Grafo	0.3	Ambos	Expansión de 1 salto a través de la tabla `relations` (servidor) o aristas en memoria (local)

Los mejores resultados de cada fuente se combinan con RRF(d) = Σᵢ wᵢ / (k + rankᵢ(d)) y se devuelven los top-N. El índice BM25 local almacena en caché por (count, max(updated_at)) y se invalida en cada alta/actualización/eliminación/olvido automático.

Habilitar la búsqueda semántica en el MCP en la nube — regístrate en huggingface.co (gratis), obtén un token de lectura en https://huggingface.co/settings/tokens y establece HUGGINGFACE_API_KEY en Vercel. El manejador serverless en api/mcp.ts instancia createHuggingFaceEmbedder(token) y lo inyecta en el SupabaseBackend. En add_memory el contenido se incrusta y se almacena como vector(384); en search_memories la consulta se incrusta y el RPC semantic_search_memories realiza una búsqueda por coseno mediante el índice HNSW.

Sin la clave, el servidor sigue funcionando: simplemente omite la fuente vectorial y el RRF se convierte en bidireccional (BM25 + grafo).

Relleno de recuerdos antiguos — después de habilitar el incrustador, las filas existentes tienen embedding = NULL. Ejecuta la herramienta MCP backfill_embeddings repetidamente hasta que remaining = 0:

backfill_embeddings({ limit: 64 })
backfill_embeddings({ limit: 64 })
…

Cada llamada cuesta ⌈N/32⌉ llamadas a la API de incrustación y respeta el límite de velocidad por usuario. El tiempo de espera de 60s del serverless cabe en ~3 lotes de HF = ~96 recuerdos por invocación.

Límite de velocidad — el esquema de Supabase añade una tabla api_rate_limits y un RPC consume_rate_limit(p_user_id, p_cost, p_max). Cada llamada de incrustación (consulta de búsqueda, inserción de recuerdo, lote de relleno) consume atómicamente ceil(texts/32) unidades de una ventana deslizante de 1 hora. El límite predeterminado es RATE_LIMIT_PER_HOUR=100, lo que deja mucho margen en el nivel gratuito de 30k/mes de HF para ~30 usuarios activos. Establece la variable de entorno a 0 para deshabilitarlo. Si alcanzas el límite, la llamada MCP devuelve isError: true con la marca de tiempo exacta de reinicio.

Importación JSONL desde sesiones de Claude Code

Arrastra un archivo de sesión de Claude Code (~/.claude/projects/-my-project/<uuid>.jsonl) a la página de importación, o llama a la herramienta MCP import_jsonl. El analizador:

Lee un objeto JSON por línea
Descarta los bloques tool_use / tool_result (conserva solo los mensajes user / assistant)
Filtra los mensajes de usuario: 20–600 caracteres, descarta recordatorios del sistema y comandos de shell (ok, ./run-build.sh, etc.)
Auto-categoriza con pistas de regex: decision > constraint > preference > architecture > context (predeterminado)
Extrae etiquetas de #hashtags y pistas de extensión de archivo (*.ts → typescript)
Limita a 200 recuerdos por archivo

Uso de MCP (funciona en modos stdio y HTTP):

{
  "name": "import_jsonl",
  "arguments": {
    "path": "/Users/you/.claude/projects/-my-project/abc123.jsonl"
  }
}

Devuelve { imported: N, total: M, user_messages: K, accepted: K }.

Sincronización en la nube (Supabase + Vercel)

Ejecuta tu propio backend de sincronización privado en ~5 minutos.

1. Crear un proyecto de Supabase

Ve a supabase.com → Nuevo proyecto
Una vez aprovisionado, abre Editor SQL → pega el contenido de supabase/schema.sql → Ejecutar
- El esquema habilita la extensión pgvector y crea la columna embedding vector(384) + índice HNSW en la primera ejecución
En Autenticación → Proveedores, habilita Email (enlace mágico) y GitHub (opcional — consulta §1a a continuación para el paso a paso)
En Configuración → API, copia tu Project URL y la clave anon
(Opcional, para búsqueda semántica) Regístrate en huggingface.co y crea un token de lectura en https://huggingface.co/settings/tokens

1a. Habilitar inicio de sesión con GitHub (opcional)

El inicio de sesión con GitHub es un clic en la página de autenticación y te permite omitir el viaje de ida y vuelta del enlace mágico por correo. La configuración toma ~5 minutos.

Paso 1 — Crear una aplicación OAuth de GitHub

Ve a https://github.com/settings/developers → Nueva aplicación OAuth
Completa:
- Nombre de la aplicación: AgentMemory (o lo que quieras)
- URL de la página de inicio: tu URL desplegada (por ejemplo, https://agentmemory-dusky.vercel.app) o http://localhost:5173 para desarrollo local
- URL de devolución de llamada de autorización: cópiala de Supabase en el siguiente paso — volverás para editarla
Haz clic en Registrar aplicación
En la página siguiente, haz clic en Generar un nuevo secreto de cliente. Copia el ID de cliente y el Secreto de cliente (no volverás a ver el secreto)

Paso 2 — Conéctalo a Supabase

De vuelta en el panel de Supabase → Autenticación → Proveedores → GitHub
Activa Habilitar inicio de sesión con GitHub
Pega el ID de cliente y el Secreto de cliente del paso 1
Haz clic en Guardar
En Autenticación → Configuración de URL, agrega tus URLs de sitio a URL del sitio y URLs de redirección adicionales:
- http://localhost:5173 (desarrollo)
- https://your-app.vercel.app (producción)
Supabase ahora muestra la URL de devolución de llamada canónica para tu proyecto — se ve como https://<project-ref>.supabase.co/auth/v1/callback. Vuelve a la aplicación OAuth de GitHub y pégala en URL de devolución de llamada de autorización

Paso 3 — Pruébalo

Abre /auth en tu aplicación → haz clic en Continuar con GitHub → deberías ser redirigido a GitHub, aprobar y volver con la sesión iniciada. El avatar en la barra lateral cambia a tu foto de perfil de GitHub y aparece un botón Cerrar sesión en la parte inferior izquierda.

Advertencia de autoalojamiento: cada dominio personalizado desde el que sirvas debe agregarse a las URLs de redirección adicionales de Supabase, de lo contrario OAuth rechazará el parámetro redirectTo. Supabase devuelve un error redirect_uri not in allowlist si omites esto.

2. Configurar el entorno

Copia public/.env.example a .env (o establece variables en Vercel):

VITE_SUPABASE_URL=https://your-project.supabase.co
VITE_SUPABASE_ANON_KEY=eyJhbGc...
SUPABASE_URL=https://your-project.supabase.co
SUPABASE_ANON_KEY=eyJhbGc...
# Optional: enables pgvector semantic search via HuggingFace Inference API (free tier)
HUGGINGFACE_API_KEY=hf_xxxxxxxxxxxxxxxxxxxxxxxx
# Optional: per-user embedding rate limit (default 100/hr, protects HF free tier)
RATE_LIMIT_PER_HOUR=100
# Service role key NOT used — RLS scopes everything to auth.uid()

3. Desplegar en Vercel

npm i -g vercel
vercel
# accept defaults; add the SUPABASE_* env vars when prompted

La aplicación web es una compilación estática de un solo archivo (dist/index.html) en la raíz. El servidor MCP se expone como una función serverless en /mcp y /api/mcp.

4. Usar el MCP remoto

Los clientes (Claude Desktop, Cursor, personalizados) pueden conectarse a tu servidor MCP alojado a través de HTTP. Envía el JWT de Supabase del usuario en el encabezado Authorization: Bearer <jwt>:

{
  "mcpServers": {
    "agentmemory-cloud": {
      "url": "https://your-app.vercel.app/mcp",
      "headers": {
        "Authorization": "Bearer <supabase-access-token>"
      }
    }
  }
}

La función valida el JWT mediante Supabase y luego consulta Postgres con RLS para que cada usuario solo vea sus propios datos. Nunca se necesita una clave de rol de servicio para las solicitudes de usuario — RLS hace el trabajo.

Arquitectura

src/
  store/memoryStore.ts        # Zustand store + pure logic helpers (hybridSearch, decay)
  utils/
    bm25.ts                   # BM25 inverted index
    rrf.ts                    # Reciprocal Rank Fusion
    stemmer.ts                # Compact Porter stemmer
    memoryDecay.ts            # calculateStrength, tierOf, touchMemory, runAutoForget
    jsonlImport.ts            # Claude Code session parser
  lib/supabase.ts             # Supabase browser client
  lib/cloudSync.ts            # Pull/push helpers used by memoryStore
  hooks/useAuth.ts            # Wires Supabase auth state to the store
  components/
    MemoryCard.tsx            # Tier badge + touch-on-mount
    Layout.tsx                # Sidebar with sign-in / cloud status
  pages/
    AuthPage.tsx              # Magic-link + GitHub OAuth sign-in
    ImportPage.tsx            # .jsonl + .md/.txt/.cursorrules dropzone
    SupportPage.tsx           # Donate CTA

mcp/
  server.ts                   # Transport-agnostic MCP server (9 tools + 3 resources)
  embeddings.ts               # HuggingFace Inference API wrapper (MiniLM-L6-v2, 384-dim)
  backends/
    local.ts                  # Reads/writes the zustand store on disk
    supabase.ts               # RRF search (BM25+vector+graph), embeds on add, RLS-scoped via caller's JWT
  index.ts                    # Stdio entrypoint (uses LocalBackend)

api/
  mcp.ts                      # Vercel serverless handler (Streamable HTTP)

supabase/
  schema.sql                  # Tables, RLS policies, search_memories / find_similar_memories RPCs

El modo local y el modo nube comparten el mismo tipo Memory y las mismas acciones memoryStore. La única diferencia es si las mutaciones se reflejan en Supabase.

Desarrollo

npm run dev                 # Vite dev server
npm run build               # Production web build
npm run mcp                 # Run stdio MCP server (tsx, no build step)
npm run typecheck:mcp       # tsc --noEmit on the MCP workspace
npx tsc --noEmit            # tsc --noEmit on the web workspace

Licencia

MIT — consulta LICENSE.