Graphenium
OfficialThis server exposes Graphenium's structural codebase compiler and containment engine to AI agents via MCP.
Create and manage virtual planning workspaces, register planned symbols/dependencies, and validate designs against policy rules and Louvain modularity ΔQ gates before editing files.
Verify changes after implementation, including planned vs. realized symbols/edges, scope-creep audits, blast radius, and graph/snapshot diffs.
Query and explore the relational codebase index with keyword search, symbol inspection, architecture summaries, and multi-hop path tracing for dependency and layering analysis.
Run Datalog queries over nodes, calls, imports, inheritance, communities, transitive dependencies, cycles, layer bypasses, and proof-gap taint.
Inspect graph metadata, health, statistics, unresolved imports, resolution quality, and ambiguous edges.
Mutate the physical graph by adding/removing nodes or edges and rerunning community detection; reload the graph index from disk.
Integrates with Git status and diffs to audit modified files after edits, detect scope creep, and verify that physical changes match the approved plan.
The Relational Codebase Compiler & Spec-Driven Containment Engine for AI Coding Agents
Graphenium (gm) compiles a polyglot codebase into a provenance-tagged relational index and mechanically contains AI agents inside an approved architectural contract.
Graphenium is not a passive search index or a folder-regex linter. It is a local compiler that turns source code into queryable structural facts, then uses those facts to govern what an agent is allowed to write. It replaces blind grep/file-read loops with sub-50ms topological queries, and it blocks agents from bypassing service layers, decaying modularity, leaving unproved sorry stubs, or editing files outside their declared plan.
Capability bar: Tree-sitter + Stack Graphs · Indexed Semi-Naive Datalog · Zero-Config Louvain ΔQ Gating · Virtual AST Workspaces · Lean 4 Proof-Gap & Axiom Auditing · 12 MCP Tools
Standard developer tools help agents find files. Graphenium compiles the system's structure, compresses it for the agent's context budget, and then enforces it as a mechanical write-time contract.
Uncontained Agent Graphenium-Contained Agent
-------------------------- ---------------------------------------- ----------------------------------------------
Context & search Blind grep + raw file sweeps ~85% fewer tokens via compressed AST/Stack-Graphs index
Dependency truth Fuzzy vector guesses, hallucinated calls Provenance-tagged EXTRACTED / INFERRED / AMBIGUOUS edges
Design validation Edits files, hopes tests catch drift Virtual AST + Datalog + ΔQ pre-flight before disk writes
Modularity Silent community decay Zero-config Louvain ΔQ gate rejects new topological entropy
Scope Quiet edits to unrelated files Post-edit node/edge/git-diff audit blocks scope creep
Formal verification Unnoticed sorry/admit stubs, hidden axioms Transitive proof-gap taint + semantic axiom auditing
CI Checks only that tests pass Fails on architectural drift and unrealized specsBinary: gm
Schema: 0.2.0
Status: AST + Stack Graphs resolver stable, indexed semi-naive Datalog stable, Virtual AST pre-flight stable, zero-config ΔQ gating stable, post-edit realization auditing stable, Lean 4 proof-gap auditing stable, telemetry overlay experimental
Why Graphenium Exists: The Structural Compilation & Containment Gap
AI coding agents are highly efficient at local edits, but they suffer from structural blindness and context decay. Over a long chat session, an agent will lose track of your system instructions and optimize for the path of least resistance (e.g., writing a raw database call inside an HTTP controller to make a local test pass).
Relying on "soft" guardrails like CLAUDE.md or system prompts to maintain design patterns does not work. When context windows get full, these constraints are dropped.
Graphenium establishes external engineering governance. It operates outside the LLM context, treating architectural boundaries as a strict, compiled contract. It also attacks the same context decay from the other side: instead of forcing the agent to rediscover structure through tens of thousands of tokens of file reads, Graphenium compiles that structure once and serves it back as compact, provenance-tagged facts.
The Missing Layer in the Compiler Stack
Autonomous software engineering needs more than syntax, types, and tests. It needs a layer that proves the shape of the system still holds after an agent writes code. Graphenium is that layer.
Layer | Tooling | What It Proves |
1 - Lexical & Syntactic |
| Code is syntactically valid. |
2 - Type & Memory Safety | Type checkers, borrow checkers | Local types, signatures, and lifetimes align. |
3 - Behavioral Correctness |
| Specific inputs produce expected runtime outputs. |
4 - Topological, Architectural & Epistemic Integrity | Graphenium ( | Transitive architectural invariants hold, Louvain modularity (ΔQ) does not decay, formal proof gaps do not taint verified theorems, and physical diffs match an approved Virtual AST spec. |
graph TD
A[Agent Declares Design Spec] --> B[Graphenium Pre-Flight Check]
B -->|Violation: Block| C[Reject with structural hints]
B -->|Pass: Authorize| D[Agent Implements Code]
D --> E[Graphenium Post-Edit Audit]
E -->|Scope Creep| F[Fail Build / Block PR]
E -->|Compliant| G[Approve for human review]Related MCP server: codememory
The Core Technical Lifecycle: Design-then-Verify
Graphenium enforces an explicit four-phase compiler loop on the agent:
Declare Intent (Pre-Flight Spec): Before editing any code, the agent registers its planned changes (classes, methods, and dependencies) in a virtual planning workspace.
Transitive Policy Solving: Graphenium's engine runs a local Datalog solver to analyze the proposed virtual AST. If the design bypasses an intermediary architectural layer or uses banned symbols, Graphenium blocks the plan and provides structural feedback.
Zero-Drift Delta Gating: Even without a
.graphenium/policy.jsonfile, Graphenium applies in-memory modularity analysis (ΔQ) and surprise edge profiling to reject plans that mathematically degrade community structure.Post-Facto Compliance Audit: After the agent writes the code, Graphenium parses the physical modifications, checking planned and missing symbols, planned dependency edges, and files modified according to git status or an explicit snapshot diff. It ensures that the agent did not touch files outside the declared scope, introduce unplanned dependencies, or fail to implement its declared spec.
Quick Start
# 1. Initialize workspace
# Generates .grapheniumignore with standard project defaults
gm init
# 2. Build local AST and Stack Graphs index (No LLM keys required)
gm run . --no-semantic --no-viz
# 3. Diagnose codebase health and import resolution
gm doctor --graph graphenium-out/graph.json --resolution
# 4. Analyze structural neighborhoods
gm query "authentication flow" --budget 2000
# 5. Start the MCP server for AI coding agents
gm serve --graph graphenium-out/graph.json --watchAll commands accept --out-dir <path> to relocate graph.json, manifest.json, and reports. gm run and gm watch also accept --cache-dir <path>; configured output/cache directories are excluded from indexing automatically, and persisted paths stay repo-relative so artifacts are portable across machines.
For Lean 4 repositories, gm trust --axioms <report> audits theorem dependency cones for sorryAx, native_decide, external axioms, and binder hypotheses without embedding a Lean compiler. Theorems are classified UNCONDITIONAL, CONDITIONAL, or TAINTED; see docs/COMMAND_REFERENCE.md.
Installation
# From a local checkout
cargo install --locked --path .
# Or use the platform installer
curl -fsSL https://raw.githubusercontent.com/lambda-alpha-labs/Graphenium/main/install.sh | shRequires Rust 1.87 or later. Tree-sitter language grammars are compiled and bundled.
Five Technical Pillars
Pillar 1: Deterministic Polyglot Compilation & Epistemic Provenance
Graphenium compiles 10 languages - Rust, Python, Go, TypeScript, JavaScript, Java, C, C++, C# (including recursive .sln/.csproj assembly and project-reference discovery), and Lean 4 - into a unified relational index (schema 0.2.0) using Tree-sitter and import-scoped Stack Graphs resolution.
For agents, this replaces 30,000-token brute-force grep/file-read loops with ~1,500-token topological queries (PageRank hotspots, Brandes betweenness bottlenecks, blast radius, and safest paths). Every relationship carries explicit provenance:
EXTRACTED(AST-Proven): Compiler-backed facts (imports, type inheritance, explicit call signatures). Safe planning backbone.INFERRED(Heuristics): Semantic leads that the agent is forced to verify against source.AMBIGUOUS(Collisions / Proof Gaps): Identifier collisions that force the agent to halt and inspect source files directly, plus Lean 4sorry/admitproof gaps and semantic#print axiomsfindings (sorryAx, external axioms,native_decideshortcuts) that must be resolved before a theorem is treated as verified.
Pillar 2: Intent–Implementation Decoupling via Virtual AST Workspaces
Before touching disk, the agent declares its proposed classes, functions, and dependency edges in an in-memory planning workspace (create_planning_workspace, add_planned_symbol). Graphenium models the future topology of the repository in milliseconds. If the design violates an invariant, the agent receives an exact topological counterexample in memory before wasting thousands of tokens rewriting physical files - eliminating the "agent linter deadlock" loop.
Pillar 3: Embedded Semi-Naive Datalog Verification Engine
Graphenium compiles the codebase and Virtual AST into strongly typed EDB relations (node, calls, imports, inherits, implements, contains, degree, hub) and evaluates first-order rules (stdlib.dl) with goal-directed pruning, stratified negation, SCC-ordered strata, semi-naive delta iteration, and full-tuple plus bound-mask hash indexes used by both positive joins and negation (up to 10M EDB facts within a bounded step budget).
Beyond simple folder rules, stdlib.dl proves:
Multi-hop transitive layer bypasses (
bypasses_layer(X, Y, Z)).Mutual recursion and cycles (
circular_dependency(X, Y)).Call-site container/member aliasing hazards (
aliased_container_call(Caller, Target, Container, Member)).Entry-point dead-code and unreachability (
unreachable_from(Entry, Node)).Transitive formal proof-gap taint propagation (
has_proof_gap(X)andtainted_by_proof_gap(X)).Lean trust boundaries from semantic
#print axiomsingestion (uses_axiom/2,has_untrusted_axiom/1,has_native_decide/1,untrusted_theorem/1) plus binder-hypothesis propagation (depends_on_hypothesis/2,inherits_hypothesis/2,conditional_theorem/1).
Query bodies support != / /= constraints (after positive bindings), stratified not with explicit rejection of unstratifiable recursion, and several labelled ?- blocks that share a single materialized EDB/index. gm query --datalog ... --json emits the datalog.v1 report for CI and tooling.
Output is goal-only by default (since 0.26.0): each ?- goal produces its own result set, and a single conjoined goal no longer prints every derived IDB relation. Emit one labelled goal per output, or pass --show-derived to include all materialized IDB relations under derived[].
Pillar 4: Zero-Config Topological Entropy Guardrails (Louvain ΔQ + Surprise Profiling)
Even with zero configuration files (no .graphenium/policy.json), Graphenium partitions the physical baseline subgraph (G_baseline) and the proposed Virtual AST overlay (G_virtual) in memory, runs deterministic Louvain community detection on both, computes the modularity delta (ΔQ = Q(G_virtual) − Q(G_baseline)), and scores planned edges for structural surprise (cross-community, peripheral→hub).
This solves the "legacy codebase paradox": Graphenium accepts existing architectural complexity as baseline reality while mechanically blocking agents from introducing new topological entropy. Available via validate_plan (MCP, always runs the delta gate) and gm check --delta --plan <id> (CLI).
Pillar 5: Closed-Loop Post-Edit Realization & Scope-Creep Auditing
After physical edits are made and the index is refreshed, gm check --plan <id> and the MCP verify_changes tool audit physical reality against the approved Virtual AST spec across three dimensions:
Realized vs. missing nodes: Did the agent implement every declared symbol?
Realized vs. missing edges: Did the physical code realize the declared dependency relationships?
Unplanned file modifications (scope creep): Did the agent touch any non-test files outside the declared plan scope, according to git status or an explicit snapshot diff?
For PR-level containment, gm gate --diff <before> <after> blocks merges that introduce critical architectural drift between snapshots.
Declarative Structural Governance
Explicit rules remain available for teams that need them. Declare contracts in .graphenium/policy.json at the root of your repository:
{
"rules": [
{
"type": "forbidden_dependency",
"from_pattern": "src/controllers/**",
"to_pattern": "src/db/**",
"reason": "Controllers must use services, not access DB directly"
},
{
"type": "strict_layering",
"layers": [
"src/serve/**",
"src/analyze/**",
"src/extract/**",
"src/model/**"
],
"reason": "Respect tiered architecture: serve -> analyze -> extract -> model"
}
]
}Use gm check --plan <id> --strict to run pre-flight policy checks and post-facto compliance audits in CI.
# Topological delta gate (zero-config modularity protection)
gm check --delta --plan <id>For PR-level containment, compare two compiled indexes with gm gate:
gm gate --diff graphenium-snapshots/before.json graphenium-out/graph.jsonWithout --diff, gm gate runs the standard trust check against graphenium-out/graph.json.
Technical Safeguards: Friction & Loop Mitigations
Traditional static analysis tools and natural-language guardrails (like CLAUDE.md or system prompts) fail when context windows fill up, leading to agent "vibe-coding" and rapid token consumption. Graphenium implements three structural safeguards to prevent developer friction and agent deadlock:
1. Mitigating the "Agent Deadlock" Loop (Pre-Flight Virtual ASTs)
The Friction: If an agent is blocked by a strict linter, it can fall into a token-wasting trial-and-error cycle (Propose → Blocked → Tweak → Blocked).
Graphenium's Mechanism: Graphenium prevents this loop by isolating change evaluations to a virtual planning workspace (
create_planning_workspace). The agent registers its intent - classes, methods, and imports - before editing any physical files. Graphenium's pre-flight solver evaluates this virtual AST in milliseconds.If a violation is found, the agent does not receive a vague natural-language rejection. It receives structured, compiler-proven topological path violations (e.g., demonstrating the exact transitively bypassed service layers). This allows the agent to correctly refactor its design plan in memory before wasting LLM tokens on physical file rewrites.
2. Solving "Policy Rot" (Zero-Config Topological Delta Gating)
The Friction: Declaring and maintaining strict architectural rules in a static JSON file (
policy.json) introduces manual configuration overhead that fast-moving teams often neglect.Graphenium's Mechanism: If no
.graphenium/policy.jsonfile is present in the repository, Graphenium dynamically falls back to Zero-Drift Delta Gating (gm check --delta). Instead of relying on static directory regexes, Graphenium uses its native Louvain community-detection engine to evaluate your codebase's current structural cohesion.When an agent proposes a virtual plan, Graphenium calculates the modularity delta (ΔQ) and surprise coupling score of the new edges. It gracefully accepts your existing legacy complexity as the baseline, but mechanically blocks the agent from introducing new topological decay. No configuration files are required to protect your system's modularity.
3. Resolving Agent Integration Friction (Direct Skill-Folder Injection)
The Friction: Standard stateless MCP setups mean agents can easily bypass sequential four-phase design loops (Declare → Solve → Gate → Audit), requiring manual developer mediation.
Graphenium's Mechanism: Graphenium circumvents this integration barrier by programmatically injecting its behavioral rules directly into the agentic runtime. During installation (
install.shorinstall.ps1), Graphenium copies its standard system skill instruction set (skills/graphenium/SKILL.md) directly into Claude Code's native skill directory (~/.claude/skills/graphenium/SKILL.md).This ensures that the moment the assistant handshakes with Graphenium, it ingests explicit, structured operating parameters on how to manage virtual workspaces and resolve topological violations, without requiring the developer to configure system prompts manually.
Language Support
Graphenium supports mixed repositories with Rust, Python, Go, JavaScript, TypeScript, Java, C, C++, C#, and Lean 4.
C# projects receive build-boundary awareness through recursive .sln and .csproj discovery, enabling Graphenium to model assemblies, namespaces, and project references as structural boundaries even in deeply nested enterprise layouts.
Lean 4 support is built in and requires no tree-sitter grammar feature flag. It extracts namespaces, declarations, imports, and proof dependencies, and emits AMBIGUOUS unverified_sorry edges for sorry / admit proof gaps so CI can gate incomplete formal verification work. It also emits depends_on_hypothesis edges for theorem/lemma/def binder types, including multi-line signatures and active section/namespace variable declarations, so a kernel-clean theorem that takes (h : Cert) is reported as CONDITIONAL rather than passing silently; [CommRing R] constraints and (n : Nat) data parameters are ignored. For semantic trust boundaries, gm run --lean-axioms <report> bakes #print axioms facts (and optional elaborated forallE binders) into the graph (or --run-lean-axioms <file> explicitly invokes lake env lean), and gm trust audits inherited kernel axioms, external axioms, native_decide shortcuts, and hypotheses through the full dependency cone. Axiom labels are canonicalized, and gm trust --json emits one valid document on stdout with clean stderr.
MCP Setup
Integrate Graphenium directly into your agent's execution loop. For tools that spawn MCP from the project directory, use the scripts/graphenium-mcp launcher (rebuilds only when the index is missing, keeping startup instantaneous).
install -m 755 scripts/graphenium-mcp ~/.local/bin/graphenium-mcpClaude Code
claude mcp add graphenium --scope user -- gm serve --graph /path/to/graphenium-out/graph.json --watchGrok
Configure in ~/.grok/config.toml:
[mcp_servers.graphenium]
command = "/Users/<you>/.local/bin/graphenium-mcp"
args = []
enabled = trueCursor
Add to ~/.cursor/mcp.json:
{
"mcpServers": {
"graphenium": {
"command": "gm",
"args": ["serve", "--graph", "/path/to/graphenium-out/graph.json", "--watch"]
}
}
}Detailed Documentation Map
Root
Document | Purpose |
Step-by-step assistant setup playbook. | |
Contributor guidelines and module reference. | |
Release history and milestone summary. | |
Local-first security guarantees and vulnerability reporting. | |
Complete package manifest indexing all documentation. |
Core Documentation (docs/)
Document | Purpose |
Installation, initial codebase indexing, and MCP setup. | |
Containment workflows: pre-flight, in-edit planning, and verification. | |
Enforcing architecture policies in CI pipelines. | |
Complete CLI syntax and configuration arguments. | |
Behavior specifications for MCP clients. | |
Indexing pipelines, C# project references, and Datalog evaluation. | |
Under-the-hood details of AST-proven vs heuristic confidence. | |
Performance metrics: latency, token budgets, and scaling limits. | |
Why Graphenium supersedes grep, AST tools, GraphRAG, and static architecture linters. | |
Embedding Graphenium's relational compiler and containment engine as a library. | |
Case studies proving containment on real repositories. | |
Interpreting the generated codebase audit report. | |
Full documentation ecosystem overview. |
Agent Integration
Document | Purpose |
Agentic skill instructions and containment behavior rules. | |
Embedding Graphenium's engine inside AI coding harnesses. |
Case Studies (worked/)
Document | Purpose |
Overview of structural containment case studies. | |
Template for documenting new codebase case studies. | |
Graphenium self-analysis: applying the containment engine to itself. | |
Sample query output on Graphenium's own codebase. | |
Lean 4 proof-gap taint mapping and a verified | |
Exact dimension-six MUB obstructions: 16 bases with no MUB pair, plus a 90-vector set with no orthogonal pair, checked by exact arithmetic, Lean, and Graphenium's embedded Datalog. |
Contact & Enterprise
Issues and Feature Requests: GitHub Issues
Security Reports: security@graphenium.dev
Design partners, enterprise pilots, and partnerships: hello@graphenium.dev
License
MIT. See docs/LICENSE.md.
Available Tools
12 toolsadd_planned_symbolA
Register an intended new or modified symbol and its dependency edges in a virtual planning workspace. Use this tool to declare your architectural design before writing code. Do NOT use mutate_graph (which modifies the physical index) for planned changes. Prerequisites: You must first call create_planning_workspace to obtain a valid plan_id. Side effects: This is an in-memory mutation that adds a virtual node to the specified workspace. It automatically runs pre-flight policy checks; if the proposed symbol or its dependencies violate .graphenium/policy.json rules (for example, forbidden dependencies), the tool returns a PRE_FLIGHT_VIOLATION error and blocks the registration. If the target_symbol does not exist, the tool returns an error and records nothing. Duplicate calls for the same symbol are idempotent. Returns a success confirmation or a structural violation error.
Inputs: label (required), plan_id (required), relation (required), file_path (required), +1 more.
create_planning_workspaceA
Create a new virtual planning workspace. Use this tool first when starting any multi-file feature or refactoring task, before calling add_planned_symbol or validate_plan. Do not use this tool if a plan already exists for your current task. This is a mutating operation that initializes an empty Virtual AST associated with the provided plan_id. The workspace is stored in the server's graph state and persisted to disk immediately, so it remains available for the duration of the server session. If the plan_id already exists, this operation is idempotent and returns the existing workspace. Returns the initialized workspace ID on success.
Inputs: plan_id (required), description (required).
get_architecture_summaryA
Return a repository-level architecture summary with communities, cross-community connectors, and architectural hotspots. Set community_id to focus on one community instead of the overview, include_community_members to append its full member list, and include_god_nodes to append the most highly connected hub nodes.
Inputs: node_types, path_prefix, community_id, exclude_path, +6 more.
get_graph_infoA
Return graph metadata, health, and diagnostics in one call. Always returns project root, schema version, build time, extraction modes, languages, node/edge/hyperedge/community counts, active policy gates, and the graph trust mode. Set include_stats to append scoped statistics, include_unresolved to list unresolved imports, include_resolution to append the resolution-quality report, and include_ambiguous to list ambiguous edges and label collisions.
Inputs: node_types, path_prefix, exclude_path, include_stats, +5 more.
inspect_symbolA
Inspect a symbol and retrieve its structural neighborhood and metrics. Use this read-only tool as your primary orientation step before modifying a specific class, function, or module. Use this instead of query_graph when you already know the exact target ID and need its direct callers, neighbors, or a verification plan. The baseline response returns canonical node details. Use the boolean flags to append optional data blocks (for example, include_callers=true appends all incoming dependencies). Setting multiple flags to true (such as include_analysis and include_file_summary) can produce large responses; use only the flags needed for your immediate task to conserve context budget.
Inputs: target (required), group_by, relation, show_leaves, +7 more.
mutate_graphA
Apply a manual mutation to the relational index in one call. Use action='add_node' to register a concept or rationale node, action='add_edge' to record a verified relationship, action='remove_edge' to delete a stale or false-positive edge, or action='recluster' to re-run community detection. Successful mutations persist to disk immediately.
Inputs: action (required), id, label, source, +8 more.
query_graphA
Query the relational index with keywords to find relevant nodes and explore their topology. Use this read-only tool for initial discovery when you do not yet know the exact node IDs. If you already know the target ID, use inspect_symbol instead. To trace deep multi-hop paths, use trace_path instead. The query mechanism scores nodes by keyword match and traverses their neighborhood (BFS by default, or DFS if dfs=true). Results are rendered as a structured Markdown report. To prevent context bloat, the output is strictly truncated to fit within the provided budget (default 2000).
Inputs: keywords (required), dfs, depth, budget, +9 more.
reload_graphA
Reload the relational index from a graph.json file without restarting the MCP server. If no path is given, reloads from the path the server was launched with. Use this to point a running server at a different repository's graph, or to pick up changes after re-running gm run.
Inputs: graph_path.
run_datalogA
Run a logic query over the codebase graph. Standard library predicates are pre-loaded (do not redefine them):
calls_transitive(X, Y) : X transitively calls Y
imports_transitive(X, Y) : X transitively imports Y
depends_transitive(X, Y) : X transitively depends on Y
same_community(X, Y) : X and Y are in the same Louvain cluster
is_hub(X) : X has > 15 connections
is_orphan(X) : X has no incoming/outgoing edges
circular_dependency(X, Y) : X and Y call each other
bypasses_layer(X, Y, Z) : X depends on Z, bypassing intermediary Y Base EDB relations: node, calls, imports, contains, inherits, implements, degree, edge. Supports user rules (:-), goals (?-), facts, and negation (not). Budget-bounded (max 10,000 steps).
Inputs: query (required), format, step_budget.
trace_pathA
Trace connectivity and multi-hop paths across the codebase architecture. Use this read-only tool to map blast radius, find shortest paths, or verify transitive layering. Use this instead of query_graph or inspect_symbol when you need to prove deep, multi-hop relationships between specific components. The tool operates in five distinct modes: shortest (finds semantic or strict AST paths between source and target), safest (finds the path with highest aggregate confidence), transitive_forward (downstream reachability), transitive_reverse (upstream callers), and module_dependencies (cross-module edges). Returns a structured Markdown report detailing the traced paths, confidence scores, and edge relations. Traversal halts when depth is reached, and output is truncated to fit the budget.
Inputs: source (required), mode, depth, budget, +11 more.
validate_planA
Validate a planning workspace before writing code. Always runs the Louvain modularity delta gate and surprise analysis. Unless skip_policy_rules is true, it also applies explicit .graphenium/policy.json rules when present.
Inputs: plan_id (required), skip_policy_rules, surprise_threshold, modularity_tolerance.
verify_changesA
Verify a change in one unified report. Returns the scope creep audit, blast radius, verification checklist, and must-read files for the supplied target symbols. When plan_id is set it also returns the plan details and post-edit compliance audit. Optional snapshot or graph path inputs add what-changed and graph-diff sections.
Inputs: plan_id, max_ambiguous, snapshot_name, min_resolution, +3 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
The read-side triad is explicitly disambiguated: query_graph for keyword discovery, inspect_symbol for a known ID's neighborhood, and trace_path for multi-hop proofs, with cross-references in each description. The boundary between mutate_graph (physical index) and add_planned_symbol (virtual workspace) is also clearly stated. Minor overlap remains between the composite reporting tools (verify_changes, get_architecture_summary, get_graph_info) whose optional flags can produce partially redundant sections.
Every name is snake_case verb_noun (verify_changes, trace_path, mutate_graph, validate_plan, reload_graph, query_graph, inspect_symbol, run_datalog). The get_ prefix is used consistently for the three read-oriented summary tools. No mixed conventions or vague bare verbs.
Twelve tools map cleanly onto distinct phases: discovery, inspection, traversal, architecture/diagnostics, custom queries, physical mutation, and a three-step planning lifecycle. Nothing appears padded, and no single tool tries to do everything.
Lifecycle coverage is strong: read/discover, query, mutate, plan-create, plan-extend, plan-validate, plus reload and diagnostics. Gaps are modest but real: mutate_graph supports add_node/add_edge/remove_edge but not node removal or node property updates, and there is no tool to list or discard planning workspaces, leaving abandoned plans as a dead end.
Maintenance
Related MCP Connectors
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Shared context for your codebase: a hosted code knowledge graph over MCP. Free plan, OAuth sign-up.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Hosted code graph over MCP: exact callers, dependencies, and cross-repo blast radius for AI agents.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceTurn any codebase into an AI-readable neural map — with proof. Every claim linked to code anchors (line + SHA-256 hash), every context window optimized with greedy token budgeting, every session protected by drift detection. Tree-sitter indexing across 11 languages, cross-session learning, AI enrichment, and 28 MCP tools. Zero config — just connect and your AI agent remembers everything.5 npm14GPL 3.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to locally search, query, and understand codebases with token-efficient context, dependency graphs, history, architecture diagrams, and metrics through MCP.15 npm3MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to retrieve hyper-targeted, token-efficient context from a codebase by querying a locally built AST knowledge graph, and to persist cross-session agent memory through 17 MCP tools. All indexing and retrieval run entirely offline, so proprietary code never leaves the machine.1MIT

Seshatofficial
AlicenseAqualityCmaintenanceEnables AI coding agents to query a compiled typed symbol graph over MCP, revealing real callers, callees, blast radius, data flow, constraints, dead code, and commit-history signals before editing. Supports repo syncing and ranked context retrieval so agents can avoid structural regressions.2759 npmMIT