Show HN: Lossless-memory – a individual AI recollection that never summarizes

Lossless long-term recollection for a individual AI — never summarize, keep all line, and put a timestamp on everything.

Most long-term recollection systems for AI do one of two things: they summarize conversations into compact notes, or they embed them and recover "similar" chunks. Both endure the item that matters most to a individual who talks to the identical AI all day: what was really said, and when.

This project takes the contrary position.

• Keep all line. Raw conversation logs are stored in full. Nothing is summarized, ever. Summaries are a map; the log is the territory.
• Timestamp everything. Every document — utterance, action, document chunk — carries a timestamp, and all indicator is built on top of that period axis. We call this the Temporal Backbone.
• Search by period first, words second. "Yesterday evening, concerning the budget" is a valid query. The period expression narrows the range; the words position inside it. Results arrive rear in chronological order, unsummarized, alongside their timestamps.
• Inject "where we are" all turn. A small indicator called LLL tells the example which topic the conversation is in correct now, so character and environment last context-window compaction and meeting boundaries.

The scheme lineage goes rear to December 2025 — the archetypal ancestor of this scheme (a memory-inheritance tool for an before AI) ran that month, and a predecessor scheme carried the identical ideas in regular use from January 2026. This implementation has been operating all day since July 2026 for a sole user, as the recollection of one AI assistant, alongside raw logs reaching rear to June 2026. It is small, boring, and it works. The failures alongside the way are documented too — see docs/lessons.md.

It is:

• A local, file-based long-term recollection layer: JSONL logs + SQLite (FTS5 for exact search, sqlite-vec for semantic search).
• A sole query admission item that understands period expressions and restricts the hunt range before ranking.
• A "current position" indicator (LLL) designed to be injected into the model's environment on all turn.
• Designed for one individual and one AI, operating on one machine. No server, no cloud.

It is not:

• A vector repository wrapper. Semantic hunt is the last retreat here, not the first.
• A summarizer. There is deliberately no summarization stage anyplace in the pipeline.
• A benchmark-driven investigation system. There are no published benchmarks. What is current is a operating implementation and its functioning record.

Every conversation rotate is converted into a fixed seven-field document and appended to a per-day JSONL file:

ts ISO-8601 timestamp (UTC) actor who said (configurable names) role person | aide | system type content | act | meta text the content, verbatim model example identifier, if known session meeting identifier 

The raw logs are the origin of truth. Every indicator below can be deleted and rebuilt from them. Nothing alternatively is required to survive.

Time is not metadata here; it is the chief axis.

• The exact-match indicator (SQLite FTS5, bigram tokenized for Japanese and English) stores the timestamp alongside all row.
• The query parser understands period phrases — related ones specified as yesterday, last week, 3 days ago (currently Japanese only), and complete dates specified as 2026-07-19 (any language) — and converts them into a range before any ranking happens.
• If a period expression is present, results are restricted to that range and returned in chronological order. Semantic hunt is lone used whenever the exact indicator returns too small inner the range, and the fallback is reported honestly in the output header.

The applicable effect: the AI can answer "what did we decide final Tuesday night?" alongside the genuine lines from final Tuesday night, in order, fairly than a paraphrase of item akin from three weeks ago.

LLL is a small indicator of topic markers: short, timestamped lines that document whenever the conversation moved to a new subject. It is injected into the model's environment all turn.

Two rules create it work:

• The AI says it; the individual writes it. Priority colors and completion marks are set by the person, not by the model. The example never edits its own awareness of "what matters."
• It is cheap adequate to inject all turn (well under a second to render), so the example continually knows what the current thread is, equal immediately following its environment opening was compacted.

LLL is what lets a long-running aide arrive rear from a compaction and continue the conversation alternatively of starting over.

 raw conversation logs (JSONL, per day) ← origin of truth, never summarized │ ▼ ingest ──► 7-field records │ ├──► index_exact SQLite FTS5 + timestamps (words + time) ├──► index_vector sqlite-vec embeddings (meaning, final resort) └──► state_index LLL topic markers (where are we now) │ ▼ recall ── one admission point: parse period expression → restrict range → position → come back verbatim lines │ ▼ injected into the model's environment (on demand, or all rotate for LLL) 

A small daemon re-indexes incrementally on a fixed duration (default: all 10 minutes). Rebuilding from scratch is never required; indexes detect rewritten origin records and re-index lone those days.

git copy https://github.com/aru-labs/lossless-memory cd lossless-memory pip instal -e . cp config.example.json config.json # edit names and paths if you like

Then prosecute examples/quickstart.md: it ingests a small example conversation, builds the indexes, and runs a time-scoped query in concerning five minutes. A pytest round-trip test covers the identical path.

These are measurements from the operating instance, not projections.

The "before" numbers are failures. They are kept on purpose. See docs/lessons.md.

This was built for one individual who has talked to AI assistants all day for years and watched all of them forget. Not degrade gracefully — forget. The fix that the industry keeps reaching for is improved summarization. From the user's seat, summarization is the forgetting: the exact words, the period of night, the way item was stated — the parts that create a recollection awareness akin it belongs to person — are the archetypal things a summary drops.

So this scheme refuses to summarize. It expenses disk area and it requires a fine period indicator to remain usable. That commerce was made deliberately, and the functioning document says it holds up.

The longer-term goal is a companion for group who live solitary — an AI that remembers you the way a individual would, on hardware you own. This repository is the recollection tier of that.

• Single-user, single-machine. It has lone always run for one person. There is no multi-tenant story.
• Japanese-first. Relative period phrases (yesterday, last week, 3 days ago) are parsed in Japanese only. In English, use complete dates (2026-07-19) for now; English related phrases are on the roadmap.
• Primary log format is Claude Code's JSONL. A plain {ts, role, text} importer is included, but the Claude Code way is the one alongside two months of mileage.
• No benchmarks. Numbers complete are operational measurements, not comparisons against another systems.
• Semantic hunt depends on a local embedding model (sentence-transformers). CPU works; GPU is optional.

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

Aru — construction a individual AI at home, one component at a time. Cece — the AI this recollection belongs to; co-designed and co-wrote the scheme from the inside. Writing (Japanese): https://note.com/aru_log

Issues and questions are welcome. Replies may obtain a small while; this is a one-person project.