🧠 NeuralMind

Persistent memory and context compression for AI coding agents.

After install, your agent:

• Boots with SYNAPSE_MEMORY.md (learned associations, strongest hub files)
• Receives PostToolUse compression automatically (Bash output → errors + signals)
• Queries your codebase in ~800 tokens instead of ~50,000

If you don't use Claude Code, configure: neuralmind install-mcp --all

v1.0.0 — Team tier ships (July 2026)

NeuralMind Team — $29/user/mo, annual, 5-50 seats. Governance, immutable audit log, self-hosted deployment, and seat management on top of the MIT core.

Acceptance: 46 Tier 2 unit + integration tests pass, both e2e scripts exit 0.

Read the full plan: TIER2-BRD.md · TIER2-TRD.md · TIER2-TEST-PLAN.md · Complete changelog

v1.4.0 — Louvain modularity clustering (July 2026)

build_graph now groups files by architectural dependency, not by path. Louvain modularity over structural edges (imports/calls/inherits) replaces balanced-per-file community assignment. Deterministic, fail-open, incremental-stable.

Measured on a 7-file test project: 7 per-file communities → 4 architectural-layer communities (auth, users, core, docs).

What's NOT shipping: Leiden algorithm (requires python-igraph C dep), multilevel Phase 2 repetition, community quality metric Q. All documented in docs/specs/G3-TRD.md §8 as future work.

v0.52.0 — The impact tool ships (July 2026)

v0.52.0 gives a capability we've had since v0.42.0 a name an agent would actually reach for. What shipped in v0.52.0:

Read the full plan: docs/FUTURE-PROOFING-PLAN.md · Handoff v2→v0.48.0 · Complete changelog

Why NeuralMind — four benefits, each backed by an eval you can run

NeuralMind is more than token reduction. Every claim below ships with a reproducible eval — run python -m evals.public.run yourself; the raw per-query traces are committed.

Honest scope: the cost and accuracy rows run on real, pinned OSS repos (fully reproducible — methodology); the learning and grounding rows are measured in committed A/Bs on the bundled reference fixture, so they're real but smaller-scope. We report where NeuralMind doesn't win too — a well-tuned vector RAG ties it on pure findability and is cheaper on raw tokens; that's in the benchmark table.

🆕 New in v0.47.0 — Impact: blast radius under a name you'd actually reach for. A Reddit comparison against GitNexus flagged "no impact tool" as a gap — not quite right (structural --blast-radius has answered "what depends on this?" since v0.42.0), but the naming critique landed: nobody finds a boolean flag on a differently-named command when they're looking for "impact analysis." neuralmind impact <symbol> --depth N is the same structural-index traversal under a name that matches the question, with richer output — each dependent row now carries its hop and its relation (calls/inherits/imports_from/implements), not just a bare id, plus resolution transparency (exact/semantic/none). Nothing about the underlying traversal changed — structural --blast-radius stays byte-identical, now implemented as a one-line wrapper over the same blast_radius_detail() this release adds, so there's exactly one traversal, not two drifting in parallel. MCP tool: neuralmind_impact(project_path, symbol, depth). Release notes

v0.45.0 — The token receipt gets a price tag. neuralmind savings has always verified the 40-70x token claim against your own logged usage; v0.45.0 converts that into the number stakeholders actually ask for: dollars. neuralmind savings --cost appends a dollar-savings block — cost without NeuralMind, cost with it, amount saved, and a labeled daily/monthly projection — priced on input tokens (NeuralMind is a retrieval layer; it only ever decides which input tokens ship, so output pricing never enters the math). --model picks from a built-in input-price table (Claude Fable 5 / Opus 4.8 / Sonnet 5 / Haiku 4.5, GPT-5.1/mini, Gemini 2.5 Pro/Flash — snapshot 2026-07), --queries-per-day tunes the projection, and --json adds a machine-readable dollar_savings block for dashboards. The math is deliberately boring: totals come straight from the token totals at the price per MTok, projections scale the observed per-event average — every assumption printed where you can see it. Release notes 🌐 Visit the landing page • 📖 Read the About page • ⚖️ Not affiliated with NeuralMind.ai

🧠 What changes when an agent has memory

🆕 New in v0.45.0 — The token receipt gets a price tag. neuralmind savings has always verified the 40-70x token claim against your own logged usage; v0.45.0 converts that into the number stakeholders actually ask for: dollars. neuralmind savings --cost appends a dollar-savings block — cost without NeuralMind, cost with it, amount saved, and a labeled daily/monthly projection — priced on input tokens (NeuralMind is a retrieval layer; it only ever decides which input tokens ship, so output pricing never enters the math). --model picks from a built-in input-price table (Claude Fable 5 / Opus 4.8 / Sonnet 5 / Haiku 4.5, GPT-5.1/mini, Gemini 2.5 Pro/Flash — snapshot 2026-07), --queries-per-day tunes the projection, and --json adds a machine-readable dollar_savings block for dashboards. The math is deliberately boring: totals come straight from the token totals at the price per MTok, projections scale the observed per-event average — every assumption printed where you can see it. Release notes

v0.44.0 — the odd one out, and the coverage that lies. The other two halves of "Surface what you can't see." (1) Cohesion outlier detection — the odd one out. When ten handlers route orgId through resolveOrgId and one skips it, NEURALMIND_SYNAPSE_OUTLIERS=1 flags the member that breaks the cluster's shared pattern — the "handler #11" a flat recall list can't distinguish. (2) neuralmind gaps — the coverage that lies. Classifies endpoints as live-covered / mock-only / untested, so a route that's "green" only under a mocked store (the P2003 shape) stops reading as tested. Release notes

v0.43.0 — The codebase remembers why, not just what. Every other NeuralMind memory is derived — embeddings from code, synapse weights from co-activation. This release adds the one memory only a human can author and the graph couldn't hold: decision rationale. Add a Decision: trailer to a commit ("resolveOrgId is per-handler — avoids Prisma on /health, keeps tests simple") and it becomes a subject-keyed, recallable memory. Ask neuralmind why "why is resolveOrgId per-handler?" and get the rationale back with its commit SHA; at prompt time the why is injected alongside synapse recall the moment its symbols light up (NEURALMIND_PROVENANCE_INJECT, on by default, fails open). The design win: git history is the store — the trailer is the persistence, so there's no database to build or drift, and it works retroactively on commits you've already made. Release notes

v0.42.0 — The code graph learns to answer "what does this touch?" NeuralMind's recall has always run on two soft signals — semantic similarity and the learned synapse graph. This release adds the hard one the graph carried all along: how the code is actually wired. graphify already extracts typed structural edges (calls, inherits, imports_from) into every graph.json; until now they were dead weight. v0.42.0 turns them into an agent-visible capability — a new neuralmind_structural_neighbors MCP tool and neuralmind structural <symbol> CLI return a symbol's callers, callees, base/sub classes, and importers, and --blast-radius gives the transitive set of code a change would affect. Precise and available day one — the complement to the learned synapse layer: structure says what can be related; synapses say what actually gets used together. Folding structural neighbors into L3 retrieval is opt-in (NEURALMIND_STRUCTURAL_RECALL=1) so default retrieval stays byte-identical; the whole layer is killable with NEURALMIND_STRUCTURAL=0. Release notes

v0.41.0 — The feedback loop closes; the relevance signal goes on the wire. Two features that make NeuralMind's half of a modular agent stack real. (1) Reuse-vs-rewrite feedback: a new Edit/Write PostToolUse hook (edit-activity) detects when freshly-written code reaches for symbols already defined elsewhere in the graph and feeds that reuse signal back into the synapse layer — so future retrieval surfaces the helpers and modules you've actually been reusing, not just what scores well semantically. This is the implicit counterpart to v0.38.0's explicit neuralmind_feedback tool: the agent doesn't have to say anything, NeuralMind learns from the edit it already made. Language-agnostic (normalizes graph labels like login_endpoint() to match bare tokens), a pure side effect that never forces a build, off-switch NEURALMIND_REUSE_FEEDBACK=0. (2) Structured relevance sidecar: retrieval can now attach a machine-readable relevance block — per file, per node, the vector score, learned synapse boost, recall flag, and line spans (built from the post-boost L3 hits, so it reflects the live synapse signals) — via neuralmind_query(include_relevance=true) or neuralmind query --relevance, so a downstream compressor can protect the load-bearing spans instead of shrinking them away. Versioned and stably-keyed, so it survives reordering — order-independent by design. Both are opt-in on the wire; default retrieval is unchanged. Release notes

v0.40.0 — Schema artifact indexing: OpenAPI, SQL, and Protocol Buffers. NeuralMind now indexes non-code schema artifacts alongside your source, closing the most-requested documentation gap. (1) OpenAPI / AsyncAPI (.yaml/.yml with an openapi/asyncapi/swagger key) — one node per path+method (POST /payments/charge), one per schema component (schema:Payment), one per AsyncAPI channel; plain YAML config files are silently skipped. (2) SQL DDL (.sql) — one node per CREATE TABLE/VIEW/PROCEDURE/FUNCTION/TRIGGER/INDEX/TYPE. (3) Protocol Buffers (.proto) — one node per message, service, rpc, and enum. All three use the same document node type as Markdown, so neuralmind_query and neuralmind_search surface them automatically — no new tools, no config change. Schema nodes participate in incremental rebuild and the synapse layer learns cross-artifact associations (e.g. POST /payments/charge co-activated with process_payment() strengthens automatically). Honest scope: $ref resolution, SQL ALTER/SELECT, and proto import edges are not modelled; GraphQL planned for v0.42.0. Release notes

v0.39.0 — Trust, transparency, and quality — six improvements. (1) neuralmind build --dry-run scans your project and shows a concrete token-savings estimate before building the index — auto-detects 10+ languages, --json for CI/onboarding scripts. (2) Faster synapse decay on deletion — neuralmind watch now detects deleted files immediately and calls NeuralMind.deactivate_files() to apply a targeted decay tick on every node in the removed file, so stale memory about deleted code stops surfacing in context after refactors. (3) neuralmind query --explain shows a human-readable breakdown of why each piece of context was selected (L0–L3 token budget, communities loaded, top search hits, synapses that fired) — implies --trace automatically. (4) neuralmind review runs git diff --name-only, seeds spreading activation from the changed files' graph nodes, and surfaces co-break candidates you probably forgot to touch — also available as the neuralmind_review MCP tool so agents can call it before proposing a change. (5) neuralmind savings reads the opt-in JSONL event log and shows cumulative token savings vs. estimated full-codebase cost, with per-query breakdown — verifies the 40-70× claim against your own real usage. (6) neuralmind probe now queries by rationale — the label-free self-test uses each symbol's docstring/intent as the query instead of its name, turning a string-match near-tautology (~0.95 MRR on any healthy index) into a genuine NL→code measurement (~0.79 MRR with real semantic blind spots disclosed). Release notes

v0.38.0 — Hybrid search, explicit feedback, and CI auto-index. Three retrieval-quality improvements in one release: (1) BM25 hybrid search — a code-aware keyword index (camelCase-split, snake_case-split) is built alongside the vector store and merged via Reciprocal Rank Fusion at query time, so "UserService" queries score exact-name matches first, not just semantically similar nodes — budget-neutral, toggle off with NEURALMIND_BM25=0. (2) neuralmind_feedback MCP tool — explicit positive/negative signal on a retrieved node that fires immediately: positive reinforces co-activation (same Hebbian update as natural co-editing, but instant); negative applies a targeted decay tick to all edges for that node (LTP-protected edges never fully removed by a single signal). (3) CI auto-index GitHub Action (.github/workflows/neuralmind-autoindex.yml) — auto-builds the index on every push to main, caches .neuralmind/, and commits the updated team memory snapshot so teammates always inherit fresh synapse intuition on their next session. No secrets needed — 100% local. Release notes

v0.37.0 — Multi-language: PHP. The built-in tree-sitter backend now indexes PHP (.php) out of the box — neuralmind build . works standalone on a PHP project, no graphify. class/interface/trait/enum become type nodes; methods/top-level functions become function nodes; properties ($ stripped from the label), class constants, and enum cases become symbol nodes; extends/implements resolve to inherits edges; use namespace imports resolve to imports_from edges (by class name, exactly like Java imports); and /** */ doc comments feed the rationale layer. That takes the bundled backend to ten languages — Python, TypeScript, Go, Rust, Java, C, C++, C#, Ruby, and PHP — behind the same _SUFFIX_LANG → _EXTRACTORS seam, proven at parity by the CI gate (54/54 symbols, 100% structural coverage, zero dangling edges), and completing the C#/Ruby/PHP breadth tier. Calls are best-effort and disclosed honestly (no $obj->method receiver-type resolution; require/include path imports aren't modelled — use is the edge source; trait-use-inside-a-class-body isn't modelled as inheritance). Release notes

v0.36.0 — Multi-language: Ruby. The built-in tree-sitter backend now indexes Ruby (.rb) out of the box — neuralmind build . works standalone on a Ruby project, no graphify. class/module become type nodes; def/def self. methods become function nodes; constant assignments (e.g. ATTEMPTS = 3) become symbol nodes; class Foo < Bar resolves to inherits edges; require_relative resolves to imports_from edges (relative-path resolved); and # doc comments feed the rationale layer. That takes the bundled backend to nine languages — Python, TypeScript, Go, Rust, Java, C, C++, C#, and Ruby — behind the same _SUFFIX_LANG → _EXTRACTORS seam, proven at parity by the CI gate (46/46 symbols, 100% structural coverage, zero dangling edges). Ruby is dynamic, so calls are best-effort and disclosed honestly (no receiver-type resolution; mixins via include/extend aren't modelled as inheritance; attr_accessor accessors/ivars aren't emitted as fields — constants are the symbol layer). Release notes

v0.35.0 — Multi-language: C#. The built-in tree-sitter backend now indexes C# (.cs) out of the box — neuralmind build . works standalone on a C# project, no graphify. class/interface/struct/record/enum become type nodes; methods/constructors become function nodes; fields, properties, and enum members become symbol nodes; base_list resolves to inherits edges; using directives resolve to imports_from edges; and /// doc comments feed the rationale layer. That takes the bundled backend to eight languages — Python, TypeScript, Go, Rust, Java, C, C++, and C# — behind the same _SUFFIX_LANG → _EXTRACTORS seam, proven at parity by the CI gate (52/52 symbols, 100% structural coverage, zero dangling edges). C# maps almost 1:1 onto the proven Java extractor, so it rides a proven shape at the smallest risk. Release notes

v0.34.0 — Answerability, not just findability. Gold-file recall measures whether the right file lands in the window — locating, not answering. The new opt-in answerability arm (python -m evals.public.run --judge) closes that gap honestly: for each query it takes the real context each backend would put in the window (whole files for full-file/ripgrep, retrieved chunks for embedding-rag, the compact L0–L3 assembly for neuralmind), asks a pinned model (claude-opus-4-8) to answer using only that context (it must say "insufficient context" otherwise), then a separate judge call grades the answer against the same def-site gold anchor on a 0–2 scale plus a grounded flag. Why it's hard to dismiss: same prompts + same pinned model for every backend (a low-recall window scores low instead of being papered over from prior knowledge); the answerer prompt, judge rubric, model id, and every raw transcript are committed under bench/public/judge/ (re-score or swap the model yourself). Off the deterministic path: it needs ANTHROPIC_API_KEY, never runs in CI, and the recall table is byte-identical with or without --judge. Recall-at-N×-tokens stays the headline; this is a clearly-labeled secondary signal. Release notes · methodology

v0.33.0 — The competitor head-to-head, run for real. The public benchmark's competitor row is no longer a scaffold — it's a live, reproducible head-to-head vs. codebase-memory-mcp 0.8.1 (the obvious incumbent) on the same pinned repos, same questions, same objective def-site gold, scored by the same quality.py as every other backend. At matched retrieval depth (top-8), NeuralMind hits 100% gold-file recall and ranks the right file far higher (MRR 0.96 vs 0.23 on requests, 0.60 vs 0.50 on click) while the competitor surfaces the gold file only ~half the time — at an order of magnitude more read cost. Honest framing: this is pure retrieval ranking (no LLM agent loop on either side — same as how we test NeuralMind's own search); we used the competitor's most-favorable reproducible keyword mapping; and we cite the competitor's published LLM-agent numbers (~90% of an "Explorer" agent; C at 0.58) as-is rather than reproduce them. So the win is on reproducible retrieval ranking, not on their agent-driven published figures. Reproduce: python -m evals.public.competitor (off the default run; pip install codebase-memory-mcp==0.8.1, no API key). Release notes · methodology

v0.32.0 — Multi-language: C and C++. The built-in tree-sitter backend now indexes C (.c/.h) and C++ (.cpp/.cc/.cxx + .hpp/.hh/.hxx) out of the box — neuralmind build . works standalone on a C/C++ project, no graphify. Functions, struct/union/enum (+ fields and constants), typedefs, C++ classes with member methods/fields, and namespace-qualified ids become code nodes; #include "local.h" resolves to imports_from edges; C++ base classes become inherits edges; and foo.h/foo.c pair onto a shared module key so a declaration and its definition land in the same neighborhood. That takes the bundled backend to seven languages — Python, TypeScript, Go, Rust, Java, C, and C++ — behind the same SUPPORTED_SUFFIXES seam, proven at parity by the CI gate (100% symbol coverage, zero dangling edges). Honest scope: macros aren't indexed as symbols, templates aren't specialized, and #ifdef isn't evaluated — we index the parseable code at full parity and disclose what's out (a competitor advertising 158 languages scored 0.58 on C; we index what we can serve). Release notes

v0.31.0 — The honest public benchmark. The "40–70× fewer tokens" claim ships with reproducible evidence built to survive hostile scrutiny: neuralmind benchmark --public clones real, pinned OSS repos (requests, click) and scores cost and correctness together against strong baselines (full-file paste, ripgrep, a same-encoder vector RAG). Result: 100% gold-file recall (objective def-site oracle, no LLM judge) at 38–85× fewer tokens than pasting files, beating ripgrep on both recall and cost. Synapse injection OFF for a fixed reproducible number; forkable runner + raw data committed. Release notes · methodology

v0.30.0 (shipped within v0.31.0) — Team memory: your agents inherit each other's intuition. NeuralMind's synapse layer learns what code goes with what from how you work; now a team can commit that learned signal so every teammate's agent inherits it automatically. neuralmind memory publish writes a committed .neuralmind-team-memory.json; on a teammate's next session/build it's imported once into the shared namespace (content-hash-gated, shared-only, off-switch NEURALMIND_TEAM_MEMORY=0, fail-open). A fresh git clone starts with the team's earned intuition — zero setup, 100% local, no source in the bundle. The differentiator a static code-index can't copy. Release notes

v0.29.0 — ChromaDB-free by default. On mainstream platforms (Linux, Apple Silicon, Windows x64), pip install neuralmind no longer pulls ChromaDB — the default is the ChromaDB-free turbovec/ONNX backend (byte-identical embeddings), removing ChromaDB's dependency tree and its recurring CVE surface from the default. The backend is platform-gated by wheel availability, so the install never breaks: platforms turbovec has no wheel for (Intel macOS, Windows ARM) auto-install ChromaDB as a transparent fallback. Retrieval is unchanged; a chroma-indexed repo auto-reindexes once into turbovec. Honest framing: ChromaDB-tree-free, not "smaller" — it trades ChromaDB's sprawl for one focused native dep (onnxruntime). Release notes

v0.28.0 — Multi-language: Java. The built-in tree-sitter backend indexes Java out of the box — classes, interfaces, enums, records, methods, constructors, fields, and enum constants become code nodes; extends/implements → inherits; import → imports_from (by FQN); Javadoc → the rationale layer. Five bundled languages (Python/TS/Go/Rust/Java). Release notes

v0.27.0 — Multi-language: Rust. The built-in tree-sitter backend indexes Rust out of the box — structs, enums, traits, impl blocks, fields, and free functions become code nodes; impl Trait for Type → inherits; use paths → imports_from; //////! doc comments → the rationale layer; target/ is skipped. Release notes

v0.26.0 — the selector starts tuning itself. Phases 1–2 of the self-improvement engine (issue #156): NeuralMind's memory logs query and wakeup events with a session_id, and an opt-in tuner (NEURALMIND_SELECTOR_AUTOTUNE=1) reads that signal back to adjust the selector's L2 recall depth from the re-query rate, persisted in the synapse store's meta table, with a transition-margin dampener. Off by default and byte-identical to v0.25.0 when unset (zero extra hot-path I/O); bounded to [2, 6] with single-step, windowed, fail-open moves. Inspect it with the read-only neuralmind self-improve status. Release notes

v0.25.0 — one learning system: the synapse layer. The old learned_patterns cooccurrence reranker is removed, and neuralmind learn is now an exit-0 deprecation no-op. The Hebbian synapse layer — which already learns continuously from queries, edits, and tool calls, and lets unused edges decay — is now NeuralMind's single learning signal. This is a removal, not a regression: a 2×2 A/B on the benchmark fixture showed the reranker moved top-k hit rate by 0.0 points with synapses on or off (71.7% → 71.7% cold, 83.3% → 83.3% warm), while the synapse layer alone adds +11.6 points. The reranker was also runtime-inert on the warm path (the synapse re-sort discarded its order), needed the manual neuralmind learn step, and went stale between runs. Warm-path behavior is unchanged — recall is synapse-driven exactly as before; the only visible difference is the L3 output no longer prints (+X.XX boost) labels from the reranker (synapse labels stay). Scripts calling neuralmind learn keep working (exit 0); a stale .neuralmind/learned_patterns.json is ignored and can be deleted; NeuralMind(enable_reranking=...) is accepted and ignored. Release notes

v0.24.0 — memory namespaces & branch isolation. The learned synapse layer is now namespace-aware: branch:<name> / personal / shared / ephemeral memory live separately in the same store, so a feature-branch spike can't pollute what the agent learned about main. Recall stays smart by default — a transparent merged view weights the active branch at 1.0×, your long-term personal memory at 0.8×, and an imported shared team baseline at 0.5× (published constants, attributed per-namespace in query --trace). New neuralmind memory {inspect,reset,export,import} shows contribution by namespace, clears exactly one namespace, and moves memory as versioned JSON bundles (the PRD 8 team-memory on-ramp). Existing learned memory migrates in place, losslessly into personal — single-transaction rebuild, rollback on any failure, proven by a no-data-loss test. Release notes

v0.23.0 — versioned index contract (IR), retrieval-quality harness, debug traces, and a local daemon. Four future-proofing foundations. (PRD 1) A canonical, schema-versioned intermediate representation of your code graph, validated on every build — a new neuralmind validate command checks the contract without a vector backend; the embedder still reads graph.json unchanged (the IR round-trips back identically), so retrieval is unaffected. (PRD 2) A new neuralmind benchmark --quality mode measures whether retrieval finds the right code — precision@k / recall@k / MRR / answerability over 30 golden queries across Python/TS/Go — and fails CI on a regression. (PRD 3) neuralmind query --trace shows why a result came back — per-layer candidates, cluster scoring with vector-vs-synapse attribution, and final hits. (PRD 5) An experimental neuralmind daemon holds project state warm so repeat query/stats skip cold backend init (auto-preferred when running, transparent direct-mode fallback). Release notes

v0.22.0 — turbovec becomes the default (when available). import neuralmind no longer requires ChromaDB, and the default backend is now auto: prefer the ChromaDB-free turbovec path when its deps are installed, else fall back to chroma. Safe by construction — a plain pip install neuralmind is unchanged; only installs with the [turbovec] extra flip, with a one-time auto-reindex (the old ChromaDB index is left as a fallback, nothing deleted). neuralmind doctor now shows the resolved backend. The staged middle step toward retiring ChromaDB. Release notes

v0.21.0 — ChromaDB-free retrieval. NeuralMind can now embed and search with zero ChromaDB: the opt-in turbovec backend pairs Google Research's TurboQuant compressed index (8–16× smaller vectors) with a bundled OnnxMiniLMEmbedder that produces vectors byte-identical to ChromaDB's (all-MiniLM-L6-v2 on just onnxruntime + tokenizers). At/above retrieval parity on the gold set (fact-recall 0.744→0.800). Enable with backend: turbovec in neuralmind-backend.yaml. This retires the dependency behind the recurring CVE-2026-45829 advisory. Release notes

v0.20.0 — Measure the onboarding lift. neuralmind eval --onboarding turns NeuralMind's headline differentiator into a number: does an agent that inherits a committed team memory retrieve better on its first queries than a cold agent with none? The headline is the top-k module hit-rate lift (a deterministic +6.5 points on the reference fixture), with fact-recall + grounding as honest secondaries; budget-neutral by design, gated in CI at lift ≥ 0. Release notes

v0.19.0 — One-command MCP setup. neuralmind install-mcp --all auto-detects your installed agents — Claude Code, Cursor, Cline, Claude Desktop — and registers NeuralMind's MCP server with each (non-destructive merge, idempotent). The agent then onboards onto your codebase through NeuralMind's tools instead of grepping cold. Distribution is half the moat; the learned synapse layer (usage memory) is the other half. Release notes

v0.18.0 — Incremental updates. Re-index just the file you edited, not the whole repo: neuralmind watch --reindex re-parses each changed file and re-embeds only its nodes (unchanged files stay byte-for-byte identical, so the embedder skips them). Your index stays fresh as you type. Release notes

v0.17.0 — Optional SCIP precision. Set NEURALMIND_PRECISION=1 with a SCIP index (scip-python/scip-typescript/scip-go) and NeuralMind folds in compiler-accurate calls/inherits edges, replacing the heuristic ones for covered files. Off by default, dependency-free, proven by a precision check in the CI gate. Release notes

v0.16.0 — Multi-language: TypeScript + Go. The built-in tree-sitter backend now indexes Python, TypeScript, and Go out of the box — neuralmind build . works standalone on a TS or Go repo, no graphify. Proven at parity per language by the CI gate (100% symbol coverage vs graphify). Release notes

v0.15.0 — No graphify needed. A built-in tree-sitter graph backend, so pip install neuralmind && neuralmind build . just works — no second, external tool. graphify still takes priority where present. Proven at parity by a CI gate (reduction + faithfulness within tolerance). Release notes

v0.14.0 — Measure faithfulness. A new contributor/CI command — neuralmind eval — turns "does the memory actually help?" into a number: it scores whether NeuralMind's selected context contains more of the facts a correct answer needs than a naive baseline at the same token budget (a faithfulness delta, plus grounding and contradiction checks). 100% local by default; the LLM-as-judge is opt-in. Release notes

v0.13.0 — Measurement foundation. The offline faithfulness dataset + expected-fact-recall scorer and polyglot (TypeScript + Go) retrieval fixtures that neuralmind eval is built on. Release notes

v0.12.0 — Install Doctor. One command — neuralmind doctor — inspects your setup (code graph, semantic index, synapse memory, MCP server, Claude Code hooks, query-memory consent) and prints each piece with a status and the exact command to fix it. Exits non-zero on a real failure so you can gate CI or an agent's setup step on it; --json gives a stable machine-readable snapshot. Release notes

v0.11.0 — Directional Synapses. The brain-like layer now learns what comes next, not just what goes together. A new `synap