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/dir - Local file:
./src/file.tsor/path/to/file.ts - Repository 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)