Mind Map

Mind Map MCP Server v1.22.0

Experimental Code Intelligence Platform - A Model Context Protocol (MCP) server that explores neuroscience-inspired approaches to software development analysis. This is an experimental research project featuring advanced query caching, associative learning patterns, context awareness, attention mechanisms, temporal knowledge modeling, and code analysis tools.

⚠️ Current Status: Experimental v1.22.0

🧪 This is experimental software under active development - Use for testing and research purposes. Features may change or be removed.

Features under development: Context-aware caching • Brain-inspired learning • Code pattern detection • Document analysis • Multi-language AST parsing • File ignore patterns • CI/CD automation • Memory optimization

🎯 Latest Update v1.22.0: Cross-Language API Detection - Comprehensive API endpoint detection across 12 programming languages. New Features: Detect REST APIs (Flask, Express, Spring Boot), GraphQL schemas, gRPC services, WebSocket endpoints, and WebAssembly modules. Language Support: Python, JavaScript/TypeScript, Java, Go, Rust, C++, C#, PHP, Ruby, Swift, Kotlin, and Scala. Intelligent Detection: Framework-specific patterns with confidence scoring for accurate API discovery. New dedicated MCP tool detect_cross_language_apis for direct API analysis.

⚠️ Important Disclaimer

This is experimental software developed for research and testing purposes. It explores various approaches to code analysis and project understanding using Model Context Protocol (MCP).

Before using:

• Expect bugs, incomplete features, and breaking changes
• Use in non-production environments only
• Backup your projects before extensive use
• Report issues and provide feedback to help improve the project

Use cases:

• Improving coding workflows with Claude Code - Enhanced project understanding and context
• Experimenting with MCP server development
• Testing code analysis and pattern detection approaches
• Research into alternative programming assistance tools
• Learning about AST parsing and project structure analysis

📦 Installation & Setup

Quick Install from npm

# Install globally

npm install -g mind-map-mcp

Or install locally in your project

npm install mind-map-mcp

Claude Code Integration

1. Automatic Setup (Recommended)

The easiest way to set up Mind Map MCP with Claude Code:

# Run the automatic setup tool

npx mind-map-mcp init-claude-code

Or if installed globally

mind-map-mcp init-claude-code

This automatically:

• ✅ Detects your operating system and Claude installation
• ✅ Creates proper configuration files with correct paths
• ✅ Provides platform-specific setup instructions
• ✅ Includes verification commands and troubleshooting

2. Manual Setup for Claude Desktop

If you prefer manual configuration, add this to your Claude Desktop config:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%/Claude/claude_desktop_config.json Linux: ~/.config/claude-desktop/config.json

{

"mcpServers": { "mind-map-mcp": { "command": "npx", "args": ["mind-map-mcp"], "env": {} } } }

3. Environment Variable Configuration

You can configure the MCP server to work with specific project directories using the MCP_PROJECT_ROOT environment variable:

{

"mcpServers": { "mind-map-mcp": { "command": "npx", "args": ["mind-map-mcp"], "env": { "MCP_PROJECT_ROOT": "/path/to/your/project" } } } }

What it does:

• Makes MCP scan and cache files in the specified project directory
• Creates .mindmap-cache folder in the target project
• Uses project-specific configuration and mind map data
• Allows working with multiple projects independently

Usage Examples:

// For a specific project

"env": { "MCP_PROJECT_ROOT": "/Users/yourname/projects/my-app" }

// For a demo or test project "env": { "MCP_PROJECT_ROOT": "/Users/yourname/projects/demo-project" }

Without this variable: MCP uses the current working directory where the MCP server was started.

4. Verify Installation

After setup, restart Claude and verify the integration:

1. Check MCP Tools: In Claude, you should see 33 new MCP tools available
2. Test Basic Functionality: Try these commands in Claude:

   Please scan the current project and show me the statistics.

1. Test Features: Try experimental features:

   Please analyze the project architecture.

📝 Usage with Claude Code

Once installed, you can experiment with these commands in Claude:

Sample Workflow

# Start with basic scanning:

Please scan the project and get initial statistics.

Explore analysis features:

Please analyze the project structure and suggest areas of focus.

Test learning features:

Please update the mind map with information about [task description].

🔬 Experimental Analysis Features

# Hebbian Learning - "Neurons that fire together, wire together"

Please show me the Hebbian learning statistics and top co-activation patterns.

Hierarchical Context - Multi-level awareness

Please get the hierarchical context stats and most relevant context items.

Attention System - Dynamic focus allocation

Please show the attention system statistics and allocate attention to important nodes.

Bi-temporal Knowledge - Valid vs Transaction time tracking

Please get bi-temporal statistics and create a context window for this session.

Pattern Prediction - Anticipatory intelligence

Please get pattern predictions and show emerging patterns.

Advanced Intelligence Features

# Get architectural insights

Please analyze the project architecture and detect design patterns.

Find cross-language dependencies

Please detect cross-language dependencies in this polyglot project.

Get intelligent refactoring suggestions

Please generate multi-language refactoring suggestions focused on architecture.

Predict emerging code patterns

Please analyze and predict what code patterns are likely to emerge.

Development Tool Integration

# Detect available tools

Please detect all development tools available in this project.

Run comprehensive analysis

Please run the full tool suite and provide aggregated results.

Get tool recommendations

Please recommend missing development tools that would benefit this project.

📋 Verification Checklist

✅ Installation: npm list -g mind-map-mcp shows the package ✅ Claude Integration: 33 MCP tools visible in Claude ✅ Basic Functionality: scan_project command works ✅ Advanced Features: Brain-inspired tools respond correctly ✅ Multi-language Support: AST analysis works for your languages

🔧 Troubleshooting

Common Issues:

1. "No MCP tools visible" → Restart Claude after configuration
2. "Command not found" → Ensure npm global install path is in PATH
3. "Permission denied" → Run npm config get prefix and check permissions
4. "Server not responding" → Check Claude Desktop config file syntax

Get Help:

• 📖 Check QUICK_USAGE.md for workflow examples
• 📖 Read CLAUDE_CODE_SETUP.md for detailed setup
• 🐛 Report issues: https://github.com/nerfels/mind-map/issues

Features

🧠 Brain-Inspired Intelligence (Phase 6)

• Associative Memory System: Neural activation spreading across connected code concepts (50-70% relevance improvement)
• Context-Aware Query Caching: Intelligent caching with similarity matching (5-10x performance boost for repeated queries)
• Parallel Processing Engine: Chunked file analysis with worker pool orchestration (3-5x faster project scanning)
• Neuromorphic Query Patterns: Replaces linear search with brain-like associative activation networks
• Intelligent Cache Invalidation: Path-based selective cache clearing with LRU eviction and 100MB memory management
• Hebbian Learning System: Co-activation tracking with synaptic strengthening ("neurons that fire together, wire together")
• Inhibitory Learning: Failure avoidance through negative pattern recognition (30% reduction in repeated mistakes)
• Hierarchical Context Management: Multi-level context awareness (immediate, session, project, domain)
• Attention Mechanisms: Multi-modal attention fusion with cognitive load management (Miller's 7±2 rule)
• Bi-temporal Knowledge Model: Valid time vs transaction time tracking with complete audit trails
• Pattern Prediction Engine: Anticipates code patterns before they emerge using time series analysis and predictive forecasting

🚀 Memory Optimization (v1.15.0)

• Variable Lazy Loading: Intelligent memory management with 40.3% reduction in variable node memory usage
• Smart Filtering: Only loads critical variables (exported, global, heavily-used >5 references) immediately
• Summary Node System: Creates single nodes containing lazy-loaded variable metadata for thousands of variables
• On-Demand Loading: 8ms average retrieval time for pattern-based variable queries
• Full Functionality Preservation: All variable querying capabilities maintained while dramatically reducing memory footprint
• Automatic Optimization: No configuration required - automatically detects important vs. lazily-loadable variables

📊 Advanced Call Pattern Analysis (v1.1.5)

• Function Call Graph Construction: Complete call graph analysis with entry points, cycles, and depth calculation
• Constructor Call Detection: Accurate detection of class instantiation and constructor patterns
• Method Call Analysis: Comprehensive tracking of method invocations and chaining patterns
• Async/Await Pattern Recognition: Full support for asynchronous call pattern detection
• Recursion Detection: Automatic identification of recursive functions and call cycles
• Code Style Recognition: Comprehensive naming convention and style pattern analysis
• Complexity Calculation: Enhanced cyclomatic complexity with callback function and control flow analysis
• Cross-File Pattern Resolution: Advanced resolution of call patterns across multiple files

🚀 CI/CD Pipeline Infrastructure (v1.1.5)

• Automated Testing: Comprehensive test suite with multi-language AST validation
• Security Scanning: Automated vulnerability detection with npm audit integration
• Performance Monitoring: Continuous performance benchmarking with alert thresholds
• Code Quality Analysis: Bundle size monitoring, style analysis, and quality reporting
• Release Automation: Automated NPM publishing with GitHub release creation
• Maintenance Workflows: Dependency updates, health checks, and system monitoring
• Pull Request Validation: PR title validation, impact analysis, and comprehensive testing

📁 Enhanced File Ignore Configuration (v1.6.0)

• Multi-Source Pattern Loading: Intelligent pattern merging from defaults, .gitignore, .mindmapignore, and custom configuration
• Real-Time Pattern Testing: Live pattern validation with performance metrics and file matching preview
• Pattern Analytics & Statistics: Comprehensive stats on pattern effectiveness, scan time reduction, and filtering efficiency
• Smart Default Patterns: 30 intelligent default patterns for common file types (node_modules, build artifacts, etc.)
• Configuration Management API: 3 new MCP tools for dynamic pattern updates and testing
• Developer-Friendly Interface: Familiar .gitignore syntax with enhanced capabilities and precedence rules
• Performance Optimization: 33% file filtering efficiency with 8-12ms pattern loading for improved scan performance
• Framework-Specific Patterns: Language and framework-specific ignore patterns (*.pyc, *.class, target/, dist/)

🧠 Advanced Code Int