A
securityA
licenseA
qualityA Model Context Protocol server that enables AI agents to retrieve and understand entire codebases at once, providing tools to analyze local workspaces or remote GitHub repositories.
Last updated -
3
53
MIT License
Enables analysis of GitHub repositories through URL specification and supports multi-repository relationship analysis
Generates diagrams in Mermaid format for dependency visualization and knowledge graph export
Built on Node.js with specific version requirements (18+) for running the MCP server environment
Uses Redis for session storage in production environments, providing persistence across server restarts and distributed state management
Supports analysis of TypeScript code with specific capabilities for parsing and analyzing TypeScript projects
Uses XState-based state machines for defining tool execution flow and managing transitions between tool states
Leverages Zod for schema validation when creating stateful tools and validating tool parameters
MCP Code Analysis
A powerful codebase analysis toolkit that leverages the Model Context Protocol (MCP) for AI-assisted code understanding and transformation.
Features
Code Analysis: Parse and analyze codebases with abstract syntax trees
Context Generation: Create rich contextual information for AI models
Tool Integration: Built on the MCP SDK for seamless AI tool integration
Extensible Architecture: Plugin-based system for custom analyzers
Requirements
Node.js 18+
NPM 9+
Redis (optional, only required for production environments)
Installation
# Clone the repository
git clone https://github.com/yourusername/mcp-codeanalysis.git
cd mcp-codeanalysis
# Install dependencies
npm install
# Build the project
npm run build
Redis Configuration (Optional)
Redis is used for session storage in production environments. For development and testing, the system will automatically fall back to an in-memory session store if Redis is not available.
Note: There is a known issue with Redis connectivity where operations may fail even when Redis is running. See the "Tech Debt" section in
plan.mdfor details. For now, you can use the./use-memory-session.shscript to run the server with the memory session store. For more information, see Redis Troubleshooting Guide.
To install Redis:
# Ubuntu/Debian
sudo apt-get install redis-server
# macOS
brew install redis
# Windows (using WSL is recommended)
# For native Windows, download from https://redis.io/download
By default, the application tries to connect to Redis at redis://localhost:6379. You can configure the Redis connection using environment variables:
# Set custom Redis URL
export REDIS_URL=redis://custom-host:6379
# Force memory session store even if Redis is available
export FORCE_MEMORY_SESSION=true
Development
# Run in development mode
npm run dev
# Run tests
npm test
# Run linting
npm run lint
Usage
# Start the MCP server
npm start
# Run CLI tool
node ./tools/mcp-stdio-client.js --task "Analyze dependencies" --files "src/*.ts"
Documentation
License
MIT
CodeAnalysis MCP Server
A comprehensive Model Context Protocol (MCP) server for advanced code analysis, providing tools and insights through an extensible architecture.
🚀 Features
Basic Code Analysis: Syntax and structure analysis
Code Metrics: Complexity, line counts, and code quality metrics
Dependency Analysis: Package and import relationship visualization
Knowledge Graph: Code relationships visualization and querying
Memory System: Store and retrieve insights about codebases
Visualizations: Generate diagrams in multiple formats (Mermaid, DOT, ASCII)
Socio-Technical Analysis: Understand team and code relationships
Multi-Repository Analysis: Cross-repository relationship analysis
Evolution Planning: Code improvement recommendations
Live Watching: Monitor code changes in real-time
IDE Integration: Tools for editor integration
Developer Tools: Enhanced AI-assisted development workflow support
📋 Prerequisites
Node.js 18+
npm or yarn
Redis (optional for development, recommended for production)
🛠️ Installation
# Clone the repository
git clone https://github.com/your-username/codeanalysis-mcp.git
cd codeanalysis-mcp
# Install dependencies
pnpm install
# Build the project
pnpm build
🖥️ Usage
The CodeAnalysis MCP server can be used in two ways:
1. As an MCP Server
# Start the MCP server
pnpm start
This starts the MCP server that can be connected to by any MCP client like Claude Desktop, Cursor, or others.
2. Using the CLI
The project includes a comprehensive CLI for direct interaction:
# Get help
pnpm run cli --help
# Analyze a repository or directory
pnpm run cli analyze repo ./src
# Check code quality
pnpm run cli quality analyze ./src
3. Using Developer Tools for AI-Assisted Development
The project includes special tools designed to enhance AI-assisted development:
# Generate code context for AI assistants
node tools/ai-dev-helper.js --task="Implement new feature" --search="related functionality"
# Run example client
node examples/dev-tools-client.js
See the Developer Tools Guide for detailed information.
📊 Example Commands
Basic Analysis
# Analyze a local directory
pnpm run cli analyze repo ./src
# Analyze a specific file
pnpm run cli analyze file ./src/server.ts
Code Metrics
# Get code metrics with function details
pnpm run cli metrics analyze ./src --functions
# Save metrics to a file
pnpm run cli metrics analyze ./src -o metrics-report.json
Dependency Analysis
# Analyze dependencies in Mermaid format
pnpm run cli dependencies analyze ./src -f mermaid -o deps.mmd
# Visualize dependencies
pnpm run cli visualize dependencies -p ./src --format mermaid
Code Quality
# Run quality analysis
pnpm run cli quality analyze ./src
# Generate HTML report
pnpm run cli quality analyze ./src --html -o quality-report.html
Knowledge Graph
# Build knowledge graph
pnpm run cli knowledge build ./src
# Query the knowledge graph
pnpm run cli knowledge query ./src "type:function AND complexity>5"
# Export as diagram
pnpm run cli knowledge export ./src -f mermaid
Insights & Memory
# Store an insight
pnpm run cli insights store -r ./src -t code-pattern -c "Refactoring opportunity"
# Retrieve insights
pnpm run cli insights retrieve -r ./src
Developer Tools
# Prepare context for AI interactions
node tools/ai-dev-helper.js --task="Fix authentication bug" --files="src/auth/*.ts" --search="login"
# Use with AI prompts
# Copy content from the generated ai-context.json file into your AI assistant prompt
# or use the template in templates/ai-prompt-template.md
🏗️ Architecture
The project follows the MCP architecture with these components:
MCP Server: Core server implementation using the MCP protocol
Analysis Features: Modular code analysis capabilities
CLI: Command-line interface for direct interaction
Transport Layer: Communication mechanism (stdio by default)
🔌 Integration with MCP Clients
This server is compatible with any MCP-compliant client, including:
Claude Desktop App
Cursor Editor
Continue
Other MCP-compatible tools
📝 Path Specification
Commands accept paths in various formats:
Local directory:
./srcor/absolute/path/to/dirLocal file:
./src/file.tsor/path/to/file.tsRepository URL:
https://github.com/username/repo
🤝 Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
📄 License
This project is licensed under the MIT License - see the LICENSE file for details.
MCP SDK State Management Architecture
This project implements stateful tools for the Model Context Protocol (MCP) SDK, providing a framework for building tools that maintain context between invocations.
Architecture Overview
The state management architecture is organized into several modular components:
src/state/
├── helpers/
│ └── statefulTool.ts # Main entry point for stateful tool creation
├── machines/
│ └── toolMachine.ts # XState machine for tool execution flow
├── services/
│ ├── toolService.ts # Core execution service for tools
│ ├── redisToolExecutionService.ts # Distributed execution service
│ ├── redisSessionStore.ts # Redis-based session persistence
│ └── types.ts # Shared type definitions
Core Components
Stateful Tool Helper (statefulTool.ts)
The central integration point with the MCP SDK, providing:
Tool registration with session management
MCP-compliant response formatting
In-memory session management
Helper functions for session access and manipulation
// Creating a stateful tool with state persistence
createStatefulTool(server, "my-tool", schema, handler);
// With description
createStatefulTool(server, "my-tool", "My stateful tool", schema, handler);
Tool Machine (toolMachine.ts)
XState-based state machine that defines the execution flow for tools:
State transitions (idle, toolSelected, parametersSet, executing, etc.)
Context management for parameters, results, and history
Error handling and recovery paths
This component delegates session management to the statefulTool implementation.
Tool Service (toolService.ts)
Core execution service that coordinates tool state transitions:
Manages tool selection, parameter validation, and execution
Tracks execution history
Handles execution results and errors
Types (types.ts)
Shared type definitions that ensure consistency across the state management system:
SessionData: Structure for storing tool state
SessionStore: Interface for session storage implementations
ExecutionResult: Standard response format for tools
Integration with MCP SDK
The architecture integrates with the MCP SDK by:
Extending the tool registration pattern with state management
Maintaining compatibility with MCP's response format
Providing session and context tracking for stateful operations
Usage Example
import { createServer } from "@modelcontextprotocol/sdk";
import { createStatefulTool } from "./state/helpers/statefulTool";
import { z } from "zod";
const server = createServer();
// Register a stateful tool
createStatefulTool(
server,
"counter",
"A tool that maintains a count between invocations",
{
action: z.enum(["increment", "decrement", "reset"]),
},
async (params) => {
// Get session ID from params (or a new one will be created)
const sessionId = params.sessionId;
// Process the action
let count = 0;
// Tool logic with state manipulation...
return { count };
}
);
server.listen(3000);
Distributed State Management
For distributed environments, the Redis-based implementations provide:
Session persistence across server restarts
Distributed locking for concurrent access
TTL-based session cleanup
Error handling for network/connection issues
Testing
The components include comprehensive test suites to verify:
Tool state transitions
Session management
Error handling and recovery
Response formatting
Distributed operation (with Redis)
AI Development Tools
The CodeAnalysis MCP Server provides specialized tools for AI-assisted development. These tools help collect code context that can be fed to AI systems for more effective assistance.
Client Scripts
The repository includes several client scripts in the tools/ directory:
HTTP Client (
tools/http-client.js): Connects to the MCP server via HTTP transport (default).node tools/http-client.js --task "Your task description" --files "src/features/*.ts" --search "session"Raw Client (
tools/mcp-raw-client.js): A simpler client that only captures server information.node tools/mcp-raw-client.js --task "Your task description"Simple Client (
tools/simple-client.js): Communicates with the server via stdio.node tools/simple-client.js --task "Your task description" --files "src/features/*.ts"
All client scripts generate an ai-context.json file in the project root. This file contains valuable context about your codebase that can be shared with AI assistants to provide better-informed responses.
Prompt Template
A prompt template for AI assistants is available at templates/ai-prompt-template.md. This template helps structure your requests to AI assistants with proper context from the MCP tools.
Server Transport Modes
The MCP server supports two transport modes:
HTTP Transport (default): Runs on port 3000 by default. Best for client-server architecture.
Stdio Transport: For direct process communication. Set the
STDIO_TRANSPORT=trueenvironment variable to enable.
Session Storage Architecture
MCP Code Analysis now features a modular session store architecture with automatic backend detection:
Flexible Storage: Automatically switches between Redis and in-memory storage
Development Friendly: Run without Redis during development
Production Ready: Use Redis for persistence in production environments
Automatic Fallback: Gracefully falls back to memory storage when Redis is unavailable
For more details, see the Session Store Architecture documentation.
Requirements
Node.js 18+
npm or yarn
Redis (optional for development, recommended for production)
hybrid server
The server is able to function both locally and remotely, depending on the configuration or use case.
Tools
A comprehensive Model Context Protocol server for advanced code analysis that provides tools for syntax analysis, dependency visualization, and AI-assisted development workflow support.
Related MCP Servers
- -securityFlicense-qualityA server component of the Model Context Protocol that provides intelligent analysis of codebases using vector search and machine learning to understand code patterns, architectural decisions, and documentation.Last updated -10
- AsecurityAlicenseAqualityA Model Context Protocol server that helps large language models process code repositories by providing file tree generation, code merging, and code analysis capabilities.Last updated -322MIT License
- AsecurityAlicenseAqualityA comprehensive Model Context Protocol server providing access to 70+ IT tools for developers and system administrators, including encoding/decoding, text manipulation, hashing, and network utilities.Last updated -7610112TypeScriptMIT License