Potencialize seu agente
O comando do próprio publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
uvx forensic-deepdive==0.10.0O Claude Code não tem link de instalação para um comando local. Copie o comando abaixo e execute-o em um terminal.
claude mcp add io.github.dhevenddra-forensic-deepdive -- uvx forensic-deepdive==0.10.0Execute em um terminal.
{ "mcpServers": { "io.github.dhevenddra-forensic-deepdive": { "command": "uvx", "args": [ "forensic-deepdive==0.10.0" ] } }}claude_desktop_config.json
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
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.
AbrirDo publicador
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
Persistent code knowledge graph + 9 composite MCP tools for AI coding agents.
Why this is different: every edge and every emitted claim carries a confidence tag —
EXTRACTED (deterministic fact) / INFERRED (a heuristic resolved cleanly) / AMBIGUOUS
(multiple candidates, shown, not guessed) — so your agent knows what to trust before it
acts on it. Nothing else in this category tags confidence at all.
GitNexus is the runaway leader in this category — but its PolyForm Noncommercial
license locks every commercial user out. forensic-deepdive is the Apache-2.0
alternative: same persistent-graph-plus-MCP shape, plus honest confidence tags, git
archaeology, persistent agent memory, and the 5 markdown artifacts as a fallback for any
agent that doesn't speak MCP — with a license your employer's legal team will actually
sign off on.
forensic-deepdive analyzes any codebase (9 languages, polyglot) and produces:
<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.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.<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.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.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.Extract also regenerates ARCHITECTURE.md — a system-level Mermaid view of the cross-boundary graph (ROUTES_TO / INJECTS / PERSISTS_TO, confidence-styled), a separate human-validation surface (not one of the five contract artifacts, exactly like forensic visualize and serve --ui). Regenerate it on its own with forensic diagram --repo <repo>. Use it to sanity-check the graph — a wrong edge there is a wrong edge everywhere.
Add --emit-vault to also write an Obsidian-friendly vault under <output>/vault/ — every artifact gets summary:/tags: frontmatter, cross-references become [[wikilinks]], and an INDEX.md MOC ties them together (with a .obsidian/ config). A local-first second brain for humans (graph view, backlinks) and agents (triage by summary: without opening files, a traversable index). Opt-in; off by default.
v0.10.0 "The Upgrade Path" — an integrity release. v0.9 shipped correct, and then its findings run caught --refresh-shims being structurally unable to refresh half its targets, with 909 tests green over it. The cause wasn't the fix — it was that every test in the suite wrote into an empty directory, so only the first run had ever been tested. Everyone who isn't a new user lives on the untested path.
So 0.10 adds almost no surface. It makes the guarantees already made real: running Deepdive over a repo that already carries a previous release's output now provably converges (and provably leaves your hand-edited files alone), extract tells you when generated shims are stale instead of waiting for you to know the flag exists, and a stale examples/ fails CI rather than being caught by eye mid-release. New: forensic extract --timings, per-phase wall clock.
It also contains a cancelled feature, which is the more useful story. The planned performance work targeted PageRank. The profile required before touching it measured PageRank at 0.04 % of a large extract, and the already-batched store writes at 79–87 %. The optimization was disproven before it was written — see docs/findings/v0.10/PROFILE.md. Confirming a known technique had been applied had been mistaken for confirming it was fast.
The engine, the graph, the contract layer and the 5-artifact + 9-MCP-tool contract are unchanged from 0.9, and emitted content is byte-identical but for the version footer.
⚠ If you installed 0.8.0 or 0.9.0 and
forensic servestopped working — this is why. Those releases declaremcp>=1.27.1with no upper bound.mcp2.0.0 removedmcp.server.fastmcp, which the MCP server imports, so a fresh install of 0.8.0 or 0.9.0 today resolves tomcp2.0.0 and fails on import. Our development lockfile pinned 1.27.1, so every local check stayed green and only the clean-environment wheel smoke in CI could see it. Fix: upgrade to 0.10.0 (which capsmcp<2), or pinmcp<2yourself. Nothing else about those releases is affected.
What's proven, and what isn't — the honest-framing section moved to
docs/findings/HONEST.md (unchanged content, DEC-119). Short
version: proven usable with real agent auto-discovery; not proven to make
autonomous issue resolution measurably faster end-to-end (hardware-gated). This is an
assisted-analysis tool, and it is not overclaimed as more.
# 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
Published as forensic-deepdive —
no clone needed:
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
Optional extras: uv tool install "forensic-deepdive[semantic]" (offline ONNX NL
query), [interactive] (the forensic repl query console, the forensic browse
TUI graph browser, and the deepdive session shell), [openapi] (YAML spec
parsing), [graphiti] (temporal insight backend).
Re-run extract with --refresh-shims once. The generated shims and skills under
.claude/, .cursor/ and .continue/ are written only if absent, so a plain
re-extract leaves your 0.8-era copies in place, and two of the skill files still cite
internal decision IDs that 0.9 removed:
forensic extract /path/to/repo --force --refresh-shims
Only files Deepdive generated are rewritten. A shim you have hand-edited is never
touched.
pip install forensic-deepdive works too if you're not on uv.
forensic serve is a stdio MCP server exposing the 9 composite tools to any
MCP-aware agent (Claude Code, Cursor, VS Code/Copilot, Codex, Continue, Cline,
Windsurf). First build the graph once (forensic extract <repo>), then wire the
server. Three ways, easiest first:
1. Claude Code plugin (self-hosted marketplace — no PyPI step):
/plugin marketplace add Dhevenddra/forensic-deepdive
/plugin install forensic-deepdive@dhevenddra
2. From the MCP Registry — indexed as
io.github.Dhevenddra/forensic-deepdive, so registry-aware clients and discovery hubs
(PulseMCP, MCPJungle, the VS Code @mcp index) can find and install it directly.
3. Manual config — generate a client snippet with forensic mcp-config, or paste:
{
"mcpServers": {
"forensic-deepdive": {
"command": "uvx",
"args": ["forensic-deepdive", "serve", "--repo", "."]
}
}
}
Per-client copy-paste blocks (Cursor, VS Code, Codex, the uvx-not-found GUI gotcha)
are in docs/install.md.
Python, C, Dart, Swift, TypeScript, JavaScript, Java, Go, Rust.
Tool descriptions are individually ≤200 tokens so the 9-tool envelope stays comfortably inside Anthropic's per-turn skill metadata budget.
Every edge and every emitted claim carries EXTRACTED / INFERRED / AMBIGUOUS:
EXTRACTED — deterministic from AST or git log. Facts.INFERRED — a heuristic resolved cleanly (import-graph walk, receiver-type inference, single same-name candidate cross-file). High-trust but derived.AMBIGUOUS — multiple candidates surfaced; the resolver couldn't disambiguate. You see every candidate, not a silent guess.HOTPATHS shows a per-row confidence-mix column so at a glance you can tell Logger (4 EXTRACTED + 1458 INFERRED — mostly clean) from ChatToolResponse (449 AMBIGUOUS — same-name cross-file collision).
forensic extract works end-to-end with no ANTHROPIC_API_KEY, no OPENAI_API_KEY, no Ollama, no network. Graphiti is opt-in via the [graphiti] PyPI extra plus a 2-of-5 repo-size threshold (≥50 k LOC, ≥25 contributors, ≥18 mo old, ≥200 PRs/12 mo, ≥100 issues with discussion). The JsonlInsightStore is the always-available floor.
(The GitNexus/CodeGraphContext/DeepWiki/Sourcegraph comparison table is up top — it's the headline, not a footnote.)
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
Read CLAUDE.md, DECISIONS.md (81 active DECs), and PROGRESS.md before making changes. This repo dogfoods its own pattern: every session starts with the protocol in CLAUDE.md, every architectural choice is captured as a DEC-N entry, and the artifact-name contract (MAP, HOTPATHS, ARCHAEOLOGY, MENTAL_MODEL, AGENT_BRIEF) is part of the public API.
aider as a package.~/.deepdive/registry.json, DEC-018), the composite-MCP-tool shape, and being the licensing wedge that makes this project's Apache-2.0 differentiation matter.uv and ruff.--legacy-repomix (DEC-017) but still available for legacy use cases.Contributions are welcome — see CONTRIBUTING.md for the dev
setup, the verification gate, and the architectural invariants (the 5-artifact contract,
the Endpoint keystone, the confidence taxonomy). By contributing you agree your work
is licensed under Apache-2.0.
Apache-2.0. See LICENSE.
If you redistribute, modify, or build on this project, the Apache-2.0 terms apply: you
must retain the copyright notice, the LICENSE text, and the NOTICE file, and
state any changes you made (License §4). Attribution is required; the project is
Copyright 2026 Dhevenddra (see NOTICE). The boilerplate header in the
LICENSE appendix (Copyright [yyyy] [name of copyright owner]) is a template for
applying the license to source files — it is not itself a requirement, and the LICENSE
file is kept verbatim as the official Apache-2.0 text.
Persistent code knowledge graph + 9 composite MCP tools for AI coding agents.
{ "mcpServers": { "io.github.dhevenddra-forensic-deepdive": { "command": "uvx", "args": [ "forensic-deepdive==0.10.0" ] } }}Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Forensic Deepdive roda localmente via stdio.
Última verificação: 2026-11-09. Persistent code knowledge graph + 9 composite MCP tools for AI coding agents.