Your Claude Code agent, with a memory that survives. Plus structural code intelligence.
One line in .mcp.json and Claude Code recalls decisions across every session, every project, and answers structural questions about your codebase (callers of X, class of Y) in sub-ms — no grep, no re-reading files. Free tier, no card.
Remembers across repos
Decisions you made in repo A are recallable from repo B. No copy-pasting CLAUDE.md across projects.
Zero-boilerplate capture
neruva-record installs as a Claude Code hook. Every session, every tool call, every decision — captured.
Redacted client-side
14-pattern leak guard before bytes leave your machine. Keys, tokens, secrets — never recorded.
Two ways to wire it in.
52 tools, hand-callable
Add to ~/.config/claude-code/.mcp.json (or your project's). Restart Claude Code. Tools show up under the neruva namespace.
{
"mcpServers": {
"neruva": {
"command": "npx",
"args": ["-y", "@neruva/mcp@latest"],
"env": { "NERUVA_API_KEY": "<your-key>" }
}
}
}Zero-touch session capture
Adds a Claude Code hook that records every session as typed events. Recall surfaces in your next conversation automatically.
# pip install neruva-record # adds a Claude Code hook that auto-records every session # plus auto-indexes the cwd codebase at SessionStart python -m neruva_record.install_hook --api-key <your-key> # add Go / Rust / Java / Ruby / C++ to the code-graph: pip install 'neruva-record[multilang]'
# In Claude Code: > Use neruva to recall what we decided about auth last week > Use neruva to save a decision: "switched to JWT refresh tokens" > Use neruva to find every bug we've fixed in src/billing
More than “another vector DB.”
Typed records substrate
kind + tags + ts + meta + auto-embed. records_compact deterministically summarizes old runs into one row + tombstones the originals. Replayable from seed.
5 knowledge-graph engines
Hadamard / OPB / multishard / 3-shard quorum / feature_bundle — selectable per query. Scales from a handful of facts to hundreds of thousands per matrix. N-hop derive in a single matmul.
Pearl do-operator
Causal queries on agent memory. “What if X had happened” returns a different answer than “X happened” — arithmetically distinct, not a paraphrase.
HD analogy parallelogram
Cross-domain analogy retrieval. Find the auth bug in repo B that's the same shape as the one you fixed in repo A six months ago.
CBR episode store
Factored episode storage with top-K majority-vote retrieval. Sub-ms recall over thousands of cases.
Deterministic replay
Bit-identical reruns from the same seed. Auditable, exportable as one .neruva file. The compliance story no other agent-memory vendor ships.
Your codebase, indexed once. Queried sub-ms. Forever.
One install adds a SessionStart hook that auto-indexes any Python or JavaScript/TypeScript project on the first turn. Functions, classes, callers, callees, imports, inheritance — all bound into the same HD substrate that holds your decisions. No grep, no re-reading 10 files per question.
Auto-fire on session start
On by default. Open any project (pyproject.toml / package.json / Cargo.toml / go.mod / setup.py) and your code-graph indexes silently in the background. Stable KG name from cwd hash; 1-hour dedup; persists across sessions.
Eight languages, one engine
Python · JavaScript · TypeScript · Go · Rust · Java · Ruby · C / C++. Same triple schema, same engine, same MCP surface across every language. Free across every tier — code-graph storage does not count against the records cap.
Five new MCP tools
code_kg_callees / callers / class_of / module_of / imports. Each is a thin wrapper over hd_kg_query with “Call this when…” routing nudges so Claude picks the structural path instead of grepping.
99%+ macro recall on real codebases
Measured top-1 recall across calls / callers / classes / imports queries on real production codebases. Index runs in under a minute on a laptop; SessionStart auto-hook makes it invisible to the developer. See /benchmarks for the open harness.
> Use neruva code_kg_callers to find what calls bind() in this repo > Use neruva code_kg_class_of to find the class that owns HDKnowledgeGraph.query > Use neruva code_kg_imports to list every module that imports zlib > Use neruva agent_recall to find any prior decision about how we factored this module
Same one API key. Same one billing ledger. Sub-ms each. $0/call substrate side (no LLM in the query path). Code graph is portable in the same .neruva bundle that carries your records, KG, theory-of-mind, episodes, rules.
CLAUDE.md doesn't scale. We do.
Markdown files don't search. They go stale. They don't carry decision context between repos. Neruva is queryable, time-stamped, semantic, and cross-project.
Pasting yesterday's chat into today's prompt is $0.00625/turn at Opus 4.7 list. Neruva recall is ~3,000× cheaper and sub-100ms.
Key-value persistence inside one vendor's SDK. Neruva is vendor-neutral substrate with 5 KG engines, causal, analogy, CBR — works across Claude / GPT / open-weights.
You'd build records-with-types, KG with 5 engines, causal do-operator, HD analogy, episode store, secrets redaction, injection guard, portable export. Or install Neruva.
Per-repo licensing, separate billing from your AI stack, no agent-memory pairing, no causal / ToM / replay. Neruva lives in the same engine as the rest of your substrate — one ledger, MCP-native, replayable from a seed.
They re-grep + re-read every session — O(tokens × codebase) every turn. Neruva indexes once at SessionStart, then sub-ms queries forever. Substrate side: $0/call.
Your next Claude Code session
starts with everything you've done before.
Free tier: 10k records, 100 recalls/day, no card. Pro $20/mo unlocks 1M records + unlimited cognitive primitives + unlimited recalls.