Membase

Sep 2026

A research prototype for personal memory and imperfect recall. Membase explores how notes can remain useful when you remember only a person, event, or vague connection, not the exact words you originally stored.

What got me started

I kept noticing that I never forget a note the way I write it. I forget it in terms of who it was about, or roughly when, or what it felt like. Most search tools want a query close to the original text, and that's exactly the part of my memory I don't have. I didn't want a bigger embedding model to paper over that; I wanted to actually design for it. The underlying idea I was chasing is pretty simple: I should be able to hand something to a system and trust I can get it back later, even once I've forgotten the words I used to put it there.

The rule I kept coming back to

A note gets captured verbatim and is never rewritten. It then splits into separate memory units, and each one carries four layers, strictly ordered: what I actually typed, which nothing outranks; what I clarified later, appended rather than overwritten; what the model inferred, which I can always regenerate; and the fully derived search indexes sitting on top of all of it. Re-running an embedding or a re-analysis can only touch its own layer and whatever's beneath; it has no way to reach up and change something I wrote or confirmed myself. I spent more time on this ordering than on anything else in the project, mostly because the alternative, letting a model quietly "clean up" what I wrote, was the one failure mode I actually cared about avoiding.

What's underneath

Ingestion doesn't stop at chunking and embedding. It turns unstructured input into structured memory units, extracts the relationships between them, and organises the episodic side of things, and retrieval reads back off that: associative and iterative passes that reconstruct something from incomplete clues rather than matching a query against documents. Concretely that's ingestion and processing pipelines, a PostgreSQL/pgvector memory backend, an associative memory graph over it, and an adaptive retrieval engine running on locally hosted models. The decision I'm happiest with is treating the graph as a deterministic, rebuildable projection of the underlying memories rather than as primary data: I can throw it away and regenerate it. That's what let me put a richer representation of memory in without the system coming to depend on a fragile structure I'd have to maintain separately.

Letting it say "I don't know"

Search is hybrid, lexical plus vector, run over both the raw text and the derived semantic layer. The retrieval step only calls an answer "grounded" if what came back actually supports it; otherwise it just says "I don't have a stored memory about this," through the same code path as any other answer, not as a special-cased failure. If a few memories could plausibly answer a question, there's a separate recall flow that asks one concrete clarifying question instead of silently picking one, which, as it turned out when I benchmarked it, costs correctness rather than buying it. And if two memories flatly disagree, that gets surfaced instead of quietly resolved; I'd rather see the contradiction than have the system guess which one I meant.

Whether it actually works

I didn't want to leave the approach as an assertion, so I built a benchmark: 40 queries over 44 interconnected memories, comparing conventional vector retrieval, semantic reranking, associative retrieval, and adaptive retrieval. Associative retrieval came out best on Recall@5, 0.943 against 0.886 for vector search. Adaptive retrieval did worse than I expected, and the clarification questions in particular pushed overall correctness down rather than up, the opposite of what the design assumed. I documented the regression and left it as an open research question instead of quietly dropping it.

Where it's at

The app itself is seven sections now: an overview, Recall, a graph explorer, a timeline, a library of everything stored, the benchmark results, and Store for writing something new. I wrote more documentation for this one than for most things I've built: ARCHITECTURE.md for the actual design, DECISIONS.md as a log of what I tried and walked back, REPORT.md for how it did against a real local model rather than just unit tests against fakes, and a TODO.md of what I still haven't figured out. MIT-licensed. It's still an experiment. I haven't established that associative retrieval is universally superior, only that it won on Recall@5 in my own benchmark. What I did get out of it is the path from an intuitive question about human cognition to a system that runs, has an interface you can actually use, and produces numbers I can argue with. What I'm most curious about now is whether any of it transfers to memory in LLM systems, where storing and retrieving information reliably over long periods is still an open problem.

Open the app · Source and design notes