Recall

Sin un servidor de memoria, cada conversación con Claude / Copilot / Cursor comienza en frío. Vuelves a explicar el código, las convenciones, las decisiones, los detalles complicados — cada vez. Recall soluciona eso.

Empieza aquí: qué hace Recall para un desarrollador, una IA

Instálalo una vez, apunta tu cliente MCP hacia él, y tu IA ahora:

• Recuerda entre sesiones — "¿qué decidimos sobre el flujo de autenticación la semana pasada?" devuelve la decisión real, no una alucinación
• Indexa tu código y documentación — index_file + recall = RAG semántico local sobre tu repositorio
• Cita de dónde proviene la respuesta — answer devuelve texto más los fragmentos de los que se extrajo
• Construye conocimiento del proyecto — cada checkpoint, reflect y anti_pattern se vuelve buscable más adelante
• Sobrevive a reinicios — artefactos de solo añadido en disco, almacén vectorial reconstruible a partir de ellos

Un pip install, un bloque de configuración, listo. Sin clave de API. Sin servicio externo. Sin factura por token. Licencia MIT. Esto es lo que el 95% de los usuarios usará de Recall.

---

¿En qué se diferencia de mem0 / Letta / Zep?

Recall hace el mismo trabajo que ellos — memoria persistente entre sesiones de IA, recuerdo semántico, "recuerda lo que el usuario dijo la semana pasada". La diferencia es dónde y cómo:

	mem0 / Letta / Zep	Recall
Dónde vive la memoria	Su nube	Tu ~/.recall/
Clave de API requerida	Sí	No
Costo	Por token / SaaS mensual	Gratis
Embeddings	Su servicio	ONNX local (sin conexión)
Llamadas de red	Cada recuerdo	Cero
Aislable de la red	No	Sí
Nativo de MCP	Envoltorio o SDK	Construido sobre MCP
Coordinación multiagente	Ninguna	6 primitivas

Si estás contento pagando a un proveedor de memoria alojado por token, esos son grandes productos y no necesitas Recall. Si prefieres que la memoria de tu IA viva en tu portátil o en tu propio servidor, gratis y sin conexión, para eso es Recall.

---

Escalando: coordinación cuando ejecutas más de un agente

La misma instalación que da a un desarrollador una memoria de IA personal también funciona como un cerebro compartido cuando más de un agente habla con él. Dos ventanas de Copilot. Un par planificador + ejecutor. Tres instancias de Claude dividiendo una refactorización. Un agente pre-commit y un agente code-review en el mismo PR. Todos remember y recall del mismo almacén.

Eso introduce un problema nuevo que ninguno de los servicios de memoria alojados ha intentado siquiera resolver: agentes pisándose entre sí. El agente A comienza a refactorizar src/auth.py. El agente B, en otra ventana, reescribe el mismo archivo sin saber que A está a mitad de edición. El último que guarda gana. El trabajo del otro agente se pierde.

Recall incluye seis primitivas MCP que convierten agentes paralelos de un caos de sobrescritura en un equipo coordinado:

Herramienta	Qué hace
claim(resource, agent)	Bloqueo suave de un archivo/tabla/URL con TTL de expiración automática
release(resource, agent)	Libera el bloqueo (archivo suave — la pista de auditoría sobrevive)
who_has(resource)	"¿Alguien está editando src/foo.py ahora mismo?"
claims()	Todos los bloqueos activos en todos los agentes
handoff(to_agent, ...)	Transferencia explícita de trabajo con intención + archivos + contexto
pulse_others(self_agent)	Los N puntos de control más recientes de agentes distintos a ti

Los reclamos son consultivos (como los bloqueos de git) — Recall no impide físicamente que un segundo agente escriba, pero todo cliente bien comportado comprueba primero. Los TTL evitan que un agente bloqueado congele un recurso para siempre. Las liberaciones archivan suavemente (según la regla de borrado=archivo del proyecto) para que la pista de auditoría de quién tuvo qué y cuándo sobreviva.

Si eres un usuario único, estas herramientas simplemente permanecen sin usar. Si alguna vez escalas a múltiples agentes, ya están ahí.

   ┌──────────────┐                           ┌──────────────┐
   │  Agent a3f7  │      claim(file, ttl)     │  Agent b1c4  │
   │  Claude #1   │ ───────────┐  ┌─────────► │  Claude #2   │
   └──────┬───────┘            ▼  │           └──────┬───────┘
          │              ┌────────┴───────┐          │
          │   remember   │     Recall     │   pulse  │
          ├────────────► │ • shared memory│ ◄────────┤
          │              │ • claims/locks │          │
          │   handoff    │ • handoffs     │  handoff │
          ├────────────► │ • who_has      │ ◄────────┤
          │              └────────────────┘          │
          ▼                                          ▼
       22 MCP tools — Copilot, Claude, Cursor, custom

22 herramientas MCP en total — 16 herramientas de memoria que todo usuario recibe, más las 6 primitivas de coordinación que se activan cuando escalas.

---

Instalación en una línea (Claude Desktop, VS Code, Cursor)

Recall se distribuye como un servidor MCP stdio. Configuración cero — sin claves de API, sin Docker, sin puertos. La memoria vive en ~/.recall/.

pip install "ai-recallworks[mcp]"

Luego añade Recall a la configuración de tu cliente MCP:

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json en macOS, %APPDATA%\Claude\claude_desktop_config.json en Windows):

{
  "mcpServers": {
    "recall": {
      "command": "recall-mcp"
    }
  }
}

VS Code (mcp.json en tu espacio de trabajo o configuración de usuario):

{
  "servers": {
    "recall": {
      "command": "recall-mcp"
    }
  }
}

Reinicia el cliente. Tu agente ahora tiene memoria persistente entre sesiones. Los embeddings se ejecutan completamente sin conexión (all-MiniLM-L6-v2 incluido de Chroma). Actualiza a embeddings de Ollama / OpenAI / Voyage mediante variables de entorno cuando quieras.

---

Instalación en cinco minutos (HTTP / multiusuario / equipo)

1. Ejecuta el servidor:

docker run -d --name recall \
  -p 8787:8787 \
  -e API_KEY=changeme \
  -v recall-data:/data \
  ghcr.io/recallworks/recall:latest

2. Habla con él — elige tu pila:

# Raw HTTP (any language)
curl -H "X-API-Key: changeme" \
     -H "Content-Type: application/json" \
     -d '{"content":"first memory","tags":"hello"}' \
     http://localhost:8787/tool/remember

# Python (use requests/httpx — no SDK pkg needed)
import requests
h = {"X-API-Key": "changeme", "Content-Type": "application/json"}
requests.post("http://localhost:8787/tool/remember", headers=h,
              json={"content": "first memory", "tags": "hello"})
print(requests.post("http://localhost:8787/tool/recall", headers=h,
                    json={"query": "memory"}).json()["result"])

// TypeScript / JavaScript (Node 18+, Bun, Deno, browser)
npm install @recallworks/recall-client

import { RecallClient } from "@recallworks/recall-client";
const c = new RecallClient({ baseUrl: "http://localhost:8787", apiKey: "changeme" });
await c.remember("first memory", { tags: "hello" });
console.log((await c.recall("memory")).result);

Guía completa: docs/quickstart.md.

---

Lo que obtienes

• 13 herramientas — remember, recall, reflect, anti_pattern, checkpoint, pulse, session_close, index_file, reindex, snapshot_index, memory_stats, forget, maintenance.
• Dos transportes — HTTP simple (POST /tool/{name}) y MCP sobre SSE. Úsalo con Copilot, Claude Code, Cursor o cualquier cliente MCP.
• Trae tus propios modelos — incrustador conectable (predeterminado / OpenAI / Ollama) y resumidor (noop / OpenAI / Ollama). Ejecuta completamente sin conexión, completamente en tus instalaciones, o contra tu propio inquilino de Azure-OpenAI. Consulta docs/byo-models.md.
• Duradero por defecto — almacén efímero en vivo con instantánea automática en disco; los reinicios del contenedor se recuperan completos.
• Artefactos de solo añadido — cada escritura también aterriza como un archivo .md. Si el almacén vectorial alguna vez se quema, reindex lo reconstruye a partir de los artefactos.
• forget es archivo suave — salvaguarda integrada en el propio código OSS, no añadida como política. La memoria que eliminas se puede recuperar.

---

En qué se diferencia

	Recall	Mem0 / Letta / Zep
Licencia (núcleo)	MIT	mixta; primero SaaS
Autoalojamiento	un docker run	varía, a menudo no trivial
Incrustador BYO	predeterminado / OpenAI / Ollama (variable de entorno)	generalmente fijo
LLM BYO	noop / OpenAI / Ollama (variable de entorno)	generalmente fijo
Modelo de almacenamiento	artefactos de solo añadido + índice vectorial, reconstruible	solo base de datos en vivo
delete	archivo suave por diseño	borrado duro
Superficie de herramientas	13 herramientas opinadas (memoria + flujo de trabajo)	primitivas de incrustación y recuperación
Nativo de MCP	sí, además de HTTP simple	parcial / mediante envoltorio
Modelo operativo	binario único, contenedor único	pila de múltiples servicios

Si quieres un servicio gestionado, consulta Recall Cloud a continuación. Si quieres un cerebro que poseas por completo, este núcleo OSS es suficiente.

---

Estructura del repositorio

Ruta	Qué es
src/recall/	Servidor OSS (MIT)
src/recall/tools/	Un módulo por herramienta
src/recall/transport/	Adaptadores HTTP + MCP/SSE
docker/single-tenant/	Dockerfile de referencia + compose
tests/	Suite pytest (sin Docker requerido)
docs/	Inicio rápido, convenciones, arquitectura
enterprise/	Multiinquilino, SSO, plano de control (BSL)

---

Convenciones

Estas son las prácticas que hacen que las herramientas den resultados. Elige lo que encaje.

• Ritual de inicio en frío — protocolo de apertura que cada sesión debería ejecutar.
• Marca — encabezados de edición firmada para que puedas rastrear qué agente tocó qué archivo y cuándo.

---

Estado

Alfa. El código en src/recall/ está extraído de un cerebro de producción alojado que ha servido miles de sesiones, luego saneado de rutas específicas de la organización, extensiones y datos de inquilinos. Espera cambios que rompan compatibilidad antes de 1.0; fija la etiqueta de la imagen.

---

Contribuciones

Sí — por favor lee CONTRIBUTING.md primero. Aceptamos correcciones de errores, nuevos backends de Store, mejoras de documentación y entradas de antipatrones. No aceptamos reescrituras arquitectónicas sin discusión previa.

Problemas de seguridad: consulta SECURITY.md.

---

Licencia

• src/recall/, clients/, docker/single-tenant/, docs/, examples/ — MIT (LICENCIA)
• enterprise/ — BSL 1.1, concesión de uso adicional de 5 asientos, se convierte a MIT después de 3 años (LICENCIA-COMERCIAL.md)

---

Recall de Código Abierto vs. Recall Pro vs. Alojado

Capacidad	OSS (este repositorio)	Recall Pro	Recall Cloud
Imagen Docker de un solo inquilino	✅	✅	n/a (alojado)
13 herramientas de memoria, MCP + HTTP	✅	✅	✅
Incrustador y LLM BYO	✅	✅	✅
Artefactos de solo añadido + instantánea automática	✅	✅	✅
Multiinquilino, SSO, RBAC	—	✅	✅
Registro de auditoría + política de retención	—	✅	✅
Grafo de entidades entre sesiones	—	✅	✅
Canalización de saneamiento de PII	—	✅	✅
Replicación de instantáneas / DR	—	✅	✅
Soporte del proveedor + SLA	comunidad	horas laborables	24×7
Alojado en nuestra infraestructura	—	—	✅
Precio	gratis	desde $99/mes por nodo	desde $0.10 por 1k herramientas

Recall Pro se distribuye desde el árbol enterprise/ bajo una Licencia de Código Fuente Comercial — código fuente disponible, concesión de uso adicional gratuita de 5 asientos, se convierte a MIT después de 3 años. Compra una licencia y los módulos enterprise/ se activan junto a tu instalación OSS.

Recall Cloud es la versión alojada multiinquilino. Las mismas herramientas, sin infraestructura. Contacta para obtener precios de acceso anticipado.

➡️ Habla con ventas: sales@recall.works · Reserva un recorrido de 20 minutos: https://recall.works/demo

---

Construcciones verticales impulsadas por Recall

Recall es el motor. Distribuimos cerebros verticales llave en mano sobre él:

• IceWhisperer — el cerebro de memoria + flujo de trabajo para equipos de ICE Mortgage Technology / Encompass. Índice de SDK precargado, recetas de configuración, auditorías de plugins, detección de desviaciones. Planes desde $250/mes.

Si quieres un cerebro vertical para tu industria, lo construiremos. Envía un correo a partners@recall.works.

---

Mantenedores

Contacta a los mantenedores en maintainers@recall.works. Los problemas y solicitudes de extracción son bienvenidos en GitHub.