Linked DeepGraph Provider

Provide deep code graph analysis and architectural visualization for any codebase through a general-purpose DeepGraph MCP server connection.

When to Use This MCP Server

Connect this server when you need to:

• Analyze codebases that do not use a specific framework like Next.js or Vue, including vanilla JavaScript, TypeScript, or Python projects
• Generate cross-language dependency graphs and module relationship maps for polyglot repositories with multiple languages
• Perform architectural analysis on backend services, CLI tools, or library packages where framework-specific DeepGraph servers do not apply

Consider alternatives when:

• Your project is a Next.js or Vue.js application, where the dedicated framework-specific DeepGraph servers provide more accurate and detailed analysis
• You need runtime profiling or performance metrics rather than static code structure analysis

Quick Start

Configuration

Copy
name: linked-deepgraph-provider
type: mcp
category: deepgraph

Example Connection

Copy
claude mcp:connect linked-deepgraph-provider

Available Tools

analyze-structure:    Parse project files and build a comprehensive code structure map
dependency-map:       Generate module-level dependency graphs with import/export tracking
find-dead-code:       Identify exported symbols and modules that have no importers
complexity-report:    Calculate cyclomatic complexity and coupling metrics per module
call-graph:           Trace function call chains across module boundaries

Core Concepts

General DeepGraph Overview

Aspect	Details
Transport	stdio-based process communication with the code graph analysis engine
Language Support	JavaScript, TypeScript, Python, Go, Rust, and other languages with import resolution
Analysis Type	Static analysis using AST parsing without requiring code execution
Graph Model	Directed acyclic graph of modules with weighted edges for dependency strength
Output	Structured JSON graph data consumable by Claude Code for contextual answers

General Analysis Architecture

Claude Code IDE
    |
    v
[MCP Client] --stdio--> [DeepGraph Engine]
                              |
                              v
                     [Multi-Language Parser]
                      /       |        \
                  JS/TS    Python     Go/Rust
                  Parser   Parser     Parser
                      \       |        /
                    [Unified Graph Builder]
                              |
                              v
                     [Analysis Modules]
                   /      |       |      \
              Deps    DeadCode  Complex  Calls

Configuration

Parameter	Type	Default	Description
project_path	string	cwd	Root directory of the project to analyze
languages	string[]	auto-detect	Languages to include in analysis; auto-detected from file extensions
max_file_size	integer	100000	Maximum file size in bytes to parse; larger files are skipped
exclude_dirs	string[]	[node_modules,.git,dist]	Directories to exclude from analysis traversal
follow_symlinks	boolean	false	Whether to follow symbolic links during directory traversal

Best Practices

1. Start with Structure Analysis - Begin every codebase exploration with analyze-structure to get a high-level map of the project. This provides context for more targeted queries and helps you understand the project organization before diving into specific modules.

2. Use Dead Code Detection During Cleanup - Run find-dead-code periodically to identify modules and exports that are no longer referenced. Removing dead code reduces maintenance burden, shrinks bundle sizes, and simplifies the dependency graph.

3. Monitor Complexity Metrics Over Time - Track cyclomatic complexity trends across your codebase. Modules with consistently rising complexity scores are candidates for refactoring into smaller, more focused units before they become unmaintainable.

4. Configure Language Filters for Polyglot Repos - In repositories with multiple languages, set the languages parameter to focus analysis on the specific language you are working with. This reduces noise and speeds up analysis by skipping irrelevant file types.

5. Exclude Generated Code Directories - Add build output directories, generated type files, and vendor directories to exclude_dirs. Including generated code produces misleading dependency graphs with artificial connections.

Common Issues

1. Parser Fails on Unsupported Syntax - Very new language features or experimental syntax may not be parseable. Check that your source files compile successfully, and consider excluding files with experimental syntax from analysis.

2. Graph Too Large to Display - Projects with thousands of modules produce graphs that are difficult to interpret. Use dependency-map with a specific entry point or module path to generate a focused subgraph rather than the entire project graph.

3. Auto-Detection Picks Wrong Language - In polyglot repos, auto-detection may prioritize the wrong language based on file count. Explicitly set the languages parameter to ensure the correct parsers are used for your analysis.