MemX: A Local-First Long-Term Memory System for AI Assistants

Het paper introduceert MemX, een lokaal geïmplementeerde, stabiel ontworpen langdurig geheugensysteem voor AI-assistenten dat gebruikmaakt van een hybride zoek- en herordeningpijplijn om zoekresultaten te verbeteren en valse recalls te onderdrukken.

De kern

MemX: De Slimme, Lokale Notitieblok voor je AI

Stel je voor dat je een persoonlijke assistent hebt die alles voor je doet: je agenda plannen, code schrijven, of je favoriete koffiebestelling onthouden. Maar nu, stel je voor dat deze assistent elke ochtend opstaat met een leeg hoofd. Hij vergeet wat je gisteren zei, weet niet wat je lievelingskleur is, en moet elke keer opnieuw vragen hoe je je naam is. Dat is hoe de meeste AI-assistenten vandaag werken: ze zijn slim, maar ze hebben geen geheugen.

Deze paper introduceert MemX, een systeem dat AI-assistenten een echt, langdurig geheugen geeft. En het beste deel? Het werkt lokaal. Dat betekent dat al je geheugen op jouw eigen computer staat, niet in de cloud bij een groot bedrijf. Je bent de eigenaar van je eigen data, net als een fysiek notitieblok dat in je la ligt.

Hier is hoe MemX werkt, vertaald in alledaagse termen:

1. De Twee Manieren om te Onthouden (Hybride Zoeken)

Stel je voor dat je in een enorme bibliotheek (jouw geheugen) op zoek bent naar een specifiek boek.

• De "Betekenis"-Zoeker (Vector Search): Deze zoekt op het gevoel van wat je vraagt. Als je zegt "Hoe moet ik die fout in mijn code oplossen?", zoekt hij naar boeken die over "code-fouten" gaan, zelfs als het woord "code" niet letterlijk in de titel staat.
• De "Woord"-Zoeker (Keyword Search): Deze zoekt op exacte woorden. Als je vraagt "Wat is de datum van de Rust-conferentie?", zoekt hij naar boeken met het woord "Rust" erin.

MemX gebruikt beide tegelijk. Het is alsof je twee detectives hebt die samenwerken: de ene snapt de context, de andere is goed in exacte details. Ze geven hun resultaten aan elkaar door, en een slimme "rechter" (een algoritme genaamd Reciprocal Rank Fusion) beslist welke antwoorden het belangrijkst zijn.

2. De "Niet-Verzonnen" Regel (Rejection Rule)

Een groot probleem bij AI is dat ze soms dingen uit hun duim zuigen als ze het antwoord niet weten. Ze zeggen dan iets als: "Oh, je favoriete sport is waarschijnlijk tennis!" (terwijl je dat nooit hebt gezegd).

MemX heeft een speciale veiligheidsregel: "Als we het antwoord echt niet weten, zeg dan gewoon niets."
Het systeem kijkt naar de zekerheid van het antwoord. Als de "betekenis"-zoeker niet zeker genoeg is (bijvoorbeeld minder dan 50% zekerheid) en er is ook geen exact woord-match, dan geeft MemX geen antwoord. Liever stilte dan een leugen. Dit maakt de AI betrouwbaarder.

3. De Slimme Rangschikking (Re-ranking)

Stel je voor dat je 100 notities hebt over een project. Als je iets vraagt, wil je niet de oudste notitie zien, maar de meest recente en belangrijke. MemX kijkt naar vier factoren om te beslissen wat bovenaan staat:

1. Betekenis: Past het antwoord bij je vraag?
2. Nieuwheid: Is het recent? (Net als een vers krantje vs. een oude krant).
3. Frequentie: Hoe vaak werd dit antwoord eerder gebruikt? (Populaire notities krijgen meer aandacht).
4. Belang: Heb je dit zelf als "belangrijk" gemarkeerd?

4. Waarom is dit zo snel? (De Bibliotheek-Optimalisatie)

Als je een bibliotheek hebt met 100.000 boeken en je zoekt op een woord zonder een goede catalogus, moet je elk boek openmaken. Dat duurt eeuwen.
MemX gebruikt een slimme catalogus (FTS5-index). In plaats van door 100.000 boeken te bladeren, duurt het zoeken minder dan een seconde, zelfs met een gigantische hoeveelheid data. Het is alsof je van een stapel papieren kaarten overschakelt op een super-snelle digitale zoekmachine.

5. Wat hebben ze ontdekt? (De Resultaten)

De onderzoekers hebben MemX getest met twee soorten "proefjes":

• Kleine, specifieke tests: Hier deed MemX het fantastisch. Het vond het juiste antwoord in 91% tot 100% van de gevallen en verzon niets als het antwoord er niet was.
• Grote, chaotische tests: Hier werd het lastiger. Als je vraagt over gebeurtenissen die maanden geleden in verschillende gesprekken zijn besproken, wordt het lastig voor de AI. Maar door de informatie in heel kleine stukjes (feiten) te splitsen in plaats van hele gesprekken als één blok te zien, verdubbelde de prestatie.

Waarom is dit belangrijk voor jou?

Vroeger dachten we dat AI's alleen in de cloud konden werken met enorme servers. MemX bewijst dat je een persoonlijke, veilige en slimme AI kunt hebben die op je eigen laptop draait.

• Privacy: Je data verlaat je computer nooit.
• Snelheid: Geen wachttijd voor verbindingen.
• Betrouwbaarheid: Het weet wanneer het iets niet weet, en verzonnt dan niets.

Kortom: MemX is de eerste stap naar een AI-assistent die je echt kent, je geheugen deelt, en dat alles doet terwijl jij de baas blijft over je eigen data.

Technische samenvatting

Probleemstelling

Grote Taalmodellen (LLMs) hebben sterke single-turn begrijpingsvermogens, maar missen vaak een persistente geheugenschicht over sessies heen. Zonder dit kunnen AI-assistenten geen gebruikersvoorkeuren, projectconventies of domeinspecifieke kennis betrouwbaar onthouden. Bestaande oplossingen zoals Retrieval-Augmented Generation (RAG) richten zich vaak op grote, vooraf bestaande documentcorpora in de cloud, in plaats van op incrementele, gepersonaliseerde geheugens die tijdens dagelijkse interacties ontstaan.

Er is een specifieke kloof voor lokaal geïmplementeerde (local-first) AI-assistenten:

1. Gebruikers willen volledige eigendom van hun data, offline-functionaliteit en privacy.
2. Bestaande systemen zijn vaak te complex of afhankelijk van de cloud.
3. De uitdaging ligt in het vinden van een balans tussen recall (het vinden van relevant geheugen) en het voorkomen van spurius recalls (het hallucineren van antwoorden wanneer er geen relevant geheugen bestaat), vooral binnen de beperkingen van lokale hardware.

Methodologie: MemX

MemX is een lokaal-first, langdurig geheugensysteem geschreven in Rust, gebouwd bovenop libSQL (een open fork van SQLite) en een OpenAI-compatibele embedding API. Het systeem volgt vier ontwerpprincipes: lokale implementatie, structurele eenvoud, reproduceerbare evaluatie en stabiliteit boven maximale recall.

De Architectuur en Zoekpijplijn:
De zoekpijplijn is deterministisch en bestaat uit de volgende stappen (zie Figuur 1 en Algoritme 1):

1. Hybride Recall: Een query wordt verwerkt via twee parallelle paden:
   • Vector Recall: Semantische zoekopdracht via een embedding model (Qwen3-0.6B, 1024-dim) en DiskANN voor nearest-neighbor search.
   • Keyword Recall: Exacte term-matching via SQLite FTS5 (Full-Text Search).
2. Fusie (RRF): De resultaten van beide paden worden samengevoegd met Reciprocal Rank Fusion (RRF) om een gecombineerde ranglijst te maken.
3. Her-ranking (Four-Factor): Kandidaten worden opnieuw gesorteerd op basis van een gewogen som van vier factoren:
   • Semantische similariteit (45%)
   • Recency (25%): Gebaseerd op last_retrieved_at (niet last_accessed_at) met een exponentiële halfwaardetijd.
   • Frequentie (5%): Gebaseerd op retrieval_count (niet access_count).
   • Importance (10%): Expliciete annotatie.
   • De scores worden genormaliseerd met Z-score en een sigmoid-transformatie.
4. Afkeuring (Rejection Rule): Een cruciale stap voor stabiliteit. Als de keyword-resultaten leeg zijn én de maximale vector-similariteit onder een drempelwaarde ($\tau = 0.50$) ligt, wordt een lege set teruggegeven. Dit voorkomt hallucinaties bij vragen die niet in het geheugen staan.
5. Deduplicatie: Er wordt gedupliceerd op basis van inhoud en "tag-signatures" (combinatie van type en tags) om te voorkomen dat één onderwerp de top-k resultaten domineert.

Data Model:
Gegevens worden opgeslagen in een enkele libSQL-bestand. Er is een secundaire tabel voor relaties (memory_links) met zeven relationele types (bijv. contradicts, caused_by), hoewel multi-hop traversie nog niet volledig in de zoekpijplijn is geïntegreerd.

Belangrijkste Bijdragen

1. Implementatie: Een volledig werkend lokaal geheugensysteem met hybride zoekopdracht en expliciete scheiding tussen "toegang" (viewen) en "herwinning" (zoeken).
2. Benchmark Framework: Een reproduceerbaar framework dat interne zoekfuncties direct aanroept (zonder HTTP-overhead) met live embeddings, ondersteunend voor scenario-extensie en drempel-sweeping.
3. Empirische Validatie: Evaluatie op twee aangepaste Chinese benchmarks (43 queries) en de externe LongMemEval benchmark (500 queries, tot 220k records).
4. Granulariteitsstudie: Een analyse die aantoont dat het opsplitsen van conversaties in "fact-level" (atomische feiten) de zoekkwaliteit aanzienlijk verbetert ten opzichte van "session-level" opslag.

Resultaten

1. Prestaties op Custom Benchmarks (43 queries):

• Hit@1: 91,3% (standaard scenario) tot 100% (hoog-confusie scenario).
• Miss-Handling: Het systeem slaagt erin om vragen zonder antwoord te onderdrukken (Miss-Empty-Rate van 50-75%), terwijl het valide vragen niet afkeurt.
• Latentie: Dankzij FTS5 blijft de zoeklatentie onder de 90 ms, zelfs bij grotere datasets.

2. LongMemEval Evaluatie (500 queries, schaal tot 220k records):

• Invloed van Granulariteit: Fact-level opslag (220k records) verdubbelt de prestaties ten opzichte van session-level opslag:
  • Hit@5: Steeg van 24,6% (session) naar 51,6% (fact).
  • MRR: Steeg van 0,183 naar 0,380.
• Ableit Type: "Knowledge update" profiteert het meest (+44,8% Hit@5). "Temporal reasoning" en "Multi-session reasoning" blijven uitdagend (≤43,6% Hit@5), wat aangeeft dat extra mechanismen (zoals tijdsindexering) nodig zijn.
• Latentie Schaalbaarheid: Het vervangen van LIKE zoekopdrachten door FTS5 indexering resulteerde in een 1.100x snelheidswinst bij 100k records (van 3.305 ms naar 2,9 ms voor keyword search).

3. Ablatie Studies:

• Afkeurregel: De afkeurregel is de enige component die zorgt voor het onderdrukken van foutieve recalls (Miss-Empty-Rate), zonder valide queries te verliezen.
• Deduplicatie: Werkt goed voor gestructureerde, getagde data, maar kan de recall verminderen bij tag-vrije, atomaire feiten (waar alle items dezelfde "tag-signature" hebben).

Betekenis en Conclusie

MemX bewijst dat een structuur-simpel, lokaal-first geheugensysteem stabiel en betrouwbaar kan werken voor AI-assistenten.

• Stabiliteit: Door een conservatieve afkeurregel en de scheiding tussen toegang en herwinning, voorkomt het systeem dat administratieve activiteiten (zoals het bekijken van een item) de ranking verstoren.
• Schaalbaarheid: FTS5 is essentieel voor lokale systemen om keyword-zoekopdrachten snel te houden bij groeiende datasets.
• Toekomstperspectief: Hoewel MemX een sterke baseline is voor single-topic recall, blijven temporeel redeneren en multi-sessie redeneren uitdagingen. De auteurs suggereren dat toekomstige verbeteringen moeten focussen op tijdsindexering, cross-sessie koppelingen en adaptieve deduplicatie.

Het paper biedt een solide v1-baseline die reproduceerbaar is en de weg vrijmaakt voor lokale AI-assistenten die hun eigen kennis kunnen opbouwen zonder afhankelijk te zijn van cloud-infrastructuur.