What it does
One question. One answer drawn from your own sources.
Mnemosyne vectorizes your code, your docs, your notes, your conversations — and more, then chooses which vaults to query, doses the context, ranks it and drops the sources that add nothing. All of it on your processor, without a single line leaving your disk.
And the dosing matters more than the quantity: with the same model, question and retrieval, 91 injected sources give a hollow answer; 12 chosen sources give a structured synthesis.
The architecture
Everything fits inside your machine. Only one line leaves it.
The kernel queries your memory, sorts it, and consolidates it when the machine is at rest. The cartridges — the reader, the CRM, the translator — plug into it without ever touching it: each writes into its own vault, isolated from search and invisible to the rest.
Cognitive firewall
Between your data and the model, a checkpoint.
The model never touches your vault . Every retrieval is assembled on your machine, filtered, and only the chosen sources are handed to it — the boundary is deliberate: it's what stops a clever prompt from exfiltrating your memory.
Zero-Trust , even locally: every SDK or MCP request carries a scope-limited signed token (FGAC ). And when nothing relevant surfaces, the memory abstains — it tells you, rather than inventing.
How it works
Four mechanisms, and why they exist.
I
The vaults
Your memory isn't a heap. It's cut into watertight vaults, one per life domain, each with its own rights: who can read it, what it's allowed to be mixed with, whether it appears on the map. Your private journal only mixes with your code if you decide so. Never by default, never by accident.
II
The topics
Memory sorts itself into topics on its own, and that structure is stored as data — not as a side effect. It's what makes the rest possible.
III
The dream state
With the machine at rest, Mnemosyne rereads its own memory, topic by topic, and writes out its ledger: every occurrence, every value, every date, the running total. The ledger settles alongside the raw — never in its place. That's what earns +4.9 points on the real query path and 1/8 → 5/8 on the hardest category. Not "it doubles your memory." This.
IV
The sandbox pact
Each application gets exactly one vault, isolated from federated search, invisible to the map and the dream. It cannot widen its own walls: opening permanence is an operation the network cannot reach — only your hand on your keyboard can. An agent can propose. It cannot engrave.
The engine
Any model. Local or cloud. The same memory.
Pick the best model for each task — cloud for raw power, local for absolute privacy. Underneath, the memory doesn't change: switch providers without losing a thing.
Reasoning & chat
Embeddings & resonance
Hubs & providers
Under the hood
The engines.
Not one big "AI" black box — several independent, purpose-built engines:
Embedding engine
A priority-ordered chain of providers — cloud, local ONNX, Ollama. Fails loud rather than returning a null vector: a failed embedding must never silently become an invisible memory.
Retrieval engine
An in-RAM, decrypted vector cache (int8-quantized to scale). ANN search unioned with exact term matching, then a final re-rank pass.
Spine engine
Classifies every memory by semantic nature — its "spine" + tags — from a taxonomy that lives as data, not hardcoded logic. New categories need no code change.
Dream State
Two-speed consolidation: a fast tier extracts facts during use, a heavier tier runs at idle/night to resolve contradictions and link sessions. Appended alongside raw retrieval, never silently replacing it.
Adaptive RAG — the gearbox
Context selection (top-k / MMR / low-discrepancy sampling) scales to the model tier you run and the thinking mode you pick — instead of injecting every candidate.
Voice — STT & TTS
Independent engines: small STT models in-process, large ones in an isolated GPU/CPU sidecar; TTS system, cloud or local, sample-accurate for gapless playback. No NVIDIA GPU → CPU fallback, never a hard block.
242 IPC channels
Zod-validated channels connect every engine to the UI — auto-generated and checked by a drift test on every build.
The modules
Nine modules. One kernel.
Not one big "AI" box, but independent modules, each cut for its task, all plugged into the same memory core. Here's what you see and manipulate — the internal engines stay sealed.
Neural Map
Your memory rendered as living mathematical topology: nodes are memories, edges are measured semantic links, tuned live.
Dream state
A consolidation engine that rereads and reconnects your memories during rest phases.
Vaults
Memory partitioned by life domain, each with its own protection level and consent boundary.
Adaptive RAG
Retrieval depth and ranking adapt to the model you run — from a laptop LLM to a cutting-edge cloud model.
Voice assistant
Local or cloud voice, streaming STT/TTS, gapless local reading.
Multimodal chat
Text, voice and file conversation, with live retrieval from your own vaults.
MnemoHub
A catalog of cartridges signed by a sovereign wallet and verified client-side before any render.
Sovereign wallet & Engramm
A local Web3 wallet drives the license (verified on Base), the pseudonym and cloud credits — no account, no password, no gas fees.
Spatial canvas
Widgets live on a 2D canvas, not stacked tabs: position carries meaning.