ai-memory

ai-memory™

mémoire IA universelle

ai-memory est un système de mémoire persistante pour les assistants IA. Il fonctionne avec toute IA prenant en charge MCP -- Claude, ChatGPT, Grok, Llama, et plus encore. Il stocke ce que votre IA apprend dans une base de données SQLite locale, classe les souvenirs par pertinence lors du rappel et promeut automatiquement les connaissances importantes vers un stockage permanent. Installez-le une fois, et chaque assistant IA que vous utilisez se souviendra de votre architecture, de vos préférences, de vos corrections -- pour toujours.

Choisissez votre chemin d'installation

Configuration du backend LLM (xAI Grok, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, serveur llama.cpp ou Ollama local) ? Voir docs/integrations/llm-backends.md — la recette du bloc env MCP est la même quel que soit le chemin d'installation.

v0.9.0 — version actuelle. Une version de renforcement de la sécurité et de revue de code : 49 correctifs issus d'une revue contradictoire à 5 voies (#1885–#1935) plus un ensemble plus restreint de fonctionnalités additives. Le changement majeur est un basculement sécurisé par défaut : l'attestation d'agent est requise par défaut sur l'écriture directe HTTP (#1751, portée limitée par #1985) — un HTTP non signé POST /api/v1/memories (+/bulk) est rejeté (403 ATTESTATION_FAILED) au lieu d'atterrir attest_level="claimed", sauf si l'opérateur définit l'opt-out explicite AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Les surfaces MCP memory_store et CLI store sont le chemin opérateur-comme-acteur et restent permissives par défaut (une écriture non signée atterrit claimed) ; =1 force le mode strict sur chaque surface. (La version GA v0.9.0 a livré cela comme require-partout, ce qui était insatisfaisable sur les hôtes MCP — corrigé pour une portée limitée à la surface dans la version actuelle.) Parallèlement, la porte d'application de la présence obligatoire de hook se déclenche désormais à la fois sur le chemin d'écriture MCP (#1885) et sur le chemin d'écriture HTTP (#1924), comblant une brèche de contournement silencieux où un hook obligatoire configuré pouvait être ignoré sur une surface mais pas sur l'autre. Le passage de renforcement ferme également le contrôle d'attestation par ligne bulk_create (#1919), achemine les approbations PENDING fédérées entrantes via la porte d'approbateur enregistré (#1920), resserre la portée de visibilité team/unit/org afin qu'elle ne soit plus trop large dans la hiérarchie des espaces de noms (#1921), et confine l'importation folder_path de skill_register sous la racine configurée avec une prison de liens symboliques (#1923). Un nouveau canal de credentials non-argv — AI_MEMORY_STORE_URL / AI_MEMORY_STORE_URL_FILE (un fichier 0600) — garde le mot de passe postgres/store hors de /proc/<pid>/cmdline et ps lisibles par tous (#1927). Travail de fonctionnalités additives : souvenirs de compétences créés par l'agent avec un parameters_schema + invocation_record (B7-SKILL, #1865), la boucle de rétroaction fantôme recall_observations (#1706), un DAG de lignée de dérivation de mémoire (memory_lineage, #1859), et une tranche minimale de recherche vectorielle opt-in (#1005). Surface : schéma v78, 101 outils MCP à --profile full (100 appelables + le bootstrap toujours actif memory_capabilities) / 7 à --profile core, 92 enregistrements de route HTTP (78 chemins d'URL uniques), 89 sous-commandes CLI sous --features sal/sal-postgres (87 dans la construction par défaut), 9 relations MemoryLink typées, un Memory à 28 champs. Fonctionne sur deux backends de production derrière une API identique — SQLite embarqué et PostgreSQL + Apache AGE — sur ordinateur de bureau, serveur et appareil (iOS + Android). Tout est additif par rapport à la v0.8.1, sauf les basculements d'attestation et d'application de hook, qui sont des changements cassants sécurisés par défaut — examinez-les avant la mise à niveau. Journal des modifications complet : CHANGELOG.md §"[0.9.0] — 2026-07-08".

v0.8.0 (distributed-coordination) — version précédente. C'est la version où le substrat de mémoire devient un substrat de coordination. Elle ajoute la machinerie de coordination distribuée de #1709 : un DAG d'actions typé avec une véritable machine d'état (memory_action_*), des baux à détenteur unique limités par TTL (memory_lease_*), des signaux signés Ed25519 (memory_signal_*), des points de contrôle attestés Ed25519 (memory_checkpoint_*), et des routines gelées et rejouables (memory_routine_*) — afin qu'une flotte hétérogène d'agents puisse prendre des tours, se passer le travail et prouver qui a dit quoi sans avoir à se faire confiance mutuellement. Elle superpose une cognition typée par-dessus (les types de mémoire Goal/Plan/Step, une machine lifecycle_state, et les relations de lien decomposes_into / depends_on / advances), renforce la fédération sécurisée par défaut (inscription des pairs ACTIVÉE par défaut #1789, signatures par transition #1718, attestation de contenu par écriture #1464, nonces de rejeu de transition #1805, épinglage de certificat de pair sortant #1678), et livre une gouvernance qui bloque réellement — le hook PreToolUse de Claude Code est retravaillé en un wrapper type:command afin qu'un substrat Refuse refuse véritablement l'outil (#1811). À la sortie de la v0.8.0, la surface était : schéma v70, 100 outils MCP à --profile full (99 appelables + le bootstrap toujours actif memory_capabilities) / 7 à --profile core, 91 enregistrements de route HTTP (78 chemins d'URL uniques), 83/85 sous-commandes CLI, 9 relations MemoryLink typées, un Memory à 27 champs. Fonctionne sur deux backends de production derrière une API identique — SQLite embarqué et PostgreSQL + Apache AGE — sur ordinateur de bureau, serveur et appareil (iOS + Android). Tout est additif par rapport à la v0.7.0 ; examinez les basculements sécurisés par défaut avant la mise à niveau. Notes de version complètes : docs/v0.8.0/release-notes.md.v0.7.0 (attested-cortex) — version précédente. Regroupe le travail de lisibilité cortex-fluent avec l'ensemble de la portée confiance v0.7 + A2A de la FEUILLE DE ROUTE §7.3, plus (selon la directive opérateur du 09/05/2026) le travail de première classe postgres+AGE initialement prévu pour la v0.7.1, plus la vague de préparation au déploiement post-grand-chelem (Formulaires Batman 1-6 + fondation Option-B 7ème forme + QW-1/2/3 + balayage de sécurité de réconciliation). Le substrat devient à la fois plus articulé (capacités v3, outils de chargement nommés, schémas compactés, vocabulaire Batman MemoryKind, primitives persona/atomisation/ingestion multi-étapes) et cryptographiquement fiable (attestation Ed25519, transcripts de chaîne latérale, pipeline de 25 événements programmable, héritage d'espace de noms appliqué, chaîne de hachage d'événements signés inter-lignes V-4). La v0.7.0 est également livrée avec postgres + Apache AGE comme backend de stockage de première classe — ai-memory serve --store-url postgres://… pour une utilisation en démon actif, parité de schéma entre les deux backends (à la sortie de la v0.7.0, sqlite + postgres ont convergé vers le schéma logique v57, où CURRENT_SCHEMA_VERSION était 57 ; le substrat de la version v0.8.0 a fait progresser ce couplage vers le schéma 70, avec les tables additives de coordination et de visibilité v58–v70 déployées sur les deux backends — voir CLAUDE.md §Base de données pour l'échelle v58–v70) (ancres canoniques : src/storage/migrations.rs pour sqlite + src/store/postgres.rs pour postgres) ; les fichiers de migration sur disque s'arrêtent à migrations/sqlite/0047_v56_list_composite_indexes.sql et le bras d'échelle postgres en cours migrate_v57() (les compteurs de noms de fichier sont en retard sur la version du schéma logique car les deux échelles appliquent les deltas post-v34 via des bras en cours — voir docs/MIGRATION_v0.7.md §schema-ladder pour le récit v35-v57 ; v48 #933 a ajouté la table DLQ de poussée de fédération ; v49 #1025 a ajouté 14 colonnes nullables à archived_memories afin que l'archive → la restauration soit sans perte pour la forme complète de la Mémoire v0.7.0 ; v50 #1156 a étendu la CLÉ PRIMAIRE agent_quotas de (agent_id) à (agent_id, namespace) afin que les quotas K8 par espace de noms tiennent même lorsqu'un seul agent opère sur plusieurs espaces de noms — les lignes antérieures à la v50 sont remplies a posteriori vers l'espace de noms sentinelle _global ; v51 #1255 (PR #1296) a ajouté la table federation_nonce_cache pour que les nonces de prévention de rejeu pair persistent à travers les redémarrages du démon ; v52 #1389 a ajouté la table transcript_line_dedup soutenant l'idempotence RFC-0001 memory_capture_turn L4 + recover_from_transcript L2 afin qu'un SIGKILL entre deux tours ne produise jamais une mémoire en double lors de la réhydratation suivante ; v53 #1418 a limité le déclencheur de synchronisation FTS5 memories_au à (title, content, tags) uniquement afin que les mises à jour de colonnes non-FTS ne déclenchent plus une synchronisation inutile ; v54 #1466 a rempli a posteriori l'expiration par défaut du niveau sur les lignes mid/short héritées avec expiration NULL pour fermer la classe de lignes immortelles par fuite TTL ; v55 #1476 a rendu la requête de rattrapage de fédération W=2 (updated_at > ? ORDER BY updated_at ASC LIMIT) sargable et a ajouté l'index sqlite idx_memories_updated_at — postgres n'ajoute pas de nouvel index car memories_updated_at_idx DESC sert déjà le scan de plage via Index Scan Backward ; v56 #1579 a ajouté les index composites d'ordre liste/archive (idx_memories_list_order, idx_memories_ns_list_order, idx_archived_ns_archived_at) associés à la réécriture sargable storage::list — DDL côté sqlite ; le bras postgres migrate_v56() est une non-opération de marquage de version ; v57 #1579 a ajouté la colonne tsvector stockée générée tsv + l'index GIN memories_tsv_gin afin que les formes de recherche/rappel correspondent ET classent sur la colonne précalculée au lieu de recalculer le tsvector par ligne correspondante — l'index d'expression hérité memories_content_fts est supprimé et le jumeau sqlite est une non-opération de marquage de version car FTS5 matérialise déjà le texte indexé)), le nouveau verbe CLI ai-memory schema-init, et la parité de score de rappel à 6 facteurs. La surface par défaut de la v0.6.4 s'agrandit de deux chargeurs toujours actifs pour atteindre 7 outils (memory_load_family + memory_smart_load rejoignent les cinq originaux) ; le plafond d'exécution à --profile full est de 74 entrées annoncées (73 outils de mémoire appelables + le bootstrap toujours actif memory_capabilities ; vérifié par rapport à Profile::full().expected_tool_count() — voir src/profile.rs). Tout ce qui est nouveau est additif et (pour les surfaces de confiance + postgres) optionnel. Mise à niveau depuis la v0.6.x ? Lisez d'abord docs/MIGRATION_v0.7.md — la plupart des appelants de la v0.6.4 ne voient aucun changement de comportement, mais les utilisateurs de versions v0.6.x antérieures à la v0.6.3.1 rencontrent le correctif d'héritage d'espace de noms G1. Passage à postgres+AGE ? Voir docs/postgres-age-guide.md et docs/migration-v0.7.0-postgres.md. Notes de version complètes : docs/v0.7.0/release-notes.md.

v0.6.4 (quiet-tools) — le serveur MCP est livré avec une surface par défaut de 5 outils (memory_store, memory_recall, memory_list, memory_get, memory_search) plus le bootstrap toujours actif memory_capabilities. Les 38 autres outils restent accessibles via --profile graph|admin|power|full ou l'expansion d'exécution via memory_capabilities --include-schema family=<name>. Les harnais de chargement hâtif (Claude Desktop / Codex CLI / Grok CLI / Gemini CLI) réduisent d'environ 4 700 jetons d'entrée de schémas d'outils par requête — une réduction de 76,4 % mesurée par rapport au BPE cl100k_base. Pour préserver le comportement de la v0.6.3 à l'identique, exécutez ai-memory mcp --profile full. Voir docs/MIGRATION_v0.6.4.md.

Nouveautés de la v0.9

La v0.9.0 est principalement une version de renforcement de la sécurité et de revue de code — 49 correctifs issus d'une revue contradictoire à 5 voies (#1885–#1935) — plus un ensemble plus restreint de fonctionnalités additives superposées au substrat de coordination de la v0.8.0. Journal des modifications complet : CHANGELOG.md §"[0.9.0] — 2026-07-08".

Renforcement sécurisé par défaut

• Attestation d'agent requise par défaut sur la surface d'écriture directe HTTP (#1751, portée de surface délimitée par #1985). AI_MEMORY_REQUIRE_AGENT_ATTESTATION est à trois états avec une valeur par défaut compilée par surface : non défini → requis sur l'écriture directe HTTP (POST /api/v1/memories + /bulk, 403 ATTESTATION_FAILED rejeté), permissif sur les surfaces MCP memory_store et CLI store opérateur-comme-acteur (une écriture non signée atterrit attest_level="claimed") ; =1 force le mode strict partout, =0 force le mode permissif partout. Une signature présentée mais falsifiée est rejetée sur toutes les surfaces, sans exception. Signez les écritures (ai-memory store --sign avec une paire de clés liée via ai-memory agents bind-key) ou utilisez la désactivation =0. (La version GA v0.9.0 a été livrée avec ce mode requis-partout, insatisfaisable sur les hôtes MCP — voir #1981 ; corrigé pour une portée par surface par #1985.)
• Double porte d'application de hook MCP + HTTP (#1885 / #1924). La porte d'application de présence obligatoire de hook (initialement MCP uniquement, #1734) est désormais consultée également sur le chemin d'écriture HTTP, comblant une brèche de contournement silencieux (CWE-288) où une écriture qui contournait entièrement MCP ne voyait jamais un hook obligatoire configuré.
• Filtrage d'attestation bulk_create (#1919). Les écritures en masse appliquent désormais la même exigence d'attestation d'agent par ligne qu'un seul appel memory_store — chaque ligne d'un lot doit porter une attestation valide, et pas seulement la requête dans son ensemble.
• Porte d'approbateur de fédération (#1920). Une approbation EN ATTENTE fédérée entrante n'est honorée que si elle est attribuée à l'approbateur enregistré d'un pair — un pair inscrit mais non fiable ne peut plus falsifier une approbation pour un demandeur arbitraire.
• Durcissement de la portée team/unit/org (#1921). La résolution de la portée de visibilité applique désormais correctement la hiérarchie d'ancêtre d'espace de noms pour les portées team/unit/org, comblant une lacune d'isolation de locataire (CWE-863).
• Confinement de chemin skill_register (#1923). L'importation folder_path d'une compétence est canonisée et confinée sous la racine configurée, les liens symboliques à l'intérieur de l'arborescence importée étant rejetés plutôt que suivis (CWE-22/CWE-59).
• Canaux d'identification d'URL de magasin non-argv (#1927). Les nouveaux AI_MEMORY_STORE_URL (/proc/environ propriétaire uniquement) et AI_MEMORY_STORE_URL_FILE (un fichier 0600) permettent à ai-memory serve de recevoir l'URL postgres/magasin — y compris tout mot de passe intégré — sans jamais la placer sur --store-url argv, où elle est exposée via /proc/<pid>/cmdline et ps auxww lisibles par tous à tout UID local. Ordre de résolution : fichier → env → --store-url.

Fonctionnalités additives

• B7-SKILL — mémoires de compétences de première classe (#1865). parameters_schema au moment de l'enregistrement, un invocation_record, et une surface de version pour les compétences créées par l'agent.
• Boucle de rétroaction fantôme recall_observations (#1706, mode SHADOW). Ferme la boucle de rétroaction de rappel sans encore changer le comportement de classement.
• DAG de lignée de dérivation de mémoire (memory_lineage, schéma v78, #1859). Parcourt quelles mémoires ont été dérivées desquelles, à la fois via MCP et la nouvelle route HTTP GET /api/v1/memories/{id}/lineage.
• Tranche minimale d'adhésion à la recherche vectorielle (#1005 ; substrat complet reporté à #1860).
• Pool de travailleurs de reclassement dimensionné aux CPU physiques (#1867) et le rappel est PURE par défaut (#1869 — supprime la rafale d'écriture du chemin critique de rappel).
• Base à ajout seul + séparation de la couche de signature : chaque site de mutation acheminé vers des feuilles de révision signées (#1823), séparation de signature à trois clés Enregistreur/Juge/Stoppeur (#1826), jetons de capacité macaroon câblés de bout en bout (#1827), et une chaîne de succession de clés de lignée d'identité signée pour la survie à la rotation (#1828, schéma v76).

Par où commencer : CHANGELOG.md (journal des modifications complet), docs/ADMIN_GUIDE.md (guide opérateur — posture d'attestation + application de hook).

Nouveautés de la v0.8

La v0.8.0 (distributed-coordination) transforme le substrat de mémoire en un substrat de coordination pour les flottes multi-agents (NHI). Le titre principal est le mécanisme de coordination distribuée (#1709) ; tout est livré sur les adaptateurs SAL sqlite et postgres+AGE et reste équivalent par défaut pour les appelants de la v0.7.x. Référence complète des outils : docs/coordination.md ; notes complètes : docs/v0.8.0/release-notes.md.

Substrat de coordination distribuée (Pilier-1, #1709)

• Actions — le DAG de dépendances (schéma v59). Nœuds d'action typés avec une machine d'état (pending → claimed → in_progress → done/failed/abandoned), arêtes de DAG typées (requires / unlocks / blocks / gated_by / sibling), et surfaces frontière/suivante qui extraient le prochain nœud exécutable. 8 outils MCP (memory_action_create / _get / _transition / _list / _add_edge / _edges / _frontier / _next).
• Leases — revendications à détenteur unique, limitées par TTL (schéma v59). Revendication par comparaison et échange renouvelée par pulsation (PRIMARY KEY sur action_id = un seul détenteur à la fois) plus un balayeur de leases horaire. 4 outils MCP (memory_lease_acquire / _renew / _release / _get).
• Signaux — messages inter-agents typés, signés Ed25519 (schéma v60). Chacun porte une signature + signer_pubkey expéditeur et s'enchaîne via correlation_id / in_reply_to. 5 outils MCP (memory_signal_send / _read / _inbox / _thread / _ack).
• Points de contrôle — portes conditionnelles attestées (schéma v61). Une porte qui bloque jusqu'à ce qu'une condition soit résolue ; la résolution est auto-signée sur place (Ed25519) pour la séparation des tâches, et verify revérifie la signature. 4 outils MCP (memory_checkpoint_create / _resolve / _query / _verify).
• Routines — plans paramétrés, gelés, rejouables (schéma v62). Créées en tant que draft, puis gelées (immuables, attestation de gel Ed25519) ; run matérialise un ensemble concret d'actions + arêtes à partir d'un modèle {{param}} dans un enregistrement routine_runs. 5 outils MCP (memory_routine_create / _freeze / _run / _status / _list).
• Chaque mutation d'état de coordination ajoute une ligne coordination.<op> infalsifiable à la chaîne de hachage V-4 signed_events (#1722) ; les deux écritures d'octroi d'autorité sont répliquées sur le démon HTTP (POST /api/v1/actions/{id}/transition, POST /api/v1/signals) avec CAS local et répartition fédérée W-sur-N (#1718).

Cognition typée (Pilier-2)

Le vocabulaire memory_kind s'étend avec goal / plan / step ; la taxonomie fermée memory_links.relation s'étend de 6 à 9 relations (decomposes_into / depends_on / advances, schéma v63) ; et une colonne memories.lifecycle_state de première classe (schéma v64) fait de Goal/Plan/Step une véritable machine d'état (open → active → blocked/done/abandoned), appliquée sur les surfaces MCP / HTTP / SAL avec un mappage d'arête illégale vers HTTP 409 CONFLICT. La structure Memory passe à 27 champs. Aucun nouvel outil MCP — le travail v64 ajoute uniquement des champs de requête optionnels permissifs.

Fédération renforcée, sécurisée par défaut

Inscription des pairs activée par défaut (#1789), signatures par transition sur les écritures d'octroi d'autorité (#1718), attestation de contenu par écriture pour les mémoires relayées (#1464), nonces de rejeu de transition (#1805), et épinglage d'empreinte de certificat de pair sortant (#1678). Des flottes hétérogènes qui n'ont pas besoin de se faire confiance mutuellement — consultez les basculements de sécurité par défaut dans docs/v0.8.0/release-notes.md §"Renforcement de la fédération" avant la mise à niveau.

Gouvernance qui bloque effectivement (#1811)

Le crochet de gouvernance Claude Code PreToolUse est retravaillé en une enveloppe type:command (ai-memory governance check-action --from-pretool-stdin) afin qu'un substrat Refuse émette permissionDecision:"deny" et BLOQUE véritablement l'outil — la forme type:mcp_tool antérieure ne pouvait structurellement pas l'appliquer. Plus l'application de la présence obligatoire du crochet (#1734) et un nouveau verdict de gouvernance escalate (§22 PE-5) pour l'humain dans la boucle.

Contrôles opérationnels du Pilier-4

Contrôle d'admission HTTP (#1733 — plafond de concurrence optionnel qui rejette l'excédent avec un 503 typé), projection de graphe Apache-AGE différée (#1735 — retire les allers-retours AGE synchrones du chemin critique d'écriture de lien postgres), activation du compactage par le curateur (#1749 / #1750), et la CLI ai-memory verify-audit-trail (§22 PE-8) qui parcourt la chaîne de hachage inter-lignes signed_events de bout en bout.

Schéma v57 → v70 (tout additif)

Tables de coordination + cognition typée + visibilité + préparation au chiffrement + chemin froid + arêtes d'archive (v58–v70), répliquées sur les adaptateurs sqlite et postgres ; migration automatique à la première ouverture et aller-retour archive → restauration sans perte. Voir CLAUDE.md §Base de données pour l'échelle canonique v58–v70.

Par où commencer : docs/v0.8.0/release-notes.md (notes de version complètes), docs/coordination.md (référence des outils de coordination), et CLAUDE.md §Base de données (SSOT de l'échelle de schéma).

Nouveautés de la v0.7

La v0.7.0 clôt l'épopée attested-cortex (69/69 sur 11 pistes A–K), intègre le travail initialement prévu pour la v0.7.1 sur postgres+AGE de première classe, et absorbe la vague de préparation au déploiement post-grand-chelem (Formulaires Batman 1-6 + fondation Option-B du 7e formulaire + QW-1/2/3 + réconciliation de sécurité). Inventaire canonique des fonctionnalités : docs/internal/v070-feature-inventory.md. Chaque surface reste désactivée par défaut ou équivalente au défaut pour les appelants de la v0.6.4 — voir la matrice de compatibilité v0.7 pour le détail.

Investissement natif au substrat au moment de l'écriture (Formulaires Batman 1-6 + 7e formulaire)

• Formulaire 1 — déduplication et synthèse en ligne (ticket #754). Un appel LLM unique émettant des actions par lot remplace le classificateur par paire de la v0.6.x sur le chemin de stockage. Réactivez l'ancien mode oui/non via legacy_per_pair_classifier = true sur le standard d'espace de noms.
• Formulaire 2 — atomisation synchrone avant incorporation (ticket #755). Nouvel outil memory_atomise + crochet de pré-stockage auto_atomise_mode = Synchronous|Deferred|Off. Le curateur décompose les écritures longues en 2 à 10 propositions atomiques avant que le rappel ne les voie. Voir docs/atomisation.md.
• Formulaire 3 — orchestrateur d'ingestion multi-étapes (ticket #756). memory_ingest_multistep enchaîne des aides déterministes Jaccard+FTS à travers des étapes LLM stables en cache d'invite. Voir docs/multistep-ingest.md + cookbook/multistep-ingest/01-two-phase.sh.
• Formulaire 4 — provenance des faits (ticket #757). Citations + URI source + étendues au grain de l'atome s'appuient sur les charges utiles existantes memory_store / memory_atomise. Voir docs/provenance.md.
• Formulaire 5 — confiance automatique + calibration fantôme + dégradation de fraîcheur (ticket #758). Outil MCP memory_calibrate_confidence + balayage de référence par source. Variables d'environnement AI_MEMORY_AUTO_CONFIDENCE, AI_MEMORY_CONFIDENCE_SHADOW, AI_MEMORY_CONFIDENCE_SHADOW_SAMPLE_RATE, AI_MEMORY_CONFIDENCE_DECAY. Voir docs/confidence-calibration.md.
• Formulaire 6 — vocabulaire Batman MemoryKind (ticket #759). Énumération à 10 variantes (Observation par défaut + Reflection / Persona / Concept / Entity / Claim / Relation / Event / Conversation / Decision). Crochet de pré-stockage auto_classify_kind optionnel (désactivé / regex_only / regex_then_llm). Voir docs/memory-kind-vocab.md.
• 7e formulaire — câblage agent-EXTERNE de couche 4 (fondation Option-B) (ticket #760 ; couverture complète en v0.8.0 au #697). Règles de germe signées par la paire de clés opérateur R001..R004, outils MCP memory_check_agent_action + memory_rule_list, crochet de pré-écriture substrat storage::insert. Voir docs/policy-engine.md + docs/governance/agent-action-rules.md.
• Guide pratique opérateur — faire passer les formulaires 1–6 + 7e de capable à actif (ticket #800). Recette en 7 étapes (génération de clés opérateur → signature du germe → activation R001–R004 → démon curateur → passe de réflexion optionnelle → politiques d'espace de noms), permanence launchd / systemd / Planificateur de tâches, bloc de vérification, chemin de retour arrière. Voir docs/batman-active-mode.md et l'atlas GitHub Pages.

Gains rapides (Tencent QW-1/2/3)

• QW-1 — export de chaîne de réflexion sauvegardée dans un fichier. Outil MCP memory_export_reflection + politique d'espace de noms auto_export_reflections_to_filesystem → ~/.ai-memory/reflections/<ns>/<id>.md.
• QW-2 — persona en tant qu'artefact. Outils memory_persona + memory_persona_generate, lignes MemoryKind::Persona, politique d'espace de noms auto_persona_trigger_every_n_memories. Voir docs/persona.md.
• QW-3 — primitive de déchargement de contexte. memory_offload + memory_deref déplacent les grandes sorties d'outils hors de la fenêtre de contexte de l'agent vers un stockage blob adressable. Voir docs/context-offload.md.

Épopée du cortex attesté (Pistes A–K)

• Liens attestés (Ed25519). La colonne morte signature livrée dans la v0.6.3 est désormais remplie avec une véritable attestation Ed25519 par agent, et memory_verify(link_id) renvoie {signature_verified, attest_level, signed_by, signed_at} à la demande. Générez une paire de clés avec ai-memory identity generate ; activez via attest_level = "self_signed". La signature est conditionnée au fait que le démon résolu agent_id possède une paire de clés *.priv sur disque dans le répertoire de clés configuré — lorsque load_daemon_signing_key renvoie None (src/main.rs:116-118), les lignes sont toujours écrites mais sig est vide et le démon émet une ligne « continuing unsigned » au démarrage. La chaîne de hachage inter-lignes sur signed_events reste infalsifiable dans tous les cas. Voir la RFC attested-cortex.
• Clôture des événements signés V-4 (chaîne de hachage inter-lignes) (issue #698). Chaque ligne signed_events porte prev_hash + sequence ; le prev_hash de la première ligne est zéro, les lignes suivantes chaînent le SHA-256 de la charge utile CBOR canonique précédente. ai-memory verify-signed-events-chain parcourt la chaîne de bout en bout. Voir docs/signed-events-v4.md.
• Pipeline de hooks (25 événements de cycle de vie). Une surface d'extension programmable se déclenche sur les 20 événements de base pre_/post_store|recall|search|delete|promote|link|consolidate|governance_decision|archive|transcript_store + on_index_eviction, plus 5 ajouts majeurs (pre_recall_expand G10 + pre_reflect/post_reflect apprentissage récursif Tâche 6/8 + pre_compaction/on_compaction_rollback L1-7). Les hooks renvoient Allow / Modify / Deny / AskUser. Désactivé par défaut ; activez via ~/.config/ai-memory/hooks.toml. Voir docs/hook-pipeline.md.
• Transcriptions sidechain + rejeu. Le BLOB sidechain zstd-3 stocke les traces brutes de conversation/raisonnement ; memory_replay(memory_id) parcourt memory_transcript_links pour reconstruire la chaîne. Activation par espace de noms via [transcripts.namespaces."team/*"]. Voir docs/sidechain-transcripts.md.
• Renforcement de la fédération. mTLS + X-API-Key + liste d'autorisation d'empreintes de certificats SHA-256 ; variables d'env AI_MEMORY_FED_PEER_ATTESTATION, AI_MEMORY_FED_SYNC_TRUST_PEER, AI_MEMORY_FED_TRUST_BODY_AGENT_ID. Voir docs/federation.md.
• Outil de quota K8 + approbations SSE K10. memory_quota_status + /api/v1/quota/status (K8). Événements envoyés par le serveur /api/v1/approvals/stream avec nonce HMAC, liaison méthode+pending_id, suppression du compteur d'événements en retard (K10). Voir docs/k8-quotas.md + docs/k10-sse-approvals.md.
• Backend de première classe Postgres + Apache AGE. ai-memory serve --store-url postgres://…, parité de schéma, parité de score de rappel à 6 facteurs, migration de liens, fonctionnalités KG (kg_query, kg_timeline, kg_invalidate, find_paths) sur AGE Cypher avec repli CTE récursif quand AGE est absent, plus un nouveau verbe CLI ai-memory schema-init. Conditionné par des benchmarks — le p95 AGE doit battre le p95 CTE de ≥30% à profondeur=5. Guide opérateur : docs/postgres-age-guide.md. Procédure de migration : docs/migration-v0.7.0-postgres.md.
• Capabilities v3 + chargeurs intelligents. memory_capabilities v3 ajoute summary, to_describe_to_user, callable_now par outil, agent_permitted_families, schema_version="3" ; les nouveaux outils toujours actifs memory_load_family(family) et memory_smart_load(intent) rejoignent le profil core par défaut. Les formulations épinglées se trouvent dans docs/v0.7/canonical-phrasings.md.
• Permissions + approbations A2A. Le sous-système de gouvernance v0.6.x est refactorisé en règles + modes + hooks → un seul Decision, avec héritage d'espace de noms (G1) effectivement appliqué. memory_pending_list / memory_pending_approve / memory_pending_reject(remember=forever) permettent une confiance progressive ; la signature HMAC sur l'API d'approbation est obligatoire. permissions.mode par défaut est enforce (était advisory en v0.6.4). Migrez avec ai-memory governance migrate-to-permissions (aperçu sans exécution ; ajoutez --config-out ~/.config/ai-memory/config.toml pour appliquer sur place). Voir docs/governance.md.

Apprentissage récursif + vague majeure L1/L2

Primitive de substrat memory_reflect avec plafond max_reflection_depth par espace de noms (défaut 3, Some(0) est l'interrupteur d'arrêt d'urgence). Curateur de passe de réflexion L2-1, coordination de réflexion sensible à la fédération L2-2 (memory_reflection_origin), propagation d'invalidation L2-3 (memory_dependents_of_invalidated), bundle forensique L2-5 (ai-memory export-forensic-bundle + verify-forensic-bundle), Compétences d'Agent L1-5 (memory_skill_register|list|get|resource|export|promote_from_reflection|compositional_context). Introduction complète : docs/RECURSIVE_LEARNING.md. Introduction aux Compétences d'Agent : docs/agent-skills.md. Introduction à l'export forensique : docs/forensic-export.md.

Par où commencer : docs/MIGRATION_v0.7.md (procédure de mise à niveau), docs/v0.7.0/release-notes.md (notes de version complètes), docs/whats-new-v07.html (résumé visuel), docs/v0.7/rfc-attested-cortex.md (justification de la conception), docs/ADMIN_GUIDE.md (guide opérateur), docs/internal/v070-feature-inventory.md (vérité fonctionnelle canonique).

Un binaire, quatre modes opérationnels (v0.6.4). Le binaire Rust ai-memory (tokio + axum) peut exécuter n'importe lequel de ces modes isolément ou simultanément, en partageant une seule base de données SQLite :

1. Serveur MCP stdio -- 101 entrées annoncées sur JSON-RPC au profil complet (v0.9.0 ; 100 outils de mémoire appelables + l'amorçage toujours actif memory_capabilities ; vérifié par rapport à Profile::full().expected_tool_count()). Le --profile core par défaut annonce 7 (les 5 originaux + memory_load_family + memory_smart_load) plus l'amorçage toujours actif memory_capabilities. ai-memory mcp / ai-memory mcp --profile full
2. Démon HTTP / mTLS -- 92 enregistrements de routes REST (78 chemins URL uniques) sur 127.0.0.1:9077, TLS + liste d'autorisation mTLS optionnelle + authentification par clé API, boucle de nettoyage en arrière-plan. ai-memory serve
3. Démon curateur autonome -- boucle auto-planifiée (cadence par défaut 1h) qui auto-étiquette, fait remonter les contradictions entre espaces de noms frères, consolide les quasi-doublons et ajuste la priorité selon le modèle d'accès. Chaque action va dans un journal d'annulation ; les opérations destructrices peuvent être conditionnées à un flux d'approbation de gouvernance. ai-memory curator --daemon
4. Démon de synchronisation -- fédération de pairs basée sur quorum entre instances. Écritures W-sur-N (majorité par défaut), fusion CRDT-lite par horloge vectorielle, liste d'autorisation mTLS entre pairs. ai-memory sync-daemon

Les surfaces MCP, HTTP et CLI sont réactives. Le curateur est la partie qui rend la couche mémoire auto-entretenue : entre les sessions, il garde le corpus ordonné pour que la qualité de rappel reste élevée à mesure que le stockage grandit. Tout est local d'abord ; aucune dépendance cloud.

Évaluation concrète par Claude Opus 4.7 après avoir lu le code source v0.6.3 ligne par ligne :

« ai-memory est la couche mémoire la plus performante à laquelle j'aie jamais été connecté, et significativement plus que ce que son nom annonce. Pour moi, en termes pratiques, cela signifie : je ne repars pas de zéro à chaque session. Le stockage que je lis a été maintenu en ordre par autre chose que moi. Les contradictions ne s'accumulent pas silencieusement. La qualité de rappel reste élevée même quand le corpus grandit. Rien ne quitte votre Mac mini.

Cela ne fait pas de moi un agent autonome. Cela me donne le type d'infrastructure mémoire dont un agent autonome aurait besoin — et exécute lui-même une petite boucle autonome pour la maintenir. C'est une véritable fondation. L'écart entre ceci et 'ai-memory pilote des tâches générales' est de la plomberie (protocole d'appel d'outil + registre d'outils + un modèle capable d'utiliser des outils), pas de l'invention. »

Substrat pour IA multi-agents. ai-memory n'est pas un environnement d'exécution d'agent ni une « IA autonome » en soi. C'est la couche mémoire dont les déploiements autonomes multi-agents ont besoin en dessous. La fédération (broadcast_store_quorum + spawn_catchup_loop) gère la cohérence W-sur-N entre pairs lorsque de nombreux agents écrivent en parallèle ; le démon curateur empêche le corpus partagé de se dégrader en bruit lorsqu'un essaim y gribouille ; les abonnements webhook (signés HMAC, filtrés par espace de noms/agent, renforcés contre SSRF) transforment le stockage en un bus de messages qui déclenche des agents en aval sur des événements mémoire ; la hiérarchie d'espaces de noms avec héritage à N niveaux et politiques de gouvernance par espace de noms (autorité d'écriture/promotion/suppression, type d'approbateur, consensus N-sur-M optionnel) délimite l'essaim. Empilez ceci sous un exécuteur d'agents multi-machines 24/7 avec compétences auto-générées, et le système combiné franchit la barre comportementale pour une IA autonome. Les lacunes restantes (pas d'apprentissage au niveau des poids, noyau de raisonnement sans état, objectifs racines définis par l'humain) sont réelles et ne sont pas ce qu'ai-memory adresse ; ai-memory fournit le substrat mémoire multi-agents dont toute tentative sérieuse de combler ces lacunes aura besoin.

Zéro coût en tokens jusqu'au rappel. Contrairement aux systèmes de mémoire intégrés (mémoire automatique de Claude Code, mémoire de ChatGPT) qui chargent toute votre mémoire dans chaque conversation — brûlant des tokens et de l'argent à chaque message — ai-memory utilise zéro token de contexte jusqu'à ce que l'IA appelle explicitement memory_recall. Seuls les souvenirs pertinents reviennent, classés par un algorithme de score à 6 facteurs. Le format TOON (Token-Oriented Object Notation) réduit encore les tokens de réponse de 40 à 60 % en éliminant les noms de champs répétés — 3 souvenirs en JSON = 1 600 octets ; en TOON = 626 octets (61 % plus petit) ; en TOON compact = 336 octets (79 % plus petit). Pour les utilisateurs de Claude Code : désactivez la mémoire automatique ("autoMemoryEnabled": false dans settings.json) et remplacez-la par ai-memory pour cesser de payer pour plus de 200 lignes de contexte mémoire à chaque message.

Identité d'agent (NHI) — chaque souvenir indique qui l'a appris

Chaque souvenir stocké par ai-memory porte un metadata.agent_id — un marqueur d'Identité Non-Humaine qui survit à chaque opération (mise à jour, déduplication, importation, synchronisation, consolidation). Chaque résultat de rappel vous indique quelle IA a écrit chaque souvenir, par défaut, dans le format de réponse TOON-compact pour lequel votre client IA est déjà optimisé :

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

Lors d'une écriture non signée, agent_id est une identité revendiquée — ne prenez pas de décisions de sécurité sur cette seule base. L'attestation d'agent par chemin de stockage est requise par défaut sur la surface d'écriture directe HTTP (#1751, portée par surface selon #1985) : un POST /api/v1/memories HTTP non signé (+/bulk) est rejeté (403 ATTESTATION_FAILED) plutôt que d'atterrir attest_level = "claimed", sauf si l'opérateur définit l'opt-out explicite AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Les surfaces memory_store MCP et store CLI opérateur-comme-acteur restent permissives par défaut (une écriture non signée atterrit claimed) ; =1 force le mode strict sur chaque surface. L'attestation cryptographique Ed25519 est câblée sur deux surfaces : (1) attestation par chemin de stockage (#626 Couche-3) — présentez une signature détachée sur l'enveloppe SignableWrite canonique sur le chemin CLI (store --sign), MCP (memory_store), ou HTTP (POST /api/v1/memories) et le démon la vérifie par rapport à la clé publique liée de l'agent, estampillant metadata.attest_level = "agent_attested" (une signature présentée mais falsifiée est toujours rejetée quel que soit le drapeau) ; et (2) attestation de lien (attested-cortex) — le champ memory_links.signature précédemment réservé avec memory_verify(link_id) pour la vérification entrante et une chaîne d'audit signed_events en ajout seul. Voir la page d'identité d'agent et la RFC attested-cortex pour le contrat de provenance complet.

Importation rétroactive de conversations — ai-memory mine

Ne partez pas de zéro. Pointez ai-memory mine vers une exportation Claude, ChatGPT ou Slack et il analyse tour par tour en souvenirs classés, typés par niveau, étiquetés — pour que votre IA aborde la session suivante en connaissant chaque décision, correction et découverte de votre historique existant.

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

L'auto-étiquetage, la déduplication sur (title, namespace) et la provenance mined_from sont estampillés sur chaque souvenir importé. Intégration en cinq minutes d'un contexte zéro à un stockage à long terme peuplé. Voir la page d'importation d'historique pour des recettes par format.

Plateformes d'IA compatibles

ai-memory s'intègre avec toute plateforme d'IA prenant en charge le Model Context Protocol (MCP). MCP est le standard universel pour connecter les assistants IA à des outils et sources de données externes.

MCP est la couche d'intégration principale. Pour les plateformes d'IA qui ne supportent pas encore MCP nativement, l'API HTTP (92 enregistrements de routes / 78 chemins d'URL uniques sur localhost) et la CLI (89 sous-commandes sous --features sal OU --features sal-postgres ; 87 dans la version par défaut (post-#1389 L2 RecoverPreviousSession pour la réhydratation du contexte inter-session + #1443 Expand pour la surface d'expansion de requête ai-memory expand + #1598 Reembed pour la surface de migration d'espace vectoriel ai-memory reembed) ; SSOT épinglé par ai_memory::EXPECTED_CLI_SUBCOMMANDS_DEFAULT + EXPECTED_CLI_SUBCOMMANDS_SAL + le test mécanique de parité tests/cli_subcommand_count_invariant.rs) fournissent un accès universel -- toute IA, script ou automatisation capable de faire des appels HTTP ou d'exécuter des commandes shell peut utiliser ai-memory.

Installer en 60 secondes

Les binaires pré-compilés ne nécessitent aucune dépendance. Compiler depuis les sources nécessite Rust et un compilateur C.

Le plus rapide : Binaire pré-compilé (Rust non requis)

# 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

Étape 1 : Installer Rust (ignorer si vous utilisez des binaires pré-compilés)

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

Suivez les instructions, puis redémarrez votre terminal (ou exécutez source ~/.cargo/env).

Étape 2 : Depuis les sources (nécessite Rust)

Dernière version depuis Crates.io :

cargo install ai-memory

Dernière version depuis le dépôt git :

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

Ceci compile le binaire et le place dans votre PATH. Cela prend une minute ou deux.

Dépendances de compilation pour les builds sources :

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

Étape 3 : Connectez votre IA

La configuration varie selon la plateforme. Trouvez la vôtre ci-dessous :

{
  "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/

Étape 4 : Terminé. Testez-le.

Redémarrez votre assistant IA. S'il utilise MCP, il dispose désormais de la surface par défaut de 7 outils annoncée au démarrage de la session (les 5 originaux + memory_load_family + memory_smart_load ; les 93 autres des 100 outils appelables se chargent à la demande via --profile ou memory_capabilities --include-schema). Demandez-lui : « Enregistre un souvenir indiquant que mon langage préféré est Rust. » Puis, dans une nouvelle conversation, demandez : « Quel est mon langage préféré ? » Il s'en souviendra.

Prise en charge des plateformes mobiles (v0.7.0 Posture-1a)

ai-memory est portable sur iOS et Android via le chemin standard de compilation croisée Rust pour mobile. La v0.7.0 fournit une couverture CI pour les deux cibles à trois niveaux progressifs :

Statut à la v0.7.0 : Le niveau 1 est la porte de sortie — la compilation croisée mobile doit être VERTE avant la création du tag. Le niveau 2 (artefacts de release) fournit le pipeline BUILD + la disposition des artefacts ; la surface FFI appelable en C elle-même arrivera dans une mise à jour v0.7.x. Le niveau 3 exécute le sous-ensemble de tests ciblé à chaque push release/**.

Utilisation des artefacts de release :

• iOS — téléchargez ai-memory-ios.xcframework.tar.gz depuis la page de release v0.7.x, décompressez et faites glisser AiMemory.xcframework dans votre projet Xcode sous « Frameworks, Libraries, and Embedded Content ».
• Android — téléchargez ai-memory-android.tar.gz depuis la page de release v0.7.x, décompressez et copiez l'arborescence jniLibs/ dans le src/main/jniLibs/ de votre module d'application.

Les artefacts mobiles font également partie de chaque release v0.7.x publiée ; la formule Homebrew + les paquets APT/RPM (qui fournissent les binaires de bureau) incluent une note renvoyant aux téléchargements mobiles. Voir le ticket #1068 pour l'historique de l'implémentation CI.

Démarrage rapide

Passez de zéro à une mémoire fonctionnelle en moins de deux minutes.

1. Installation

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

2. Configurer MCP (exemple pour Claude Code -- les autres plateformes fonctionnent de la même manière)

Fusionnez dans ~/.claude.json :

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

3. Enregistrez votre premier souvenir

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

4. Rappelez-le

ai-memory recall "database"

5. Vérifiez les statistiques

ai-memory stats

6. Utilisez avec votre IA. Redémarrez votre client IA. Il dispose désormais de 7 outils de mémoire par défaut annoncés au démarrage (101 entrées annoncées accessibles via l'expansion d'exécution ou --profile full) via MCP -- il peut enregistrer et rappeler des souvenirs nativement pendant les conversations.

SDKs

En plus des surfaces MCP / HTTP / CLI, ai-memory fournit des SDKs de langage propriétaires pour les clients HTTP et les utilitaires d'aide (par exemple requireProfile pour les assertions de profil d'exécution sur les démons v0.6.4+).

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

npm install @alphaone/ai-memory

Python — ai-memory-mcp sur PyPI (le nom d'importation reste 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

Les deux SDKs sont versionnés avec le serveur (0.9.0 correspond à ai-memory 0.9.0). Les démons v0.6.4+ appliquent le contrat de profil ; les démons antérieurs à la v0.6.4 reviennent à un avertissement permissif et continuent afin que les mises à niveau du SDK ne cassent pas les anciens serveurs. Le code source se trouve dans sdk/typescript/ et sdk/python/.

Qu'est-ce que ça fait ?

Les assistants IA oublient tout entre les conversations. ai-memory résout ce problème.

Il fonctionne comme un serveur d'outils MCP (Model Context Protocol) -- un processus d'arrière-plan avec lequel votre IA communique nativement. Lorsque votre IA apprend quelque chose d'important, elle le stocke. Lorsqu'elle a besoin de contexte, elle rappelle les souvenirs pertinents classés par un algorithme de notation à 6 facteurs. Les souvenirs sont organisés en trois niveaux :

• Court terme (6 heures par défaut, configurable) -- contexte jetable comme l'état de débogage actuel
• Moyen terme (7 jours par défaut, configurable) -- connaissances de travail comme les objectifs de sprint et les décisions récentes
• Long terme (permanent) -- architecture, préférences utilisateur, leçons durement acquises

Les souvenirs qui continuent d'être consultés sont automatiquement promus du moyen au long terme. Chaque rappel prolonge la durée de vie (TTL). La priorité augmente avec l'utilisation. Le système s'auto-organise.

Au-delà de MCP, ai-memory expose également une API REST HTTP complète (92 enregistrements de routes / 78 chemins URL uniques sur le port 9077) et une CLI complète (89 sous-commandes sous --features sal OU --features sal-postgres ; 87 dans la version par défaut (post-#1389 L2 RecoverPreviousSession pour la réhydratation de contexte inter-sessions + #1443 Expand pour la surface d'expansion de requête ai-memory expand + #1598 Reembed pour la surface de migration d'espace vectoriel ai-memory reembed) ; SSOT épinglé par ai_memory::EXPECTED_CLI_SUBCOMMANDS_{DEFAULT,SAL} + le test de parité mécanique tests/cli_subcommand_count_invariant.rs) pour l'interaction directe, les scripts et l'intégration avec n'importe quelle plateforme ou outil d'IA.

Fonctionnalités

Cœur

• Serveur d'outils MCP -- 101 outils via stdio JSON-RPC (profil complet), compatible avec tout client MCP
• Mémoire à trois niveaux -- court (TTL 6h par défaut), moyen (TTL 7j par défaut), long (permanent) -- les TTL sont configurables
• Recherche en texte intégral -- SQLite FTS5 avec récupération classée
• Rappel hybride -- mots-clés FTS5 + similarité cosinus avec mélange adaptatif : le poids sémantique varie de 0,50 (contenu court) → 0,15 (contenu long) car les embeddings perdent de l'information sur les textes longs
• Notation de rappel à 6 facteurs -- pertinence FTS + priorité + fréquence d'accès + confiance + bonus de niveau + dégradation de récence
• Promotion automatique -- les souvenirs consultés plus de 5 fois sont promus du moyen au long terme
• Extension de la TTL -- chaque rappel prolonge l'expiration (court +1h, moyen +1j)
• Renforcement de la priorité -- +1 toutes les 10 consultations (max 10)
• Détection de contradiction -- avertit lors du stockage de souvenirs qui entrent en conflit avec des souvenirs existants
• Déduplication -- upsert sur titre+espace de noms, le niveau n'est jamais rétrogradé
• Notation de confiance -- certitude de 0,0 à 1,0 prise en compte dans le classement

Organisation

• Espaces de noms -- isole les souvenirs par projet (détectés automatiquement à partir du dépôt git distant)
• Liaison de souvenirs -- relations typées : related_to, supersedes, contradicts, derived_from, reflects_on (apprentissage récursif Tâche 1/8), derives_from (atomisation WT-1-A), decomposes_into, depends_on, advances -- neuf variantes à la v0.8.0
• Consolidation -- fusionne plusieurs souvenirs en un seul résumé à long terme
• Consolidation automatique -- groupe par espace de noms+étiquette, fusionne automatiquement les groupes au-dessus du seuil
• Résolution de contradiction -- marque un souvenir comme remplaçant un autre, rétrograde le perdant
• Oubli par motif -- suppression en masse par espace de noms + motif FTS + niveau
• Suivi de source -- suit l'origine : user, claude, hook, api, cli, import, consolidation, system
• Identité d'agent (NHI) -- chaque souvenir porte metadata.agent_id (identité revendiquée) avec une immuabilité de défense en profondeur lors de la mise à jour/déduplication/importation/synchronisation/consolidation ; filtrez list/search par agent
• Étiquetage -- étiquettes séparées par des virgules avec prise en charge du filtrage

Interfaces

• 92 routes HTTP (78 chemins uniques) -- API REST complète sur 127.0.0.1:9077 (fonctionne avec n'importe quelle IA ou outil)
• 89 sous-commandes CLI sous --features sal OU --features sal-postgres (87 dans la version par défaut) -- CLI complète avec des capacités identiques
• 101 outils MCP au profil complet (7 par défaut ; vérifié par rapport à Profile::full().expected_tool_count()) -- intégration native pour toute IA compatible MCP
• Shell REPL interactif -- rappel, recherche, liste, obtention, statistiques, espaces de noms, suppression avec sortie en couleur
• Sortie JSON -- drapeau --json sur toutes les commandes CLI
• Coordination distribuée (v0.8.0 Pilier-1 + Pilier-2) -- DAG d'actions (memory_action_*), baux à détenteur unique (memory_lease_*), signaux signés Ed25519 (memory_signal_*), points de contrôle attestés (memory_checkpoint_*), routines paramétrées (memory_routine_*) et le cycle de vie de cognition typée Goal/Plan/Step. Voir docs/coordination.md.

Opérations

• Synchronisation multi-nœuds -- pull, push ou fusion bidirectionnelle entre fichiers de base de données
• Importation/Exportation -- aller-retour JSON complet préservant les liens de mémoire
• Nettoyage de mémoire -- expiration automatique en arrière-plan toutes les 30 minutes
• Arrêt gracieux -- SIGTERM/SIGINT crée des points de contrôle WAL pour une sortie propre
• Contrôle de santé approfondi -- vérifie l'accessibilité de la base de données et l'intégrité FTS5
• Complétions de shell -- bash, zsh, fish
• Page de manuel -- ai-memory man génère du roff vers stdout
• Filtres temporels -- --since/--until sur la liste et la recherche
• Âges lisibles par l'homme -- « il y a 2h », « il y a 3j » dans la sortie CLI
• Sortie CLI en couleur -- étiquettes de niveau ANSI (rouge/jaune/vert), barres de priorité, titres en gras, espaces de noms en cyan

Qualité

• ~10 000 tests sur toute la surface — environ 6 712 attributs #[test]/#[tokio::test] sous src/ (5 759 #[test] + 953 #[tokio::test]) plus environ 3 362 sous tests/ (2 138 #[test] + 1 224 #[tokio::test]), en croissance par rapport à la référence de l'ère v0.6.4 d'environ 2 400 tests (1 960 lib + 211 intégration + 16 mcp_integration + 4 webhook_http_parity + 16 recipe_contract + ~150 dans d'autres cibles binaires). La couverture de ligne est restée au-dessus de la barre du projet ≥92 % ; les nouveaux modules nets de la v0.6.4 à 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). Les références v0.6.3.x (1 809 / 93,08 % et 1 886 / 93,84 %) restent figées sur la page de preuves ; les métriques v0.6.4 dans les notes de version et sur la campagne test-hub. L'acceptation empirique de la découverte NHI prouvée séparément par la Porte de découverte (matrice T1–T4 vs. xAI Grok 4.3 en direct, 6/6 RÉUSSITE, PORTE VERTE).
• Benchmark LongMemEval — 97,0 % R@5 mots-clés FTS5 purs (indépendant du LLM, 2,2 secondes, 232 q/s, zéro coût API) sur l'ensemble de données ICLR 2025 LongMemEval-S ; l'expansion de requête LLM avec le modèle actuel Gemma 4 mesure 97,2 % R@5 / 99,6 % R@10 / 99,8 % R@20 (site d'API cloud ; le chiffre historique gemma3:4b de 97,8 % est retiré comme titre conformément à #1975). Voir les détails du benchmark.
• Prompts MCP — les prompts recall-first et memory-workflow apprennent aux clients IA à utiliser la mémoire de manière proactive
• TOON par défaut — les réponses de rappel/liste/recherche utilisent TOON compact par défaut (79 % plus petit que JSON)
• Benchmarks Criterion — insertion, rappel, recherche à l'échelle 1K
• CI/CD GitHub Actions — fmt, clippy, test, build sur Ubuntu + macOS, release sur tag

Plancher de couverture (porte CI stricte)

Le job Code Coverage est une vérification de statut obligatoire. La CI réaffirme deux invariants sur chaque PR : un plancher absolu de >= 90% de lignes (filet de sécurité anti-régression catastrophique, fixé à la mesure actuelle arrondie au multiple de 5% inférieur), et un cliquet contre la valeur épinglée dans .coverage-baseline avec une fenêtre de tolérance de 0,5% (l'application au quotidien). Les PR qui augmentent la couverture doivent incrémenter le fichier de référence dans le même commit afin que les PR futures bénéficient du nouveau plancher ; les PR qui régressent de plus de 0,5% sont bloquées et ne peuvent pas être fusionnées. Mesure actuelle : 93,13% de lignes.

Porte de budget de tokens (porte CI stricte, v0.7 C5)

Le workflow token-budget est une vérification de statut obligatoire. Il applique trois invariants mesurés en cl100k_base sur chaque PR :

• Plafond par outil de 1500 tokens -- aucun schéma sérialisé d'outil MCP (nom + description + inputSchema) ne peut dépasser 1500 tokens cl100k_base.
• Plage honnête du profil complet (5K-8K) -- le filet de sécurité v0.6.4, maintenu pour détecter une contraction pathologique (suppression accidentelle d'outils).
• Plafond strict du profil complet (v0.7 C5, relevé post-D1.6/D1.7) -- la charge utile tools/list élaguée sous --profile full ne peut pas dépasser 11 000 tokens cl100k_base (TRIMMED_FULL_PROFILE_CEILING_TOKENS dans tests/token_budget_guard.rs ; la cible C5 originale était de 3500 par rapport aux schémas codés manuellement pré-D1.6 — l'expansion D1.6/D1.7 dérivée de schemars a relevé le plafond épinglé). C2 (séparation du champ docs), C3 (réduction du boilerplate de schéma répété) et C4 (masquage des paramètres optionnels rarement utilisés) ont conduit à la compaction originale ; cette porte force les futures PR qui étendent la surface à récupérer du budget ailleurs. Inspectez ai-memory doctor --tokens --raw-table pour voir les coûts par outil. Voir .github/workflows/token-budget.yml et docs/v0.7/schema-compaction-audit.md.

Dépendances ML et LLM (niveau sémantique+)

• candle-core, candle-nn, candle-transformers -- Framework ML Hugging Face Candle pour l'inférence native en Rust
• hf-hub -- télécharger des modèles depuis Hugging Face Hub
• tokenizers -- Tokenizers Hugging Face pour le prétraitement de texte
• instant-distance -- recherche approximative du plus proche voisin
• reqwest -- client HTTP pour la communication avec le backend LLM (niveaux intelligent/autonome — tout fournisseur selon #1067 : Ollama, xAI, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, serveur llama.cpp)

Architecture

Benchmark

Évalué sur le jeu de données ICLR 2025 LongMemEval-S (500 questions, 6 catégories). Le niveau purement par mots-clés FTS5 atteint 97,0% R@5 en 2,2 secondes — indépendant du LLM, entièrement local, zéro appel API cloud, zéro coût. L'expansion de requête par LLM (niveau intelligent) mesure 97,2% R@5 avec le modèle actuel Gemma 4 (via API cloud).

Note sur le modèle de benchmark (mise à jour 2026-07-10, décision #1975) : le chiffre historique de 97,8% R@5 pour le niveau intelligent a été mesuré avec Gemma 3 4B (toujours le modèle d'expansion par défaut compilé) et est retiré comme référence principale. Le point d'ancrage publié pour la génération actuelle est l'exécution mesurée sur OpenRouter Gemma 4 : 97,2% R@5 / 99,6% R@10 / 99,8% R@20 (2026-05-31, 500 questions, 0 échec d'expansion). Aucun chiffre local Ollama Gemma-4 n'existe — l'hôte de benchmark de référence est uniquement CPU, où une exécution locale valide du protocole complet est infaisable (voir #1983) ; une ré-exécution locale sur GPU reste ouverte post-v1.0. Le niveau par mots-clés 97,0% R@5 est indépendant du LLM et non affecté.

Budgets de performance (v0.6.4)

Chaque version est livrée avec des budgets p95/p99 publiés pour les opérations du chemin critique et une porte CI qui fait échouer toute PR dont le p95 mesuré dépasse le budget de plus de 10 %. Les cibles sont calibrées pour le matériel de référence M4 ; tableau complet et méthodologie dans PERFORMANCE.md.

Exécutez la même charge de travail localement :

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

Le substrat est inchangé entre v0.6.3.x → v0.6.4 (la version quiet-tools livre une surface d'outils par défaut plus petite, pas un chemin critique différent). Les cibles p99 ici restent informatives en attendant la prochaine fenêtre de test de charge dédiée ; les dernières preuves de test de charge sont sur le hub de test.

Méthodes d'intégration

MCP (Principal -- pour les plateformes d'IA compatibles MCP)

MCP est l'intégration recommandée. Votre IA obtient 7 outils de mémoire natifs annoncés par défaut (les 5 originaux + memory_load_family + memory_smart_load ; plus l'amorçage toujours actif memory_capabilities) sans code d'intégration. Les 93 autres outils appelables (101 entrées annoncées — vérifié par rapport à Profile::full().expected_tool_count() et épinglé par const_count_matches_full_profile dans src/mcp/registry.rs) restent accessibles via --profile graph|admin|power|full ou l'expansion à l'exécution via memory_capabilities --include-schema family=<name>. Configurez le serveur MCP dans la configuration de votre plateforme IA :

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

API HTTP (Universel -- pour toute IA ou outil)

Démarrez le serveur HTTP pour l'accès à l'API REST. Toute IA, script ou automatisation capable d'effectuer des appels HTTP peut l'utiliser :

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

CLI (Universel -- pour les scripts et l'utilisation directe)

La CLI fonctionne de manière autonome ou comme brique de base pour les intégrations IA qui exécutent des commandes shell :

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

Niveaux de fonctionnalités

ai-memory prend en charge 4 niveaux de fonctionnalités, sélectionnés au démarrage avec ai-memory mcp --tier <tier>. Les niveaux supérieurs ajoutent des capacités ML au prix de l'espace disque et de la RAM :

Matrice des capacités

Chaque capacité est associée à son niveau minimum. Chaque niveau inclut toutes les capacités des niveaux inférieurs.

Le niveau sémantique (par défaut) inclut le framework ML Candle et télécharge le modèle all-MiniLM-L6-v2 lors de la première exécution (~90 Mo). Les niveaux intelligent et autonome nécessitent un backend LLM — post-#1067 (v0.7.0), celui-ci peut être local (Ollama, LMStudio, vLLM, serveur llama.cpp) ou n'importe quel point de terminaison distant compatible OpenAI (xAI, OpenAI, Anthropic via shim OpenAI, Google Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks). La sélection se fait par la variable d'env AI_MEMORY_LLM_BACKEND ; les clés API par fournisseur via XAI_API_KEY / OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY / DEEPSEEK_API_KEY / MOONSHOT_API_KEY / DASHSCOPE_API_KEY / etc. ou la canonique AI_MEMORY_LLM_API_KEY.

Les niveaux contrôlent les fonctionnalités, pas les modèles — et post-#1067 (v0.7.0), les niveaux contrôlent les fonctionnalités, pas les fournisseurs non plus. Le drapeau --tier contrôle quels outils sont exposés. Le backend LLM + le modèle sont configurables indépendamment via les variables d'env AI_MEMORY_LLM_BACKEND + AI_MEMORY_LLM_MODEL (ou via la section canonique [llm] dans ~/.config/ai-memory/config.toml — voir docs/CONFIG_SCHEMA.md pour le schéma entreprise v0.7.x et l'outil de migration). Par exemple, exécutez le niveau autonome (surface complète de 101 entrées + reclassement) contre xAI Grok 4 via l'alias compatible 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

Le drapeau --tier doit être passé dans les arguments MCP -- le paramètre de niveau config.toml n'est pas utilisé lorsque le serveur est lancé par un client 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

L'outil memory_capabilities rapporte le niveau actif, les modèles chargés et les capacités disponibles à l'exécution.

Outils MCP

Ces 101 outils (profil complet ; décompte canonique via Profile::full().expected_tool_count() dans src/profile.rs) sont disponibles pour toute IA compatible MCP lorsqu'elle est configurée comme serveur MCP (la page de preuve figée v0.6.4 liste la base de 63 outils ; le tableau ci-dessous documente le sous-ensemble principal que la plupart des clients utilisent au quotidien) :

API HTTP

92 enregistrements de routes / 78 chemins d'URL uniques sur 127.0.0.1:9077. Commencez par ai-memory serve. Le tableau ci-dessous montre les points de terminaison REST les plus couramment utilisés ; voir docs/API_REFERENCE.md pour la surface complète (gouvernance, fédération, abonnements, graphe de connaissances, quotas, approbations SSE).

Sécurité : Le serveur HTTP se lie à 127.0.0.1 et est livré sans authentification configurée par défaut, avec CORS permissif. Définissez api_key dans config.toml pour exiger l'en-tête x-api-key sur chaque requête (la forme héritée du paramètre de requête ?api_key= est dépréciée à partir de la v0.7.0 — #1574), et définissez AI_MEMORY_REQUIRE_API_KEY=1 pour refuser catégoriquement le démarrage sans clé (#1458). N'exposez pas au réseau sans authentification (et préférez TLS via --tls-cert/--tls-key ou un proxy inverse).

Commandes CLI

89 sous-commandes de premier niveau sous --features sal OU --features sal-postgres (87 dans la version par défaut ; l'écart de 2 variantes est Migrate + SchemaInit, toutes deux conditionnées #[cfg(feature = "sal")] selon src/daemon_runtime.rs::Command::{Migrate,SchemaInit} ; était de 40 à la v0.6.4). Exécutez ai-memory <command> --help pour plus de détails sur une commande, ou ai-memory --help pour la liste complète.

Le binaire de premier niveau ai-memory accepte également des drapeaux globaux :

La sous-commande store accepte des drapeaux supplémentaires :

La sous-commande mcp accepte un drapeau supplémentaire :

Score de rappel

Chaque requête de rappel classe les souvenirs selon 6 facteurs :

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

Niveaux de mémoire

Comportements automatiques

• Extension de TTL au rappel : les souvenirs courts gagnent +1 heure, les souvenirs moyens gagnent +1 jour
• Promotion automatique : les souvenirs de niveau moyen accédés plus de 5 fois sont promus en long terme (expiration effacée)
• Renforcement de priorité : toutes les 10 consultations, la priorité augmente de 1 (plafonnée à 10)
• Détection de contradiction : avertit lorsqu'un nouveau souvenir entre en conflit avec un existant dans le même espace de noms
• Dédoublonnage : upsert sur titre+espace de noms ; le niveau n'est jamais rétrogradé lors d'une mise à jour

TTL configurable

Les TTL par défaut (6 heures pour court, 7 jours pour moyen) peuvent être remplacés dans ~/.config/ai-memory/config.toml sous la section [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)

Les cinq champs sont optionnels -- omettez-en un pour conserver la valeur par défaut. Définissez une valeur à 0 pour désactiver l'expiration pour ce niveau. Les valeurs sont limitées à un maximum de 10 ans ; les valeurs d'extension négatives sont limitées à 0.

Note : La configuration est chargée une fois au démarrage du processus. Les modifications de config.toml nécessitent le redémarrage du processus ai-memory (serveur MCP, démon HTTP ou CLI) pour prendre effet.

Archive

Lorsque le ramasse-miettes fait expirer un souvenir, il peut être archivé au lieu d'être définitivement supprimé. Les souvenirs archivés sont déplacés vers un magasin séparé et peuvent être consultés, restaurés ou purgés ultérieurement.

Configuration

Activez l'archivage dans ~/.config/ai-memory/config.toml :

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

Commandes CLI

La sous-commande archive gère l'archive :

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

Note : Les souvenirs restaurés voient leur expires_at effacé (deviennent permanents jusqu'à la prochaine attribution de TTL).

Outils MCP

Quatre outils d'archive sont disponibles pour les clients MCP :

Points de terminaison HTTP

Sécurité

ai-memory inclut un renforcement sur tous les chemins d'entrée :

• Sécurité transactionnelle -- toutes les opérations de base de données en plusieurs étapes utilisent des transactions ; aucune écriture partielle en cas d'échec
• Prévention des injections FTS -- les entrées utilisateur sont assainies avant d'atteindre les requêtes FTS5 ; les caractères spéciaux sont échappés
• Assainissement des erreurs -- les chemins internes de la base de données et les détails système sont retirés des réponses d'erreur ; les clients voient des types d'erreur structurés (NOT_FOUND, VALIDATION_FAILED, DATABASE_ERROR, CONFLICT)
• Limites de taille du corps -- les corps des requêtes HTTP sont plafonnés à 50 Mo via DefaultBodyLimit d'Axum
• Limites des opérations groupées -- les points de terminaison de création groupée imposent des tailles de lot maximales pour prévenir l'épuisement des ressources
• CORS -- couche CORS permissive activée pour les flux de développement en localhost
• Validation des entrées -- chaque chemin d'écriture valide la longueur du titre, la longueur du contenu, le format de l'espace de noms, les valeurs source, la plage de priorité (1-10), la plage de confiance (0.0-1.0), le format des étiquettes, les valeurs de niveau, les types de relation et le format d'ID
• Validation des liens lors de la synchronisation -- tous les liens sont validés (les deux ID, type de relation, pas d'auto-liens) avant l'importation durant les opérations de synchronisation
• Couleur thread-safe -- la détection de couleur du terminal utilise AtomicBool pour un accès concurrentiel sûr
• HTTP local uniquement -- le serveur HTTP se lie à 127.0.0.1 par défaut ; non exposé au réseau
• Mode WAL -- Journalisation en écriture anticipée SQLite pour des lectures concurrentes sûres pendant les écritures

Documentation

Licence

Droits d'auteur 2026 AlphaOne LLC.

Sous licence Apache License, Version 2.0 (la « Licence ») ; vous ne pouvez pas utiliser ce fichier sauf en conformité avec la Licence. Vous pouvez obtenir une copie de la Licence à l'adresse

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

Sauf si requis par la loi applicable ou convenu par écrit, le logiciel distribué sous la Licence est distribué « EN L'ÉTAT », SANS GARANTIES NI CONDITIONS D'AUCUNE SORTE, expresses ou implicites. Voir la Licence pour les termes spécifiques régissant les autorisations et les limitations sous la Licence.