v0.5.1 · One-click auto-update · Agent auto-start · Per-folder brains · Windows + macOS live

Claude forgets you after every conversation. NeuroVault doesn't.

100% local. Your memory is embedded on your own machine and never leaves it — no cloud, no API keys, no account. Private by architecture, not a setting you switch on.

A local-first memory layer for AI agents. Notes, decisions, people, projects — captured once, recalled whenever any MCP-speaking agent asks. Analytics mode shows the structure of your brain at a glance: bigger nodes for what gets referenced most, soft tints for clusters of linked notes.

macOS says "NeuroVault is damaged"? It's the missing Apple certificate (we're open-source), not malware — drag the app to Applications, then run xattr -dr com.apple.quarantine /Applications/NeuroVault.app once, or right-click → Open. Details ↗

94%
hit@5 · LongMemEval
full 470-question run
118 ms
recall over 120k-token
haystacks — zero cloud
23 MB
macOS DMG
download
1-click
install
& Claude integration
UP AND RUNNING IN SECONDS

One download. One line. It remembers.

THE PITCH

Most "agent memory" products are a RAG pipeline in a trench coat.
NeuroVault is a living wiki your agent can read, write, and challenge.

Every memory is a plain .md file on your disk. The database is just an index. If the index ever breaks, we rebuild it from the files. You own your brain.

YOUR SECOND BRAIN, FORMING

One memory. Then it connects everything.

Every note, decision, person, and project becomes a node. Each one wires to what it relates to — until the shape of how you think is something you can actually see.

WHY IT'S DIFFERENT

Stop re-explaining yourself.

Every new session, your agent forgets. So you compensate — and the workarounds cost you more context than they save.

The old way

  • Re-explain your stack, your preferences, your decisions — every single session.
  • Cram everything into a 22k-token CLAUDE.md that bloats every prompt — and still goes stale.
  • Past chats vanish the moment you close the window. The agent starts from zero.
  • Your "memory" lives in one vendor's cloud, in a format you can't read or move.

With NeuroVault

  • Say it once. Any MCP agent recalls it the moment it's relevant.
  • Recall returns the handful of passages that actually matter — not the whole file.
  • Notes, decisions, people, projects persist across every session and every agent.
  • Plain markdown on your disk. Yours forever, readable in any editor.
THE FLAGSHIP

Point it at your codebase. Watch it become a graph.

Graphify parses your repo on-device with tree-sitter and builds a living graph of every symbol, import, and call. Now your agent reasons about your code's structure — not just greps its text. No source ever leaves your machine.

8languages
1,887files in 8.4s
100%on-device
0API keys
where_defined

Jump straight to where any symbol is declared — across the whole repo.

who_calls

Every caller of a function or method, so the agent traces real usage.

blast_radius

Change this and what breaks? The transitive set of everything that depends on it.

whats_in_file

The symbols and signatures in any file — a structured table of contents.

fuse

Link a decision or wiki note to the code it governs — memory meets source.

RustPythonTypeScriptTSXGoJavaC#Ruby

BENCHMARKED IN THE OPEN

94% recall on one of the hardest memory benchmarks there is.

LongMemEval is brutal — long multi-session histories, facts that get updated and contradicted, questions that need temporal reasoning. Across the full 470-question set, NeuroVault surfaces the right memory in its top 5 results 93.8% of the time, and in the top 10 98.1% of the time — running entirely on your machine. Every number reproduces on your laptop with one command.

94%
hit@5
right memory in the top 5
98%
hit@10
right memory in the top 10
118ms
median query
over a 120k-token haystack
100%
on-device
zero cloud · no API keys

Measured on LongMemEval-S with NeuroVault's real recall() path — the exact code your agent calls — using 100% on-device embeddings. The stricter recall@5 (every gold passage, not just one) is published too: 0.861. The full harness and a per-question receipt for every answer live in the repo. Full methodology, harness & per-question receipts ↗

WHAT YOU GET

Memory that sticks.

Never leaves your laptop

No cloud, no account, no telemetry — just plain markdown files on your disk. The backend binds to loopback only and refuses outside connections.

See how you think

Every note is a node in a live, force-directed graph. Analytics mode sizes nodes by influence (PageRank) and tints clusters of linked ideas (Louvain), so the shape of your knowledge is visible at a glance.

Recall that thinks like you do

Hybrid search fuses semantic, keyword, and graph hits, reranks them, and weights by recency — so recall surfaces what you meant, not just what you literally typed.

Write without friction

Live preview, [[wikilinks]], a ⌘K command palette, VS Code-style tabs, and 7 themes. It behaves like the editor you already use all day.

AI does the busywork — in your session

Claude drafts wiki pages from your raw notes and names your clusters, running in the Claude / Cursor session you already have open via MCP. No API keys. Every change is a diff you approve.

Works with your agent — zero setup

One click writes NeuroVault's MCP entry into ~/.claude.json (your login untouched). The agent auto-starts the backend on first use — no "is the server running?". Just recall().

A brain per context

Work, research, personal — switch brains with one keystroke, Obsidian-compatible. Opt a project folder into its own brain with a .neurovault file; each codebase gets memory scoped to itself.

A widget, not a window

A tiny floating control parks in the corner: backend status, start / pause, open the app. Shrink it to just the logo, or hide it entirely.

ONE BRAIN, COUNTLESS USES

What can you use NeuroVault for?

Anything you'd keep in notes, NeuroVault makes askable — and because it's all on your machine, even the private, proprietary, and privileged stuff is fair game.

Ask your own notes

Thousands of notes, but search can't find what you phrased differently years ago. Ask in plain language and get the actual passage back — even when no keyword matches.

Organize a folder of work

Point NeuroVault at any folder of markdown and it builds a searchable brain in minutes. Recall finds the right note by what you meant, not the words you typed.

Your codebase as a brain

Run graphify on any repo for an on-device code knowledge graph, then ask where_defined, who_calls, or blast_radius before you refactor. Source never leaves the machine.

Write a dissertation

Build a linked web of literature notes across years of work. The graph and semantic recall surface every note on a theme across chapters — and reveal where two sources disagree.

A journal that answers back

Ask your diary when your anxious entries cluster, or what you said last time you felt burned out. The embeddings and retrieval run entirely on-device — nothing reaches a cloud LLM.

Give Claude a memory of you

Save your preferences, decisions, and context once as markdown you own. Every session your agent recalls it over MCP — across Claude, Cursor, and Codex, not locked to one vendor.

A confidential client brain

Even Obsidian-plus-AI ships your note text to a cloud LLM. NeuroVault keeps the files and the search local — so lawyers, accountants, and therapists can ask about privileged notes with nothing leaving the device.

Keep your coding agent grounded

Save the repo layout, auth flow, and why-we-did-X once; the next session recalls them instead of inventing wrong file paths. Per-project brains keep one repo's context out of another's.

And it scales with you. Add as many notes as you want — your vault is plain markdown (10,000 notes is only ~130 MB), the database is a lightweight rebuildable cache over it, and recall stays in the low‑hundreds of milliseconds even on a big brain.

PLUGS INTO YOUR AGENT

52 tools. Your agent loads only what it needs.

NeuroVault speaks MCP, so Claude Code, Claude Desktop, Cursor, and Codex all read and write the same brain. Tools are grouped into tiers — pick a slice, not the kitchen sink. Switch any time in Settings.

minimal

3

recall · related · session_start

read-only

lite

8

+ remember · status · switch_brain · update

default

standard

18

+ chunk & temporal recall · duplicate check · core memory · history

power users

full

52

+ graphify · maintenance · graph editing · contradictions · images

everything
SEE IT

Every surface, customisable.

NeuroVault graph view with the Filters panel open — sliders for node size, link thickness, layout shape, and time-lapse
Graph view + Filters panel. Force-directed brain in the centre, orphan halo around it, full Obsidian-style customisation panel on the right. Search, filter by edge type, scale node size and link thickness, switch layout shapes, retune the d3-force simulation, all live.
NeuroVault graph view with semantic edges enabled — every inferred relationship visible at once
Semantic edges on. Toggle the inferred similarity layer back on and watch the brain densify. manual wikilinks, entity co-mentions, and semantic embedding matches each have their own colour. Hide them by default to read the structure; bring them back when you want the full neighbourhood.
NeuroVault command palette — commands, notes, and semantic memory in one prompt
Command palette. ⌘K is the primary nav verb. Three sections in one palette — Commands (fuzzy), Notes (title search), Memory (semantic recall after three characters).
NeuroVault Compile tab with the agent compile flow expanded — topic, source pack, auto-approve toggle
Agent-driven compile. Type a topic, hit Prepare. NeuroVault gathers every relevant engram, hands the source pack to your agent. The agent writes a canonical wiki page, you review and approve — or flip the auto-approve toggle and let trusted compiles ship straight to the vault.
NeuroVault Notes view with multiple tabs and right-click context menu — Close, Close others, Close all
VS Code-style note tabs. Open as many notes as you like. Drag to reorder, middle-click to close, right-click for Close / Close others / Close all. Behaves like the editor you already use all day.
HOW IT WORKS

Three paths to the same memory.

01

You write a note

Auto-saved as markdown. A file watcher triggers the ingestion pipeline — chunk, embed locally, extract entities, update the knowledge graph.

02

You drop a fact in chat

A UserPromptSubmit hook silently runs your message through an extractor. Eight patterns catch preferences, decisions, deadlines, stacks. Each fact becomes a first-class kind='insight' engram with a wikilink back to where you said it.

03

The agent asks

Claude calls recall() via MCP. Hybrid search fuses semantic, keyword, and graph hits. Cross-encoder reranks the top candidates; PageRank importance lifts hub notes when Analytics mode is on. Answers now carry context they couldn't have had before.

ON THE ROADMAP · FOR TEAMS

A shared brain for your whole company.

The same local-first engine, synced through a private Git repo you already own. Drop in your meeting notes and decisions; NeuroVault turns them into a knowledge graph every teammate's agent can recall — "what did we promise Acme, and when?" answered with sources.

Star on GitHub for early access
DATA SAFETY

100% local. Actually.

Give Claude a memory that survives the window close.