amem

Memoria local del agente sin Docker: amem + MCP (los hechos permanecen en ~/.amem)

Documentación

amem

Memoria personal del agente que permanece en tu máquina.

Los agentes de codificación olvidan entre sesiones. Vuelven a buscar en el mismo árbol, vuelven a aprender las mismas restricciones y queman tokens redescubriendo decisiones que ya pagaste una vez.

amem les da a Cursor, Claude Code y otros hosts locales una memoria privada y buscable de hechos duraderos sobre tus repositorios — qué es dueño de qué, qué archivos importan, qué se rompió la última vez — para que la próxima sesión comience orientada en lugar de en frío.

amem context "sync auth startup"

# Agent Memory Context

## Best Claims
### claim.sync_auth_mode_startup
Kind: `constraint`
Why: `keyword+8`, `fts+18.0`, `embed+6.3`, `kind:constraint`, `fresh`

The sync service checks auth mode during startup before enabling Drive sync.
Anchors: `src/background/sync-service.ts`

Nada se sube. Nada se escribe en el historial de git de tu producto. La memoria vive bajo ~/.amem/ solo en tu laptop.

Por qué existe amem

Sin amem	Con amem
El agente explora ampliamente cada sesión	El agente consulta la memoria primero, luego verifica los archivos correctos
Las decisiones viven en el scrollback del chat	Las decisiones se convierten en afirmaciones estructuradas con anclas de archivo
Presión de compartir en equipo sobre documentos de "contexto de IA"	Explícitamente personal — tus prompts y aprendizajes permanecen locales
`AGENTS.md` plano que se vuelve obsoleto	Grafo pequeño: componentes → flujos → afirmaciones, actualizado mediante propuestas

amem no es un wikiware compartido de empresa y no es un producto RAG en la nube. Es una herramienta local para desarrolladores individuales que quieren agentes que recuerden su trabajo.

Privacidad (no negociable)

Pieza	Ubicación	¿Compartida?
La herramienta amem (este repo)	GitHub / npm	Sí — instalable
Tu base de datos de memoria	`~/.amem/graph.db` (o `.enc` cuando está bloqueada)	No
Regla de proyecto de Cursor	`.cursor/rules/amem.mdc` en el repo del producto	Seguro de commitear — solo orientación, sin contenidos de memoria
Exportaciones / copias de seguridad que crees	Donde las escribas	Mantén privadas — no las commitees

Garantías:

~/.amem se crea con modo 0700
La UI local se vincula solo a 127.0.0.1
La memoria nunca sale de la máquina — sin sincronización gestionada, sin modo "compartir con la organización"
Solo ping anónimo de instalación opcional (ver Telemetría); puedes optar por no participar en cualquier momento
Se instruye a los agentes a almacenar hechos del repo, no estrategia de prompting propietaria
Bloqueo AES-256-GCM opcional y copias de seguridad locales cifradas — aún sin nube

Requisitos

Node.js 20+ (better-sqlite3 nativo)
git (la identidad del repo usa URL remota / ruta raíz)

Instala la herramienta

npx @iamem/amem setup   # Node 20+ — installs the `amem` CLI
# or
npm i -g @iamem/amem && amem setup

Desde un clon mientras desarrollas:

git clone https://github.com/sslugic/amem.git
cd amem
npm install
npm link
amem setup

Ver docs/npm-release.md. CI ejecuta npm test y npm run pack:check. better-sqlite3 usa sus propios prebuilds — sin paso nativo extra en macOS/Linux comunes + Node 20/22.

Si npm install falla al compilar código nativo, instala Xcode CLT (macOS) o build-essential (Linux) y reintenta, o usa un binario oficial de Node 20/22 que coincida con la matriz de prebuilds.

Telemetría

En npm install / npx (fuera de CI y pruebas), amem puede enviar un único POST anónimo a https://getamem.com/api/beacon/npm-install con:

nombre y versión del paquete
versión de Node.js
plataforma del SO y arquitectura de CPU

No se incluyen código, rutas, nombres de usuario, correos electrónicos, IPs ni contenidos de memoria. Opta por no participar:

AMEM_TELEMETRY_DISABLED=1 npm i -g @iamem/amem

La memoria bajo ~/.amem sigue sin salir nunca de tu máquina.

Rutas rápidas

# Cursor or Claude Code in a git repo
amem init --platform cursor    # or: claude

# Other hosts (thin installers, same local DB)
amem init --platform windsurf|continue|aider|zed|claude-desktop

# Any other MCP client — binds the repo and prints the endpoint to paste
amem init --platform codex|copilot|gemini|cline|roo|jetbrains|opencode|goose|…
amem platforms                  # every id amem accepts (aliases included)

# Cross-repo “how I work” prefs (blended into project context)
amem init --personal
# or: amem setup --personal

Cifrado en reposo + copias de seguridad locales

amem lock --passphrase '…'       # or AMEM_PASSPHRASE
amem unlock --passphrase '…'
amem backup --passphrase '…'     # ~/.amem/backups by default
amem backup schedule             # daily local timer (no cloud)
amem backup unschedule

Mientras esté bloqueado, establece AMEM_PASSPHRASE (o desbloquea) antes de cualquier comando que abra la base de datos.

Embeddings y el resto del kit de herramientas

Todo es gratis. No hay niveles ni nada retenido — embeddings locales, higiene de memoria y su horario, sincronización de reglas y el paquete de atestación están todos incluidos.

amem embed use ngram                     # local n-gram model, or `external` for your own command
amem embed reindex
amem restore --file ~/.amem/backups/amem-….db.enc
amem hygiene
amem rules sync
amem it-pack --out ~/.amem/it-pack
amem doctor --attest

El embedder se envía como modelo de hash por defecto (sin descarga); ngram y external (texto stdin → vector JSON) también son locales. Aún sin API de embed en la nube, y nada se sube.

El checkout + entrega por correo es un proceso de vendedor separado (npm run shop) que no se publica con el CLI. Puede incluir en la lista blanca nombres de Mailtrap y Stripe desde el .env de otro proyecto — ver shop/README.md.

Enseñar a cada cliente cómo usar amem

Conectar un host al endpoint MCP le dice a amem que existe; no le dice que revise el tablero de tareas o consulte la memoria antes de explorar. amem init y amem setup ahora escriben instrucciones en el archivo que el host realmente lee, y un comando cubre todo lo demás:

amem instructions                 # the client(s) bound to this repo
amem instructions --all           # every supported client
amem instructions --check         # CI-friendly: exits 1 if missing or stale
amem instructions --platform roo  # just one

Un texto canónico (src/instructions.ts) se renderiza por host, para que la orientación no se desvíe entre clientes:

Archivo	Clientes
`.cursor/rules/amem.mdc`	Cursor
`CLAUDE.md`	Claude Code
`AGENTS.md`	Codex, Grok, OpenCode, Crush, Amp, Qwen, Droid, OpenHands, Warp, Zed, Cody, Antigravity, Neovim, Claude Desktop, Devin, Jules
`GEMINI.md`	Gemini CLI
`.github/copilot-instructions.md`	GitHub Copilot
`.windsurf/rules/amem.md` · `.continue/rules/amem.md` · `.clinerules/amem.md` · `.roo/rules/amem.md` · `.kilocode/rules/amem.md` · `.augment/rules/amem.md` · `.kiro/steering/amem.md` · `.trae/rules/amem.md` · `.amazonq/rules/amem.md`	Windsurf, Continue, Cline, Roo, Kilo, Augment, Kiro, Trae, Amazon Q
`.junie/guidelines.md` · `.goosehints` · `.aider.amem.md`	Junie, Goose, Aider

Los hosts que comparten un archivo se escriben una vez, así que --all produce 17 archivos, no 30. Los archivos compartidos (CLAUDE.md, AGENTS.md, .github/copilot-instructions.md) reciben un bloque marcado que se reemplaza en su lugar — cualquier cosa que escribas alrededor sobrevive:

# My Project
Use pnpm, not npm.

<!-- BEGIN amem (generated) -->
…
<!-- END amem -->

Aider no tiene MCP, así que recibe comandos CLI en lugar de nombres de herramientas. Cada archivo es solo orientación — sin contenidos de memoria — y seguro de commitear. amem doctor lo dice cuando las instrucciones de un cliente vinculado faltan o están desactualizadas.

Memoria que se cura sola

La memoria se pudre si nada la retira. amem limpia en un horario en lugar de esperar a que se lo pidan:

amem hygiene schedule          # daily; amem doctor warns when it is not installed

Cada ejecución toma una copia de seguridad de seguridad, luego, por repo:

Señal	Qué significa	Acción
No-hecho	Relleno de chat almacenado como afirmación	Eliminado (retenido si supera el 25% del repo — un heurístico que coincide con la mayor parte de un corpus es un heurístico roto)
Ancla podrida	Cada archivo al que apunta la afirmación ha desaparecido	Decaído. Las anclas de tipo etiqueta y los espacios de trabajo sin fuente están exentos
Poco útil	Atestiguado 3+ veces y nunca respondió la pregunta	Decaído
Sin uso	No devuelto y no tocado dentro de la ventana	Decaído
Casi duplicado	Mismo contenido, anclas superpuestas	Fusionado

Una afirmación solo se retira con evidencia positiva. La falta de atestación nunca cuenta en su contra — de lo contrario, enviar esto decaería todo a la vez. Las afirmaciones fijadas nunca decaen.

Ahorros que puedes verificar

amem context registra lo que entregó; el agente (o el hook de detención, desde la transcripción del host) registra lo que aún tuvo que abrir. El ahorro se calcula entonces a partir del tamaño real de los archivos que se evitaron:

saved = Σ(measured tokens of anchors returned but not opened) − packet_tokens

Nada le pide a un modelo que estime su propio valor, y un paquete que no evitó nada reporta una pérdida. El panel dice modelled hasta que se hayan atestiguado 30 eventos, luego cambia a measured y corrige el total por la proporción observada.

amem usage attest --opened "src/db.ts"   # or let the stop hook do it
amem usage recompute --scope all --apply # re-measure historical events

Configuración inicial (recomendada)

amem ui

Eso abre http://127.0.0.1:7843 en la pestaña Configuración. Escanea tu carpeta de inicio en busca de repos git (omite Library, node_modules, Downloads y ruido similar). Marca los que quieras, elige clientes (Cursor, Claude Code, Windsurf, Continue, Aider, Zed, …), luego Comenzar a rastrear los seleccionados. Cada selección se vincula en ~/.amem y recibe el instalador correspondiente cuando esté disponible.

¿Prefieres una ventana de escritorio en lugar de una pestaña del navegador (mismo servidor localhost, misma privacidad)?

# once per machine/checkout (downloads Electron — not included in npm i -g)
npm run app:setup

amem app

amem ui sigue abriendo el navegador; amem app abre Electron. Ambos hablan solo con 127.0.0.1. Si el servidor de UI ya está en ejecución, amem app se adjunta a él. Instalaciones globales: ejecuta npm run app:setup desde el directorio del paquete (o clon), luego amem app.

El encabezado tiene un interruptor Personal (preferencias entre repos) y un marco Bloquear / respaldar — estado de bloqueo, último respaldo y un horario local diario. La memoria muestra los mismos chips de bloqueo/respaldo. La pestaña Configuración incluye un contrato de recordar copiable para cualquier host MCP (amem recipe).

Opcional: marca Iniciar amem ui cuando esta computadora inicie sesión para que el servidor localhost regrese después de un reinicio:

amem service install    # macOS LaunchAgent, Linux systemd --user, or Windows Startup
amem service status
amem service uninstall

Pestañas después de la configuración:

Configuración — escanear/seleccionar repos, plataformas, auto-inicio de inicio de sesión, propuesta de arranque
Memoria — hechos por archivo, borradores puntuados (aprobar / reemplazar más antiguos / descartar / rechazar ruidosos), editar/fijar/eliminar, buscar, aciertos/fallos recientes
Tareas — Kanban por proyecto para trabajo diferido del agente (Pendiente → Siguiente → Haciendo → Bloqueado → Hecho). MCP: amem_task_add / amem_task_update / amem_task_complete. Las tareas abiertas aparecen en amem_context. Usa Memoria para hechos duraderos; Tareas para "hacer después".
Estadísticas — tokens estimados ahorrados por LLM, más exportación JSON / markdown / PDF (proxies, no una factura)

Solo servidor (sin navegador abierto):

amem ui --port 7843 --no-open

Para escanear carpetas adicionales (o solo un subconjunto), establece AMEM_SCAN_ROOTS a una lista de directorios separada por dos puntos.

Alternativa CLI (sin UI)

cd ~/path/to/your-real-project
amem init --platform cursor    # or: --platform claude
amem doctor
amem status

Para conectar ambos agentes a la misma memoria local, ejecuta init una vez por plataforma (o selecciona ambos en la UI).

Bucle del día a día

1. Consulta antes de explorar

amem context "billing webhook retry"

O deja que el agente lo haga — Cursor obtiene una regla de proyecto siempre activa; Claude obtiene orientación de hooks. Ambos instalan las habilidades:

amem-bootstrap — sembrar memoria de línea base
amem-update-working-memory — guardar aprendizajes duraderos después de una sesión

Los hooks también inyectan contexto al inicio de la sesión / envío de prompt, almacenan notas de conversación, ponen en cola borradores de fin de sesión y pueden poner en cola borradores fallo→aprendizaje después de búsquedas de contexto vacías cuando el agente luego cita archivos reales. Aprueba borradores en Memoria (o permite tipos de bajo riesgo mediante la política auto_apply_kinds).

2. Trabaja como de costumbre

Trata la memoria como un mapa, no como fuente de verdad. Lee los archivos anclados antes de cambiarlos. Prefiere afirmaciones marcadas como frescas; verifica las obsoletas (archivos anclados cambiados después de la afirmación).

3. Guarda lo que debería sobrevivir

Pídele al agente que ejecute amem-update-working-memory, aprueba borradores de Memoria o aplica una propuesta tú mismo:

amem propose validate /tmp/memory.json
amem propose diff /tmp/memory.json
amem propose apply /tmp/memory.json

4. Instalación opcional de una sola vez del agente

Desde dentro del repo del producto, pega docs/agent-install-prompt.md en Cursor o Claude Code y deja que ejecute la configuración por ti.

Qué se almacena

La memoria es un pequeño grafo local en SQLite:

Objeto	Significado
Componente	Un subsistema / módulo (`component.api`)
Flujo	Cómo se mueve el trabajo (`flow.checkout`)
Afirmación	Un hecho duradero con anclas de archivo (puede ser `active` o `superseded`; pin opcional)
Borde	Enlaces (afirmación → flujo → componente); `kind: "supersedes"` archiva la afirmación objetivo
Borrador	Propuestas pendientes de sesión / fallo→aprendizaje esperando aprobación de Memoria
Tarea	Trabajo diferido en el Kanban del proyecto (Pendiente / Siguiente / Haciendo / Bloqueado / Hecho) — no es un hecho duradero
Habilidad	Un procedimiento reutilizable de varios pasos, almacenado como archivo `SKILL.md` (ver abajo)
Evento de uso	Cada acierto de `amem context` + estimación de tokens

Las afirmaciones son la unidad de recuperación. La clasificación combina:

SQLite FTS5 (stemming de Porter) + puntuación de palabras clave
Embeddings de hash en el dispositivo (sin descarga de modelo)
Impulso de pin, pesos de tipo (constraint / gotcha > session), frescura
Afirmaciones de preferencias personales opcionales mezcladas en el contexto del proyecto

Cada afirmación inyectada incluye una línea Por qué:. Las afirmaciones obsoletas (anclas cambiadas después de updated_at) se clasifican más abajo.

Ejemplo de afirmación:

{
  "id": "claim.webhook_idempotency",
  "kind": "constraint",
  "text": "Stripe webhooks must be idempotent on event.id before mutating invoices.",
  "code_anchors": ["src/webhooks/stripe.ts"],
  "supersedes": ["claim.webhook_old_rule"]
}

supersedes (o un borde con kind: "supersedes") marca ids de afirmaciones más antiguas como archivados para que salgan de la recuperación.

Habilidades (memoria procedimental)

Claims responden qué es verdad. Skills responden cómo hacemos esto aquí — una secuencia de despliegue, un baile de migración, un camino de depuración que alguien ya recorrió. Son demasiado largos para estar en cada prompt, así que se cargan bajo demanda.

Los skills viven como archivos SKILL.md bajo ~/.amem/skills/, indexados en SQLite para clasificación:

~/.amem/skills/deploy-staging/SKILL.md
~/.amem/skills/deploy-staging/references/runbook.md

Divulgación progresiva. Un paquete de contexto lleva solo nombres y descripciones. El agente llama a amem_skill_view para extraer un cuerpo una vez que decide que el procedimiento aplica, por lo que una biblioteca de skills no utilizada cuesta casi cero tokens.

El bucle de aprendizaje. amem no incluye ningún modelo, por lo que nunca escribe un skill por sí mismo. Al final de la sesión, busca la forma de un procedimiento difícil de conseguir — pasos enumerados o comandos reales, más un error del que se recuperó o una corrección que diste. Cuando varias señales coinciden, pone en cola una sugerencia, que llega a tu agente como un empujón en el siguiente paquete de contexto. El agente escribe el skill; tú lo apruebas. Si un skill se cargó durante una sesión que aún así salió mal, amem pone en cola una revisión en lugar de un duplicado.

El listón es deliberadamente alto, y una sesión puede poner en cola como máximo una sugerencia.

amem skills list                # index of what is stored
amem skills show deploy-staging # full body
amem skills new deploy-staging --desc "Deploy staging and verify health"
amem skills import ./some-skill # bring in an agentskills.io skill
amem skills drafts              # pending suggestions and staged writes
amem skills approve <draft-id>

Los skills también son una pestaña de Skills en amem ui.

Seguridad. Los skills son instrucciones que un agente seguirá, por lo que el contenido se escanea en busca de credenciales y patrones de inyección de prompts antes de cualquier escritura. Tres claves de política los controlan:

Clave	Predeterminado	Efecto
`skills_enabled`	`true`	Interruptor maestro para almacenamiento, clasificación e inyección
`skill_write_approval`	`false`	Escenifica las escrituras del agente para revisión en lugar de escribir en disco
`skill_capture`	`true`	Permitir sugerencias de skills al final de la sesión

Un policy.toml ilegible fuerza skill_write_approval a activarse. amem doctor --attest informa cada skill instalado con un hash de contenido, para que puedas comparar lo que se les dice a los agentes que hagan.

Las copias de seguridad actualmente copian solo la base de datos — ~/.amem/skills/ aún no está incluido. Mantén los skills que te importan en control de versiones hasta que eso llegue.

Ahorro de tokens (estimaciones)

Cada amem context registra un evento de uso. La pestaña Stats de la interfaz desglosa esto por plataforma (cursor, claude, …).

Estimación automática:

estimated_avoided = max(0, anchors×4000 + claims×200 − packet_tokens)

Esto es un proxy de exploración evitada — no tu factura de Cursor/Anthropic. El dinero usa el mismo proxy de tokens a $3 por 1M de tokens de entrada (entrada de clase Sonnet). El uso incluido de Cursor y los tokens de salida no se facturan de esta manera, así que trata $ como una estimación de orden de magnitud.

El tiempo ahorrado es un proxy separado: cada ancla de archivo devuelta se trata como ~1.2s de ida y vuelta de herramienta que el agente no tuvo que hacer. El tiempo de búsqueda local se mide (SQLite en localhost). La tasa de aciertos son coincidencias de palabras clave en amem context — no llamadas a la API de Cursor/modelo (esas aún ocurren). Un fallo significa que ningún hecho almacenado coincidió con la consulta; los hechos más nuevos aún pueden inyectarse como un respaldo débil, y el agente aún habla con el modelo.

Stats también muestra una proyección mensual: últimos 7 días de llamadas (o menos si acabas de empezar), escalados a 30 días. Sigue siendo un proxy, no una factura.

Si luego conoces un número mejor:

amem usage report --platform cursor --saved 12000
# or attach to a specific event:
amem usage report --event-id usage_… --saved 12000

Clientes LLM (más allá de repositorios git)

amem puede vincular un espacio de trabajo nombrado que no es un checkout de git — para Luna Client o cualquier herramienta que hable con Cursor/Claude/otros modelos.

amem init --workspace my-app
# seeds starter facts and runs a context check automatically

Adjunta cualquier cliente LLM tú mismo (HTTP o MCP). Mantén amem ui ejecutándose para HTTP. Desde el cliente, antes de cada llamada al modelo:

const res = await fetch("http://127.0.0.1:7843/api/context", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    workspace: "my-app",
    query: userMessage,
    platform: "app",
    sessionId,
  }),
});
const { markdown } = await res.json();
// prepend markdown to the prompt / tool result so the model skips a large retrieve

Después de un resultado duradero:

await fetch("http://127.0.0.1:7843/api/remember", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    workspace: "my-app",
    text: takeaway,
    kind: "session",
    anchors: ["my-app"],
  }),
});

Configuración MCP (cualquier host MCP):

Mantén amem ui ejecutándose (o amem service install para que se inicie al iniciar sesión). Las aplicaciones GUI a menudo no pueden encontrar amem en PATH, lo que aparece como "falló el descubrimiento de herramientas en vivo" / MCP error — no un mensaje de inicio de sesión. Prefiere HTTP:

{
  "mcpServers": {
    "amem": {
      "url": "http://127.0.0.1:7843/mcp?workspace=my-app"
    }
  }
}

Stdio también funciona si el host puede generar el binario. Imprime una configuración con rutas absolutas:

amem mcp --print-config --workspace my-app

Misma base de datos localhost que la memoria de repositorio git. El conmutador de la interfaz agrupa Repositorios Git y Espacios de trabajo. Renombra el nombre para mostrar de un espacio de trabajo en cualquier momento — el slug MCP (workspace=luna-ai) y los claims almacenados permanecen en el mismo id.

amem rename "Luna Client" --workspace luna-ai

Herramientas MCP (stdio o HTTP):

Herramienta	Cuándo usarla
`amem_context`	Paquete de memoria clasificado para la pregunta actual
`amem_remember`	Almacenar un hecho duradero después de un resultado
`amem_recipe`	Contrato genérico de lectura-luego-escritura (cualquier host MCP)
`amem_skill_list`	Índice barato de procedimientos almacenados (solo nombres + descripciones)
`amem_skill_view`	Cargar un cuerpo de skill, después de que el índice diga que aplica
`amem_skill_save`	Almacenar un procedimiento de varios pasos que acabas de resolver
`amem_repos`	Qué se monitorea (repositorios git + espacios de trabajo nombrados)
`amem_stats`	Tiempo de búsqueda, tokens/ms estimados ahorrados, tasa de aciertos
`amem_graph`	Claims / componentes / flujos almacenados para un espacio de trabajo o repositorio
`amem_status`	Vinculación + conteos; omite el espacio de trabajo para una visión general de toda la máquina

Referencia de comandos

amem setup [--personal] [--platform <host>]
amem init --platform <client>      # amem platforms lists every id
amem platforms [--json]
amem init --workspace <name> [--path <dir>] [--platform …]
amem init --personal
amem rename "<display name>" --workspace <slug>
amem status [--workspace <name>]
amem doctor [--attest] [--json]
amem context "<query>" [--workspace <name>] [--platform …]
amem remember "<text>" [--workspace <name>] [--kind …] [--anchor <path>]
amem recipe [--json]
amem skills list|show <name>|new <name> [--desc <text>]|rm <name>|sync|import <path>
amem skills drafts|approve <draft-id>|dismiss <draft-id>
amem mcp [--print-config] [--workspace <name>]
amem propose validate|diff|apply <file.json>
amem export [--out <file.json>]
amem wipe --yes
amem wipe --all --yes
amem lock|unlock --passphrase <secret>
amem backup [--out <dir>] [--passphrase <secret>] [--label <name>]
amem backup schedule [--out <dir>] [--hour <0-23>]
amem backup unschedule
amem session touch --platform cursor|claude [--session-id <id>]
amem hook
amem usage report --saved <n> [--platform …] [--event-id …]
amem usage export [--format json|md|pdf] [--days 30] [--scope current|all] [--out <file>]
amem license status|apply|activate|clear|issue|keys
amem embed status|use hash|use ngram|reindex
amem ui [--port 7843] [--no-open]
amem app [--port 7843]
amem service install|uninstall|status

Comando	Propósito
`setup`	Espacio de trabajo personal de una sola vez + instalación opcional del host
`init`	Vincular un repositorio git, espacio de trabajo nombrado, preferencias personales o host
`rename`	Cambiar el nombre para mostrar de un espacio de trabajo; el slug MCP y la memoria permanecen vinculados
`context`	Recuperar un paquete Markdown; registrar uso
`remember`	Almacenar un hecho local
`mcp`	Herramientas MCP stdio; MCP HTTP en `http://127.0.0.1:7843/mcp` mientras la interfaz se ejecuta
`skills`	Gestionar memoria procedimental (`list`, `show`, `new`, `import`, `drafts`, `approve`)
`propose diff`	Previsualizar cambios de claim/componente/flujo antes de aplicar
`propose apply`	Insertar o actualizar memoria estructurada localmente
`lock` / `unlock`	Cifrado opcional en reposo AES-256-GCM para `graph.db`
`backup`	Instantánea local (opcionalmente cifrada); `schedule` para temporizador diario
`ui`	Asistente de configuración + Memoria + Stats en el navegador (localhost)
`app`	Misma interfaz en una ventana Electron (`npm run app:setup` una vez)
`service`	Elemento de inicio de sesión para que `amem ui` se inicie después del reinicio
`doctor --attest`	Atestación de política/privacidad para tickets de TI
`export` / `wipe`	Copia de seguridad personal o eliminación (aún local)
`wipe --all --yes`	Desvinculación: borrar cada repositorio y eliminar `~/.amem`

Qué coloca la instalación y dónde

Cursor

Artefacto	Ruta
Skills	`~/.cursor/skills/amem-*`
Regla de proyecto	`.cursor/rules/amem.mdc` (en el repositorio del producto)
Hooks	`~/.cursor/hooks.json`

Recarga Cursor si los skills/reglas no aparecen de inmediato.

Claude Code

Artefacto	Ruta
Skills	`~/.claude/skills/amem-*`
Hooks	`~/.claude/settings.json` (`UserPromptSubmit` / `Stop` / relacionados → `amem hook` completo)

Otros hosts

Host	Qué escribe amem
Windsurf	Entrada MCP `~/.codeium/windsurf/mcp_config.json`
Continue	Servidores MCP `~/.continue/config.json`
Aider	Sugerencias CLI `.aider.amem.md` en el repositorio
Zed	Sugerencia `settings.json` `context_servers` / HTTP
Claude Desktop	Entrada MCP stdio `claude_desktop_config.json`

Cada otro cliente en amem platforms — Codex, Copilot, Gemini CLI, Grok, Cline, Roo, Kilo, Cody, Augment, JetBrains, Kiro, Trae, Antigravity, Neovim, OpenCode, Goose, Crush, Amp, Qwen Code, Factory Droid, OpenHands, Amazon Q, Warp, Devin, Jules — no tiene instalador local: amem init --platform <id> vincula el repositorio e imprime el endpoint MCP para pegar (amem recipe para la configuración completa).

Los ids de cliente se pliegan por alias, por lo que claude-code, vscode, pycharm y chatgpt se resuelven a claude, copilot, jetbrains y codex en lugar de disparar policy.allowed_platforms.

Preguntas frecuentes de seguridad y arquitectura

¿Cómo previene amem el envenenamiento de herramientas y la inyección de prompts?

Las herramientas de memoria sin restricciones que registran ciegamente transcripciones de chat son vulnerables a almacenar residuos conversacionales, instrucciones adversarias o contexto envenenado. amem aplica múltiples puertas defensivas:

Filtrado de sintaxis Hecho vs. Ruido (isFactLike): Las oraciones de transcripción, preguntas, cortesías de chat y fragmentos de prompts de usuario se rechazan automáticamente antes de convertirse en claims, incluso si mencionan rutas de archivo reales.
Listas de denegación de secretos integradas y personalizadas (BUILTIN_DENY_CLAIM_PATTERNS): Las expresiones regulares integradas eliminan contraseñas, claves API, tokens y claves privadas. Los administradores pueden imponer patrones de denegación regex adicionales mediante política del sistema.
Puntuación de calidad y especificidad (scoreProposal): Las propuestas se puntúan según la presencia de anclas, vocabulario duradero (constraint, gotcha, must) y especificidad. Las entradas delgadas o de baja puntuación por debajo del umbral de rechazo se descartan.
Cola de ingesta escalonada por defecto (ProposalDraft): Las capturas en segundo plano y las deducciones al final de la sesión se escalonan como propuestas en SQLite para revisión humana en la interfaz. La aplicación automática está deshabilitada por defecto (auto_apply_kinds = []).
Seguimiento de conflictos y superación: Cuando nuevos claims comparten anclas con hechos existentes, amem calcula similitud y plantea advertencias de conflicto, requiriendo superación explícita en lugar de permitir sobrescrituras silenciosas.

¿Cómo previene amem la hinchazón de contexto y la fuga de memoria entre proyectos?

Partición por repositorio: Cada claim de memoria, tarea, componente y nota está claveado por repo_id (derivado de la URL remota git / ruta del espacio de trabajo). Las consultas en un proyecto no pueden recuperar ni filtrar memoria de otro repositorio.
Recuperación híbrida y límites estrictos: En lugar de volcar el grafo, amem_context usa búsqueda híbrida de texto completo BM25, embeddings en el dispositivo, coincidencia de palabras clave y multiplicadores de frescura para clasificar y seleccionar solo los hechos relevantes principales (límite predeterminado: 12).
Límites duros de caracteres: Las inyecciones automáticas de hooks están limitadas a 2,400 caracteres para prevenir la hinchazón de prompts y ataques de agotamiento de tokens.
Divulgación progresiva para skills: Los paquetes de contexto inyectan solo un índice de Nivel 0 (nombres de skills y descripciones de una línea). Los cuerpos procedimentales completos nunca se inyectan a menos que el modelo los solicite explícitamente mediante amem_skill_view.

¿Cómo maneja amem los cambios de código sin servir memoria obsoleta?

Cada claim está fundamentado con anclas de archivo (code_anchors). Durante la generación de contexto, amem verifica la existencia de archivos y compara las marcas de tiempo de modificación de archivos con los tiempos de creación de claims:

Si los archivos anclados han cambiado, el claim se marca como obsoleto y se penaliza en la clasificación.
Los paquetes de contexto inyectan explícitamente una advertencia en el prompt del agente: "_X claim(s) marked stale — anchored files changed after the claim was written. Verify before trusting._"

¿Expone amem un servidor de red no autenticado o sube código?

Vinculación estricta a loopback: El daemon HTTP / MCP de la interfaz local se vincula exclusivamente a 127.0.0.1. Las vinculaciones que no sean loopback están bloqueadas por reglas de política codificadas.
Cero egress externo: La telemetría está codificada como desactivada (telemetry: false). Todas las bases de datos SQLite (graph.db), vectores y registros permanecen bajo ~/.amem con permisos de sistema de archivos local 0700.
Cifrado opcional en reposo: La base de datos local se puede cifrar usando AES-256-GCM (amem lock --passphrase '...').

Desarrolla amem tú mismo

cd amem
npm install
npm run build
npm run test          # unit + integration + CLI e2e (node:test)
npm run smoke         # end-to-end CLI/API smoke
npm run test:all      # both
npm link

Diseño:

src/           CLI, SQLite, policy, attest, installers, localhost API
ui-static/     Setup / Memory / Stats UI
skills/        Agent skill markdown
templates/     Cursor rule + example enterprise policy
docs/          Agent install prompt + IT endpoint runbook + backlog
test/          Comprehensive node:test suite
scripts/       Smoke tests + MDM offboard helper

Anula el hogar de memoria para pruebas:

AMEM_HOME=/tmp/amem-test amem status

Endpoint empresarial (gestionado por TI)

amem sigue siendo memoria personal en la computadora portátil — no una wiki compartida ni RAG en la nube.
TI / DevEx puede gobernar la flota: instalación aprobada, política, atestación, desvinculación.

Control	Mechanism
Política	`/etc/amem/policy.toml` (sistema) anula `~/.amem/policy.toml`; o `AMEM_POLICY_PATH`
Atestación	`amem doctor --attest` / `--json` (también `GET /api/attest` en la UI local)
Higiene de secretos	Patrones de denegación integrados + política `deny_claim_patterns` al proponer
Bloqueo de exportación	`allow_export = false`
Listas de permitidos de plataforma/repositorio	`allowed_platforms`, `allowed_remote_hosts`
Borradores de auto-aplicación	`auto_apply_kinds` (vacío = nunca; aún local)
Offboarding	`amem wipe --all --yes` o scripts/mdm-offboard.sh

Garantías estrictas (no configurables):

Sin telemetría de memoria ni carga de reclamos — ~/.amem permanece local
Solo ping opcional y anónimo de instalación npm (exclusión: AMEM_TELEMETRY_DISABLED=1)
La UI se vincula solo a loopback (127.0.0.1)
La memoria permanece bajo ~/.amem (modo 0700)

Inicio rápido de TI

# 1) Pin / install amem on the endpoint (internal npm, pkg, or npm link)
# 2) Deploy policy (root-owned on managed machines)
sudo mkdir -p /etc/amem
sudo cp templates/policy.example.toml /etc/amem/policy.toml

# 3) Verify for security review
amem doctor --attest --json

# 4) On offboard / laptop return
amem wipe --all --yes
# or: scripts/mdm-offboard.sh

Política de ejemplo: templates/policy.example.toml
Runbook completo de TI: docs/enterprise-endpoint.md

Despliegue sugerido: piloto pequeño de DevEx → paquete MDM + política → builds firmados/SBOM si adquisiciones lo solicita. La memoria organizacional compartida está intencionalmente fuera de alcance.

No objetivos

Memoria compartida o sincronizada de la empresa
"Cerebro de equipo" alojado en la nube
Integración exacta de facturación del proveedor
APIs de incrustación en la nube/remota (solo FTS5 local + embeddings de hash en el dispositivo)
Escribir contenidos de memoria en el historial de git del producto

Ideas futuras (no programadas): ver docs/backlog.md.

Licencia

MIT — ver LICENSE.