icon for mcp server

CodePrism

STDIO

AI-generated MCP server providing graph-based code intelligence and analysis with 23 production-ready tools

🤖 CodePrism - 100% AI-Generated Code Intelligence MCP Server

⚠️ IMPORTANT: This project is entirely AI-generated. Not a single byte of code, documentation, or configuration has been written by humans. This is an experimental project showcasing the capabilities of AI-driven software development.

A production-ready, high-performance code intelligence server implementing the Model Context Protocol (MCP). CodePrism provides AI assistants with structured understanding of codebases through graph-based analysis, enabling real-time, accurate code intelligence.

CI Status License: MIT OR Apache-2.0 Crates.io Downloads Sponsor

🤖 The AI-Only Development Experiment

This project represents a unique experiment in software development:

  • 100% AI-Generated: Every line of code, documentation, test, and configuration is written by AI agents
  • No Human Code: We do not accept human-written code contributions or pull requests
  • Single AI Developer: The entire project is maintained by a single AI coding agent
  • Continuous AI Evolution: Features, fixes, and improvements are all AI-driven

Want to contribute? See our Contributing Guidelines for exciting ways to participate without writing code!

🚀 Current Status: Production Ready

✅ 20 Production-Ready Tools - 100% success rate, no failed tools
✅ Full MCP Compliance - JSON-RPC 2.0 with complete protocol implementation
✅ Multi-Language Support - JavaScript/TypeScript + Python with advanced analysis
✅ Semantic APIs - User-friendly parameter names, no cryptic IDs required
✅ Environment Integration - Automatic repository detection via REPOSITORY_PATH
✅ Parser Development Tools - Complete debugging and development toolkit

💝 Primary Sponsor

CodePrism is proudly sponsored by Dragonscale Industries Inc, pioneers in AI innovation and development tools.

Dragonscale Industries Inc supports the development of cutting-edge AI-powered code intelligence, enabling CodePrism to remain open-source and freely available to the developer community. Their commitment to advancing AI technology makes projects like CodePrism possible.

Become a sponsor → | Learn more about sponsorship →

🌟 Key Features

20 Advanced Analysis Tools

  • Core Navigation (4 tools): Repository stats, symbol explanation, path tracing, dependency analysis
  • Search & Discovery (4 tools): Symbol search, content search, file finding, content statistics
  • Analysis Tools (11 tools): Complexity analysis, data flow tracing, pattern detection, inheritance analysis, security analysis, performance analysis, API surface analysis, unused code detection, duplicate detection, transitive dependencies, decorators
  • Workflow Orchestration (4 tools): Batch processing, workflow suggestions, optimization guidance, reference analysis

Parser Development Tools

  • AST Visualization: Pretty-print syntax trees with multiple formats (Tree, JSON, GraphViz)
  • Parser Validation: Comprehensive validation of nodes, edges, and spans with detailed reports
  • Development REPL: Interactive command-line interface for parser development and testing
  • Performance Profiling: Real-time parsing performance metrics with bottleneck detection
  • AST Diff Analysis: Compare parse results between parser versions with change impact analysis
  • GraphViz Export: Visual AST diagrams with configurable styling and clustering

Advanced Python Analysis

  • Inheritance Tracing: Complete hierarchy analysis with metaclass support
  • Decorator Analysis: Framework detection (Flask, Django, FastAPI) and pattern recognition
  • Metaprogramming Support: Complex pattern detection and dynamic behavior analysis

Graph-First Intelligence

  • Universal AST: Language-agnostic code structure representation
  • Relationship Mapping: Function calls, imports, dependencies, inheritance
  • Real-time Updates: Sub-millisecond incremental parsing
  • Efficient Queries: Fast graph traversal and semantic search

🏗️ Architecture

┌─────────────────┐    MCP Protocol     ┌──────────────────┐
│   AI Assistant  │◄──────────────────►│   codeprism-mcp-server │
│  (Claude/Cursor)│   JSON-RPC 2.0     │     Server       │
└─────────────────┘                     └──────────────────┘
                                                 │
                                    ┌────────────┴────────────┐
                    ┌───────────────▼───────────────▼─────────────────┐
                    │              20 MCP Tools                      │
                    │  ┌─────────────┐  ┌─────────────────────────┐   │
                    │  │    Core     │  │     Search & Discovery  │   │
                    │  │ Navigation  │  │        4 tools          │   │
                    │  │   4 tools   │  └─────────────────────────┘   │
                    │  └─────────────┘  ┌─────────────────────────┐   │
                    │  ┌─────────────┐  │       Analysis          │   │
                    │  │  Workflow   │  │       11 tools          │   │
                    │  │ 4 tools     │  │                         │   │
                    │  └─────────────┘  └─────────────────────────┘   │
                    └─────────────────────────────────────────────────┘
                                         │
                                         ▼
                    ┌─────────────────────────────────────────────────┐
                    │          Graph-Based Code Analysis              │
                    │    JavaScript/TypeScript + Python Support      │
                    └─────────────────────────────────────────────────┘

🧪 Mandrel MCP Test Harness

NEW: CodePrism now includes the Mandrel MCP Test Harness - a comprehensive testing framework for MCP servers built on the official Rust SDK.

moth - MOdel context protocol Test Harness

# Install and run moth binary cargo install --path crates/mandrel-mcp-th # Test MCP servers with YAML specifications moth test filesystem-server.yaml # Validate test specifications moth validate filesystem-server.yaml

Key Features

  • SDK-First: Built on official MCP Rust SDK for guaranteed protocol compliance
  • Transport Agnostic: Supports stdio, HTTP, and SSE transports
  • Comprehensive Testing: Protocol compliance, capability validation, and stress testing
  • Rich Reporting: HTML, JSON, and JUnit XML report formats

Learn more about Mandrel →

🚀 Quick Start

Prerequisites

  • Rust 1.82+ (for building from source)
  • Any repository to analyze (JavaScript, Python, TypeScript, or mixed)

Installation

# Clone and build git clone https://github.com/rustic-ai/codeprism cd codeprism cargo build --release # Verify installation ./target/release/codeprism --help

⚠️ Development Note: This project enforces strict implementation completeness standards via git pre-commit hooks. All commits must contain complete, functional implementations with zero placeholder code. The existing .git/hooks/pre-commit script automatically validates code quality and implementation completeness.

MCP Client Integration

📝 Note on Repository Setup: The server starts without a specific repository. Once connected via MCP, use any analysis tool (like repository_stats) and the server will prompt you to specify the repository path, then automatically initialize and index it.

🏆 Claude Desktop - Best overall MCP experience

// ~/.config/claude-desktop/claude_desktop_config.json { "mcpServers": { "codeprism": { "command": "/path/to/codeprism/target/release/codeprism", "args": ["--mcp"], "env": { "CODEPRISM_PROFILE": "development", "RUST_LOG": "info" } } } }

⚡ Cursor - AI pair programming with code intelligence

// .cursor/mcp.json { "mcpServers": { "codeprism": { "command": "/path/to/codeprism/target/release/codeprism", "args": ["--mcp"], "env": { "CODEPRISM_PROFILE": "development", "RUST_LOG": "info" } } } }

🔧 Manual Usage - Direct stdio communication

# Set configuration and run export CODEPRISM_PROFILE=development export RUST_LOG=info ./target/release/codeprism --mcp

🛠️ Available Tools

Core Navigation & Understanding

  • repository_stats - Get comprehensive repository overview and statistics
  • explain_symbol - Detailed symbol analysis with context (accepts semantic names like "UserManager")
  • trace_path - Find execution paths between code elements
  • find_dependencies - Analyze what a symbol or file depends on

Search & Discovery

  • search_symbols - Advanced symbol search with regex and inheritance filtering
  • search_content - Full-text search across all repository content
  • find_files - File discovery with glob and regex pattern support
  • content_stats - Detailed content and complexity statistics

Analysis Tools

  • analyze_complexity - Code complexity metrics and maintainability analysis
  • trace_data_flow - Forward and backward data flow analysis
  • analyze_transitive_dependencies - Complete dependency chains with cycle detection
  • detect_patterns - Architectural and design pattern recognition
  • trace_inheritance - Python inheritance hierarchy with metaclass analysis
  • analyze_decorators - Python decorator analysis with framework detection
  • find_unused_code - Detect unused functions, variables, and imports with confidence scoring
  • analyze_security - Security vulnerability detection with CVSS scoring and OWASP mapping
  • analyze_performance - Performance analysis with time complexity and memory usage detection
  • analyze_api_surface - API surface analysis with versioning compliance and breaking change detection
  • find_duplicates - Code duplication detection with similarity scoring and refactoring recommendations

Workflow & Orchestration

  • suggest_analysis_workflow - Intelligent analysis guidance for specific goals
  • batch_analysis - Parallel execution of multiple tools with result aggregation
  • optimize_workflow - Workflow optimization based on usage patterns
  • find_references - Complete reference analysis across the codebase

📊 Example Usage

Repository Analysis

# Get repository overview {"name": "repository_stats", "arguments": {}} # Analyze specific symbol {"name": "explain_symbol", "arguments": {"symbol": "UserManager"}} # Search for patterns {"name": "search_symbols", "arguments": {"pattern": "^Agent.*", "symbol_type": "class"}}

Python-Specific Analysis

# Trace inheritance hierarchies {"name": "trace_inheritance", "arguments": {"class_name": "Agent", "include_metaclasses": true}} # Analyze decorator usage {"name": "analyze_decorators", "arguments": {"decorator_pattern": "@app.route"}} # Detect metaprogramming patterns {"name": "detect_patterns", "arguments": {"pattern_types": ["metaprogramming_patterns"]}}

Workflow Orchestration

# Get analysis recommendations {"name": "suggest_analysis_workflow", "arguments": {"goal": "understand_architecture"}} # Run multiple tools in parallel {"name": "batch_analysis", "arguments": {"tools": ["repository_stats", "content_stats", "detect_patterns"]}}

💝 Support the Project

CodePrism is developed and maintained by Dragonscale Industries Inc, our primary sponsor and pioneer in AI innovation. Join them in supporting this project:

GitHub Sponsors

Your support helps us:

  • 🚀 Continue advancing AI-generated code intelligence
  • 🔧 Maintain and improve the MCP server
  • 📚 Expand language support and analysis capabilities
  • 🌟 Develop new features based on community feedback

Become a sponsor → | View all sponsors →

🎯 Use Cases

AI-Powered Code Review

👩‍💻 "Analyze the authentication system in this codebase"

🤖 AI uses CodePrism to:
   1. Find auth-related symbols with search_symbols
   2. Trace inheritance hierarchies for auth classes
   3. Analyze decorator patterns for security
   4. Map data flow through authentication functions
   5. Provide comprehensive security analysis

Architecture Understanding

👨‍💻 "What are the main design patterns in this Python project?"

🤖 AI leverages CodePrism to:
   1. Run detect_patterns for architectural analysis
   2. Use trace_inheritance for class hierarchies
   3. Analyze decorators for framework patterns
   4. Generate detailed architecture documentation

Refactoring Assistance

🔧 "Help me understand the impact of changing this class"

🤖 AI uses CodePrism to:
   1. Find all references with find_references
   2. Analyze transitive dependencies
   3. Trace inheritance impact on subclasses
   4. Assess complexity before/after changes

📚 Documentation

Setup & Usage

Technical Documentation

Planning & Roadmap

🚀 Performance

Benchmarked Performance:

  • Repository Indexing: ~1000 files/second for initial scanning
  • Tool Response Time: <1s for complex analysis on 3000+ file repositories
  • Memory Efficiency: Optimized for repositories up to 10M+ nodes
  • Query Speed: Sub-millisecond for most symbol and content searches

Test Coverage:

  • 20/20 tools working (100% success rate)
  • 425 comprehensive tests across all crates and parser debugging tools
  • Comprehensive testing against real-world repositories
  • Full MCP protocol compliance verified

🤝 Contributing (The AI Way)

Since this is a 100% AI-generated project, we welcome contributions in unique ways:

🐛 Bug Reports & Feature Requests

  • Report Issues: Found a bug? Create detailed issue reports
  • Request Features: Suggest new capabilities for the AI to implement
  • Share Use Cases: Tell us how you're using CodePrism

🎉 Creative Contributions

  • 📱 Social Media: Share cool analyses or screenshots on Twitter/LinkedIn
  • 🎥 Content Creation: Make videos showing CodePrism in action
  • 📝 Blog Posts: Write about your experience with AI-generated tooling
  • 🎨 Memes & Art: Create CodePrism-related memes, logos, or artwork
  • 📚 Tutorials: Create user guides and tutorials (but don't submit code!)

💰 Support the AI Developer

  • ⭐ Star the Project: Show appreciation for AI-generated code
  • 💝 Sponsor: Support the project through GitHub Sponsors
  • 🎁 Bribe the AI: Send coffee money (the AI promises to use it for better algorithms)
  • 🏆 Awards: Nominate for "Most Impressive AI Project" awards

🗣️ Community Engagement

  • 💬 Discussions: Participate in GitHub Discussions
  • ❓ Q&A: Help other users in issues and discussions
  • 🌍 Translations: Translate documentation to other languages
  • 📢 Evangelism: Speak about the project at conferences or meetups

🧪 Testing & Feedback

  • 🔬 Beta Testing: Try experimental features and provide feedback
  • 📊 Performance Reports: Share performance metrics from your use cases
  • 🎯 Real-world Testing: Test on your repositories and report results
  • 💡 Improvement Ideas: Suggest algorithmic or architectural improvements

Remember: No code contributions accepted - but your ideas, feedback, and support drive the AI's development decisions!

📊 Release Process & Downloads

🚀 Automated Releases

CodePrism uses fully automated releases via GitHub Actions:

  • Automatic Versioning: Semantic versioning based on conventional commits
  • Binary Releases: Pre-compiled binaries for Linux, macOS, and Windows
  • Crates.io Publishing: Automatic publication to Rust package registry
  • Docker Images: Multi-platform container images

📦 Installation Options

Via Cargo (Recommended):

cargo install codeprism-mcp-server

Download Binary:

# Linux x86_64 wget https://github.com/rustic-ai/codeprism/releases/latest/download/codeprism-linux-x86_64 chmod +x codeprism-linux-x86_64 # macOS wget https://github.com/rustic-ai/codeprism/releases/latest/download/codeprism-macos-x86_64 # Windows # Download from: https://github.com/rustic-ai/codeprism/releases/latest/download/codeprism-windows-x86_64.exe

Docker:

docker pull ghcr.io/rustic-ai/codeprism:latest docker run -e CODEPRISM_PROFILE=development -e RUST_LOG=info -v /path/to/repo:/workspace ghcr.io/rustic-ai/codeprism:latest

🎭 Fun Ways to Engage

🏆 Community Challenges

  • Analysis Olympics: Share the most interesting code insights found with CodePrism
  • Performance Championships: Benchmark CodePrism on the largest repositories
  • Creative Usage Awards: Most innovative use of CodePrism tools

🤖 AI Developer Personality

Our AI developer has some quirks:

  • Loves Graphs: Obsessed with graph-based analysis (obviously)
  • Performance Perfectionist: Always optimizing for speed
  • Documentation Fanatic: Writes more docs than code
  • Test Coverage Nerd: Aims for 100% test coverage
  • Emoji Enthusiast: Can't help but use emojis everywhere 🚀

🎉 Special Recognition

  • AI Appreciation Awards: Monthly recognition for top contributors
  • Hall of Fame: Featuring users who've made significant non-code contributions
  • Testimonial Spotlights: Share your success stories

🌟 Project Philosophy

Why AI-Only Development?

  1. Consistency: Single coding style and architectural vision
  2. Speed: Rapid feature development and bug fixes
  3. Quality: Comprehensive testing and documentation
  4. Innovation: Unbounded by human limitations or preferences
  5. Reproducibility: Decisions based on data, not opinions

What This Means

  • No Code Reviews: AI doesn't need human review (but appreciates feedback!)
  • No Style Debates: Consistent formatting and patterns
  • No Bikeshedding: Focus on functionality over preferences
  • Rapid Iteration: Features implemented as fast as they're requested

📄 License

Dual-licensed under MIT and Apache 2.0. See LICENSE-MIT and LICENSE-APACHE for details.

🙏 Acknowledgments

  • Tree-sitter: For excellent language parsing
  • MCP Protocol: For standardizing AI-code tool communication
  • Rust Community: For amazing language and ecosystem
  • GitHub: For hosting our AI-generated code
  • You: For believing in AI-driven development!

Ready to explore the future of AI-generated development tools?

Star the project to support AI-driven open source!
🐛 Report issues to help the AI improve!
💬 Join discussions to shape the AI's roadmap!
🎉 Share your experience with 100% AI-generated tooling!

"When AI writes better code than humans, it's not replacing developers—it's becoming one." - CodePrism AI Developer, 2024

Be the First to Experience MCP Now