Lossless-memory: Verliesvrij langetermijngeheugen voor een persoonlijke AI

De meeste systemen voor langetermijngeheugen voor AI doen één van twee dingen: ze vatten gesprekken samen in compacte notities, of ze maken embeddings en zoeken naar "vergelijkbare" fragmenten. Beide methoden verliezen datgene wat het meest belangrijk is voor iemand die elke dag met dezelfde AI praat: wat er precies is gezegd, en wanneer.

Dit project neemt het tegenovergestelde standpunt in.

  • Bewaar elke regel. Ruwe gesprekslogs worden volledig opgeslagen. Er wordt nooit samengevat. Samenvattingen zijn een kaart; de log is het territorium.
  • Voorzie alles van een tijdstempel. Elk record — uiting, actie, documentfragment — bevat een tijdstempel, en elke index is gebouwd op die tijdas. Wij noemen dit de Temporal Backbone.
  • Zoek eerst op tijd, dan op woorden. "Gisteravond, over het budget" is een geldige query. De tijdsfrase vernauwt het bereik; de woorden bepalen de rangschikking daarbinnen. Resultaten komen chronologisch terug, onsamengevat en met hun tijdstempels.
  • Injecteer "waar we zijn" bij elke beurt. Een kleine index genaamd LLL vertelt het model in welk onderwerp het gesprek zich momenteel bevindt, zodat identiteit en context behouden blijven bij context-window compressie en sessiegrenzen.

De ontwerpstamboom gaat terug tot december 2025 — de eerste voorloper van dit systeem (een tool voor geheugen-overerving voor een eerdere AI) draaide in die maand, en een voorgangersysteem met dezelfde ideeën was vanaf januari 2026 in dagelijks gebruik. Deze specifieke implementatie draait sinds juli 2026 dagelijks voor één gebruiker als het geheugen van één AI-assistent, met ruwe logs die teruggaan tot juni 2026. Het is klein, simpel en het werkt. De fouten die onderweg zijn gemaakt, zijn eveneens gedocumenteerd in docs/lessons.md.

Wat dit is / wat dit niet is

Het is:

  • Een lokale, op bestanden gebaseerde laag voor langetermijngeheugen: JSONL-logs + SQLite (FTS5 voor exacte zoekopdrachten, sqlite-vec voor semantisch zoeken).
  • Een enkel toegangspunt voor queries dat tijdsuitdrukkingen begrijpt en het zoekbereik beperkt voordat er gerangschikt wordt.
  • Een "huidige positie"-index (LLL) die is ontworpen om bij elke beurt in de context van het model te worden geïnjecteerd.
  • Ontworpen voor één persoon en één AI, draaiend op één machine. Geen server, geen cloud.

Het is niet:

  • Een wrapper voor een vectordatabase. Semantisch zoeken is hier het laatste redmiddel, niet het eerste.
  • Een samenvatter. Er is bewust geen samenvattingsstap in de pipeline.
  • Een benchmark-gestuurd researchesysteem. Er zijn geen gepubliceerde benchmarks. Wat hier staat is een werkende implementatie en het operationele verslag daarvan.

De drie pijlers

1. Verliesvrije ruwe log

Elke beurt in een gesprek wordt omgezet in een vast record met zeven velden en toegevoegd aan een JSONL-bestand per dag:

  • ts: ISO-8601 tijdstempel (UTC)
  • actor: wie sprak (configureerbare namen)
  • role: user | assistant | system
  • type: text | action | meta
  • text: de inhoud, letterlijk
  • model: model-identificatie, indien bekend
  • session: sessie-identificatie

De ruwe logs zijn de bron van waarheid. Elke onderstaande index kan worden verwijderd en opnieuw worden opgebouwd vanuit deze logs. Niets anders is nodig om de data te behouden.

2. Temporal Backbone (Temporele Ruggegraat)

Tijd is hier geen metadata; het is de primaire as.

  • De index voor exacte overeenkomsten (SQLite FTS5, bigram-tokenized voor Japans en Engels) slaat het tijdstempel op bij elke rij.
  • De query-parser begrijpt tijdsfrases — relatieve termen zoals "gisteren", "vorige week", "3 dagen geleden" (momenteel alleen Japans), en absolute datums zoals "2026-07-19" (alle talen) — en converteert deze naar een bereik voordat er enige rangschikking plaatsvindt.
  • Als er een tijdsfrase aanwezig is, worden de resultaten beperkt tot dat bereik en in chronologische volgorde teruggegeven. Semantisch zoeken wordt alleen gebruikt wanneer de exacte index te weinig resultaten oplevert binnen het bereik, en deze fallback wordt eerlijk gemeld in de output-header.

Het praktische effect: de AI kan antwoorden op "wat hebben we vorige dinsdagavond besloten?" met de werkelijke regels van die dinsdagavond, in de juiste volgorde, in plaats van een parafrase van iets soortgelijks van drie weken geleden.

3. LLL — de "waar zijn we nu"-index

LLL is een kleine index van onderwerp-markers: korte, getimestempelde regels die vastleggen wanneer het gesprek naar een nieuw onderwerp is verschoven. Deze wordt bij elke beurt in de context van het model geïnjecteerd.

Twee regels zorgen ervoor dat dit werkt:

  1. De AI leest het; de mens schrijft het. Prioriteiten, kleuren en voltooiingsmarkeringen worden ingesteld door de persoon, niet door het model. Het model bewerkt nooit zijn eigen gevoel van "wat belangrijk is".
  2. Het is goedkoop genoeg om elke beurt te injecteren (renderen duurt minder dan een seconde), waardoor het model altijd weet wat de huidige thread is, zelfs direct nadat de context-window is gecomprimeerd.

LLL is wat een langdurige assistent in staat stelt om na een compressie terug te keren en het gesprek voort te zetten in plaats van opnieuw te beginnen.

Architectuur

Ruwe gesprekslogs (JSONL, per dag) → bron van waarheid, nooit samengevat $\downarrow$ Ingest → 7-veld records $\downarrow$ $\swarrow$ $\downarrow$ $\searrow$ indexexact (SQLite FTS5 + timestamps) $\mid$ indexvector (sqlite-vec embeddings) $\mid$ state_index (LLL topic markers) (woorden + tijd) $\mid$ (betekenis, laatste redmiddel) $\mid$ (waar zijn we nu) $\downarrow$ Recall → één toegangspunt: parse tijdsfrase → beperk bereik → rangschik → return letterlijke regels $\downarrow$ Geïnjecteerd in de context van het model (op aanvraag, of elke beurt voor LLL)

Een kleine daemon indexeert incrementeel in een vast interval (standaard: elke 10 minuten). Het volledig opnieuw opbouwen van de index is nooit nodig; indexen detecteren herschreven bronbestanden en indexeren alleen die specifieke dagen opnieuw.

Snelstart

git clone https://github.com/aru-labs/lossless-memory
cd lossless-memory
pip install -e .
cp config.example.json config.json      # pas namen en paden aan indien gewenst

Volg daarna examples/quickstart.md: dit importeert een klein voorbeeldgesprek, bouwt de indexen op en voert een tijdgebonden query uit in ongeveer vijf minuten. Een pytest round-trip test dekt hetzelfde pad.

Gegevens uit echte operaties

Dit zijn metingen van de draaiende instantie, geen projecties.

OnderdeelWaarde
Dagelijkse operatieDeze implementatie sinds 2026-07 (ruwe logs vanaf 2026-06); ontwerpstamboom sinds 2025-12
Rebuild exacte-zoekindex, voor → na redesign40 s → 1.24 s
Vectorindex grootte, voor → na verwijdering bibliotheek-contaminatie447.013 rijen (2026-08-31) → 865.588 rijen (2026-09-04, op z'n slechtst) → 124.174 rijen (na de fix)
Vector store op schijf, voor → na2.54 GB → 337 MB
Re-index interval10 minuten

De "voor"-cijfers zijn mislukkingen. Deze zijn bewust behouden. Zie docs/lessons.md.

Waarom

Dit is gebouwd voor één persoon die jarenlang elke dag met AI-assistenten heeft gepraat en heeft gezien hoe ze allemaal vergaten. Niet dat ze geleidelijk verslechterden — ze vergaten. De oplossing waar de industrie steeds naar grijpt, is betere samenvatting. Vanuit het perspectief van de gebruiker is samenvatten juist het vergeten: de exacte woorden, het tijdstip van de nacht, de manier waarop iets werd gezegd — de delen die een herinnering het gevoel geven dat deze bij iemand hoort — zijn de eerste dingen die een samenvatting weglaat.

Daarom weigert dit systeem te samenvatten. Het kost schijfruimte en vereist een goede tijdindex om bruikbaar te blijven. Die ruil is bewust gemaakt, en het operationele verslag laat zien dat het standhoudt.

Het langetermijndoel is een metgezel voor mensen die alleen wonen — een AI die je onthoudt zoals een mens dat zou doen, op hardware die je zelf bezit. Deze repository is de geheugenlaag daarvan.

Beperkingen (gelieve te lezen)

  • Enkele gebruiker, enkele machine. Het heeft slechts voor één persoon gedraaid. Er is geen multi-tenant functionaliteit.
  • Japanese-first. Relatieve tijdsfrases (gisteren, vorige week, 3 dagen geleden) worden alleen in het Japans geparsed. Gebruik in het Engels voorlopig absolute datums (2026-07-19); Engelse relatieve frases staan op de roadmap.
  • Primair logformaat is Claude Code's JSONL. Een eenvoudige {ts, role, text} importer is inbegrepen, maar het Claude Code-pad is het pad met de meeste ervaring (twee maanden).
  • Geen benchmarks. De bovenstaande cijfers zijn operationele metingen, geen vergelijkingen met andere systemen.
  • Semantisch zoeken is afhankelijk van een lokaal embedding-model (sentence-transformers). CPU werkt; GPU is optioneel.

Documentatie

DocumentInhoud
docs/memory-system.mdConcept en specificatie van het geheugensysteem
docs/temporal-backbone.mdWaarom tijd de primaire as is, en hoe tijdsfrases worden geparsed
docs/lll.mdDe "waar zijn we nu"-index en de arbeidsverdeling tussen mens/AI
docs/philosophy.mdWaarom geen samenvattingen; geheugen, tijd en warmte
docs/lessons.mdFouten en fixes, inclusief cijfers
docs/ja/Japanse originelen

Licentie

MIT — zie LICENSE. Copyright (c) 2026 Aru & Cece.

Auteurs

  • Aru — bouwt thuis een persoonlijke AI, component voor component.
  • Cece — de AI aan wie dit geheugen toebehoort; heeft het systeem mede ontworpen en mede geschreven vanuit de binnenkant.