m1nd-core 0.4.0

🇬🇧 English | 🇧🇷 Português | 🇪🇸 Español | 🇮🇹 Italiano | 🇫🇷 Français | 🇩🇪 Deutsch | 🇨🇳 中文

m1nd doesn't search your codebase -- it activates it. Fire a query into the graph and watch signal propagate across structural, semantic, temporal, and causal dimensions. Noise cancels out. Relevant connections amplify. And the graph learns from every interaction via Hebbian plasticity.

335 files -> 9,767 nodes -> 26,557 edges in 0.91 seconds.
Then: activate in 31ms. impact in 5ms. trace in 3.5ms. learn in <1ms.

Proven Results

Live audit on a production Python/FastAPI codebase (52K lines, 380 files):

Criterion micro-benchmarks (real hardware):

Quick Start

git clone https://github.com/maxkle1nz/m1nd.git
cd m1nd && cargo build --release
./target/release/m1nd-mcp

// 1. Ingest your codebase (910ms for 335 files)
{"method":"tools/call","params":{"name":"m1nd.ingest","arguments":{"path":"/your/project","agent_id":"dev"}}}
// -> 9,767 nodes, 26,557 edges, PageRank computed

// 2. Ask: "What's related to authentication?"
{"method":"tools/call","params":{"name":"m1nd.activate","arguments":{"query":"authentication","agent_id":"dev"}}}
// -> auth fires -> propagates to session, middleware, JWT, user model
//    ghost edges reveal undocumented connections

// 3. Tell the graph what was useful
{"method":"tools/call","params":{"name":"m1nd.learn","arguments":{"feedback":"correct","node_ids":["file::auth.py","file::middleware.py"],"agent_id":"dev"}}}
// -> 740 edges strengthened via Hebbian LTP. Next query is smarter.

Add to Claude Code (~/.claude.json):

{
  "mcpServers": {
    "m1nd": {
      "command": "/path/to/m1nd-mcp",
      "env": {
        "M1ND_GRAPH_SOURCE": "/tmp/m1nd-graph.json",
        "M1ND_PLASTICITY_STATE": "/tmp/m1nd-plasticity.json"
      }
    }
  }
}

Works with any MCP client: Claude Code, Cursor, Windsurf, Zed, or your own.

It worked? Star this repo -- it helps others find it. Bug or idea? Open an issue. Want to go deeper? See EXAMPLES.md for real-world pipelines.

Why Not Just Use Cursor/RAG/grep?

Comparisons reflect capabilities at time of writing. Each tool excels at its primary use case; m1nd is not a replacement for Sourcegraph's enterprise search or Cursor's editing UX.

What Makes It Different

The graph learns. Confirm results are useful -- edge weights strengthen (Hebbian LTP). Mark results wrong -- they weaken (LTD). The graph evolves to match how your team thinks about your codebase. No other code intelligence tool does this.

The graph tests claims. "Does worker_pool depend on whatsapp_manager at runtime?" m1nd explores 25,015 paths in 58ms and returns a Bayesian confidence verdict. 89% accuracy across 10 live claims. It confirmed a session_pool leak at 99% confidence (3 bugs found) and correctly rejected a circular dependency hypothesis at 1%.

The graph ingests memory. Pass adapter: "memory" to ingest .md/.txt files into the same graph as code. activate("antibody pattern matching") returns both pattern_models.py (implementation) and PRD-ANTIBODIES.md (spec). missing("GUI web server") finds specs with no implementation -- gap detection across domains.

The graph detects bugs before they happen. Five engines beyond structural analysis:

• Antibody System -- remembers bug patterns, scans for recurrence on every ingest
• Epidemic Engine -- SIR propagation predicts which modules harbor undiscovered bugs
• Tremor Detection -- change acceleration (second derivative) precedes bugs, not just churn
• Trust Ledger -- per-module actuarial risk scores from defect history
• Layer Detection -- auto-detects architectural layers, reports dependency violations

The graph saves investigations. trail.save -> trail.resume days later from the exact same cognitive position. Two agents on the same bug? trail.merge -- automatic conflict detection on shared nodes.

The 61 Tools

Full API reference with examples ->

Architecture

Three Rust crates. No runtime dependencies. No LLM calls. No API keys. ~8MB binary.

m1nd-core/     Graph engine, spreading activation, Hebbian plasticity, hypothesis engine,
               antibody system, flow simulator, epidemic, tremor, trust, layer detection
m1nd-ingest/   Language extractors (28 languages), memory adapter, JSON adapter,
               git enrichment, cross-file resolver, incremental diff
m1nd-mcp/      MCP server, 61 tool handlers, JSON-RPC over stdio, HTTP server + GUI

graph LR
    subgraph Ingest
        A[Code / 28 langs] --> R[Reference Resolver]
        MA[Memory adapter] --> R
        JA[JSON adapter] --> R
        R --> GD[Git enrichment]
        GD --> G[CSR Graph]
    end
    subgraph Core
        G --> SA[Spreading Activation]
        G --> HP[Hebbian Plasticity]
        G --> HY[Hypothesis Engine]
        G --> SX[Superpowers Extended]
        SA --> XLR[XLR Noise Cancel]
    end
    subgraph MCP
        XLR --> T[61 Tools]
        HP --> T
        HY --> T
        SX --> T
        T --> IO[JSON-RPC stdio]
        T --> HTTP[HTTP API + GUI]
    end
    IO --> C[Claude Code / Cursor / any MCP client]
    HTTP --> B[Browser on localhost:1337]

28 languages via tree-sitter across two tiers. Default build includes Tier 2 (8 langs). Add --features tier1 for all 28. Language details ->

When NOT to Use m1nd

• You need neural semantic search. V1 uses trigram matching, not embeddings. "Find code that means authentication but never uses the word" won't work yet.
• You have 400K+ files. The graph lives in memory (~2MB per 10K nodes). It works, but it wasn't optimized for that scale.
• You need dataflow / taint analysis. m1nd tracks structural and co-change relationships, not data propagation through variables. Use Semgrep or CodeQL for that.
• You need sub-symbol tracking. m1nd models function calls and imports as edges, not data flow through arguments.
• You need real-time indexing on every save. Ingest is fast (910ms for 335 files) but not instantaneous. m1nd is for session-level intelligence, not keystroke feedback. Use your LSP for that.

Use Cases

Bug hunt: hypothesize -> missing -> flow_simulate -> trace. Zero grep. The graph navigates to the bug. 39 bugs found in one session.

Pre-deploy gate: antibody_scan -> validate_plan -> epidemic. Scans for known bug shapes, assesses blast radius, predicts infection spread.

Architecture audit: layers -> layer_inspect -> counterfactual. Auto-detects layers, finds violations, simulates what breaks if you remove a module.

Onboarding: activate -> layers -> perspective.start -> perspective.follow. New developer asks "how does auth work?" -- graph lights up the path.

Cross-domain search: ingest(adapter="memory", mode="merge") -> activate. Code + docs in one graph. One question returns both the spec and the implementation.

Contributing

m1nd is early-stage and evolving fast. Contributions welcome: language extractors, graph algorithms, MCP tools, and benchmarks. See CONTRIBUTING.md.

License

MIT -- see LICENSE.