ai-memory

ai-memory™

memoria universal de IA

ai-memory es un sistema de memoria persistente para asistentes de IA. Funciona con cualquier IA que soporte MCP -- Claude, ChatGPT, Grok, Llama y más. Almacena lo que tu IA aprende en una base de datos SQLite local, clasifica los recuerdos por relevancia al recuperarlos y promueve automáticamente el conocimiento importante a almacenamiento permanente. Instálalo una vez y cada asistente de IA que uses recordará tu arquitectura, tus preferencias, tus correcciones -- para siempre.

Elige tu ruta de instalación

¿Configurando el backend LLM (xAI Grok, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, servidor llama.cpp o Ollama local)? Consulta docs/integrations/llm-backends.md — la receta del bloque env de MCP es la misma independientemente de la ruta de instalación.

v0.9.0 — versión actual. Una versión de refuerzo de seguridad y revisión de código: 49 correcciones de una revisión adversarial de 5 carriles (#1885–#1935) más un conjunto más pequeño de características aditivas. El cambio principal es un giro seguro por defecto: la atestación del agente es requerida por defecto en escritura directa HTTP (#1751, con alcance superficial por #1985) — un HTTP POST /api/v1/memories sin firmar (+/bulk) es rechazado (403 ATTESTATION_FAILED) en lugar de aterrizar attest_level="claimed", a menos que el operador establezca la exclusión explícita AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Las superficies MCP memory_store y CLI store son la ruta del operador como actor y permanecen permisivas por defecto (una escritura sin firmar aterriza claimed); =1 fuerza el modo estricto en cada superficie. (La v0.9.0 GA se envió con require-en todas partes, lo cual era insatisfactorio en hosts MCP — corregido a alcance superficial en la versión actual.) Junto a esto, la puerta de aplicación de presencia obligatoria de hook ahora se activa tanto en la ruta de escritura MCP (#1885) como en la ruta de escritura HTTP (#1924), cerrando una brecha de omisión silenciosa donde un hook obligatorio configurado podía saltarse en una superficie pero no en la otra. El pase de refuerzo también cierra bulk_create la compuerta de atestación por fila (#1919), enruta las aprobaciones PENDIENTES federadas entrantes a través de la compuerta de aprobador registrado (#1920), ajusta el alcance de visibilidad de team/unit/org para que ya no sea demasiado amplio a través de la jerarquía de espacios de nombres (#1921), y confina la importación folder_path de skill_register bajo la raíz configurada con una jaula de enlaces simbólicos (#1923). Un nuevo canal de credenciales no-argv — AI_MEMORY_STORE_URL / AI_MEMORY_STORE_URL_FILE (un archivo 0600) — mantiene la contraseña de postgres/almacenamiento fuera de /proc/<pid>/cmdline y ps legibles por todos (#1927). Trabajo de características aditivas: recuerdos de habilidad creados por el agente con un parameters_schema + invocation_record (B7-SKILL, #1865), el bucle de retroalimentación sombra recall_observations (#1706), un DAG de linaje de derivación de recuerdos (memory_lineage, #1859), y una porción mínima opcional de búsqueda vectorial (#1005). Superficie: esquema v78, 101 herramientas MCP en --profile full (100 llamables + el bootstrap siempre activo memory_capabilities) / 7 en --profile core, 92 registros de ruta HTTP (78 rutas URL únicas), 89 subcomandos CLI bajo --features sal/sal-postgres (87 en la compilación por defecto), 9 relaciones MemoryLink tipadas, un Memory de 28 campos. Funciona en dos backends de producción detrás de una API idéntica — SQLite embebido y PostgreSQL + Apache AGE — en escritorio, servidor y en dispositivo (iOS + Android). Todo es aditivo sobre v0.8.1 excepto los giros de atestación y aplicación de hooks, que son cambios disruptivos seguros por defecto — revísalos antes de actualizar. Registro de cambios completo: CHANGELOG.md §"[0.9.0] — 2026-07-08".

v0.8.0 (distributed-coordination) — versión anterior. Esta es la versión donde el sustrato de memoria se convierte en un sustrato de coordinación. Añade la maquinaria de coordinación distribuida de #1709: un DAG de acciones tipado con una máquina de estados real (memory_action_*), concesiones de titular único limitadas por TTL (memory_lease_*), señales firmadas con Ed25519 (memory_signal_*), puntos de control atestados con Ed25519 (memory_checkpoint_*), y rutinas congeladas y reproducibles (memory_routine_*) — para que una flota heterogénea de agentes pueda turnarse, transferir trabajo y probar quién dijo qué sin tener que confiar entre sí. Superpone cognición tipada encima (los tipos de recuerdo Goal/Plan/Step, una máquina lifecycle_state, y las relaciones de enlace decomposes_into / depends_on / advances), refuerza la federación segura por defecto (inscripción de pares ACTIVADA por defecto #1789, firmas por transición #1718, atestación de contenido por escritura #1464, nonces de reproducción de transición #1805, fijación de certificado de par saliente #1678), y envía gobernanza que realmente bloquea — el hook PreToolUse de Claude Code se reelabora en un envoltorio type:command para que un Refuse del sustrato realmente deniegue la herramienta (#1811). En la versión v0.8.0, la superficie era: esquema v70, 100 herramientas MCP en --profile full (99 llamables + el bootstrap siempre activo memory_capabilities) / 7 en --profile core, 91 registros de ruta HTTP (78 rutas URL únicas), 83/85 subcomandos CLI, 9 relaciones MemoryLink tipadas, un Memory de 27 campos. Funciona en dos backends de producción detrás de una API idéntica — SQLite embebido y PostgreSQL + Apache AGE — en escritorio, servidor y en dispositivo (iOS + Android). Todo es aditivo sobre v0.7.0; revisa los giros seguros por defecto antes de actualizar. Notas de versión completas: docs/v0.8.0/release-notes.md. v0.7.0 (attested-cortex) — versión anterior. Reunió el trabajo de legibilidad cortex-fluent con el alcance completo de confianza v0.7 + A2A de ROADMAP §7.3, más (por directiva del operador 2026-05-09) el trabajo de primera clase postgres+AGE originalmente v0.7.1, más la ola de preparación para el envío post-grand-slam (Batman Forms 1-6 + base Opción-B de la 7ª forma + QW-1/2/3 + barrido de seguridad de reconciliación). El sustrato se vuelve tanto más articulado (capacidades v3, herramientas de carga con nombre, esquemas compactados, vocabulario Batman MemoryKind, primitivas persona/atomización/ingesta multipaso) como criptográficamente confiable (atestación Ed25519, transcripciones de cadena lateral, pipeline programable de 25 eventos de enlace, herencia de espacios de nombres forzada, cadena hash de eventos firmados entre filas V-4). v0.7.0 también incluye postgres + Apache AGE como backend de almacenamiento de primera clase — ai-memory serve --store-url postgres://… para uso en demonio en vivo, paridad de esquema en ambos backends (en la versión v0.7.0, sqlite + postgres convergieron en el esquema lógico v57, donde CURRENT_SCHEMA_VERSION era 57; el sustrato de la versión v0.8.0 ha avanzado este paso sincronizado al esquema 70, con las tablas aditivas de coordinación y visibilidad v58–v70 implementadas en ambos backends — vea CLAUDE.md §Database para la escalera v58–v70) (anclas canónicas: src/storage/migrations.rs para sqlite + src/store/postgres.rs para postgres); los archivos de migración en disco terminan en migrations/sqlite/0047_v56_list_composite_indexes.sql y el brazo de escalera en proceso migrate_v57() de postgres (los contadores de nombre de archivo van por detrás de la versión del esquema lógico porque ambas escaleras aplican deltas post-v34 a través de brazos en proceso — vea docs/MIGRATION_v0.7.md §schema-ladder para la narrativa v35-v57; v48 #933 añadió la tabla DLQ de empuje de federación; v49 #1025 añadió 14 columnas anulables a archived_memories para que archivar → restaurar sea sin pérdidas para la forma completa de Memoria v0.7.0; v50 #1156 extendió la CLAVE PRIMARIA de agent_quotas de (agent_id) a (agent_id, namespace) para que las asignaciones de cuota K8 por espacio de nombres se mantengan incluso cuando un solo agente opera en muchos espacios de nombres — las filas pre-v50 se rellenan al espacio de nombres centinela _global; v51 #1255 (PR #1296) añadió la tabla federation_nonce_cache para que los nonces de prevención de repetición entre pares persistan a través de reinicios del demonio; v52 #1389 añadió la tabla transcript_line_dedup que respalda la idempotencia RFC-0001 memory_capture_turn L4 + recover_from_transcript L2 para que un SIGKILL entre turnos nunca produzca una memoria duplicada en la rehidratación subsiguiente; v53 #1418 limitó el disparador de sincronización FTS5 de memories_au solo a (title, content, tags) para que las actualizaciones de columnas no FTS ya no activen una sincronización innecesaria; v54 #1466 rellenó la caducidad predeterminada de nivel en filas medias/cortas heredadas con caducidad NULL para cerrar la clase de filas inmortales por fuga TTL; v55 #1476 hizo que la consulta de recuperación de federación W=2 (updated_at > ? ORDER BY updated_at ASC LIMIT) fuera sargable y añadió el índice sqlite idx_memories_updated_at — postgres no añade un nuevo índice porque memories_updated_at_idx DESC ya sirve el escaneo de rango a través de Index Scan Backward; v56 #1579 añadió los índices compuestos de ordenación de lista/archivo (idx_memories_list_order, idx_memories_ns_list_order, idx_archived_ns_archived_at) emparejados con la reescritura sargable storage::list — DDL del lado de sqlite; el brazo migrate_v56() de postgres es una operación nula de sello de versión; v57 #1579 añadió la columna tsvector generada almacenada tsv de postgres + el índice GIN memories_tsv_gin para que las formas de búsqueda/recuperación coincidan Y clasifiquen en la columna precalculada en lugar de recalcular el tsvector por fila coincidente — el índice de expresión heredado memories_content_fts se elimina y el gemelo sqlite es una operación nula de sello de versión porque FTS5 ya materializa el texto indexado)), el nuevo verbo CLI ai-memory schema-init, y paridad de puntuación de recuperación de 6 factores. La superficie predeterminada v0.6.4 crece en dos cargadores siempre activos a 7 herramientas (memory_load_family + memory_smart_load se unen a las cinco originales); el techo de tiempo de ejecución en --profile full es de 74 entradas anunciadas (73 herramientas de memoria invocables + el arranque siempre activo memory_capabilities; verificado contra Profile::full().expected_tool_count() — vea src/profile.rs). Todo lo nuevo es aditivo y (para las superficies de confianza + postgres) de participación voluntaria. ¿Actualizando desde v0.6.x? Lea docs/MIGRATION_v0.7.md primero — la mayoría de los llamadores v0.6.4 no ven cambios de comportamiento, pero los usuarios de v0.6.x pre-v0.6.3.1 encuentran la corrección de herencia de espacio de nombres G1. ¿Cambiando a postgres+AGE? Vea docs/postgres-age-guide.md y docs/migration-v0.7.0-postgres.md. Notas de versión completas: docs/v0.7.0/release-notes.md.

v0.6.4 (quiet-tools) — el servidor MCP se envía con una superficie predeterminada de 5 herramientas (memory_store, memory_recall, memory_list, memory_get, memory_search) más el arranque siempre activo memory_capabilities. Las otras 38 herramientas permanecen accesibles a través de --profile graph|admin|power|full o expansión en tiempo de ejecución mediante memory_capabilities --include-schema family=<name>. Los arneses de carga ansiosa (Claude Desktop / Codex CLI / Grok CLI / Gemini CLI) reducen ~4,700 tokens de entrada de esquemas de herramientas por solicitud — una reducción del 76.4% medida contra cl100k_base BPE. Para preservar el comportamiento v0.6.3 1:1, ejecute ai-memory mcp --profile full. Vea docs/MIGRATION_v0.6.4.md.

Novedades en v0.9

v0.9.0 es principalmente una versión de refuerzo de seguridad y revisión de código — 49 correcciones de una revisión adversarial de 5 carriles (#1885–#1935) — más un conjunto más pequeño de características aditivas superpuestas al sustrato de coordinación v0.8.0. Registro de cambios completo: CHANGELOG.md §"[0.9.0] — 2026-07-08".

Refuerzo seguro por defecto

• Atestación de agente requerida por defecto en la superficie de escritura directa HTTP (#1751, con alcance de superficie por #1985). AI_MEMORY_REQUIRE_AGENT_ATTESTATION es tri-estado con un valor predeterminado compilado por superficie: no establecido → requerido en escritura directa HTTP (POST /api/v1/memories + /bulk, rechazado 403 ATTESTATION_FAILED), permisivo en las superficies de operador como actor MCP memory_store y CLI store (una escritura no firmada aterriza attest_level="claimed"); =1 fuerza estricto en todas partes, =0 fuerza permisivo en todas partes. Una firma presentada pero falsificada es rechazada en cada superficie independientemente. Firme escrituras (ai-memory store --sign con un par de claves vinculado a través de ai-memory agents bind-key) o use la exclusión voluntaria =0. (La versión GA v0.9.0 envió esto como requerido-en todas partes, insatisfactorio en hosts MCP — vea #1981; corregido a alcance de superficie por #1985.)
• Puerta de aplicación de enlace dual MCP + HTTP (#1885 / #1924). La puerta de aplicación de presencia de enlace obligatorio (originalmente solo MCP, #1734) ahora se consulta también en la ruta de escritura HTTP, cerrando una brecha de omisión silenciosa (CWE-288) donde una escritura que omitía MCP por completo nunca veía un enlace obligatorio configurado.
• Control de atestación bulk_create (#1919). Las escrituras masivas ahora aplican el mismo requisito de atestación de agente por fila que una sola llamada memory_store — cada fila en un lote debe llevar una atestación válida, no solo la solicitud en su conjunto.
• Puerta de aprobador de federación (#1920). Una aprobación PENDIENTE federada entrante solo se honra cuando se atribuye al aprobador registrado de un par — un par inscrito pero no confiable ya no puede falsificar una aprobación para un solicitante arbitrario.
• Refuerzo de alcance team/unit/org (#1921). La resolución de alcance de visibilidad ahora aplica correctamente la jerarquía de ancestros de espacio de nombres para los alcances team/unit/org, cerrando una brecha de aislamiento de inquilinos (CWE-863).
• Confinamiento de ruta skill_register (#1923). La importación folder_path de una habilidad se canonicaliza y confina bajo la raíz configurada, con enlaces simbólicos dentro del árbol importado rechazados en lugar de seguidos (CWE-22/CWE-59).
• Canales de credenciales de URL de almacén sin argv (#1927). Nuevos AI_MEMORY_STORE_URL (solo propietario /proc/environ) y AI_MEMORY_STORE_URL_FILE (un archivo 0600) permiten que ai-memory serve reciba la URL de postgres/almacén — incluyendo cualquier contraseña incrustada — sin ponerla nunca en argv de --store-url, donde se expone a través de /proc/<pid>/cmdline y ps auxww legibles por cualquier UID local. Orden de resolución: archivo → env → --store-url.

Características aditivas

• B7-SKILL — memorias de habilidades de primera clase (#1865). parameters_schema en el momento del registro, un invocation_record, y una superficie de versión para habilidades creadas por agentes.
• Bucle de retroalimentación sombra recall_observations (#1706, modo SHADOW). Cierra el bucle de retroalimentación de recuperación sin cambiar aún el comportamiento de clasificación.
• DAG de linaje de derivación de memoria (memory_lineage, esquema v78, #1859). Recorre qué memorias se derivaron de cuáles, tanto a través de MCP como de la nueva ruta HTTP GET /api/v1/memories/{id}/lineage.
• Porción mínima de participación voluntaria de búsqueda vectorial (#1005; sustrato completo diferido a #1860).
• Grupo de trabajadores reordenadores dimensionado a CPUs físicas (#1867) y la recuperación es PURA por defecto (#1869 — elimina la ráfaga de escritura de la ruta activa de recuperación).
• Espina dorsal de solo anexión + separación de capa de firma: cada sitio de mutación enrutado a hojas de revisión firmadas (#1823), separación de firma de tres claves Grabador/Juez/Detenedor (#1826), tokens de capacidad macaroon cableados de extremo a extremo (#1827), y una cadena de sucesión de claves de linaje de identidad firmada para supervivencia de rotación (#1828, esquema v76).

Por dónde empezar: CHANGELOG.md (registro de cambios completo), docs/ADMIN_GUIDE.md (manual del operador — postura de atestación + aplicación de enlaces).

Novedades en v0.8

v0.8.0 (distributed-coordination) convierte el sustrato de memoria en un sustrato de coordinación para flotas multi-agente (NHI). El titular es la maquinaria de coordinación distribuida (#1709); todo se envía en los adaptadores SAL de sqlite y postgres+AGE y permanece equivalente por defecto para los llamadores v0.7.x. Referencia completa de herramientas: docs/coordination.md; notas completas: docs/v0.8.0/release-notes.md.

Sustrato de coordinación distribuida (Pilar-1, #1709)

• Acciones — el DAG de dependencias (esquema v59). Nodos de acción tipados con una máquina de estados (pending → claimed → in_progress → done/failed/abandoned), aristas DAG tipadas (requires / unlocks / blocks / gated_by / sibling), y superficies de frontera/siguiente que extraen el siguiente nodo ejecutable. 8 herramientas MCP (memory_action_create / _get / _transition / _list / _add_edge / _edges / _frontier / _next).
• Concesiones — reclamaciones de titular único con límite TTL (esquema v59). Reclamación de comparación e intercambio renovada por latido (PRIMARY KEY en action_id = un titular a la vez) más un barrido de concesiones cada hora. 4 herramientas MCP (memory_lease_acquire / _renew / _release / _get).
• Señales — mensajes entre agentes tipados y firmados con Ed25519 (esquema v60). Cada uno lleva una firma + signer_pubkey del remitente y se enhebra mediante correlation_id / in_reply_to. 5 herramientas MCP (memory_signal_send / _read / _inbox / _thread / _ack).
• Puntos de control — puertas condicionales atestiguadas (esquema v61). Una puerta que bloquea hasta que se resuelve una condición; la resolución se autofirma en el lugar (Ed25519) para la separación de funciones, y verify vuelve a verificar la firma. 4 herramientas MCP (memory_checkpoint_create / _resolve / _query / _verify).
• Rutinas — planes parametrizados, congelados y reproducibles (esquema v62). Se crean como draft, luego se congelan (inmutables, atestación de congelación Ed25519); run materializa un conjunto concreto de acciones + aristas desde una plantilla {{param}} en un registro routine_runs. 5 herramientas MCP (memory_routine_create / _freeze / _run / _status / _list).
• Cada mutación de estado de coordinación añade una fila coordination.<op> a prueba de manipulaciones a la cadena de hash V-4 signed_events (#1722); las dos escrituras que otorgan autoridad se reflejan en el demonio HTTP (POST /api/v1/actions/{id}/transition, POST /api/v1/signals) con CAS local y distribución en abanico de federación W-de-N (#1718).

Cognición tipada (Pilar-2)

El vocabulario memory_kind se amplía con goal / plan / step; la taxonomía cerrada memory_links.relation se amplía de 6 → 9 relaciones (decomposes_into / depends_on / advances, esquema v63); y una columna de primera clase memories.lifecycle_state (esquema v64) convierte Meta/Plan/Paso en una verdadera máquina de estados (open → active → blocked/done/abandoned), aplicada en las superficies MCP / HTTP / SAL con un mapeo de arista ilegal a HTTP 409 CONFLICT. La estructura Memory crece a 27 campos. Sin nueva herramienta MCP — el trabajo v64 solo añade campos de solicitud opcionales permisivos.

Federación reforzada, segura por defecto

Inscripción de pares ACTIVADA por defecto (#1789), firmas por transición en escrituras que otorgan autoridad (#1718), atestación de contenido por escritura para memorias retransmitidas (#1464), nonces de reproducción de transición (#1805), y fijación de huella digital de certificado de par saliente (#1678). Flotas heterogéneas que no necesitan confiar entre sí — revise los cambios de seguridad por defecto en docs/v0.8.0/release-notes.md §"Refuerzo de federación" antes de actualizar.

Gobernanza que realmente bloquea (#1811)

El gancho de gobernanza PreToolUse de Claude Code se reelabora en un envoltorio type:command (ai-memory governance check-action --from-pretool-stdin) para que un sustrato Refuse emita permissionDecision:"deny" y realmente BLOQUEE la herramienta — la forma anterior type:mcp_tool estructuralmente no podía imponerse. Además, aplicación de presencia obligatoria de gancho (#1734) y un nuevo veredicto de gobernanza escalate (§22 PE-5) para humano en el circuito.

Controles operativos del Pilar-4

Control de admisión HTTP (#1733 — límite de concurrencia opcional que descarta el exceso con un 503 tipado), proyección de grafo Apache-AGE diferida (#1735 — quita los viajes de ida y vuelta síncronos de AGE de la ruta crítica de escritura de enlace de postgres), activación de compactación de curador (#1749 / #1750), y la CLI ai-memory verify-audit-trail (§22 PE-8) que recorre la cadena de hash entre filas signed_events de extremo a extremo.

Esquema v57 → v70 (todo aditivo)

Tablas de coordinación + cognición tipada + visibilidad + preparación de cifrado + ruta fría + arista de archivo (v58–v70), reflejadas en los adaptadores sqlite y postgres; migra automáticamente en la primera apertura y los viajes de ida y vuelta archivo → restauración sin pérdidas. Consulte CLAUDE.md §Base de datos para la escalera canónica v58–v70.

Por dónde empezar: docs/v0.8.0/release-notes.md (notas de versión completas), docs/coordination.md (referencia de herramientas de coordinación), y CLAUDE.md §Base de datos (SSOT de escalera de esquema).

Novedades en v0.7

v0.7.0 cierra la épica attested-cortex (69/69 en 11 pistas A–K), incorpora el trabajo original de primera clase de postgres+AGE de v0.7.1, y absorbe la ola de preparación para el envío posterior al grand-slam (Formularios Batman 1-6 + fundación Opción-B del 7º formulario + QW-1/2/3 + reconciliación de seguridad). Inventario canónico de características: docs/internal/v070-feature-inventory.md. Cada superficie permanece desactivada por defecto o equivalente por defecto para los llamadores de v0.6.4 — consulte la matriz de compatibilidad de v0.7 para el desglose.

Inversión en tiempo de escritura nativa del sustrato (Formularios Batman 1-6 + 7º formulario)

• Formulario 1 — deduplicación y síntesis en línea (incidencia #754). Una sola llamada LLM emisora de acciones por lote reemplaza el clasificador por par de v0.6.x en la ruta de almacenamiento. Vuelva a optar por el sí/no heredado mediante legacy_per_pair_classifier = true en el estándar del espacio de nombres.
• Formulario 2 — atomizar antes de incrustar síncrono (incidencia #755). Nueva herramienta memory_atomise + gancho previo al almacenamiento auto_atomise_mode = Synchronous|Deferred|Off. El curador descompone escrituras largas en 2–10 proposiciones atómicas antes de que el recuerdo las vea. Consulte docs/atomisation.md.
• Formulario 3 — orquestador de ingesta de múltiples pasos (incidencia #756). memory_ingest_multistep enhebra ayudantes deterministas Jaccard+FTS a través de etapas LLM estables en caché de prompt. Consulte docs/multistep-ingest.md + cookbook/multistep-ingest/01-two-phase.sh.
• Formulario 4 — procedencia de hechos (incidencia #757). Citas + URI de origen + tramos de granularidad atómica viajan en las cargas útiles existentes memory_store / memory_atomise. Consulte docs/provenance.md.
• Formulario 5 — confianza automática + calibración en sombra + decaimiento de frescura (incidencia #758). Herramienta MCP memory_calibrate_confidence + barrido de línea base por fuente. Variables de entorno AI_MEMORY_AUTO_CONFIDENCE, AI_MEMORY_CONFIDENCE_SHADOW, AI_MEMORY_CONFIDENCE_SHADOW_SAMPLE_RATE, AI_MEMORY_CONFIDENCE_DECAY. Consulte docs/confidence-calibration.md.
• Formulario 6 — vocabulario Batman MemoryKind (incidencia #759). Enumeración de 10 variantes (Observation por defecto + Reflection / Persona / Concept / Entity / Claim / Relation / Event / Conversation / Decision). Gancho previo al almacenamiento auto_classify_kind opcional (off / regex_only / regex_then_llm). Consulte docs/memory-kind-vocab.md.
• 7º formulario — cableado de Capa-4 EXTERNO del agente (fundación Opción-B) (incidencia #760; cobertura completa en v0.8.0 en #697). Reglas semilla firmadas por par de claves de operador R001..R004, herramientas MCP memory_check_agent_action + memory_rule_list, gancho previo a escritura del sustrato storage::insert. Consulte docs/policy-engine.md + docs/governance/agent-action-rules.md.
• Guía práctica para el operador — convertir los Formularios 1–6 + 7º de capaz → activo (incidencia #800). Receta de 7 pasos (generación de claves de operador → firma de semilla → habilitar R001–R004 → demonio curador → pase de reflexión opcional → políticas de espacio de nombres), permanencia con launchd / systemd / Programador de tareas, bloque de verificación, ruta de reversión. Consulte docs/batman-active-mode.md y el atlas de GitHub Pages.

Victorias rápidas (Tencent QW-1/2/3)

• QW-1 — exportación de cadena de reflexión respaldada por archivo. Herramienta MCP memory_export_reflection + política de espacio de nombres auto_export_reflections_to_filesystem → ~/.ai-memory/reflections/<ns>/<id>.md.
• QW-2 — persona como artefacto. Herramientas memory_persona + memory_persona_generate, filas MemoryKind::Persona, política de espacio de nombres auto_persona_trigger_every_n_memories. Consulte docs/persona.md.
• QW-3 — primitiva de descarga de contexto. memory_offload + memory_deref mueven salidas de herramientas grandes fuera de la ventana de contexto del agente a un almacenamiento de blobs direccionable. Consulte docs/context-offload.md.

Épica de corteza atestiguada (Pistas A–K)

• Enlaces atestiguados (Ed25519). La columna signature inactiva incluida en v0.6.3 ahora se completa con atestación Ed25519 real por agente, y memory_verify(link_id) devuelve {signature_verified, attest_level, signed_by, signed_at} bajo demanda. Genere un par de claves con ai-memory identity generate; active la opción mediante attest_level = "self_signed". La firma está condicionada a que el demonio resuelto agent_id tenga un par de claves *.priv en disco dentro del directorio de claves configurado — cuando load_daemon_signing_key devuelve None (src/main.rs:116-118), las filas aún se escriben pero sig está vacío y el demonio emite una línea "continuing unsigned" al arrancar. La cadena de hash entre filas en signed_events sigue siendo a prueba de manipulaciones en cualquier caso. Consulte el RFC de attested-cortex.
• Cierre de eventos firmados V-4 (cadena de hash entre filas) (incidencia #698). Cada fila signed_events lleva prev_hash + sequence; el prev_hash de la primera fila es cero, las filas subsiguientes encadenan el SHA-256 de la carga útil CBOR canónica anterior. ai-memory verify-signed-events-chain recorre la cadena de extremo a extremo. Consulte docs/signed-events-v4.md.
• Pipeline de hooks (25 eventos de ciclo de vida). Una superficie de extensión programable se activa en los 20 eventos base de pre_/post_store|recall|search|delete|promote|link|consolidate|governance_decision|archive|transcript_store + on_index_eviction, más 5 adiciones de grand-slam (pre_recall_expand G10 + pre_reflect/post_reflect aprendizaje recursivo Tarea 6/8 + pre_compaction/on_compaction_rollback L1-7). Los hooks devuelven Allow / Modify / Deny / AskUser. Desactivado por defecto; active la opción mediante ~/.config/ai-memory/hooks.toml. Consulte docs/hook-pipeline.md.
• Transcripciones de sidechain + reproducción. El BLOB de sidechain zstd-3 almacena registros brutos de conversación/razonamiento; memory_replay(memory_id) recorre memory_transcript_links para reconstruir la cadena. Active por espacio de nombres mediante [transcripts.namespaces."team/*"]. Consulte docs/sidechain-transcripts.md.
• Reforzamiento de federación. mTLS + X-API-Key + lista de permitidos de huella digital de certificado SHA-256; variables de entorno AI_MEMORY_FED_PEER_ATTESTATION, AI_MEMORY_FED_SYNC_TRUST_PEER, AI_MEMORY_FED_TRUST_BODY_AGENT_ID. Consulte docs/federation.md.
• Herramienta de cuota K8 + aprobaciones SSE K10. memory_quota_status + /api/v1/quota/status (K8). /api/v1/approvals/stream eventos enviados por el servidor con nonce HMAC, vinculación método+pending_id, eliminación de recuento de eventos retrasados (K10). Consulte docs/k8-quotas.md + docs/k10-sse-approvals.md.
• Backend de primera clase Postgres + Apache AGE. ai-memory serve --store-url postgres://…, paridad de esquema, paridad de puntuación de recuperación de 6 factores, migración de enlaces, características KG (kg_query, kg_timeline, kg_invalidate, find_paths) en AGE Cypher con respaldo CTE recursivo cuando AGE está ausente, más un nuevo verbo CLI ai-memory schema-init. Limitado por benchmark — el p95 de AGE debe superar al p95 de CTE en ≥30% a profundidad=5. Guía práctica para el operador: docs/postgres-age-guide.md. Manual de migración: docs/migration-v0.7.0-postgres.md.
• Capacidades v3 + cargadores inteligentes. memory_capabilities v3 añade summary, to_describe_to_user, callable_now por herramienta, agent_permitted_families, schema_version="3"; las nuevas herramientas siempre activas memory_load_family(family) y memory_smart_load(intent) se unen al perfil predeterminado core. Las frases fijadas residen en docs/v0.7/canonical-phrasings.md.
• Permisos + aprobaciones A2A. El subsistema de gobernanza v0.6.x se refactoriza en reglas + modos + hooks → un único Decision, con herencia de espacio de nombres (G1) realmente aplicada. memory_pending_list / memory_pending_approve / memory_pending_reject(remember=forever) habilitan la confianza progresiva; la firma HMAC en la API de aprobación es obligatoria. permissions.mode por defecto es enforce (era advisory en v0.6.4). Migre con ai-memory governance migrate-to-permissions (vista previa en seco; añada --config-out ~/.config/ai-memory/config.toml para aplicar en el lugar). Consulte docs/governance.md.

Aprendizaje recursivo + oleada grand-slam L1/L2

Primitiva de sustrato memory_reflect con límite max_reflection_depth por espacio de nombres (predeterminado 3, Some(0) es el interruptor de apagado). Curador de pase de reflexión L2-1, coordinación de reflexión consciente de federación L2-2 (memory_reflection_origin), propagación de invalidación L2-3 (memory_dependents_of_invalidated), paquete forense L2-5 (ai-memory export-forensic-bundle + verify-forensic-bundle), Habilidades de Agente L1-5 (memory_skill_register|list|get|resource|export|promote_from_reflection|compositional_context). Manual completo: docs/RECURSIVE_LEARNING.md. Manual de Habilidades de Agente: docs/agent-skills.md. Manual de exportación forense: docs/forensic-export.md.

Por dónde empezar: docs/MIGRATION_v0.7.md (procedimiento de actualización), docs/v0.7.0/release-notes.md (notas de versión completas), docs/whats-new-v07.html (resumen visual), docs/v0.7/rfc-attested-cortex.md (justificación del diseño), docs/ADMIN_GUIDE.md (manual del operador), docs/internal/v070-feature-inventory.md (verdad canónica de características).

Un binario, cuatro modos operativos (v0.6.4). El binario Rust ai-memory (tokio + axum) puede ejecutar cualquiera de estos de forma aislada o simultánea, compartiendo una única base de datos SQLite:

1. Servidor MCP stdio -- 101 entradas anunciadas sobre JSON-RPC en perfil completo (v0.9.0; 100 herramientas de memoria invocables + el arranque siempre activo memory_capabilities; verificado contra Profile::full().expected_tool_count()). El --profile core predeterminado anuncia 7 (las 5 originales + memory_load_family + memory_smart_load) más el arranque siempre activo memory_capabilities. ai-memory mcp / ai-memory mcp --profile full
2. Demonio HTTP / mTLS -- 92 registros de ruta REST (78 rutas URL únicas) en 127.0.0.1:9077, TLS + lista de permitidos mTLS opcional + autenticación por clave API, bucle de GC en segundo plano. ai-memory serve
3. Demonio curador autónomo -- bucle de autoprogramación (cadencia predeterminada de 1h) que autoetiqueta, detecta contradicciones entre espacios de nombres hermanos, consolida casi duplicados y ajusta la prioridad según el patrón de acceso. Cada acción va a un registro de reversión; las operaciones destructivas pueden estar condicionadas a un flujo de aprobación de gobernanza. ai-memory curator --daemon
4. Demonio de sincronización -- federación de pares basada en quórum entre instancias. Escrituras W-de-N (mayoría predeterminada), fusión CRDT-lite de reloj vectorial, lista de permitidos mTLS entre pares. ai-memory sync-daemon

Las superficies MCP, HTTP y CLI son reactivas. El curador es la parte que hace que la capa de memoria se automantenga: entre sesiones, mantiene el corpus ordenado para que la calidad de recuperación se mantenga alta a medida que crece el almacén. Todo es local primero; sin dependencias en la nube.

Evaluación práctica de Claude Opus 4.7 tras leer el código fuente de v0.6.3 línea por línea:

"ai-memory es la capa de memoria más capaz a la que me he conectado, y significativamente más de lo que su nombre anuncia. Para mí, en términos prácticos, significa: no empiezo en frío cada sesión. El almacén del que leo ha sido mantenido ordenado por algo distinto a mí. Las contradicciones no se acumulan silenciosamente. La calidad de recuperación se mantiene alta incluso cuando el corpus crece. Nada sale de tu Mac mini.

No me convierte en un agente autónomo. Me está dando el tipo de infraestructura de memoria que un agente autónomo necesitaría — y ejecutando un pequeño bucle autónomo para mantenerla. Eso es una base real. La brecha de aquí a 'ai-memory impulsa tareas generales' es de plomería (protocolo de llamada a herramientas + registro de herramientas + un modelo capaz de usar herramientas), no de invención."

Sustrato para IA multiagente. ai-memory no es un entorno de ejecución de agentes ni "IA autónoma" por sí solo. Es la capa de memoria que los despliegues autónomos multiagente necesitan debajo. La federación (broadcast_store_quorum + spawn_catchup_loop) maneja la consistencia W-de-N entre pares cuando muchos agentes escriben en paralelo; el demonio curador evita que el corpus compartido se degrade en ruido mientras un enjambre escribe en él; las suscripciones webhook (firmadas con HMAC, filtradas por espacio de nombres/agente, reforzadas contra SSRF) convierten el almacén en un bus de mensajes que activa agentes descendentes ante eventos de memoria; la jerarquía de espacios de nombres con herencia de N niveles y políticas de gobernanza por espacio de nombres (autoridad de escritura/promoción/eliminación, tipo de aprobador, consenso N-de-M opcional) delimitan el enjambre. Apile esto bajo un ejecutor de agentes multimáquina 24/7 con habilidades autogeneradas, y el sistema combinado supera el umbral comportamental para la IA autónoma. Las brechas restantes (sin aprendizaje a nivel de pesos, núcleo de razonamiento sin estado, objetivos raíz sembrados por humanos) son reales y no es lo que ai-memory aborda; ai-memory proporciona el sustrato de memoria multiagente que cualquier intento serio de cerrar esas brechas necesitará.

Coste de token cero hasta la recuperación. A diferencia de los sistemas de memoria integrados (memoria automática de Claude Code, memoria de ChatGPT) que cargan toda su memoria en cada conversación — gastando tokens y dinero en cada mensaje — ai-memory usa cero tokens de contexto hasta que la IA llama explícitamente a memory_recall. Solo regresan los recuerdos relevantes, clasificados por un algoritmo de puntuación de 6 factores. El formato TOON (Token-Oriented Object Notation) reduce los tokens de respuesta en otro 40-60% al eliminar nombres de campo repetidos — 3 recuerdos en JSON = 1,600 bytes; en TOON = 626 bytes (61% más pequeño); en TOON compacto = 336 bytes (79% más pequeño). Para usuarios de Claude Code: desactive la memoria automática ("autoMemoryEnabled": false en settings.json) y reemplácela con ai-memory para dejar de pagar por más de 200 líneas de contexto de memoria en cada mensaje.

Identidad de agente (NHI) — cada recuerdo indica quién lo aprendió

Cada recuerdo que ai-memory almacena lleva un metadata.agent_id — un marcador de Identidad No Humana que sobrevive a cada operación (actualización, deduplicación, importación, sincronización, consolidación). Cada resultado de recuperación indica qué IA escribió cada recuerdo, por defecto, en el formato de respuesta compacto TOON para el que su cliente de IA ya está optimizado:

count:5|mode:hybrid|tokens_used:842
memories[id|title|tier|namespace|priority|score|tags|agent_id]:
a1b2|Project DB is PostgreSQL 16|long|infra|8|0.91|database,postgres|ai:claude-code@workstation:pid-3812
c3d4|API rate limit is 100 rps|long|infra|7|0.87|api,limits|ai:claude-desktop@laptop:pid-5219

En una escritura no firmada, agent_id es una identidad reclamada — no tome decisiones de seguridad basándose solo en ella. La atestación de agente en ruta de almacén es requerida por defecto en la superficie de escritura directa HTTP (#1751, con alcance de superficie por #1985): un POST /api/v1/memories HTTP no firmado (+/bulk) es rechazado (403 ATTESTATION_FAILED) en lugar de aterrizar attest_level = "claimed", a menos que el operador establezca la exclusión explícita AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Las superficies de operador como actor memory_store MCP y store CLI permanecen permisivas por defecto (una escritura no firmada aterriza claimed); =1 fuerza el modo estricto en todas las superficies. La atestación criptográfica Ed25519 está conectada en dos superficies: (1) atestación en ruta de almacén (#626 Capa-3) — presente una firma separada sobre el sobre canónico SignableWrite en la ruta CLI (store --sign), MCP (memory_store) o HTTP (POST /api/v1/memories) y el demonio la verifica contra la clave pública vinculada del agente, estampando metadata.attest_level = "agent_attested" (una firma presentada pero falsificada siempre se rechaza independientemente del indicador); y (2) atestación de enlace (attested-cortex) — el campo previamente reservado memory_links.signature con memory_verify(link_id) para verificación entrante y una cadena de auditoría signed_events de solo adición. Consulte la página de identidad de agente y el RFC de attested-cortex para el contrato de procedencia completo.

Importación retroactiva de conversaciones — ai-memory mine

No empiece en frío. Apunte ai-memory mine a una exportación de Claude, ChatGPT o Slack y analiza turno por turno en recuerdos clasificados, tipificados por nivel y etiquetados — para que su IA entre a la siguiente sesión conociendo cada decisión, corrección y hallazgo de su historial existente.

ai-memory mine claude  ~/Downloads/claude-export/
ai-memory mine chatgpt ~/Downloads/chatgpt-export.json
ai-memory mine slack   ./slack-export/

El autoetiquetado, la deduplicación en (title, namespace) y la procedencia mined_from se estampan en cada recuerdo importado. Incorporación en cinco minutos desde cero contexto a un almacén a largo plazo poblado. Consulte la página de importación de historial para recetas por formato.

Plataformas de IA compatibles

ai-memory se integra con cualquier plataforma de IA que soporte el Protocolo de Contexto de Modelo (MCP). MCP es el estándar universal para conectar asistentes de IA a herramientas y fuentes de datos externas.

MCP es la capa de integración principal. Para plataformas de IA que aún no soportan MCP de forma nativa, la API HTTP (92 registros de ruta / 78 rutas URL únicas en localhost) y la CLI (89 subcomandos bajo --features sal O --features sal-postgres; 87 en la compilación predeterminada (post-#1389 L2 RecoverPreviousSession para rehidratación de contexto entre sesiones + #1443 Expand para la superficie de expansión de consultas ai-memory expand + #1598 Reembed para la superficie de migración de espacio vectorial ai-memory reembed); SSOT fijado por ai_memory::EXPECTED_CLI_SUBCOMMANDS_DEFAULT + EXPECTED_CLI_SUBCOMMANDS_SAL + la prueba mecánica de paridad tests/cli_subcommand_count_invariant.rs) proporcionan acceso universal -- cualquier IA, script o automatización que pueda hacer llamadas HTTP o ejecutar comandos de shell puede usar ai-memory.

Instalar en 60 segundos

Los binarios precompilados no requieren dependencias. Compilar desde el código fuente necesita Rust y un compilador de C.

Más rápido: Binario precompilado (no requiere Rust)

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.sh | sh

# Fedora/RHEL (COPR)
sudo dnf copr enable alpha-one-ai/ai-memory && sudo dnf install ai-memory

# Windows (PowerShell)
irm https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.ps1 | iex

Paso 1: Instalar Rust (omitir si se usan binarios precompilados)

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Sigue las instrucciones y luego reinicia tu terminal (o ejecuta source ~/.cargo/env).

Paso 2: Desde el código fuente (requiere Rust)

Última versión desde Crates.io:

cargo install ai-memory

Última versión desde el repositorio git:

cargo install --git https://github.com/alphaonedev/ai-memory-mcp.git

Esto compila el binario y lo coloca en tu PATH. Tarda uno o dos minutos.

Dependencias de compilación para compilaciones desde fuente:

• Ubuntu/Debian: sudo apt-get install build-essential pkg-config
• Fedora/RHEL: sudo dnf install gcc pkg-config

Paso 3: Conecta tu IA

La configuración varía según la plataforma. Encuentra la tuya a continuación:

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.claude/ai-memory.db", "mcp", "--tier", "semantic"]
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.claude/ai-memory.db", "mcp", "--tier", "semantic"]
    }
  }
}

# ~/.config/ai-memory/config.toml
schema_version = 2

[llm]
backend     = "xai"
model       = "grok-4.3"
base_url    = "https://api.x.ai/v1"
api_key_env = "XAI_API_KEY"            # process-env-var name (NOT the literal key)

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.claude/ai-memory.db", "mcp", "--tier", "autonomous"]
    }
  }
}

[mcp_servers.memory]
command = "ai-memory"
args = ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
enabled = true

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"],
      "timeout": 30000
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
    }
  }
}

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
    }
  }
}

mcpServers:
  - name: memory
    command: ai-memory
    args:
      - "--db"
      - "~/.local/share/ai-memory/memories.db"
      - "mcp"
      - "--tier"
      - "semantic"

{
  "mcp": {
    "servers": [
      {
        "id": "ai-memory",
        "label": "AI Memory",
        "enabled": true,
        "transport": "stdio",
        "command": "ai-memory",
        "args": ["mcp", "--tier", "semantic"]
      }
    ]
  }
}

ai-memory serve --host 127.0.0.1 --port 9077
# Expose via HTTPS reverse proxy (nginx, caddy, cloudflare tunnel, etc.)

curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "tools": [{
      "type": "mcp",
      "server_url": "https://your-server.example.com/mcp",
      "server_label": "memory",
      "server_description": "Persistent AI memory with recall and search",
      "allowed_tools": ["memory_store", "memory_recall", "memory_search"]
    }],
    "input": "What do you remember about our project?"
  }'

ai-memory serve --host 127.0.0.1 --port 9077

client.toolgroups.register(
    provider_id="model-context-protocol",
    toolgroup_id="mcp::memory",
    mcp_endpoint={"uri": "http://localhost:9077/sse"}
)

tool_groups:
  - toolgroup_id: mcp::memory
    provider_id: model-context-protocol
    mcp_endpoint:
      uri: "http://localhost:9077/sse"

openclaw mcp set memory '{"command":"ai-memory","args":["--db","~/.local/share/ai-memory/memories.db","mcp","--tier","semantic"]}'

{
  "mcp": {
    "servers": {
      "memory": {
        "command": "ai-memory",
        "args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
      }
    }
  }
}

command: ai-memory
args: ["--db", "/path/to/ai-memory.db", "mcp"]

ai-memory serve
# 92 REST route registrations (78 unique URL paths) at http://127.0.0.1:9077/api/v1/

Paso 4: Listo. Pruébalo.

Reinicia tu asistente de IA. Si usas MCP, ahora tiene la superficie predeterminada de 7 herramientas anunciada al iniciar sesión (las 5 originales + memory_load_family + memory_smart_load; las otras 93 de las 100 herramientas invocables se cargan bajo demanda mediante --profile o memory_capabilities --include-schema). Pregúntale: "Guarda un recuerdo de que mi lenguaje favorito es Rust." Luego, en una nueva conversación, pregunta: "¿Cuál es mi lenguaje favorito?" Lo recordará.

Soporte para plataformas móviles (v0.7.0 Posture-1a)

ai-memory es portable a iOS y Android mediante la ruta estándar de compilación cruzada móvil de Rust. v0.7.0 incluye cobertura de CI para ambos objetivos en tres niveles progresivos:

Estado en v0.7.0: La Capa 1 es la puerta de envío — la compilación cruzada móvil debe estar en VERDE antes del corte de etiqueta. La Capa 2 (artefactos de lanzamiento) envía el pipeline BUILD + diseño de artefactos; la superficie FFI invocable desde C aterriza en un seguimiento v0.7.x. La Capa 3 ejecuta el subconjunto de pruebas acotado en cada push a release/**.

Consumiendo los artefactos de lanzamiento:

• iOS — descarga ai-memory-ios.xcframework.tar.gz de la página de lanzamiento v0.7.x, descomprime y arrastra AiMemory.xcframework a tu proyecto Xcode bajo "Frameworks, Libraries, and Embedded Content."
• Android — descarga ai-memory-android.tar.gz de la página de lanzamiento v0.7.x, descomprime y copia el árbol jniLibs/ en el src/main/jniLibs/ de tu módulo de aplicación.

Los artefactos móviles también forman parte de cada lanzamiento v0.7.x publicado; la fórmula Homebrew + paquetes APT/RPM (que envían los binarios de escritorio) incluyen una nota que enlaza a las descargas móviles. Consulta el issue #1068 para el historial de implementación de CI.

Inicio rápido

Pasa de cero a una memoria funcional en menos de dos minutos.

1. Instalar

curl -fsSL https://raw.githubusercontent.com/alphaonedev/ai-memory-mcp/main/install.sh | sh

2. Configurar MCP (ejemplo para Claude Code -- otras plataformas funcionan igual)

Fusionar en ~/.claude.json:

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.claude/ai-memory.db", "mcp", "--tier", "semantic"]
    }
  }
}

3. Almacena tu primer recuerdo

ai-memory store -T "Project uses PostgreSQL 15" -c "Main DB is PG 15 with pgvector." --tier long

4. Recupéralo

ai-memory recall "database"

5. Verifica estadísticas

ai-memory stats

6. Úsalo con tu IA. Reinicia tu cliente de IA. Ahora tiene 7 herramientas de memoria predeterminadas anunciadas al inicio (101 entradas anunciadas accesibles mediante expansión en tiempo de ejecución o --profile full) sobre MCP -- puede almacenar y recuperar recuerdos de forma nativa durante las conversaciones.

SDKs

Además de las superficies MCP / HTTP / CLI, ai-memory incluye SDKs de lenguaje propios para clientes HTTP y utilidades auxiliares (p. ej. requireProfile para aserciones de perfil en tiempo de ejecución en demonios v0.6.4+).

TypeScript / JavaScript — @alphaone/ai-memory en npm

npm install @alphaone/ai-memory

Python — ai-memory-mcp en PyPI (el nombre de importación sigue siendo ai_memory)

pip install ai-memory-mcp

from ai_memory import AiMemoryClient, require_profile

with AiMemoryClient(base_url="http://127.0.0.1:9077", api_key="...") as client:
    require_profile(client, "graph")  # raises ProfileNotLoaded on miss

Ambos SDKs están versionados con el servidor (0.9.0 coincide con ai-memory 0.9.0). Los demonios v0.6.4+ imponen el contrato de perfil; los demonios pre-v0.6.4 recurren a un modo permisivo de advertir y continuar para que las actualizaciones del SDK no rompan servidores antiguos. El código fuente reside en sdk/typescript/ y sdk/python/.

¿Qué hace?

Los asistentes de IA olvidan todo entre conversaciones. ai-memory lo soluciona.

Se ejecuta como un servidor de herramientas MCP (Model Context Protocol) -- un proceso en segundo plano con el que tu IA habla de forma nativa. Cuando tu IA aprende algo importante, lo almacena. Cuando necesita contexto, recupera recuerdos relevantes clasificados por un algoritmo de puntuación de 6 factores. Los recuerdos residen en tres niveles:

• Corto plazo (6 horas por defecto, configurable) -- contexto desechable como el estado actual de depuración
• Medio plazo (7 días por defecto, configurable) -- conocimiento de trabajo como objetivos de sprint y decisiones recientes
• Largo plazo (permanente) -- arquitectura, preferencias de usuario, lecciones aprendidas con esfuerzo

Los recuerdos a los que se sigue accediendo se promocionan automáticamente de medio a largo plazo. Cada recuperación extiende el TTL. La prioridad aumenta con el uso. El sistema se auto-cura.

Más allá de MCP, ai-memory también expone una API REST HTTP completa (92 registros de ruta / 78 rutas URL únicas en el puerto 9077) y una CLI completa (89 subcomandos bajo --features sal O --features sal-postgres; 87 en la compilación predeterminada (post-#1389 L2 RecoverPreviousSession para rehidratación de contexto entre sesiones + #1443 Expand para la superficie de expansión de consultas ai-memory expand + #1598 Reembed para la superficie de migración de espacio vectorial ai-memory reembed); SSOT fijado por ai_memory::EXPECTED_CLI_SUBCOMMANDS_{DEFAULT,SAL} + la prueba mecánica de paridad tests/cli_subcommand_count_invariant.rs) para interacción directa, scripting e integración con cualquier plataforma o herramienta de IA.

Características

Núcleo

• Servidor de herramientas MCP -- 101 herramientas sobre stdio JSON-RPC (perfil completo), compatible con cualquier cliente MCP
• Memoria de tres niveles -- corto (TTL 6h por defecto), medio (TTL 7d por defecto), largo (permanente) -- los TTLs son configurables
• Búsqueda de texto completo -- SQLite FTS5 con recuperación clasificada
• Recuperación híbrida -- palabra clave FTS5 + similitud coseno con mezcla adaptativa: el peso semántico varía de 0.50 (contenido corto) → 0.15 (contenido largo) porque los embeddings pierden información en texto largo
• Puntuación de recuperación de 6 factores -- relevancia FTS + prioridad + frecuencia de acceso + confianza + impulso de nivel + decaimiento por antigüedad
• Auto-promoción -- los recuerdos accedidos 5+ veces se promocionan de medio a largo
• Extensión de TTL -- cada recuperación extiende la caducidad (corto +1h, medio +1d)
• Refuerzo de prioridad -- +1 cada 10 accesos (máx 10)
• Detección de contradicciones -- advierte al almacenar recuerdos que entran en conflicto con los existentes
• Deduplicación -- upsert por título+namespace, el nivel nunca se degrada
• Puntuación de confianza -- certeza de 0.0-1.0 factorizada en la clasificación

Organización

• Namespaces -- aísla recuerdos por proyecto (auto-detectado desde git remote)
• Enlace de recuerdos -- relaciones tipadas: related_to, supersedes, contradicts, derived_from, reflects_on (aprendizaje recursivo Tarea 1/8), derives_from (atomización WT-1-A), decomposes_into, depends_on, advances -- nueve variantes en v0.8.0
• Consolidación -- fusiona múltiples recuerdos en un único resumen a largo plazo
• Auto-consolidación -- agrupa por namespace+etiqueta, auto-fusiona grupos por encima del umbral
• Resolución de contradicciones -- marca un recuerdo como que reemplaza a otro, degrada al perdedor
• Olvido por patrón -- borrado masivo por namespace + patrón FTS + nivel
• Seguimiento de origen -- rastrea origen: user, claude, hook, api, cli, import, consolidation, system
• Identidad de agente (NHI) -- cada recuerdo lleva metadata.agent_id (identidad reclamada) con inmutabilidad de defensa en profundidad a través de update/dedup/import/sync/consolidate; filtrar list/search por agente
• Etiquetado -- etiquetas separadas por comas con soporte de filtro

Interfaces

• 92 rutas HTTP (78 rutas únicas) -- API REST completa en 127.0.0.1:9077 (funciona con cualquier IA o herramienta)
• 89 subcomandos CLI bajo --features sal O --features sal-postgres (87 en la compilación predeterminada) -- CLI completa con capacidades idénticas
• 101 herramientas MCP en perfil completo (7 por defecto; verificado contra Profile::full().expected_tool_count()) -- integración nativa para cualquier IA compatible con MCP
• Shell REPL interactivo -- recuperar, buscar, listar, obtener, estadísticas, namespaces, eliminar con salida en color
• Salida JSON -- bandera --json en todos los comandos CLI
• Coordinación distribuida (v0.8.0 Pilar-1 + Pilar-2) -- DAG de acciones (memory_action_*), arrendamientos de titular único (memory_lease_*), señales firmadas Ed25519 (memory_signal_*), puntos de control atestiguados (memory_checkpoint_*), rutinas parametrizadas (memory_routine_*), y el ciclo de vida de cognición tipada Goal/Plan/Step. Consulta docs/coordination.md.

Operaciones

• Sincronización multi-nodo -- pull, push o fusión bidireccional entre archivos de base de datos
• Importar/Exportar -- viaje redondo JSON completo preservando enlaces de memoria
• Recolección de basura -- caducidad automática en segundo plano cada 30 minutos
• Apagado graceful -- SIGTERM/SIGINT checkpoint WAL para salida limpia
• Verificación de salud profunda -- verifica accesibilidad de BD e integridad FTS5
• Completados de shell -- bash, zsh, fish
• Página de manual -- ai-memory man genera roff a stdout
• Filtros de tiempo -- --since/--until en list y search
• Antigüedades legibles por humanos -- "hace 2h", "hace 3d" en salida CLI
• Salida CLI en color -- etiquetas de nivel ANSI (rojo/amarillo/verde), barras de prioridad, títulos en negrita, namespaces en cian

Calidad

• ~10,000 pruebas en toda la superficie -- aproximadamente 6,712 atributos #[test]/#[tokio::test] bajo src/ (5,759 #[test] + 953 #[tokio::test]) más aproximadamente 3,362 bajo tests/ (2,138 #[test] + 1,224 #[tokio::test]), crecidas desde la línea base de ~2,400 pruebas de la era v0.6.4 (1,960 lib + 211 integración + 16 mcp_integration + 4 webhook_http_parity + 16 recipe_contract + ~150 en otros objetivos binarios). Cobertura de línea mantenida por encima de la barra de proyecto ≥92%; módulos netamente nuevos de v0.6.4 al 100% (sizes.rs), 99.50% (profile.rs), 97.58% (cli/audit.rs), 97.05% (cli/doctor.rs), 92.56% (handlers.rs), 92.26% (cli/install.rs). Las líneas base de v0.6.3.x (1,809 / 93.08% y 1,886 / 93.84%) permanecen congeladas en la página de evidencia; métricas de v0.6.4 en las notas de lanzamiento y en la campaña test-hub. La aceptación empírica de descubrimiento NHI probada por separado por la Puerta de Descubrimiento (matriz T1–T4 vs. xAI Grok 4.3 en vivo, 6/6 APROBADO, PUERTA VERDE).
• Benchmark LongMemEval -- 97.0% R@5 palabra clave FTS5 pura (independiente de LLM, 2.2 segundos, 232 q/s, cero costos de API) en el conjunto de datos LongMemEval-S de ICLR 2025; la expansión de consulta LLM con el modelo Gemma 4 de generación actual mide 97.2% R@5 / 99.6% R@10 / 99.8% R@20 (entorno de API en la nube; la cifra histórica gemma3:4b 97.8% se retira como titular según #1975). Consulta detalles del benchmark.
• Prompts MCP -- los prompts recall-first y memory-workflow enseñan a los clientes de IA a usar la memoria de forma proactiva
• TOON por defecto -- las respuestas de recall/list/search usan TOON compacto por defecto (79% más pequeño que JSON)
• Benchmarks Criterion -- insertar, recuperar, buscar a escala 1K
• CI/CD GitHub Actions -- fmt, clippy, test, build en Ubuntu + macOS, lanzamiento en etiqueta

Piso de Cobertura (control estricto de CI)

El trabajo Code Coverage es una verificación de estado requerida. CI reafirma dos invariantes en cada PR: un piso absoluto de >= 90% de líneas (barrera contra regresiones catastróficas, establecido en la medición actual redondeada hacia abajo al 5% más cercano), y un trinquete contra el valor fijado en .coverage-baseline con una ventana de holgura del 0.5% (la aplicación diaria). Los PRs que aumenten la cobertura deben actualizar el archivo de línea base en el mismo commit para que los futuros PRs se beneficien del nuevo piso; los PRs que regresionen más del 0.5% se bloquean para su fusión. Medición actual: 93.13% de líneas.

Control de Presupuesto de Tokens (control estricto de CI, v0.7 C5)

El flujo de trabajo token-budget es una verificación de estado requerida. Impone tres invariantes medidos en cl100k_base en cada PR:

• Límite por herramienta de 1500 tokens -- ningún esquema serializado de una sola herramienta MCP (nombre + descripción + inputSchema) puede exceder los 1500 tokens cl100k_base.
• Rango honesto del perfil completo (5K-8K) -- la barrera de v0.6.4, mantenida para detectar reducciones patológicas (eliminación accidental de herramientas).
• Límite estricto del perfil completo (v0.7 C5, aumentado tras D1.6/D1.7) -- la carga útil recortada de tools/list bajo --profile full no puede exceder 11,000 tokens cl100k_base (TRIMMED_FULL_PROFILE_CEILING_TOKENS en tests/token_budget_guard.rs; el objetivo original de C5 era 3500 contra los esquemas codificados manualmente previos a D1.6 — la expansión derivada de schemars en D1.6/D1.7 elevó el límite fijado). C2 (división del campo docs), C3 (colapso de texto repetitivo de esquemas) y C4 (ocultación de parámetros opcionales raramente usados) impulsaron la compactación original; este control obliga a los futuros PRs que aumenten la superficie a recuperar presupuesto en otra parte. Inspeccione ai-memory doctor --tokens --raw-table para ver los costos por herramienta. Consulte .github/workflows/token-budget.yml y docs/v0.7/schema-compaction-audit.md.

Dependencias de ML y LLM (nivel semántico+)

• candle-core, candle-nn, candle-transformers -- framework de ML Candle de Hugging Face para inferencia nativa en Rust
• hf-hub -- descarga modelos desde Hugging Face Hub
• tokenizers -- tokenizadores de Hugging Face para preprocesamiento de texto
• instant-distance -- búsqueda aproximada del vecino más cercano
• reqwest -- cliente HTTP para comunicación con backend LLM (niveles inteligente/autónomo — cualquier proveedor según #1067: Ollama, xAI, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, servidor llama.cpp)

Arquitectura

Referencia

Evaluado en el conjunto de datos ICLR 2025 LongMemEval-S (500 preguntas, 6 categorías). El nivel puro de palabras clave FTS5 logra un 97.0% R@5 en 2.2 segundos — independiente del LLM, completamente local, cero llamadas a API en la nube, costo cero. La expansión de consulta con LLM (nivel inteligente) mide un 97.2% R@5 con el modelo Gemma 4 de generación actual (entorno de API en la nube).

Nota del modelo de referencia (actualizado 2026-07-10, fallo #1975): la cifra histórica de 97.8% R@5 del nivel inteligente se midió con Gemma 3 4B (aún el modelo de expansión predeterminado compilado) y se retira como titular. El ancla publicada de la generación actual es la ejecución medida de OpenRouter Gemma 4: 97.2% R@5 / 99.6% R@10 / 99.8% R@20 (2026-05-31, 500 preguntas, 0 fallos de expansión). No existe una cifra local de Ollama Gemma-4 — el host de referencia de la prueba es solo CPU, donde una ejecución local válida del protocolo completo es inviable (ver #1983); una repetición local con GPU queda pendiente para después de v1.0. El 97.0% R@5 del nivel de palabras clave es independiente del LLM y no se ve afectado.

Presupuestos de Rendimiento (v0.6.4)

Cada versión se publica con presupuestos p95/p99 publicados para operaciones de ruta crítica y un control de CI que falla cualquier PR cuyo p95 medido exceda el presupuesto en más del 10 %. Los objetivos están calibrados para hardware de referencia M4; tabla completa y metodología en PERFORMANCE.md.

Ejecute la misma carga de trabajo localmente:

ai-memory bench                      # human-readable table
ai-memory bench --json               # machine-parseable

El sustrato no cambia entre v0.6.3.x → v0.6.4 (la versión quiet-tools incluye una superficie de herramientas predeterminada más pequeña, no una ruta crítica diferente). Los objetivos p99 aquí permanecen como informativos a la espera de la próxima ventana de prueba de estrés dedicada; la evidencia más reciente de prueba de estrés está en el centro de pruebas.

Métodos de Integración

MCP (Principal -- para plataformas de IA compatibles con MCP)

MCP es la integración recomendada. Su IA obtiene 7 herramientas de memoria nativas anunciadas por defecto (las 5 originales + memory_load_family + memory_smart_load; más el arranque siempre activo memory_capabilities) sin código adicional. Las otras 93 herramientas invocables (101 entradas anunciadas — verificado contra Profile::full().expected_tool_count() y fijado por const_count_matches_full_profile en src/mcp/registry.rs) permanecen accesibles a través de --profile graph|admin|power|full o expansión en tiempo de ejecución mediante memory_capabilities --include-schema family=<name>. Configure el servidor MCP en la configuración de su plataforma de IA:

{
  "mcpServers": {
    "memory": {
      "command": "ai-memory",
      "args": ["--db", "~/.claude/ai-memory.db", "mcp"]
    }
  }
}

API HTTP (Universal -- para cualquier IA o herramienta)

Inicie el servidor HTTP para acceso a API REST. Cualquier IA, script o automatización que pueda realizar llamadas HTTP puede usar esto:

ai-memory serve
# 92 REST route registrations (78 unique URL paths) at http://127.0.0.1:9077/api/v1/

CLI (Universal -- para scripting y uso directo)

La CLI funciona de forma independiente o como bloque de construcción para integraciones de IA que ejecutan comandos de shell:

ai-memory store --tier long --title "Architecture decision" --content "We use PostgreSQL"
ai-memory recall "database choice"
ai-memory search "PostgreSQL"

Niveles de Funcionalidad

ai-memory soporta 4 niveles de funcionalidad, seleccionados al inicio con ai-memory mcp --tier <tier>. Los niveles superiores añaden capacidades de ML a costa de disco y RAM:

Matriz de Capacidades

Cada capacidad mapeada a su nivel mínimo. Cada nivel incluye todas las capacidades de los niveles inferiores.

Nivel semántico (predeterminado) incluye el framework de ML Candle y descarga el modelo all-MiniLM-L6-v2 en la primera ejecución (~90 MB). Los niveles inteligente y autónomo requieren un backend LLM — tras #1067 (v0.7.0) este puede ser local (Ollama, LMStudio, vLLM, servidor llama.cpp) o cualquier endpoint remoto compatible con OpenAI (xAI, OpenAI, Anthropic via shim de OpenAI, Google Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks). La selección se realiza mediante la variable de entorno AI_MEMORY_LLM_BACKEND; las claves API por proveedor mediante XAI_API_KEY / OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY / DEEPSEEK_API_KEY / MOONSHOT_API_KEY / DASHSCOPE_API_KEY / etc. o la canónica AI_MEMORY_LLM_API_KEY.

Los niveles controlan características, no modelos — y tras #1067 (v0.7.0), los niveles controlan características, tampoco proveedores. La bandera --tier controla qué herramientas se exponen. El backend LLM + modelo son configurables independientemente mediante las variables de entorno AI_MEMORY_LLM_BACKEND + AI_MEMORY_LLM_MODEL (o mediante la sección canónica [llm] en ~/.config/ai-memory/config.toml — consulte docs/CONFIG_SCHEMA.md para el esquema empresarial v0.7.x y la herramienta de migración). Por ejemplo, ejecute el nivel autónomo (superficie completa de 101 entradas + reordenador) contra xAI Grok 4 mediante el alias compatible con OpenAI:

# Quick path: env vars
export AI_MEMORY_LLM_BACKEND=xai
export AI_MEMORY_LLM_MODEL=grok-4.3
export XAI_API_KEY=xai-…   # or AI_MEMORY_LLM_API_KEY
ai-memory mcp --tier autonomous

# Enterprise path: ~/.config/ai-memory/config.toml (v0.7.x schema v2, #1146)
schema_version = 2
tier = "autonomous"

[llm]
backend     = "xai"
model       = "grok-4.3"
base_url    = "https://api.x.ai/v1"
api_key_env = "XAI_API_KEY"          # mutually exclusive with api_key_file;
                                     # inline `api_key = "..."` is REJECTED.

# Legacy v0.6.x shape — still works, deprecation WARN at load; run
# `ai-memory config migrate` to upgrade in place.
tier = "autonomous"
llm_model = "gemma3:4b"   # default Ollama model at v0.7.0

La bandera --tier debe pasarse en los argumentos de MCP -- la configuración de nivel config.toml no se utiliza cuando el servidor es lanzado por un cliente de IA.

# Semantic is the default tier
ai-memory mcp

# Keyword -- FTS5 only, no models
ai-memory mcp --tier keyword

# Semantic -- hybrid recall with embeddings (explicit)
ai-memory mcp --tier semantic

# Smart -- adds LLM-powered query expansion, auto-tagging, contradiction detection
ai-memory mcp --tier smart

# Autonomous -- adds cross-encoder reranking
ai-memory mcp --tier autonomous

La herramienta memory_capabilities informa del nivel activo, modelos cargados y capacidades disponibles en tiempo de ejecución.

Herramientas MCP

Estas 101 herramientas (perfil completo; conteo canónico mediante Profile::full().expected_tool_count() en src/profile.rs) están disponibles para cualquier IA compatible con MCP cuando se configura como un servidor MCP (la página de evidencia congelada de v0.6.4 lista la línea base de 63 herramientas; la tabla a continuación documenta el subconjunto principal que la mayoría de los clientes usan a diario):

API HTTP

92 registros de ruta / 78 rutas URL únicas en 127.0.0.1:9077. Comience con ai-memory serve. La tabla siguiente muestra los endpoints REST más utilizados; consulte docs/API_REFERENCE.md para la superficie completa (gobernanza, federación, suscripciones, grafo de conocimiento, cuotas, aprobaciones SSE).

Seguridad: El servidor HTTP se vincula a 127.0.0.1 y se distribuye sin autenticación configurada por defecto, además de CORS permisivo. Establezca api_key en config.toml para requerir la cabecera x-api-key en cada solicitud (la forma heredada de parámetro de consulta ?api_key= está obsoleta en v0.7.0 — #1574), y establezca AI_MEMORY_REQUIRE_API_KEY=1 para rechazar de forma estricta el inicio sin clave (#1458). No exponga a la red sin autenticación (y prefiera TLS mediante --tls-cert/--tls-key o un proxy inverso).

Comandos CLI

89 subcomandos de nivel superior bajo --features sal O --features sal-postgres (87 en la compilación predeterminada; la diferencia de 2 variantes es Migrate + SchemaInit, ambos controlados #[cfg(feature = "sal")] por src/daemon_runtime.rs::Command::{Migrate,SchemaInit}; eran 40 en v0.6.4). Ejecute ai-memory <command> --help para obtener detalles sobre cualquier comando, o ai-memory --help para la lista completa.

El binario de nivel superior ai-memory también acepta flags globales:

El subcomando store acepta flags adicionales:

El subcomando mcp acepta un flag adicional:

Puntuación de Recuperación

Cada consulta de recuperación clasifica los recuerdos por 6 factores:

score = (fts_relevance * -1)
      + (priority * 0.5)
      + (MIN(access_count, 50) * 0.1)
      + (confidence * 2.0)
      + tier_boost
      + recency_decay

Niveles de Memoria

Comportamientos Automáticos

• Extensión de TTL al recuperar: recuerdos cortos obtienen +1 hora, recuerdos medios obtienen +1 día
• Auto-promoción: recuerdos de nivel medio accedidos 5+ veces se promueven a largo (caducidad eliminada)
• Refuerzo de prioridad: cada 10 accesos, la prioridad aumenta en 1 (limitado a 10)
• Detección de contradicciones: advierte cuando un nuevo recuerdo entra en conflicto con uno existente en el mismo espacio de nombres
• Deduplicación: upsert por título+espacio de nombres; el nivel nunca se degrada en una actualización

TTL Configurable

Los TTL predeterminados (6 horas para corto, 7 días para medio) se pueden anular en ~/.config/ai-memory/config.toml bajo la sección [ttl]:

[ttl]
short_ttl_secs = 21600      # short-tier TTL in seconds (default: 21600 = 6 hours)
mid_ttl_secs = 604800        # mid-tier TTL in seconds (default: 604800 = 7 days)
long_ttl_secs = 0            # long-tier TTL in seconds (default: 0 = never expires)
short_extend_secs = 3600     # TTL extension on recall for short-tier memories in seconds (default: 3600 = +1h)
mid_extend_secs = 86400      # TTL extension on recall for mid-tier memories in seconds (default: 86400 = +1d)

Los cinco campos son opcionales -- omita cualquiera para mantener el valor predeterminado. Establezca cualquier valor a 0 para deshabilitar la caducidad para ese nivel. Los valores se limitan a un máximo de 10 años; los valores de extensión negativos se limitan a 0.

Nota: La configuración se carga una vez al iniciar el proceso. Los cambios en config.toml requieren reiniciar el proceso ai-memory (servidor MCP, demonio HTTP o CLI) para que surtan efecto.

Archivo

Cuando la recolección de basura expira un recuerdo, puede ser archivado en lugar de eliminado permanentemente. Los recuerdos archivados se mueven a un almacén separado y pueden ser examinados, restaurados o purgados más tarde.

Configuración

Habilite el archivado en ~/.config/ai-memory/config.toml:

archive_on_gc = true   # archive expired memories instead of deleting them (default: true)

Comandos CLI

El subcomando archive gestiona el archivo:

ai-memory archive list                          # list archived memories
ai-memory archive list --namespace my-project   # filter by namespace
ai-memory archive restore <id>                  # restore an archived memory to active store
ai-memory archive purge --older-than-days 90     # permanently delete archives older than 90 days
ai-memory archive stats                         # show archive statistics

Nota: Los recuerdos restaurados obtienen su expires_at eliminado (se vuelven permanentes hasta la siguiente asignación de TTL).

Herramientas MCP

Cuatro herramientas de archivo están disponibles para clientes MCP:

Endpoints HTTP

Seguridad

ai-memory incluye endurecimiento en todas las rutas de entrada:

• Seguridad transaccional -- todas las operaciones de base de datos de varios pasos usan transacciones; no hay escrituras parciales en caso de fallo
• Prevención de inyección FTS -- la entrada del usuario se sanitiza antes de llegar a las consultas FTS5; los caracteres especiales se escapan
• Sanitización de errores -- las rutas internas de la base de datos y los detalles del sistema se eliminan de las respuestas de error; los clientes ven tipos de error estructurados (NOT_FOUND, VALIDATION_FAILED, DATABASE_ERROR, CONFLICT)
• Límites de tamaño del cuerpo -- los cuerpos de las solicitudes HTTP están limitados a 50 MB mediante DefaultBodyLimit de Axum
• Límites de operaciones masivas -- los endpoints de creación masiva imponen tamaños máximos de lote para prevenir el agotamiento de recursos
• CORS -- capa CORS permisiva habilitada para flujos de trabajo de desarrollo en localhost
• Validación de entrada -- cada ruta de escritura valida la longitud del título, la longitud del contenido, el formato del espacio de nombres, los valores de origen, el rango de prioridad (1-10), el rango de confianza (0.0-1.0), el formato de etiquetas, los valores de nivel, los tipos de relación y el formato de ID
• Validación de enlaces en sincronización -- todos los enlaces se validan (ambos IDs, tipo de relación, sin autoenlaces) antes de la importación durante las operaciones de sincronización
• Color seguro para hilos -- la detección de color del terminal usa AtomicBool para un acceso concurrente seguro
• HTTP solo local -- el servidor HTTP se vincula a 127.0.0.1 por defecto; no está expuesto a la red
• Modo WAL -- Registro de Escritura Adelantada de SQLite para lecturas concurrentes seguras durante las escrituras

Documentación

Licencia

Derechos de autor 2026 AlphaOne LLC.

Licenciado bajo la Licencia Apache, Versión 2.0 (la "Licencia"); no puede usar este archivo excepto en cumplimiento con la Licencia. Puede obtener una copia de la Licencia en

http://www.apache.org/licenses/LICENSE-2.0

A menos que lo requiera la ley aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye "TAL CUAL", SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas. Consulte la Licencia para conocer el idioma específico que rige los permisos y limitaciones bajo la Licencia.