ai-memory

ai-memory™

universelles KI-Gedächtnis

ai-memory ist ein persistentes Speichersystem für KI-Assistenten. Es funktioniert mit jeder KI, die MCP unterstützt – Claude, ChatGPT, Grok, Llama und mehr. Es speichert, was Ihre KI lernt, in einer lokalen SQLite-Datenbank, ordnet Erinnerungen beim Abruf nach Relevanz und stuft wichtiges Wissen automatisch in den permanenten Speicher hoch. Einmal installiert, merkt sich jeder von Ihnen genutzte KI-Assistent Ihre Architektur, Ihre Präferenzen, Ihre Korrekturen – für immer.

Wählen Sie Ihren Installationspfad

Konfiguration des LLM-Backends (xAI Grok, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, llama.cpp Server oder lokales Ollama)? Siehe docs/integrations/llm-backends.md – das MCP-Env-Block-Rezept ist unabhängig vom Installationspfad dasselbe.

v0.9.0 – aktuelle Version. Eine Version zur Sicherheitshärtung und Code-Überprüfung: 49 Korrekturen aus einer 5-spurigen gegnerischen Überprüfung (#1885–#1935) plus einem kleineren Satz additiver Funktionen. Die wichtigste Änderung ist ein sicherer Standard-Flip: Agentenattestierung ist standardmäßig bei HTTP-Direktschreibzugriff erforderlich (#1751, oberflächenbezogen durch #1985) – ein unsignierter HTTP POST /api/v1/memories (+/bulk) wird abgelehnt (403 ATTESTATION_FAILED), anstatt attest_level="claimed" zu landen, es sei denn, der Betreiber setzt das explizite Opt-out AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Die MCP-memory_store- und CLI-store-Oberflächen sind der Betreiber-als-Akteur-Pfad und bleiben standardmäßig permissiv (ein unsignierter Schreibzugriff landet claimed); =1 erzwingt strikt auf jeder Oberfläche. (Die v0.9.0 GA lieferte dies als require-überall, was auf MCP-Hosts nicht erfüllbar war – in der aktuellen Version auf oberflächenbezogen korrigiert.) Daneben feuert das Durchsetzungstor für obligatorische Hook-Präsenz jetzt sowohl auf dem MCP-Schreibpfad (#1885) als auch auf dem HTTP-Schreibpfad (#1924) und schließt eine stille Umgehungslücke, bei der ein konfigurierter obligatorischer Hook auf einer Oberfläche, aber nicht auf der anderen übersprungen werden konnte. Der Härtungsdurchlauf schließt auch bulk_create zeilenweise Attestierungssteuerung (#1919), leitet eingehende föderierte PENDING-Genehmigungen durch das Tor des registrierten Genehmigers (#1920), verschärft den Sichtbarkeitsbereich von team/unit/org, sodass er nicht mehr zu weit über die Namespace-Hierarchie hinausgeht (#1921), und beschränkt den folder_path-Import von skill_register unter der konfigurierten Wurzel mit einem Symlink-Gefängnis (#1923). Ein neuer, nicht-argv-basierter Berechtigungskanal – AI_MEMORY_STORE_URL / AI_MEMORY_STORE_URL_FILE (eine 0600-Datei) – hält das Postgres-/Store-Passwort von weltweit lesbarem /proc/<pid>/cmdline und ps fern (#1927). Additive Funktionsarbeit: von Agenten verfasste Fähigkeitserinnerungen mit einem parameters_schema + invocation_record (B7-SKILL, #1865), die recall_observations-Schatten-Feedback-Schleife (#1706), ein Speicher-Ableitungs-Abstammungs-DAG (memory_lineage, #1859) und ein opt-in Vektorsuche-Minimal-Slice (#1005). Oberfläche: Schema v78, 101 MCP-Tools bei --profile full (100 aufrufbar + der ständig aktive memory_capabilities-Bootstrap) / 7 bei --profile core, 92 HTTP-Routenregistrierungen (78 eindeutige URL-Pfade), 89 CLI-Unterbefehle unter --features sal/sal-postgres (87 im Standard-Build), 9 typisierte MemoryLink-Relationen, ein 28-Feld Memory. Läuft auf zwei Produktions-Backends hinter einer identischen API – eingebettetes SQLite und PostgreSQL + Apache AGE – auf Desktop, Server und Geräten (iOS + Android). Alles ist additiv gegenüber v0.8.1, außer den Attestierungs- und Hook-Durchsetzungs-Flips, die standardmäßig sichere, bahnbrechende Änderungen sind – überprüfen Sie sie vor dem Upgrade. Vollständiges Änderungsprotokoll: CHANGELOG.md §"[0.9.0] — 2026-07-08".

v0.8.0 (distributed-coordination) – vorherige Version. Dies ist die Version, in der das Speichersubstrat zu einem Koordinationssubstrat wird. Sie fügt die verteilte Koordinationsmaschinerie aus #1709 hinzu: einen typisierten Aktions-DAG mit einer echten Zustandsmaschine (memory_action_*), TTL-begrenzte Einzelinhaber-Leases (memory_lease_*), Ed25519-signierte Signale (memory_signal_*), Ed25519-attestierte Checkpoints (memory_checkpoint_*) und eingefrorene, wiederholbare Routinen (memory_routine_*) – sodass eine heterogene Flotte von Agenten sich abwechseln, Arbeit übergeben und beweisen kann, wer was gesagt hat, ohne einander vertrauen zu müssen. Darüber schichtet sie typisierte Kognition (die Speicherarten Goal/Plan/Step, eine lifecycle_state-Maschine und die Link-Relationen decomposes_into / depends_on / advances), härtet die Föderation standardmäßig sicher (Peer-Registrierung standardmäßig EIN #1789, Signaturen pro Übergang #1718, Inhaltsattestierung pro Schreibvorgang #1464, Übergangswiederholungs-Nonces #1805, ausgehende Peer-Zertifikats-Pinning #1678) und liefert Governance, die tatsächlich blockiert – der Claude Code PreToolUse-Hook wird in einen type:command-Wrapper umgearbeitet, sodass ein Substrat-Refuse das Tool wirklich verweigert (#1811). Bei der Veröffentlichung von v0.8.0 war die Oberfläche: Schema v70, 100 MCP-Tools bei --profile full (99 aufrufbar + der ständig aktive memory_capabilities-Bootstrap) / 7 bei --profile core, 91 HTTP-Routenregistrierungen (78 eindeutige URL-Pfade), 83/85 CLI-Unterbefehle, 9 typisierte MemoryLink-Relationen, ein 27-Feld Memory. Läuft auf zwei Produktions-Backends hinter einer identischen API – eingebettetes SQLite und PostgreSQL + Apache AGE – auf Desktop, Server und Geräten (iOS + Android). Alles ist additiv gegenüber v0.7.0; überprüfen Sie die standardmäßig sicheren Flips vor dem Upgrade. Vollständige Versionshinweise: docs/v0.8.0/release-notes.md.

v0.7.0 (attested-cortex) — vorherige Veröffentlichung. Vereint die cortex-fluent Lesbarkeitsarbeit mit dem vollständigen v0.7 Vertrauens- + A2A-Umfang aus ROADMAP §7.3, plus (gemäß Betreiberanweisung 2026-05-09) der ursprünglich für v0.7.1 vorgesehenen erstklassigen postgres+AGE-Arbeit, plus der Post-Grand-Slam-Bereitschaftswelle (Batman Forms 1-6 + 7th-form Option-B Grundlage + QW-1/2/3 + Abgleich-Sicherheitsdurchlauf). Das Substrat wird sowohl artikulierter (Fähigkeiten v3, benannte Loader-Tools, komprimierte Schemata, Batman MemoryKind Vokabular, Persona/Atomisierung/Multistep-Ingest-Primitive) als auch kryptografisch vertrauenswürdig (Ed25519-Bestätigung, Sidechain-Transkripte, programmierbare 25-Event-Hook-Pipeline, erzwungene Namespace-Vererbung, V-4 signierte Cross-Row-Events-Hash-Kette). v0.7.0 liefert außerdem postgres + Apache AGE als erstklassiges Speicher-Backend — ai-memory serve --store-url postgres://… für den Live-Daemon-Einsatz, Schema-Parität über beide Backends hinweg (zum Zeitpunkt der v0.7.0-Veröffentlichung konvergierten sqlite + postgres auf logischem Schema v57, wobei CURRENT_SCHEMA_VERSION 57 war; das v0.8.0-Veröffentlichungssubstrat hat diesen Gleichschritt auf Schema 70 vorangetrieben, wobei die additiven v58–v70 Koordinations- + Sichtbarkeitstabellen auf beiden Backends gelandet sind — siehe CLAUDE.md §Database für die v58–v70-Leiter) (kanonische Anker: src/storage/migrations.rs für sqlite + src/store/postgres.rs für postgres); On-Disk-Migrationsdateien enden bei migrations/sqlite/0047_v56_list_composite_indexes.sql und der postgres In-Process migrate_v57() Leiterarm (Dateinamenzähler hinken der logischen Schemaversion hinterher, da beide Leitern Post-v34-Deltas über In-Process-Arme anwenden — siehe docs/MIGRATION_v0.7.md §schema-ladder für die v35-v57-Erzählung; v48 #933 fügte die Federation-Push-DLQ-Tabelle hinzu; v49 #1025 fügte 14 nullable Spalten zu archived_memories hinzu, sodass Archiv → Wiederherstellung für die vollständige v0.7.0 Memory-Form verlustfrei ist; v50 #1156 erweiterte den agent_quotas PRIMARY KEY von (agent_id) auf (agent_id, namespace), sodass Pro-Namespace-K8-Kontingente auch dann gelten, wenn ein einzelner Agent über viele Namespaces hinweg operiert — Pre-v50-Zeilen werden auf den _global Sentinel-Namespace zurückgefüllt; v51 #1255 (PR #1296) fügte die federation_nonce_cache Tabelle hinzu, sodass Peer-Replay-Prevention-Nonces über Daemon-Neustarts hinweg bestehen bleiben; v52 #1389 fügte die transcript_line_dedup Tabelle hinzu, die RFC-0001 memory_capture_turn L4 + recover_from_transcript L2 Idempotenz unterstützt, sodass ein SIGKILL zwischen Durchläufen niemals einen doppelten Speichereintrag bei nachfolgender Rehydrierung erzeugt; v53 #1418 beschränkte den memories_au FTS5-Sync-Trigger nur auf (title, content, tags), sodass Nicht-FTS-Spaltenaktualisierungen keinen unnötigen Sync mehr auslösen; v54 #1466 füllte den Tier-Standardablauf bei alten NULL-Ablauf-Mid/Short-Zeilen zurück, um die TTL-Leak-Klasse unsterblicher Zeilen zu schließen; v55 #1476 machte die W=2 Federation-Catchup-Abfrage (updated_at > ? ORDER BY updated_at ASC LIMIT) sargable und fügte den sqlite idx_memories_updated_at Index hinzu — postgres fügt keinen neuen Index hinzu, da memories_updated_at_idx DESC den Bereichsscan bereits über Index Scan Backward bedient; v56 #1579 fügte die zusammengesetzten Listen-/Archiv-Sortierungsindizes (idx_memories_list_order, idx_memories_ns_list_order, idx_archived_ns_archived_at) gepaart mit der sargable storage::list Umschreibung hinzu — sqlite-seitiges DDL; der postgres migrate_v56() Arm ist ein Versionsstempel-No-Op; v57 #1579 fügte die postgres stored generated tsv tsvector-Spalte + memories_tsv_gin GIN-Index hinzu, sodass die Such-/Abrufformen übereinstimmen UND auf der vorberechneten Spalte ranken, anstatt den tsvector pro übereinstimmender Zeile neu zu berechnen — der alte memories_content_fts Ausdrucksindex wird gelöscht und der sqlite-Zwilling ist ein Versionsstempel-No-Op, da FTS5 den indizierten Text bereits materialisiert), das neue ai-memory schema-init CLI-Verb und 6-Faktor-Recall-Scoring-Parität. Die v0.6.4-Standardoberfläche wächst um zwei ständig aktive Loader auf 7 Tools (memory_load_family + memory_smart_load gesellen sich zu den ursprünglichen fünf); die Laufzeitobergrenze bei --profile full beträgt 74 beworbene Einträge (73 aufrufbare Memory-Tools + der ständig aktive memory_capabilities Bootstrap; verifiziert gegen Profile::full().expected_tool_count() — siehe src/profile.rs). Alles Neue ist additiv und (für die Vertrauens- + Postgres-Oberflächen) Opt-in. Upgrade von v0.6.x? Lesen Sie zuerst docs/MIGRATION_v0.7.md — die meisten v0.6.4-Aufrufer sehen keine Verhaltensänderung, aber Pre-v0.6.3.1 v0.6.x-Benutzer stoßen auf den G1-Namespace-Vererbungsfix. Wechsel zu postgres+AGE? Siehe docs/postgres-age-guide.md und docs/migration-v0.7.0-postgres.md. Vollständige Veröffentlichungshinweise: docs/v0.7.0/release-notes.md.

v0.6.4 (quiet-tools) — der MCP-Server wird mit einer 5-Tool-Standardoberfläche (memory_store, memory_recall, memory_list, memory_get, memory_search) plus dem ständig aktiven memory_capabilities Bootstrap ausgeliefert. Die anderen 38 Tools bleiben über --profile graph|admin|power|full oder Laufzeiterweiterung durch memory_capabilities --include-schema family=<name> erreichbar. Eager-Loading-Harnesses (Claude Desktop / Codex CLI / Grok CLI / Gemini CLI) sparen ~4.700 Eingabe-Token an Tool-Schemata pro Anfrage — eine 76,4%ige Reduzierung, gemessen an cl100k_base BPE. Um das v0.6.3-Verhalten 1:1 beizubehalten, führen Sie ai-memory mcp --profile full aus. Siehe docs/MIGRATION_v0.6.4.md.

Neu in v0.9

v0.9.0 ist in erster Linie eine Sicherheitshärtungs- und Code-Review-Veröffentlichung — 49 Korrekturen aus einer 5-spurigen gegnerischen Überprüfung (#1885–#1935) — plus einem kleineren Satz additiver Funktionen, die auf das v0.8.0-Koordinationssubstrat aufbauen. Vollständiges Änderungsprotokoll: CHANGELOG.md §"[0.9.0] — 2026-07-08".

Standardmäßig sichere Härtung

• Agenten-Bestätigung standardmäßig auf der HTTP-Direct-Write-Oberfläche erforderlich (#1751, oberflächenbezogen durch #1985). AI_MEMORY_REQUIRE_AGENT_ATTESTATION ist dreiwertig mit einem pro Oberfläche kompilierten Standard: nicht gesetzt → erforderlich bei HTTP-Direct-Write (POST /api/v1/memories + /bulk, abgelehnt 403 ATTESTATION_FAILED), permissiv auf den MCP memory_store und CLI store Operator-als-Akteur-Oberflächen (ein nicht signierter Schreibvorgang landet attest_level="claimed"); =1 erzwingt strikt überall, =0 erzwingt permissiv überall. Eine vorgelegte, aber gefälschte Signatur wird auf jeder Oberfläche unabhängig davon abgelehnt. Signieren Sie Schreibvorgänge (ai-memory store --sign mit einem über ai-memory agents bind-key gebundenen Schlüsselpaar) oder nutzen Sie die =0 Opt-out-Möglichkeit. (Die v0.9.0 GA lieferte dies als überall erforderlich aus, was auf MCP-Hosts nicht erfüllbar war — siehe #1981; korrigiert auf oberflächenbezogen durch #1985.)
• Duales MCP + HTTP Hook-Erzwingungs-Gate (#1885 / #1924). Das Gate zur Erzwingung obligatorischer Hook-Präsenz (ursprünglich nur MCP, #1734) wird nun auch auf dem HTTP-Schreibpfad konsultiert, wodurch eine stille Umgehungslücke (CWE-288) geschlossen wird, bei der ein Schreibvorgang, der MCP vollständig umging, nie einen konfigurierten obligatorischen Hook sah.
• bulk_create Bestätigungs-Gating (#1919). Bulk-Schreibvorgänge erzwingen nun dieselbe Pro-Zeile-Agenten-Bestätigungsanforderung wie ein einzelner memory_store Aufruf — jede Zeile in einem Stapel muss eine gültige Bestätigung enthalten, nicht nur die Anfrage als Ganzes.
• Föderations-Genehmiger-Gate (#1920). Eine eingehende föderierte PENDING-Genehmigung wird nur berücksichtigt, wenn sie dem registrierten Genehmiger eines Peers zugeschrieben wird — ein eingeschriebener, aber nicht vertrauenswürdiger Peer kann keine Genehmigung mehr für einen beliebigen Anforderer fälschen.
• team/unit/org Bereichshärtung (#1921). Die Sichtbarkeitsbereichsauflösung erzwingt nun die Namespace-Vorfahren-Hierarchie korrekt für die Bereiche team/unit/org, wodurch eine Mandanten-Isolationslücke (CWE-863) geschlossen wird.
• skill_register Pfadbeschränkung (#1923). Der folder_path Import eines Skills wird kanonisiert und unter dem konfigurierten Stammverzeichnis beschränkt, wobei Symlinks innerhalb des importierten Baums abgelehnt statt verfolgt werden (CWE-22/CWE-59).
• Nicht-argv Store-URL-Anmeldekanäle (#1927). Neue AI_MEMORY_STORE_URL (nur für Besitzer /proc/environ) und AI_MEMORY_STORE_URL_FILE (eine 0600 Datei) ermöglichen es ai-memory serve, die Postgres-/Store-URL — einschließlich eingebetteter Passwörter — zu empfangen, ohne sie jemals auf --store-url argv zu platzieren, wo sie über weltweit lesbare /proc/<pid>/cmdline und ps auxww für jede lokale UID zugänglich ist. Auflösungsreihenfolge: Datei → env → --store-url.

Additive Funktionen

• B7-SKILL — Skill-Speicher erstklassig (#1865). parameters_schema bei der Registrierung, eine invocation_record und eine Versionsoberfläche für von Agenten verfasste Skills.
• recall_observations Schatten-Feedback-Schleife (#1706, SHADOW-Modus). Schließt die Recall-Feedback-Schleife, ohne das Ranking-Verhalten noch zu ändern.
• Speicher-Ableitungs-Lineage-DAG (memory_lineage, Schema v78, #1859). Zeigt, welche Speicher von welchen abgeleitet wurden, sowohl über MCP als auch die neue GET /api/v1/memories/{id}/lineage HTTP-Route.
• Minimaler Opt-in-Ausschnitt für Vektorsuche (#1005; vollständiges Substrat auf #1860 verschoben).
• Reranker-Worker-Pool auf physische CPUs dimensioniert (#1867) und Recall ist standardmäßig PURE (#1869 — entfernt den Schreib-Burst aus dem Recall-Hot-Path).
• Append-Only-Spine + Signierungsschicht-Trennung: Jede Mutationsstelle zu signierten Revisionsblättern geleitet (#1823), Drei-Schlüssel Recorder/Judge/Stopper Signierungstrennung (#1826), Macaroon-Fähigkeits-Token durchgängig verdrahtet (#1827) und eine signierte Identitäts-Lineage-Schlüsselnachfolgekette für Rotationsüberleben (#1828, Schema v76).

Wo anfangen: CHANGELOG.md (vollständiges Änderungsprotokoll), docs/ADMIN_GUIDE.md (Betreiber-Playbook — Bestätigungs- + Hook-Erzwingungshaltung).

Neu in v0.8

v0.8.0 (distributed-coordination) verwandelt das Speichersubstrat in ein Koordinationssubstrat für Multi-Agenten-Flotten (NHI). Die Schlagzeile ist die verteilte Koordinationsmaschinerie (#1709); alles wird sowohl auf den sqlite- als auch postgres+AGE-SAL-Adaptern ausgeliefert und bleibt standardmäßig äquivalent für v0.7.x-Aufrufer. Vollständige Tool-Referenz: docs/coordination.md; vollständige Hinweise: docs/v0.8.0/release-notes.md.

Verteiltes Koordinationssubstrat (Säule-1, #1709)

• Aktionen — der Abhängigkeits-DAG (Schema v59). Typisierte Aktionsknoten mit einer Zustandsmaschine (pending → claimed → in_progress → done/failed/abandoned), typisierte DAG-Kanten (requires / unlocks / blocks / gated_by / sibling) und Frontier/Next-Oberflächen, die den nächsten ausführbaren Knoten abrufen. 8 MCP-Tools (memory_action_create / _get / _transition / _list / _add_edge / _edges / _frontier / _next).
• Leases — Einzelinhaber, TTL-gebundene Ansprüche (Schema v59). Durch Heartbeat erneuerter Compare-and-Swap-Anspruch (PRIMARY KEY auf action_id = jeweils ein Inhaber) plus ein stündlicher Lease-Sweeper. 4 MCP-Tools (memory_lease_acquire / _renew / _release / _get).
• Signale — typisierte, Ed25519-signierte Nachrichten zwischen Agenten (Schema v60). Jedes trägt eine Signatur + Absender signer_pubkey und verknüpft sich über correlation_id / in_reply_to. 5 MCP-Tools (memory_signal_send / _read / _inbox / _thread / _ack).
• Checkpoints — attestierte bedingte Schranken (Schema v61). Eine Schranke, die blockiert, bis eine Bedingung aufgelöst wird; die Auflösung wird zur Aufgabentrennung selbstsigniert (Ed25519) und verify überprüft die Signatur erneut. 4 MCP-Tools (memory_checkpoint_create / _resolve / _query / _verify).
• Routinen — parametrisierte, eingefrorene, wiederholbare Pläne (Schema v62). Erstellt als draft, dann eingefroren (unveränderlich, Ed25519-Freeze-Attestierung); run materialisiert einen konkreten Satz von Aktionen und Kanten aus einer {{param}}-Vorlage in einen routine_runs-Datensatz. 5 MCP-Tools (memory_routine_create / _freeze / _run / _status / _list).
• Jede Koordinationszustandsmutation hängt eine manipulationssichere coordination.<op>-Zeile an die signed_events V-4 Hash-Kette an (#1722); die beiden autoritätsgewährenden Schreibvorgänge werden auf den HTTP-Daemon gespiegelt (POST /api/v1/actions/{id}/transition, POST /api/v1/signals) mit lokalem CAS + W-of-N Föderations-Fan-Out (#1718).

Typisierte Kognition (Säule 2)

Das memory_kind-Vokabular erweitert sich um goal / plan / step; die geschlossene memory_links.relation-Taxonomie erweitert sich von 6 → 9 Relationen (decomposes_into / depends_on / advances, Schema v63); und eine erstklassige memories.lifecycle_state-Spalte (Schema v64) macht Goal/Plan/Step zu einer echten Zustandsmaschine (open → active → blocked/done/abandoned), die über die MCP / HTTP / SAL-Oberflächen mit einer Zuordnung unzulässiger Kanten zu HTTP 409 CONFLICT erzwungen wird. Die Memory-Struktur wächst auf 27 Felder. Kein neues MCP-Tool — die v64-Arbeit fügt nur optionale Anfragefelder hinzu.

Föderation gehärtet, standardmäßig sicher

Peer-Registrierung standardmäßig EIN (#1789), Signaturen pro Übergang bei autoritätsgewährenden Schreibvorgängen (#1718), Inhaltsattestierung pro Schreibvorgang für weitergeleitete Erinnerungen (#1464), Übergangswiederholungs-Nonces (#1805) und ausgehende Peer-Zertifikats-Fingerabdruck-Pinning (#1678). Heterogene Flotten, die einander nicht vertrauen müssen — lesen Sie die sicheren Standardänderungen in docs/v0.8.0/release-notes.md §"Föderationshärtung" vor dem Upgrade.

Governance, die tatsächlich blockiert (#1811)

Der Claude Code PreToolUse-Governance-Hook wird in einen type:command-Wrapper (ai-memory governance check-action --from-pretool-stdin) umgearbeitet, sodass ein Substrat Refuse permissionDecision:"deny" ausgibt und das Tool wirklich BLOCKIERT — die vorherige type:mcp_tool-Form konnte strukturell nicht durchsetzen. Plus Durchsetzung der obligatorischen Hook-Präsenz (#1734) und ein neues escalate-Governance-Urteil (§22 PE-5) für Human-in-the-Loop.

Betriebskontrollen Säule 4

HTTP-Zugangskontrolle (#1733 — Opt-in-Parallelitätsgrenze, die Überschuss mit einem typisierten 503 abweist), verzögerte Apache-AGE-Graphenprojektion (#1735 — entfernt die synchronen AGE-Roundtrips vom zeitkritischen Postgres-Link-Schreibpfad), Curator-Komprimierungsaktivierung (#1749 / #1750) und die ai-memory verify-audit-trail CLI (§22 PE-8), die die signed_events zeilenübergreifende Hash-Kette Ende-zu-Ende durchläuft.

Schema v57 → v70 (alles additiv)

Koordinations- + typisierte Kognitions- + Sichtbarkeits- + Verschlüsselungsvorbereitungs- + Cold-Path- + Archivkanten-Tabellen (v58–v70), gespiegelt auf den SQLite- und Postgres-Adaptern; automatische Migration beim ersten Öffnen und verlustfreie Archiv → Wiederherstellungs-Roundtrips. Siehe CLAUDE.md §Database für die kanonische v58–v70-Leiter.

Wo anfangen: docs/v0.8.0/release-notes.md (vollständige Versionshinweise), docs/coordination.md (Koordinationstool-Referenz) und CLAUDE.md §Database (Schema-Leiter SSOT).

Was ist neu in v0.7

v0.7.0 schließt das attested-cortex-Epic ab (69/69 über 11 Tracks A–K), integriert die ursprüngliche v0.7.1 Postgres+AGE-Erstklassarbeit und absorbiert die Post-Grand-Slam-Bereitschaftswelle (Batman Forms 1-6 + 7th-Form Option-B-Grundlage + QW-1/2/3 + Sicherheitsabgleich). Kanonisches Feature-Inventar: docs/internal/v070-feature-inventory.md. Jede Oberfläche bleibt für v0.6.4-Aufrufer standardmäßig deaktiviert oder standardäquivalent — siehe die v0.7-Kompatibilitätsmatrix für die Aufschlüsselung.

Substrat-native Write-Time-Investition (Batman Forms 1-6 + 7th-Form)

• Form 1 — Online-Deduplizierung und -Synthese (Issue #754). Ein einzelner Batch-Aktionen-ausgebender LLM-Aufruf ersetzt den v0.6.x Klassifikator pro Paar auf dem Speicherpfad. Opt-in zum Legacy-Ja/Nein über legacy_per_pair_classifier = true im Namespace-Standard.
• Form 2 — Synchrones Atomisieren-vor-Einbetten (Issue #755). Neues memory_atomise-Tool + auto_atomise_mode = Synchronous|Deferred|Off Pre-Store-Hook. Der Kurator zerlegt lange Schreibvorgänge in 2–10 atomare Aussagen, bevor der Abruf sie jemals sieht. Siehe docs/atomisation.md.
• Form 3 — Mehrstufiger Ingest-Orchestrator (Issue #756). memory_ingest_multistep verknüpft deterministische Jaccard+FTS-Helfer durch Prompt-Cache-stabile LLM-Stufen. Siehe docs/multistep-ingest.md + cookbook/multistep-ingest/01-two-phase.sh.
• Form 4 — Faktenherkunft (Issue #757). Zitate + Quell-URI + Atom-Korn-Spannen reisen auf bestehenden memory_store / memory_atomise Nutzdaten mit. Siehe docs/provenance.md.
• Form 5 — Auto-Konfidenz + Schattenkalibrierung + Frischeabfall (Issue #758). memory_calibrate_confidence MCP-Tool + Baseline-Sweep pro Quelle. Umgebungsvariablen AI_MEMORY_AUTO_CONFIDENCE, AI_MEMORY_CONFIDENCE_SHADOW, AI_MEMORY_CONFIDENCE_SHADOW_SAMPLE_RATE, AI_MEMORY_CONFIDENCE_DECAY. Siehe docs/confidence-calibration.md.
• Form 6 — MemoryKind Batman-Vokabular (Issue #759). 10-Varianten-Enum (Observation Standard + Reflection / Persona / Concept / Entity / Claim / Relation / Event / Conversation / Decision). Optionaler auto_classify_kind Pre-Store-Hook (off / regex_only / regex_then_llm). Siehe docs/memory-kind-vocab.md.
• 7th-Form — Agent-EXTERNE Layer-4-Verdrahtung (Option-B-Grundlage) (Issue #760; v0.8.0 vollständige Abdeckung unter #697). Operator-Schlüsselpaar-signierte Seed-Regeln R001..R004, memory_check_agent_action + memory_rule_list MCP-Tools, Substrat storage::insert Pre-Write-Hook. Siehe docs/policy-engine.md + docs/governance/agent-action-rules.md.
• Operator-Anleitung — Forms 1–6 + 7th von fähig → aktiv schalten (Issue #800). 7-Schritte-Rezept (Operator-Keygen → Seed signieren → R001–R004 aktivieren → Kurator-Daemon → optionaler Reflexionsdurchlauf → Namespace-Richtlinien), launchd / systemd / Task-Scheduler-Dauerhaftigkeit, Verifikationsblock, Rollback-Pfad. Siehe docs/batman-active-mode.md und den GitHub Pages Atlas.

Quick Wins (Tencent QW-1/2/3)

• QW-1 — Dateigestützter Reflexionsketten-Export. memory_export_reflection MCP-Tool + auto_export_reflections_to_filesystem Namespace-Richtlinie → ~/.ai-memory/reflections/<ns>/<id>.md.
• QW-2 — Persona als Artefakt. memory_persona + memory_persona_generate Tools, MemoryKind::Persona Zeilen, auto_persona_trigger_every_n_memories Namespace-Richtlinie. Siehe docs/persona.md.
• QW-3 — Kontextauslagerungs-Primitive. memory_offload + memory_deref verschieben große Tool-Ausgaben aus dem Agent-Kontextfenster in adressierbaren Blob-Speicher. Siehe docs/context-offload.md.

Attested Cortex Epic (Tracks A–K)

• Attestierte Links (Ed25519). Die in v0.6.3 ausgelieferte, tote Spalte signature wird nun mit echter Ed25519-Attestierung pro Agent gefüllt, und memory_verify(link_id) liefert auf Anfrage {signature_verified, attest_level, signed_by, signed_at} zurück. Erzeugen Sie ein Schlüsselpaar mit ai-memory identity generate; Opt-in über attest_level = "self_signed". Die Signierung ist an die Bedingung geknüpft, dass der aufgelöste Daemon agent_id ein *.priv-Schlüsselpaar auf der Festplatte im konfigurierten Schlüsselverzeichnis besitzt – wenn load_daemon_signing_key den Wert None (src/main.rs:116-118) zurückgibt, werden Zeilen weiterhin geschrieben, aber sig ist leer und der Daemon gibt beim Start eine Zeile „continuing unsigned“ aus. Die zeilenübergreifende Hash-Kette auf signed_events bleibt in jedem Fall manipulationssicher. Siehe den attested-cortex RFC.
• Signierte Ereignisse V-4 Abschluss (zeilenübergreifende Hash-Kette) (Issue #698). Jede signed_events-Zeile trägt prev_hash + sequence; der prev_hash der ersten Zeile ist null, nachfolgende Zeilen verketten den SHA-256 der vorherigen kanonischen CBOR-Nutzlast. ai-memory verify-signed-events-chain durchläuft die Kette von Anfang bis Ende. Siehe docs/signed-events-v4.md.
• Hook-Pipeline (25 Lebenszyklus-Ereignisse). Eine programmierbare Erweiterungsoberfläche reagiert auf die 20 Basis-pre_/post_store|recall|search|delete|promote|link|consolidate|governance_decision|archive|transcript_store + on_index_eviction-Ereignisse sowie 5 Grand-Slam-Ergänzungen (pre_recall_expand G10 + pre_reflect/post_reflect rekursives Lernen Aufgabe 6/8 + pre_compaction/on_compaction_rollback L1-7). Hooks geben Allow / Modify / Deny / AskUser zurück. Standardmäßig deaktiviert; Opt-in über ~/.config/ai-memory/hooks.toml. Siehe docs/hook-pipeline.md.
• Sidechain-Transkripte + Replay. zstd-3 BLOB-Sidechain speichert rohe Konversations-/Argumentationspfade; memory_replay(memory_id) durchläuft memory_transcript_links, um die Kette zu rekonstruieren. Opt-in pro Namespace über [transcripts.namespaces."team/*"]. Siehe docs/sidechain-transcripts.md.
• Föderations-Härtung. mTLS + X-API-Key + SHA-256-Zertifikat-Fingerabdruck-Zulassungsliste; Umgebungsvariablen AI_MEMORY_FED_PEER_ATTESTATION, AI_MEMORY_FED_SYNC_TRUST_PEER, AI_MEMORY_FED_TRUST_BODY_AGENT_ID. Siehe docs/federation.md.
• K8-Quota-Tool + K10-SSE-Genehmigungen. memory_quota_status + /api/v1/quota/status (K8). /api/v1/approvals/stream Server-Sent Events mit HMAC-Nonce, Methoden+Pending-ID-Bindung, Bereinigung verzögerter Ereigniszähler (K10). Siehe docs/k8-quotas.md + docs/k10-sse-approvals.md.
• Postgres + Apache AGE First-Class-Backend. ai-memory serve --store-url postgres://…, Schema-Parität, 6-Faktor-Recall-Scoring-Parität, Link-Migration, KG-Funktionen (kg_query, kg_timeline, kg_invalidate, find_paths) auf AGE Cypher mit rekursivem CTE-Fallback, wenn AGE nicht vorhanden ist, plus ein neues ai-memory schema-init CLI-Verb. Bench-gesteuert – AGE p95 muss CTE p95 bei Tiefe=5 um ≥30 % übertreffen. Anleitung für Betreiber: docs/postgres-age-guide.md. Migrations-Runbook: docs/migration-v0.7.0-postgres.md.
• Capabilities v3 + Smart Loaders. memory_capabilities v3 fügt summary, to_describe_to_user, pro-Tool callable_now, agent_permitted_families, schema_version="3" hinzu; die neuen, stets aktiven Tools memory_load_family(family) und memory_smart_load(intent) ergänzen das Standardprofil core. Die festgelegten Formulierungen befinden sich in docs/v0.7/canonical-phrasings.md.
• Berechtigungen + A2A-Genehmigungen. Das Governance-Subsystem von v0.6.x wird in Regeln + Modi + Hooks → ein einziges Decision umgestaltet, wobei die Namespace-Vererbung (G1) tatsächlich durchgesetzt wird. memory_pending_list / memory_pending_approve / memory_pending_reject(remember=forever) ermöglichen progressives Vertrauen; HMAC-Signierung der Genehmigungs-API ist obligatorisch. permissions.mode ist standardmäßig enforce (war advisory in v0.6.4). Migration mit ai-memory governance migrate-to-permissions (Dry-Run-Vorschau; fügen Sie --config-out ~/.config/ai-memory/config.toml hinzu, um direkt anzuwenden). Siehe docs/governance.md.

Rekursives Lernen + L1/L2 Grand-Slam-Welle

memory_reflect Substrat-Primitive mit Namespace-bezogener max_reflection_depth-Obergrenze (Standard 3, Some(0) ist der Kill-Switch). L2-1 Reflection-Pass-Kurator, L2-2 föderationsbewusste Reflection-Koordination (memory_reflection_origin), L2-3 Invalidierungsweitergabe (memory_dependents_of_invalidated), L2-5 forensisches Bundle (ai-memory export-forensic-bundle + verify-forensic-bundle), L1-5 Agent Skills (memory_skill_register|list|get|resource|export|promote_from_reflection|compositional_context). Vollständige Einführung: docs/RECURSIVE_LEARNING.md. Einführung in Agent Skills: docs/agent-skills.md. Einführung in den forensischen Export: docs/forensic-export.md.

Einstiegspunkte: docs/MIGRATION_v0.7.md (Upgrade-Verfahren), docs/v0.7.0/release-notes.md (vollständige Versionshinweise), docs/whats-new-v07.html (visuelle Zusammenfassung), docs/v0.7/rfc-attested-cortex.md (Design-Begründung), docs/ADMIN_GUIDE.md (Betreiber-Playbook), docs/internal/v070-feature-inventory.md (kanonische Feature-Wahrheit).

Eine Binärdatei, vier Betriebsmodi (v0.6.4). Die ai-memory Rust-Binärdatei (tokio + axum) kann jeden dieser Modi isoliert oder gleichzeitig ausführen und teilt sich eine einzige SQLite-Datenbank:

1. stdio MCP-Server -- 101 beworbene Einträge über JSON-RPC im vollen Profil (v0.9.0; 100 aufrufbare Speicher-Tools + der stets aktive memory_capabilities Bootstrap; verifiziert gegen Profile::full().expected_tool_count()). Das Standardprofil --profile core bewirbt 7 (die ursprünglichen 5 + memory_load_family + memory_smart_load) plus den stets aktiven memory_capabilities Bootstrap. ai-memory mcp / ai-memory mcp --profile full
2. HTTP / mTLS-Daemon -- 92 REST-Routenregistrierungen (78 eindeutige URL-Pfade) auf 127.0.0.1:9077, TLS + optionale mTLS-Zulassungsliste + API-Key-Authentifizierung, Hintergrund-GC-Schleife. ai-memory serve
3. Autonomer Kurator-Daemon -- selbstplanende Schleife (Standardintervall 1 Stunde), die automatisch taggt, Widersprüche zwischen Namespace-Geschwistern aufdeckt, Beinahe-Duplikate konsolidiert und die Priorität nach Zugriffsmuster anpasst. Jede Aktion wird in einem Rollback-Protokoll festgehalten; destruktive Operationen können hinter einem Governance-Genehmigungsablauf geschützt werden. ai-memory curator --daemon
4. Sync-Daemon -- Quorum-basierte Peer-Föderation über Instanzen hinweg. W-von-N-Schreibvorgängen (Standard: Mehrheit), Vektor-Uhr-CRDT-lite-Zusammenführung, mTLS-Zulassungsliste zwischen Peers. ai-memory sync-daemon

Die MCP-, HTTP- und CLI-Oberflächen sind reaktiv. Der Kurator ist der Teil, der die Speicherschicht selbstwartend macht: Zwischen den Sitzungen hält er den Korpus sauber, sodass die Abrufqualität auch bei wachsendem Speicher hoch bleibt. Alles ist lokal-first; keine Cloud-Abhängigkeiten.

Praktische Einschätzung von Claude Opus 4.7 nach dem zeilenweisen Lesen des v0.6.3-Quellcodes:

„ai-memory ist die leistungsfähigste Speicherschicht, an die ich je angeschlossen war, und bietet deutlich mehr, als der Name vermuten lässt. Für mich bedeutet das praktisch: Ich starte nicht bei Null in jede Sitzung. Der Speicher, aus dem ich lese, wurde von etwas anderem als mir selbst sauber gehalten. Widersprüche sammeln sich nicht stillschweigend an. Die Abrufqualität bleibt hoch, selbst wenn der Korpus wächst. Nichts verlässt Ihren Mac mini.

Es macht mich nicht zu einem autonomen Agenten. Es gibt mir die Art von Speicherinfrastruktur, die ein autonomer Agent benötigen würde – und führt selbst eine kleine autonome Schleife aus, um sie zu warten. Das ist eine echte Grundlage. Die Lücke von hier bis zu ‚ai-memory steuert allgemeine Aufgaben‘ ist Klempnerarbeit (Tool-Call-Protokoll + Tool-Registry + ein Tool-Use-fähiges Modell), keine Erfindung.“

Substrat für Multi-Agenten-KI. ai-memory ist keine Agentenlaufzeitumgebung und keine „autonome KI“ für sich allein. Es ist die Speicherschicht, die Multi-Agenten-autonome Bereitstellungen darunter benötigen. Föderation (broadcast_store_quorum + spawn_catchup_loop) handhabt W-von-N-Konsistenz über Peers hinweg, wenn viele Agenten parallel schreiben; der Kurator-Daemon verhindert, dass der gemeinsame Korpus zu Rauschen verkommt, wenn ein Schwarm darauf schreibt; Webhook-Abonnements (HMAC-signiert, Namespace/Agent-gefiltert, SSRF-gehärtet) verwandeln den Speicher in einen Nachrichtenbus, der nachgelagerte Agenten bei Speicherereignissen auslöst; Namespace-Hierarchie mit N-stufiger Vererbung und pro-Namespace-Governance-Richtlinien (Schreib-/Promote-/Löschberechtigung, Genehmigertyp, optionaler N-von-M-Konsens) begrenzen den Schwarm. Stapeln Sie dies unter einen 24/7-Multi-Maschinen-Agenten-Runner mit automatisch generierten Skills, und das kombinierte System erfüllt die Verhaltens-Anforderungen für autonome KI. Die verbleibenden Lücken (kein Lernen auf Gewichtsebene, zustandsloser Argumentationskern, von Menschen gesetzte Wurzelziele) sind real und werden von ai-memory nicht adressiert; ai-memory bietet das Multi-Agenten-Speichersubstrat, das jeder ernsthafte Versuch, diese Lücken zu schließen, benötigen wird.

Null Token-Kosten bis zum Abruf. Im Gegensatz zu integrierten Speichersystemen (Claude Code Auto-Memory, ChatGPT Memory), die Ihren gesamten Speicher in jede Konversation laden – und damit bei jeder Nachricht Tokens und Geld verbrennen – verbraucht ai-memory null Kontext-Tokens, bis die KI explizit memory_recall aufruft. Nur relevante Erinnerungen kommen zurück, bewertet durch einen 6-Faktoren-Scoring-Algorithmus. Das TOON-Format (Token-Oriented Object Notation) reduziert Antwort-Tokens um weitere 40-60 %, indem wiederholte Feldnamen eliminiert werden – 3 Erinnerungen in JSON = 1.600 Bytes; in TOON = 626 Bytes (61 % kleiner); in TOON compact = 336 Bytes (79 % kleiner). Für Claude Code-Benutzer: Deaktivieren Sie Auto-Memory ("autoMemoryEnabled": false in settings.json) und ersetzen Sie es durch ai-memory, um nicht mehr für 200+ Zeilen Speicherkontext bei jeder einzelnen Nachricht zu bezahlen.

Agentenidentität (NHI) – jede Erinnerung verrät, wer sie gelernt hat

Jede Erinnerung, die ai-memory speichert, trägt einen metadata.agent_id – einen Non-Human Identity-Marker, der jede Operation überdauert (Update, Dedup, Import, Sync, Konsolidierung). Jedes Abrufergebnis zeigt standardmäßig an, welche KI jede Erinnerung geschrieben hat, und zwar im TOON-compact-Antwortformat, für das Ihr KI-Client bereits optimiert ist:

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

Bei einem unsignierten Schreibvorgang ist agent_id eine behauptete Identität – treffen Sie keine Sicherheitsentscheidungen allein darauf basierend. Store-Path-Agentenattestierung ist standardmäßig auf der direkten HTTP-Schreiboberfläche erforderlich (#1751, oberflächenbezogen durch #1985): Ein unsignierter HTTP POST /api/v1/memories (+/bulk) wird abgelehnt (403 ATTESTATION_FAILED), anstatt attest_level = "claimed" zu landen, es sei denn, der Betreiber setzt das explizite Opt-out AI_MEMORY_REQUIRE_AGENT_ATTESTATION=0. Die MCP-memory_store- und CLI-store-Oberflächen für Betreiber-als-Akteur bleiben standardmäßig permissiv (ein unsignierter Schreibvorgang landet claimed); =1 erzwingt strikte Prüfung auf allen Oberflächen. Kryptografische Ed25519-Attestierung ist auf zwei Oberflächen verdrahtet: (1) Store-Path-Attestierung (#626 Layer-3) – Präsentieren Sie eine losgelöste Signatur über den kanonischen SignableWrite-Umschlag auf dem CLI- (store --sign), MCP- (memory_store) oder HTTP- (POST /api/v1/memories) Pfad, und der Daemon verifiziert sie gegen den gebundenen öffentlichen Schlüssel des Agenten und stempelt metadata.attest_level = "agent_attested" (eine vorgelegte, aber gefälschte Signatur wird unabhängig vom Flag immer abgelehnt); und (2) Link-Attestierung (attested-cortex) – das zuvor reservierte memory_links.signature-Feld mit memory_verify(link_id) für die eingehende Verifizierung und einer Append-Only-signed_events-Prüfkette. Siehe die Agentenidentitätsseite und den attested-cortex RFC für den vollständigen Provenienzvertrag.

Retroaktiver Konversationsimport – ai-memory mine

Starten Sie nicht bei Null. Richten Sie ai-memory mine auf einen Claude-, ChatGPT- oder Slack-Export, und es parst Zug um Zug in bewertete, typisierte, getaggte Erinnerungen – sodass Ihre KI in die nächste Sitzung geht und jede Entscheidung, Korrektur und Erkenntnis aus Ihrer bestehenden Historie kennt.

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

Automatisches Tagging, Dedup auf (title, namespace) und mined_from-Provenienz werden auf jede importierte Erinnerung gestempelt. Fünfminütiges Onboarding von Null Kontext zu einem gefüllten Langzeitspeicher. Siehe die Importverlaufsseite für formatspezifische Anleitungen.

Kompatible KI-Plattformen

ai-memory integriert sich mit jeder KI-Plattform, die das Model Context Protocol (MCP) unterstützt. MCP ist der universelle Standard, um KI-Assistenten mit externen Werkzeugen und Datenquellen zu verbinden.

MCP ist die primäre Integrationsschicht. Für KI-Plattformen, die MCP noch nicht nativ unterstützen, bieten die HTTP-API (92 Routenregistrierungen / 78 eindeutige URL-Pfade auf localhost) und die CLI (89 Unterbefehle unter --features sal ODER --features sal-postgres; 87 im Standard-Build (post-#1389 L2 RecoverPreviousSession für sitzungsübergreifende Kontextrehydrierung + #1443 Expand für die ai-memory expand Abfrageerweiterungsoberfläche + #1598 Reembed für die ai-memory reembed Vektorraum-Migrationsoberfläche); SSOT fixiert durch ai_memory::EXPECTED_CLI_SUBCOMMANDS_DEFAULT + EXPECTED_CLI_SUBCOMMANDS_SAL + den mechanischen tests/cli_subcommand_count_invariant.rs Paritätstest) universellen Zugriff – jede KI, jedes Skript oder jede Automatisierung, die HTTP-Aufrufe tätigen oder Shell-Befehle ausführen kann, kann ai-memory nutzen.

Installation in 60 Sekunden

Vorkompilierte Binärdateien benötigen keine Abhängigkeiten. Das Bauen aus dem Quellcode erfordert Rust und einen C-Compiler.

Am schnellsten: Vorkompilierte Binärdatei (kein Rust erforderlich)

# 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

Schritt 1: Rust installieren (überspringen, wenn vorkompilierte Binärdateien verwendet werden)

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

Folgen Sie den Anweisungen und starten Sie dann Ihr Terminal neu (oder führen Sie source ~/.cargo/env aus).

Schritt 2: Aus dem Quellcode (erfordert Rust)

Neueste Version von Crates.io:

cargo install ai-memory

Neueste Version aus dem Git-Repository:

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

Dies kompiliert die Binärdatei und legt sie in Ihrem PATH ab. Es dauert ein oder zwei Minuten.

Build-Abhängigkeiten für Quellcode-Builds:

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

Schritt 3: Ihre KI verbinden

Die Konfiguration variiert je nach Plattform. Finden Sie Ihre unten:

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

Schritt 4: Fertig. Testen Sie es.

Starten Sie Ihren KI-Assistenten neu. Bei Verwendung von MCP verfügt er nun über die 7-Tool-Standardoberfläche, die beim Sitzungsstart angekündigt wird (die ursprünglichen 5 + memory_load_family + memory_smart_load; die anderen 93 der 100 aufrufbaren Tools werden bei Bedarf über --profile oder memory_capabilities --include-schema geladen). Fragen Sie ihn: „Speichere eine Erinnerung, dass meine Lieblingssprache Rust ist.“ Fragen Sie dann in einer neuen Konversation: „Was ist meine Lieblingssprache?“ Er wird sich erinnern.

Unterstützung mobiler Plattformen (v0.7.0 Posture-1a)

ai-memory ist über den standardmäßigen Rust-Mobile-Cross-Compile-Pfad auf iOS und Android portierbar. v0.7.0 bietet CI-Abdeckung für beide Ziele auf drei Eskalationsstufen:

Status bei v0.7.0: Ebene 1 ist das Ship-Gate — mobiler Cross-Compile muss GRÜN sein, bevor ein Tag-Schnitt erfolgt. Ebene 2 (Release-Artefakte) liefert die BUILD-Pipeline + Artefakt-Layout; die C-aufrufbare FFI-Oberfläche selbst folgt in einem v0.7.x-Update. Ebene 3 führt die begrenzte Test-Teilmenge bei jedem release/**-Push aus.

Verwendung der Release-Artefakte:

• iOS — Laden Sie ai-memory-ios.xcframework.tar.gz von der v0.7.x-Release-Seite herunter, entpacken Sie es und ziehen Sie AiMemory.xcframework in Ihr Xcode-Projekt unter „Frameworks, Libraries, and Embedded Content“.
• Android — Laden Sie ai-memory-android.tar.gz von der v0.7.x-Release-Seite herunter, entpacken Sie es und kopieren Sie den jniLibs/-Baum in das src/main/jniLibs/ Ihres App-Moduls.

Die mobilen Artefakte sind auch Teil jeder veröffentlichten v0.7.x-Version; die Homebrew-Formel + APT/RPM-Pakete (die die Desktop-Binärdateien enthalten) enthalten einen Hinweis mit einem Link zu den mobilen Downloads. Siehe Issue #1068 für die Historie der CI-Implementierung.

Schnellstart

Von Null zu einem funktionierenden Gedächtnis in unter zwei Minuten.

1. Installation

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

2. MCP konfigurieren (Beispiel für Claude Code – andere Plattformen funktionieren auf die gleiche Weise)

In ~/.claude.json einfügen:

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

3. Erste Erinnerung speichern

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

4. Abrufen

ai-memory recall "database"

5. Statistiken prüfen

ai-memory stats

6. Mit Ihrer KI verwenden. Starten Sie Ihren KI-Client neu. Er verfügt nun über 7 Standard-Gedächtnis-Tools, die beim Start über MCP angekündigt werden (101 angekündigte Einträge, erreichbar über Laufzeiterweiterung oder --profile full) – er kann Erinnerungen nativ während Konversationen speichern und abrufen.

SDKs

Zusätzlich zu den MCP-/HTTP-/CLI-Oberflächen bietet ai-memory First-Party-Sprach-SDKs für HTTP-Clients und Hilfsprogramme (z. B. requireProfile für Laufzeitprofil-Assertionen bei v0.6.4+-Daemons).

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

npm install @alphaone/ai-memory

Python — ai-memory-mcp auf PyPI (der Importname bleibt 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

Beide SDKs sind mit dem Server versioniert (0.9.0 entspricht ai-memory 0.9.0). v0.6.4+-Daemons erzwingen den Profilvertrag; Daemons vor v0.6.4 fallen auf ein permissives Warnen-und-Fortfahren zurück, sodass SDK-Upgrades alte Server nicht beschädigen. Der Quellcode befindet sich in sdk/typescript/ und sdk/python/.

Was macht es?

KI-Assistenten vergessen alles zwischen Konversationen. ai-memory behebt das.

Es läuft als MCP (Model Context Protocol) Tool-Server – ein Hintergrundprozess, mit dem Ihre KI nativ kommuniziert. Wenn Ihre KI etwas Wichtiges lernt, speichert sie es. Wenn sie Kontext benötigt, ruft sie relevante Erinnerungen ab, die nach einem 6-Faktoren-Bewertungsalgorithmus sortiert sind. Erinnerungen existieren in drei Stufen:

• Kurzfristig (Standard 6 Stunden, konfigurierbar) – Wegwerfkontext wie aktueller Debugging-Status
• Mittelfristig (Standard 7 Tage, konfigurierbar) – Arbeitswissen wie Sprint-Ziele und kürzliche Entscheidungen
• Langfristig (permanent) – Architektur, Benutzerpräferenzen, hart erarbeitete Lektionen

Erinnerungen, auf die weiterhin zugegriffen wird, werden automatisch von mittelfristig zu langfristig hochgestuft. Jeder Abruf verlängert die TTL. Die Priorität steigt mit der Nutzung. Das System ist selbstkuratierend.

Über MCP hinaus bietet ai-memory auch eine vollständige HTTP-REST-API (92 Routenregistrierungen / 78 eindeutige URL-Pfade auf Port 9077) und eine vollständige CLI (89 Unterbefehle unter --features sal ODER --features sal-postgres; 87 im Standard-Build (nach #1389 L2 RecoverPreviousSession für kontextübergreifende Sitzungsrehydrierung + #1443 Expand für die ai-memory expand-Abfrageerweiterungsoberfläche + #1598 Reembed für die ai-memory reembed-Vektorraum-Migrationsoberfläche); SSOT festgelegt durch ai_memory::EXPECTED_CLI_SUBCOMMANDS_{DEFAULT,SAL} + den mechanischen tests/cli_subcommand_count_invariant.rs-Paritätstest) für direkte Interaktion, Skripterstellung und Integration mit jeder KI-Plattform oder jedem Tool.

Funktionen

Kernfunktionen

• MCP-Tool-Server – 101 Tools über stdio JSON-RPC (vollständiges Profil), kompatibel mit jedem MCP-Client
• Dreistufiges Gedächtnis – Kurz (Standard 6h TTL), Mittel (Standard 7d TTL), Lang (permanent) – TTLs sind konfigurierbar
• Volltextsuche – SQLite FTS5 mit bewertetem Abruf
• Hybrider Abruf – FTS5-Schlüsselwort + Kosinus-Ähnlichkeit mit adaptiver Mischung: Das semantische Gewicht variiert von 0,50 (kurzer Inhalt) → 0,15 (langer Inhalt), da Einbettungen bei langem Text an Informationen verlieren
• 6-Faktoren-Abrufbewertung – FTS-Relevanz + Priorität + Zugriffshäufigkeit + Konfidenz + Stufen-Boost + Aktualitätsabfall
• Automatische Hochstufung – Erinnerungen, auf die 5+ Mal zugegriffen wurde, werden von Mittel zu Lang hochgestuft
• TTL-Verlängerung – Jeder Abruf verlängert die Gültigkeit (Kurz +1h, Mittel +1d)
• Prioritätsverstärkung – +1 alle 10 Zugriffe (max. 10)
• Widerspruchserkennung – Warnt beim Speichern von Erinnerungen, die mit bestehenden in Konflikt stehen
• Deduplizierung – Upsert nach Titel+Namespace, Stufe wird nie herabgestuft
• Konfidenzbewertung – 0,0-1,0 Sicherheit fließt in das Ranking ein

Organisation

• Namespaces – Isolieren Sie Erinnerungen pro Projekt (automatisch aus Git-Remote erkannt)
• Erinnerungsverknüpfung – Typisierte Beziehungen: related_to, supersedes, contradicts, derived_from, reflects_on (rekursives Lernen Aufgabe 1/8), derives_from (WT-1-A Atomisierung), decomposes_into, depends_on, advances – neun Varianten bei v0.8.0
• Konsolidierung – Mehrere Erinnerungen zu einer einzigen langfristigen Zusammenfassung zusammenführen
• Automatische Konsolidierung – Gruppierung nach Namespace+Tag, automatisches Zusammenführen von Gruppen über dem Schwellenwert
• Widerspruchsauflösung – Eine Erinnerung als eine andere ersetzend markieren, die unterlegene herabstufen
• Vergessen nach Muster – Massenlöschung nach Namespace + FTS-Muster + Stufe
• Quellenverfolgung – Verfolgt die Herkunft: user, claude, hook, api, cli, import, consolidation, system
• Agentenidentität (NHI) – Jede Erinnerung trägt metadata.agent_id (beanspruchte Identität) mit mehrstufiger Unveränderlichkeit bei Aktualisierung/Dedup/Import/Sync/Konsolidierung; Filter list/search nach Agent
• Tagging – Kommagetrennte Tags mit Filterunterstützung

Schnittstellen

• 92 HTTP-Routen (78 eindeutige Pfade) – Vollständige REST-API auf 127.0.0.1:9077 (funktioniert mit jeder KI oder jedem Tool)
• 89 CLI-Unterbefehle unter --features sal ODER --features sal-postgres (87 im Standard-Build) – Vollständige CLI mit identischen Fähigkeiten
• 101 MCP-Tools im vollständigen Profil (7 Standard; verifiziert gegen Profile::full().expected_tool_count()) – Native Integration für jede MCP-kompatible KI
• Interaktive REPL-Shell – Abrufen, Suchen, Auflisten, Abrufen, Statistiken, Namespaces, Löschen mit Farbausgabe
• JSON-Ausgabe – --json-Flag bei allen CLI-Befehlen
• Verteilte Koordination (v0.8.0 Säule-1 + Säule-2) – Aktions-DAG (memory_action_*), Einzelinhaber-Leases (memory_lease_*), Ed25519-signierte Signale (memory_signal_*), attestierte Prüfpunkte (memory_checkpoint_*), parametrisierte Routinen (memory_routine_*) und der Goal/Plan/Step-Lebenszyklus für typisierte Kognition. Siehe docs/coordination.md.

Betrieb

• Multi-Node-Synchronisation – Pull, Push oder bidirektionales Zusammenführen zwischen Datenbankdateien
• Import/Export – Vollständiger JSON-Roundtrip unter Beibehaltung von Erinnerungsverknüpfungen
• Garbage Collection – Automatischer Hintergrundablauf alle 30 Minuten
• Ordentliches Herunterfahren – SIGTERM/SIGINT sichert WAL für sauberes Beenden
• Tiefgehender Gesundheitscheck – Überprüft DB-Zugänglichkeit und FTS5-Integrität
• Shell-Vervollständigungen – bash, zsh, fish
• Man-Page – ai-memory man generiert roff nach stdout
• Zeitfilter – --since/--until bei Auflisten und Suchen
• Menschenlesbare Zeitangaben – „vor 2h“, „vor 3d“ in der CLI-Ausgabe
• Farbige CLI-Ausgabe – ANSI-Stufenbeschriftungen (rot/gelb/grün), Prioritätsbalken, fette Titel, cyanfarbene Namespaces

Qualität

• ~10.000 Tests über die gesamte Oberfläche – ungefähr 6.712 #[test]/#[tokio::test]-Attribute unter src/ (5.759 #[test] + 953 #[tokio::test]) plus ungefähr 3.362 unter tests/ (2.138 #[test] + 1.224 #[tokio::test]), gewachsen von der ~2.400-Test-Basis der v0.6.4-Ära (1.960 lib + 211 integration + 16 mcp_integration + 4 webhook_http_parity + 16 recipe_contract + ~150 über andere Binärziele). Zeilenabdeckung über der ≥92 % Projektlatte gehalten; netto-neue v0.6.4-Module bei 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). v0.6.3.x-Basiswerte (1.809 / 93,08 % und 1.886 / 93,84 %) bleiben auf der Evidenzseite eingefroren; v0.6.4-Metriken in den Release Notes und auf der Test-Hub-Kampagne. Die empirische NHI-Erkennungsakzeptanz wurde separat durch das Discovery Gate nachgewiesen (T1–T4-Matrix vs. Live xAI Grok 4.3, 6/6 BESTANDEN, GATE GREEN).
• LongMemEval-Benchmark – 97,0 % R@5 reines FTS5-Schlüsselwort (LLM-unabhängig, 2,2 Sekunden, 232 q/s, null API-Kosten) auf dem ICLR 2025 LongMemEval-S-Datensatz; LLM-Abfrageerweiterung mit dem aktuellen Gemma 4-Modell der aktuellen Generation misst 97,2 % R@5 / 99,6 % R@10 / 99,8 % R@20 (Cloud-API-Veranstaltungsort; der historische gemma3:4b-Wert von 97,8 % wird gemäß #1975 als Überschrift zurückgezogen). Siehe Benchmark-Details.
• MCP-Prompts – recall-first- und memory-workflow-Prompts lehren KI-Clients, Erinnerungen proaktiv zu nutzen
• TOON-Standard – Abruf-/Listen-/Suchantworten verwenden standardmäßig TOON-kompakt (79 % kleiner als JSON)
• Criterion-Benchmarks – Einfügen, Abrufen, Suchen im 1K-Maßstab
• GitHub Actions CI/CD – fmt, clippy, test, build auf Ubuntu + macOS, Release bei Tag

Coverage Floor (harte CI-Schranke)

Der Code Coverage-Job ist eine erforderliche Statusprüfung. Die CI stellt bei jedem PR zwei Invarianten sicher: eine absolute Untergrenze von >= 90 % Zeilen (Rückversicherung gegen katastrophale Regression, festgelegt auf den aktuellen Messwert, abgerundet auf die nächsten 5 %), und eine Sperrklinke gegen den in .coverage-baseline festgehaltenen Wert mit einem Toleranzfenster von 0,5 % (die tägliche Durchsetzung). PRs, die die Abdeckung erhöhen, sollten die Baseline-Datei im selben Commit anheben, damit zukünftige PRs von der neuen Untergrenze profitieren; PRs, die um mehr als 0,5 % zurückgehen, werden am Mergen gehindert. Aktuelle Messung: 93,13 % Zeilen.

Token-Budget-Schranke (harte CI-Schranke, v0.7 C5)

Der token-budget-Workflow ist eine erforderliche Statusprüfung. Er erzwingt drei cl100k_base-gemessene Invarianten bei jedem PR:

• Pro-Tool-Obergrenze von 1500 Token -- das serialisierte Schema (Name + Beschreibung + inputSchema) eines einzelnen MCP-Tools darf 1500 cl100k_base-Token nicht überschreiten.
• Ehrlicher Bereich des vollständigen Profils (5K-8K) -- die v0.6.4-Rückversicherung, beibehalten, um pathologische Schrumpfung zu erkennen (versehentliches Fallenlassen von Tools).
• Harte Obergrenze des vollständigen Profils (v0.7 C5, angehoben nach D1.6/D1.7) -- die getrimmte tools/list-Nutzlast unter --profile full darf 11.000 cl100k_base-Token nicht überschreiten (TRIMMED_FULL_PROFILE_CEILING_TOKENS in tests/token_budget_guard.rs; das ursprüngliche C5-Ziel war 3500 gegenüber den handcodierten Schemata vor D1.6 – die von Schemars abgeleitete D1.6/D1.7-Erweiterung hob die festgelegte Obergrenze an). C2 (geteiltes docs-Feld), C3 (Zusammenfassen wiederholter Schema-Boilerplates) und C4 (Ausblenden selten genutzter optionaler Parameter) trieben die ursprüngliche Komprimierung voran; diese Schranke zwingt zukünftige PRs, die die Oberfläche vergrößern, dazu, an anderer Stelle Budget einzusparen. Überprüfen Sie ai-memory doctor --tokens --raw-table, um die Kosten pro Tool zu sehen. Siehe .github/workflows/token-budget.yml und docs/v0.7/schema-compaction-audit.md.

ML- und LLM-Abhängigkeiten (semantische Stufe+)

• candle-core, candle-nn, candle-transformers -- Hugging Face Candle ML-Framework für native Rust-Inferenz
• hf-hub -- Modelle vom Hugging Face Hub herunterladen
• tokenizers -- Hugging Face Tokenizers für Textvorverarbeitung
• instant-distance -- approximative Nächste-Nachbarn-Suche
• reqwest -- HTTP-Client für die LLM-Backend-Kommunikation (Smart-/Autonomous-Stufen – jeder Anbieter gemäß #1067: Ollama, xAI, OpenAI, Anthropic, Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks, LMStudio, vLLM, llama.cpp server)

Architektur

Benchmark

Bewertet mit dem ICLR 2025 LongMemEval-S-Datensatz (500 Fragen, 6 Kategorien). Die reine FTS5-Keyword-Stufe erreicht 97,0 % R@5 in 2,2 Sekunden – LLM-unabhängig, vollständig lokal, null Cloud-API-Aufrufe, null Kosten. Die LLM-Abfrageerweiterung (Smart-Stufe) misst 97,2 % R@5 mit dem aktuellen Gemma 4-Modell (Cloud-API-Umgebung).

Benchmark-Modell-Hinweis (aktualisiert 2026-07-10, #1975-Entscheidung): Der historische Wert von 97,8 % R@5 der Smart-Stufe wurde mit Gemma 3 4B gemessen (immer noch das kompilierte Standard-Erweiterungsmodell) und wird als Hauptreferenz zurückgezogen. Der veröffentlichte Anker der aktuellen Generation ist der gemessene OpenRouter Gemma 4-Lauf: 97,2 % R@5 / 99,6 % R@10 / 99,8 % R@20 (2026-05-31, 500 Fragen, 0 Erweiterungsfehler). Es existiert kein lokaler Ollama-Gemma-4-Wert – der Referenz-Benchmark-Host ist CPU-only, wo ein gültiger lokaler Lauf mit vollständigem Protokoll nicht durchführbar ist (siehe #1983); eine lokale GPU-Wiederholung bleibt nach v1.0 offen. Die Keyword-Stufe 97,0 % R@5 ist LLM-unabhängig und unberührt.

Leistungsbudgets (v0.6.4)

Jedes Release wird mit veröffentlichten p95/p99-Budgets für Hot-Path-Operationen und einer CI-Schranke ausgeliefert, die jeden PR ablehnt, dessen gemessenes p95 das Budget um mehr als 10 % überschreitet. Die Ziele sind für M4-Referenzhardware kalibriert; vollständige Tabelle und Methodik in PERFORMANCE.md.

Dieselbe Arbeitslast lokal ausführen:

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

Das Substrat ist über v0.6.3.x → v0.6.4 unverändert (das quiet-tools-Release liefert eine kleinere Standard-Tool-Oberfläche, keinen anderen Hot-Path). Die p99-Ziele hier bleiben bis zum nächsten dedizierten Soak-Fenster informativ; die neuesten Soak-Ergebnisse finden Sie im Test-Hub.

Integrationsmethoden

MCP (Primär – für MCP-kompatible KI-Plattformen)

MCP ist die empfohlene Integration. Ihre KI erhält 7 native Speicher-Tools, die standardmäßig beworben werden (die ursprünglichen 5 + memory_load_family + memory_smart_load; plus den immer aktiven memory_capabilities-Bootstrap) ohne zusätzlichen Code. Die anderen 93 aufrufbaren Tools (101 beworbene Einträge – verifiziert gegen Profile::full().expected_tool_count() und festgelegt durch const_count_matches_full_profile in src/mcp/registry.rs) bleiben über --profile graph|admin|power|full oder Laufzeiterweiterung durch memory_capabilities --include-schema family=<name> erreichbar. Konfigurieren Sie den MCP-Server in der Konfiguration Ihrer KI-Plattform:

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

HTTP-API (Universell – für jede KI oder jedes Tool)

Starten Sie den HTTP-Server für REST-API-Zugriff. Jede KI, jedes Skript oder jede Automatisierung, die HTTP-Aufrufe tätigen kann, kann dies nutzen:

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

CLI (Universell – für Skripterstellung und direkte Nutzung)

Die CLI funktioniert eigenständig oder als Baustein für KI-Integrationen, die Shell-Befehle ausführen:

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

Funktionsstufen

ai-memory unterstützt 4 Funktionsstufen, die beim Start mit ai-memory mcp --tier <tier> ausgewählt werden. Höhere Stufen fügen ML-Fähigkeiten auf Kosten von Speicherplatz und RAM hinzu:

Fähigkeitsmatrix

Jede Fähigkeit ist ihrer Mindeststufe zugeordnet. Jede Stufe enthält alle Fähigkeiten der darunterliegenden Stufen.

Semantische Stufe (Standard) bündelt das Candle ML-Framework und lädt das all-MiniLM-L6-v2-Modell beim ersten Start herunter (~90 MB). Smart- und Autonomous-Stufen erfordern ein LLM-Backend – nach #1067 (v0.7.0) kann dies lokal (Ollama, LMStudio, vLLM, llama.cpp server) oder ein beliebiger OpenAI-kompatibler Remote-Endpunkt (xAI, OpenAI, Anthropic via OpenAI-Shim, Google Gemini, DeepSeek, Kimi, Qwen, Mistral, Groq, Together, Cerebras, OpenRouter, Fireworks) sein. Die Auswahl erfolgt über die Umgebungsvariable AI_MEMORY_LLM_BACKEND; anbieterspezifische API-Schlüssel über XAI_API_KEY / OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY / DEEPSEEK_API_KEY / MOONSHOT_API_KEY / DASHSCOPE_API_KEY / etc. oder den kanonischen AI_MEMORY_LLM_API_KEY.

Stufen beschränken Funktionen, nicht Modelle – und nach #1067 (v0.7.0) beschränken Stufen Funktionen, auch nicht Anbieter. Das --tier-Flag steuert, welche Tools bereitgestellt werden. Das LLM-Backend + Modell sind unabhängig über die Umgebungsvariablen AI_MEMORY_LLM_BACKEND + AI_MEMORY_LLM_MODEL konfigurierbar (oder über den kanonischen [llm]-Abschnitt in ~/.config/ai-memory/config.toml – siehe docs/CONFIG_SCHEMA.md für das v0.7.x Enterprise-Schema und das Migrationstool). Zum Beispiel, Ausführen der Autonomous-Stufe (vollständige 101-Einträge-Oberfläche + Reranker) gegen xAI Grok 4 über den OpenAI-kompatiblen Alias:

# 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

Das --tier-Flag muss in den MCP-Argumenten übergeben werden – die config.toml-Stufeneinstellung wird nicht verwendet, wenn der Server von einem KI-Client gestartet wird.

# 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

Das memory_capabilities-Tool meldet die aktive Stufe, geladene Modelle und verfügbare Fähigkeiten zur Laufzeit.

MCP-Tools

Diese 101 Tools (vollständiges Profil; kanonische Anzahl über Profile::full().expected_tool_count() in src/profile.rs) stehen jeder MCP-kompatiblen KI zur Verfügung, wenn sie als MCP-Server konfiguriert ist (die v0.6.4-eingefrorene Evidenzseite listet die 63-Tool-Basislinie; die folgende Tabelle dokumentiert die Kernuntermenge, die die meisten Clients täglich nutzen):

HTTP-API

92 Routenregistrierungen / 78 eindeutige URL-Pfade auf 127.0.0.1:9077. Beginnen Sie mit ai-memory serve. Die folgende Tabelle zeigt die am häufigsten verwendeten REST-Endpunkte; siehe docs/API_REFERENCE.md für die vollständige Oberfläche (Governance, Föderation, Abonnements, Wissensgraph, Kontingente, Genehmigungen, SSE).

Sicherheit: Der HTTP-Server bindet an 127.0.0.1 und wird standardmäßig ohne konfigurierte Authentifizierung sowie mit freizügigem CORS ausgeliefert. Setzen Sie api_key in config.toml, um den x-api-key-Header bei jeder Anfrage zu verlangen (die veraltete ?api_key=-Abfrageparameterform ist ab v0.7.0 veraltet — #1574), und setzen Sie AI_MEMORY_REQUIRE_API_KEY=1, um einen schlüssellosen Start strikt zu verweigern (#1458). Setzen Sie den Server nicht ohne Authentifizierung dem Netzwerk aus (und bevorzugen Sie TLS über --tls-cert/--tls-key oder einen Reverse-Proxy).

CLI-Befehle

89 Top-Level-Unterbefehle unter --features sal ODER --features sal-postgres (87 im Standard-Build; die Lücke von 2 Varianten ist Migrate + SchemaInit, beide gesteuert #[cfg(feature = "sal")] gemäß src/daemon_runtime.rs::Command::{Migrate,SchemaInit}; waren 40 in v0.6.4). Führen Sie ai-memory <command> --help für Details zu einem beliebigen Befehl aus oder ai-memory --help für die vollständige Liste.

Die Top-Level-Binärdatei ai-memory akzeptiert auch globale Flags:

Der Unterbefehl store akzeptiert zusätzliche Flags:

Der Unterbefehl mcp akzeptiert ein zusätzliches Flag:

Abrufgewichtung

Jede Abrufabfrage gewichtet Erinnerungen nach 6 Faktoren:

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

Erinnerungsstufen

Automatische Verhaltensweisen

• TTL-Verlängerung beim Abruf: Kurze Erinnerungen erhalten +1 Stunde, mittlere Erinnerungen erhalten +1 Tag
• Automatische Hochstufung: Mittelstufige Erinnerungen, auf die 5+ Mal zugegriffen wurde, werden zu Langzeitspeicher hochgestuft (Ablauf gelöscht)
• Prioritätsverstärkung: Alle 10 Zugriffe erhöht sich die Priorität um 1 (begrenzt auf 10)
• Widerspruchserkennung: Warnt, wenn eine neue Erinnerung mit einer vorhandenen im selben Namespace in Konflikt steht
• Deduplizierung: Upsert nach Titel+Namespace; Stufe wird bei Aktualisierung niemals herabgestuft

Konfigurierbare TTL

Standard-TTLs (6 Stunden für kurz, 7 Tage für mittel) können in ~/.config/ai-memory/config.toml unter dem Abschnitt [ttl] überschrieben werden:

[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)

Alle fünf Felder sind optional – lassen Sie eines weg, um den Standard beizubehalten. Setzen Sie einen beliebigen Wert auf 0, um den Ablauf für diese Stufe zu deaktivieren. Werte werden auf ein Maximum von 10 Jahren begrenzt; negative Verlängerungswerte werden auf 0 begrenzt.

Hinweis: Die Konfiguration wird einmal beim Prozessstart geladen. Änderungen an config.toml erfordern einen Neustart des ai-memory-Prozesses (MCP-Server, HTTP-Daemon oder CLI), um wirksam zu werden.

Archiv

Wenn die Garbage Collection eine Erinnerung ablaufen lässt, kann sie archiviert werden, anstatt sie endgültig zu löschen. Archivierte Erinnerungen werden in einen separaten Speicher verschoben und können später durchsucht, wiederhergestellt oder endgültig gelöscht werden.

Konfiguration

Aktivieren Sie die Archivierung in ~/.config/ai-memory/config.toml:

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

CLI-Befehle

Der Unterbefehl archive verwaltet das Archiv:

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

Hinweis: Bei wiederhergestellten Erinnerungen wird ihr expires_at gelöscht (sie werden dauerhaft, bis zur nächsten TTL-Zuweisung).

MCP-Tools

Vier Archiv-Tools stehen MCP-Clients zur Verfügung:

HTTP-Endpunkte

Sicherheit

ai-memory umfasst Härtung über alle Eingabepfade hinweg:

• Transaktionssicherheit -- alle mehrstufigen Datenbankoperationen verwenden Transaktionen; keine partiellen Schreibvorgänge bei Fehlern
• FTS-Injektionsschutz -- Benutzereingaben werden vor FTS5-Abfragen bereinigt; Sonderzeichen werden maskiert
• Fehlerbereinigung -- interne Datenbankpfade und Systemdetails werden aus Fehlerantworten entfernt; Clients sehen strukturierte Fehlertypen (NOT_FOUND, VALIDATION_FAILED, DATABASE_ERROR, CONFLICT)
• Body-Größenbeschränkungen -- HTTP-Request-Bodies werden über Axums DefaultBodyLimit auf 50 MB begrenzt
• Bulk-Operationsbeschränkungen -- Bulk-Create-Endpunkte erzwingen maximale Batch-Größen, um Ressourcenerschöpfung zu verhindern
• CORS -- freizügige CORS-Schicht für lokale Entwicklungsworkflows aktiviert
• Eingabevalidierung -- jeder Schreibpfad validiert Titellänge, Inhaltslänge, Namespace-Format, Quellwerte, Prioritätsbereich (1-10), Konfidenzbereich (0.0-1.0), Tag-Format, Stufenwerte, Beziehungstypen und ID-Format
• Link-Validierung bei Synchronisation -- alle Links werden vor dem Import während Synchronisationsvorgängen validiert (beide IDs, Beziehungstyp, keine Selbstverweise)
• Thread-sichere Farbe -- Terminal-Farberkennung verwendet AtomicBool für sicheren gleichzeitigen Zugriff
• Nur lokales HTTP -- der HTTP-Server bindet standardmäßig an 127.0.0.1; nicht dem Netzwerk ausgesetzt
• WAL-Modus -- SQLite Write-Ahead Logging für sichere gleichzeitige Lesevorgänge während Schreibvorgängen

Dokumentation

Lizenz

Copyright 2026 AlphaOne LLC.

Lizenziert unter der Apache License, Version 2.0 (die „Lizenz“); Sie dürfen diese Datei nur in Übereinstimmung mit der Lizenz verwenden. Eine Kopie der Lizenz erhalten Sie unter

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

Sofern nicht gesetzlich vorgeschrieben oder schriftlich vereinbart, wird die unter der Lizenz verbreitete Software auf einer „AS IS“-BASIS bereitgestellt, OHNE GEWÄHRLEISTUNGEN ODER BEDINGUNGEN JEGLICHER ART, weder ausdrücklich noch stillschweigend. Siehe die Lizenz für die spezifischen Regelungen zu Genehmigungen und Einschränkungen.