Forensic Deepdive MCP-Server | PlugMCP

Agenten stärken

Diesen Server hinzufügen

Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführen

Host a copy with our keys and logs.

Lokaler Befehl

uvx forensic-deepdive==0.10.0

Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.

shClaude Code

1claude mcp add io.github.dhevenddra-forensic-deepdive -- uvx forensic-deepdive==0.10.0

In einem Terminal ausführen.

jsonClaude Desktop

1{2  "mcpServers": {3    "io.github.dhevenddra-forensic-deepdive": {4      "command": "uvx",5      "args": [6        "forensic-deepdive==0.10.0"7      ]8    }9  }10}

claude_desktop_config.json

Lokal · pypiInstallation vom HerausgeberSchritt für Schritt: in Claude hinzufügen

Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden

Auf PlugMCP ausführen

Host a copy with our keys and logs.

A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.

Server-Details

Lokal

Transport: stdio
Version: 0.10.0
Zuletzt geprüft

Vom Herausgeber

Dokumentation

forensic-deepdive

forensic-deepdive gives an AI coding agent forensic understanding of an unfamiliar codebase — a persistent knowledge graph, an MCP server, and five durable markdown artifacts, so your agent stops re-discovering the same architecture from scratch every session.

uv tool install forensic-deepdive && forensic extract /path/to/repo

	forensic-deepdive	GitNexus	CodeGraphContext	DeepWiki	Sourcegraph
License	Apache-2.0	PolyForm Noncommercial	MIT	proprietary (open variant: MIT)	partial
Persistent code knowledge graph	✅ LadybugDB	✅ LadybugDB	partial	❌	partial
MCP server	✅ 9 composite tools	✅ 16 tools	partial	❌	❌
Per-edge confidence taxonomy	✅ EXTRACTED / INFERRED / AMBIGUOUS	❌	❌	❌	❌
Git archaeology as a first-class layer	✅	❌	❌	❌	partial
Durable committed markdown artifacts	✅ 5 files	partial	partial	✅ (wiki)	❌
Agent-insight layer (`record_insight` / `recall_insights`)	✅	❌	❌	❌	❌
Multi-platform skill emission	✅ 10 shims	partial	partial	❌	❌
Local-only (no cloud required)	✅ co-equal	✅	✅	❌	❌

A persistent embedded graph at <repo>/.deepdive/graph.lbug — File, Symbol, Module, Commit, Author, Endpoint, and DbTable nodes plus DEFINES, MEMBER_OF, IMPORTS, CALLS, EXTENDS, IMPLEMENTS, TOUCHED_BY_COMMIT, AUTHORED_BY, CO_CHANGES_WITH, and the cross-boundary HANDLES / CALLS_ENDPOINT / ROUTES_TO / INJECTS / PERSISTS_TO edges. Every edge carries a confidence tag (EXTRACTED / INFERRED / AMBIGUOUS) — no hidden heuristics. The single Endpoint join node unifies five cross-boundary protocols (HTTP, MCP tools, registry-dispatch, gRPC, messaging/AMQP), so a frontend call resolves to its backend handler across the stack as one ROUTES_TO edge.
An MCP server (forensic serve) exposing 9 composite tools (impact, context, archaeology, flow, query, record_insight, recall_insights, visualize, trace) consumable by Claude Code, Cursor, Codex, Continue, Cline, Windsurf — and any other MCP-aware agent.
Five durable markdown artifacts under <repo>/docs/codebase/, regenerated from the graph on every extract:
- MAP.md — what's where, ranked by centrality.
- HOTPATHS.md — the dependency hot spots, with a per-row confidence-mix column so you see exactly how cleanly each symbol resolves.
- ARCHAEOLOGY.md — why the code looks the way it does (git history, top authors with %, bus factor, co-change clusters, defect proximity).
- MENTAL_MODEL.md — the doc the original author would write to onboard a new hire.
- AGENT_BRIEF.md — ≤5 KB of assertive Never/Always rules with per-rule confidence tags. Drop-in CLAUDE.md for any project.
Ten shims into the target repo — 4 editor rule files (CLAUDE.md, AGENTS.md, .cursor/rules/codebase.mdc, .continue/rules/codebase.md), 5 single-intent Claude skills under .claude/skills/codebase-{exploring,debugging,impact-analysis,refactoring,onboarding}/, and a .claude-plugin/plugin.json manifest. All write-if-absent — hand-edited files are never overwritten.
An agent-insight layer — record_insight / recall_insights MCP tools backed by <repo>/.deepdive/insights.jsonl by default (zero dependencies, human-readable, git-friendly). The optional [graphiti] extra upgrades to a temporal knowledge graph backend above a 2-of-5 repo-size threshold.

# install from PyPI (puts `forensic` on PATH); or run ephemerally with uvx
uv tool install forensic-deepdive
forensic info            # banner + capability panel
forensic extract /path/to/repo

# …or from source for development:
git clone https://github.com/Dhevenddra/forensic-deepdive && cd forensic-deepdive
uv sync --all-extras

# what can it do? (banner + capability panel: artifacts, protocols, MCP tools, confidence legend)
uv run forensic info

# guided setup: analyze a repo, then wire it up as an MCP server
# (--yes takes every default: scriptable, and the one mode that needs no extra)
uv run forensic onboard --repo /path/to/repo

# run on any repo
uv run forensic extract /path/to/repo

# graph lands at <repo>/.deepdive/graph.lbug
# 5 markdown artifacts at <repo>/docs/codebase/
# 10 shims at <repo>/.claude/, .cursor/, .continue/, root

# trace a cross-stack feature slice (frontend call -> endpoint -> handler -> tail)
uv run forensic trace <symbol> --repo /path/to/repo

# interactive query REPL over one held-open store (needs the [interactive] extra)
# bare text = natural-language query (no LLM) · :cypher <q> = raw Cypher · :help · Ctrl-D exits
uv run forensic repl --repo /path/to/repo

# full-screen terminal graph browser — the loopback-free sibling of serve --ui
# 1/2/3 = Symbols/Files/Endpoints · type to filter · c/e/l = confidence/edge/language · Enter = context · i/f = impact/flow
uv run forensic browse --repo /path/to/repo

# the session shell: all of the above over ONE held-open graph, with history
# in-session: extract · query · trace · impact · flow · diagram · browse · onboard · serve
uv run deepdive --repo /path/to/repo

# query the graph as an MCP server (point it at the analyzed repo)
uv run forensic serve --repo /path/to/repo

# inspect every repo you've analyzed
uv run forensic list

uv tool install forensic-deepdive        # puts `forensic` on PATH
forensic extract /path/to/repo

# …or run ephemerally, no install:
uvx forensic-deepdive extract /path/to/repo

forensic extract /path/to/repo --force --refresh-shims

/plugin marketplace add Dhevenddra/forensic-deepdive
/plugin install forensic-deepdive@dhevenddra

{
  "mcpServers": {
    "forensic-deepdive": {
      "command": "uvx",
      "args": ["forensic-deepdive", "serve", "--repo", "."]
    }
  }
}

Tool	What it does
`impact(symbol, depth, direction, min_confidence)`	Blast-radius BFS over CALLS edges, depth-bucketed, confidence-filterable.
`context(symbol)`	Single-call kitchen sink: definition + callers + callees + parent/siblings/members + extends/implements + recent commits + dominant author + recent insights.
`archaeology(file_or_symbol)`	Churn, top authors with %, bus factor, co-change cluster, defect proximity, recent commits.
`flow(entry_point, max_depth)`	DFS over CALLS with cycle detection.
`query(cypher \| natural_language)`	Raw Cypher, or hybrid NL retrieval (FTS5/BM25 + structural graph signal + opt-in offline semantic, RRF-fused and shaped) with per-hit provenance + confidence.
`record_insight(symbol, claim, evidence, verified_by)`	Persist a verified learning.
`recall_insights(symbol, since, limit)`	Newest-first substring match against stored insights.
`visualize(target, format, depth, max_nodes, ...)`	Bounded Mermaid diagram of a symbol/file neighborhood (or `central`); edge dash style encodes confidence.
`trace(symbol, direction, max_depth)`	Cross-stack feature slice across the `Endpoint` join node: `downstream` walks frontend call → `CALLS_ENDPOINT` → endpoint → `HANDLES` → handler → CALLS tail; `upstream` answers "who calls this endpoint".

git clone https://github.com/Dhevenddra/forensic-deepdive
cd forensic-deepdive
uv sync --all-extras
uv run forensic --version
uv run pytest -x          # 1000+ tests at v0.10.0
uv run ruff check src/ tests/
uv run forensic extract tests/fixtures/tiny_fixture

Forensic Deepdive

io.github.DhevenddraDiesen Server beanspruchen

Persistent code knowledge graph + 9 composite MCP tools for AI coding agents.

Developer Tools Knowledge Memory

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführenDiesen Server beanspruchen

Zu Cursor hinzufügen Zu VS Code hinzufügen Auf PlugMCP ausführen

1{2  "mcpServers": {3    "io.github.dhevenddra-forensic-deepdive": {4      "command": "uvx",5      "args": [6        "forensic-deepdive==0.10.0"7      ]8    }9  }10}

.cursor/mcp.jsonMCP-Server

Transport: stdio
Status: Lokal