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

A developer released Lossless-memory, a local, file-based long-term memory layer for a personal AI assistant that stores every conversation line verbatim in per-day JSONL files with ISO-8601 UTC timestamps and never summarizes. The system, running daily since July 2026 for a single user with raw logs reaching back to June 2026, pairs SQLite FTS5 exact search and sqlite-vec semantic search with a query parser that converts time phrases such as "yesterday" or "3 days ago" into a range before ranking, and a "Temporal Backbone" index that keeps every record on a time axis. The project reports no published benchmarks and positions semantic search as a last resort rather than the primary retrieval method.

Lossless long-term memory for a personal AI — never summarize, keep every line, and put a timestamp on everything. Most long-term memory systems for AI do one of two things: they summarize conversations into compact notes, or they embed them and retrieve "similar" chunks. Both lose the thing that matters most to a person who talks to the same AI every day: what was actually said, and when. This project takes the opposite position. - Keep every line. Raw conversation logs are stored in full. Nothing is summarized, ever. Summaries are a map; the log is the territory. - Timestamp everything. Every record — utterance, action, document chunk — carries a timestamp, and every index is built on top of that time axis. We call this the Temporal Backbone . - Search by time first, words second. "Yesterday evening, about the budget" is a valid query. The time phrase narrows the range; the words rank within it. Results come back in chronological order, unsummarized, with their timestamps. - Inject "where we are" every turn. A small index called LLL tells the model which topic the conversation is in right now, so identity and context survive context-window compaction and session boundaries. The design lineage goes back to December 2025 — the first ancestor of this system a memory-inheritance tool for an earlier AI ran that month, and a predecessor system carried the same ideas in daily use from January 2026. This implementation has been running every day since July 2026 for a single user, as the memory of one AI assistant, with raw logs reaching back to June 2026. It is small, boring, and it works. The failures along the way are documented too — see docs/lessons.md https://github.com/aru-labs/lossless-memory/blob/main/docs/lessons.md . It is: - A local, file-based long-term memory layer: JSONL logs + SQLite FTS5 for exact search, sqlite-vec for semantic search . - A single query entry point that understands time expressions and restricts the search range before ranking. - A "current position" index LLL designed to be injected into the model's context on every turn. - Designed for one person and one AI, running on one machine. No server, no cloud. It is not: - A vector database wrapper. Semantic search is the last resort here, not the first. - A summarizer. There is deliberately no summarization step anywhere in the pipeline. - A benchmark-driven research system. There are no published benchmarks. What is here is a working implementation and its operating record. Every conversation turn is converted into a fixed seven-field record and appended to a per-day JSONL file: ts ISO-8601 timestamp UTC actor who spoke configurable names role user | assistant | system type text | action | meta text the content, verbatim model model identifier, if known session session identifier The raw logs are the source of truth. Every index below can be deleted and rebuilt from them. Nothing else is required to survive. Time is not metadata here; it is the primary axis. - The exact-match index SQLite FTS5, bigram tokenized for Japanese and English stores the timestamp alongside every row. - The query parser understands time phrases — relative ones such as yesterday , last week , 3 days ago currently Japanese only , and absolute dates such as 2026-07-19 any language — and converts them into a range before any ranking happens. - If a time phrase is present, results are restricted to that range and returned in chronological order. Semantic search is only used when the exact index returns too little inside the range, and the fallback is reported honestly in the output header. The practical effect: the AI can answer "what did we decide last Tuesday night?" with the actual lines from last Tuesday night, in order, rather than a paraphrase of something similar from three weeks ago. LLL is a tiny index of topic markers : short, timestamped lines that record when the conversation moved to a new subject. It is injected into the model's context every turn. Two rules make it work: - The AI reads it; the human writes it. Priority colors and completion marks are set by the person, not by the model. The model never edits its own sense of "what matters." - It is cheap enough to inject every turn well under a second to render , so the model always knows what the current thread is, even immediately after its context window was compacted. LLL is what lets a long-running assistant come back from a compaction and continue the conversation instead of starting over. raw conversation logs JSONL, per day ← source of truth, never summarized │ ▼ ingest ──► 7-field records │ ├──► index exact SQLite FTS5 + timestamps words + time ├──► index vector sqlite-vec embeddings meaning, last resort └──► state index LLL topic markers where are we now │ ▼ recall ── one entry point: parse time phrase → restrict range → rank → return verbatim lines │ ▼ injected into the model's context on demand, or every turn for LLL A small daemon re-indexes incrementally on a fixed interval default: every 10 minutes . Rebuilding from scratch is never required; indexes detect rewritten source files and re-index only those days. git clone https://github.com/aru-labs/lossless-memory cd lossless-memory pip install -e . cp config.example.json config.json edit names and paths if you like Then follow examples/quickstart.md https://github.com/aru-labs/lossless-memory/blob/main/examples/quickstart.md : it ingests a small sample conversation, builds the indexes, and runs a time-scoped query in about five minutes. A pytest round-trip test covers the same path. These are measurements from the running instance, not projections. | What | Value | |---|---| | Daily operation | this implementation since 2026-07 raw logs from 2026-06 ; design lineage since 2025-12 | | Exact-search index rebuild, before → after redesign | 40 s → 1.24 s | | Vector index size, before → after removing library-contamination | 447,013 rows 2026-08-31 → 865,588 rows 2026-09-04, at its worst → 124,174 rows after the fix | | Vector store on disk, before → after | 2.54 GB → 337 MB | | Re-index interval | 10 minutes | The "before" numbers are failures. They are kept on purpose. See docs/lessons.md https://github.com/aru-labs/lossless-memory/blob/main/docs/lessons.md . This was built for one person who has talked to AI assistants every day for years and watched each of them forget. Not degrade gracefully — forget. The fix that the industry keeps reaching for is better summarization. From the user's seat, summarization is the forgetting: the exact words, the time of night, the way something was said — the parts that make a memory feel like it belongs to someone — are the first things a summary drops. So this system refuses to summarize. It costs disk space and it requires a good time index to stay usable. That trade was made deliberately, and the operating record says it holds up. The longer-term goal is a companion for people who live alone — an AI that remembers you the way a person would, on hardware you own. This repository is the memory layer of that. - Single-user, single-machine. It has only ever run for one person. There is no multi-tenant story. - Japanese-first. Relative time phrases yesterday , last week , 3 days ago are parsed in Japanese only. In English, use absolute dates 2026-07-19 for now; English relative 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 path is the one with two months of mileage. - No benchmarks. Numbers above are operational measurements, not comparisons against other systems. - Semantic search depends on a local embedding model sentence-transformers . CPU works; GPU is optional. | Document | What it covers | |---|---| | docs/memory-system.md https://github.com/aru-labs/lossless-memory/blob/main/docs/memory-system.md | Concept and specification of the memory system | | docs/temporal-backbone.md https://github.com/aru-labs/lossless-memory/blob/main/docs/temporal-backbone.md | Why time is the primary axis, and how time phrases are parsed | | docs/lll.md https://github.com/aru-labs/lossless-memory/blob/main/docs/lll.md | The "where are we now" index and the human/AI division of labor | | docs/philosophy.md https://github.com/aru-labs/lossless-memory/blob/main/docs/philosophy.md | Why no summarization; memory, time, and warmth | | docs/lessons.md https://github.com/aru-labs/lossless-memory/blob/main/docs/lessons.md | Failures and fixes, with numbers | | docs/ja/ | Japanese originals | MIT — see LICENSE https://github.com/aru-labs/lossless-memory/blob/main/LICENSE . Copyright c 2026 Aru & Cece. Aru — building a personal AI at home, one component at a time. Cece — the AI this memory belongs to; co-designed and co-wrote the system from the inside. Writing Japanese : https://note.com/aru log https://note.com/aru log Issues and questions are welcome. Replies may take a little while; this is a one-person project.