Mind Map MCP Server
Detects REST API endpoints in Express projects.
Detects REST API endpoints in Flask projects.
Detects GraphQL schemas in projects.
Detects REST API endpoints in Spring Boot projects.
Detects WebAssembly modules in projects.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Mind Map MCP Server Scan the current project and show statistics."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.
Related MCP server: codeweave-mcp
โ ๏ธ 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-mcpClaude 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-codeThis 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-cachefolder in the target projectUses 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:
Check MCP Tools: In Claude, you should see 33 new MCP tools available
Test Basic Functionality: Try these commands in Claude:
Please scan the current project and show me the statistics.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:
"No MCP tools visible" โ Restart Claude after configuration
"Command not found" โ Ensure npm global install path is in PATH
"Permission denied" โ Run
npm config get prefixand check permissions"Server not responding" โ Check Claude Desktop config file syntax
Get Help:
๐ Check
QUICK_USAGE.mdfor workflow examples๐ Read
CLAUDE_CODE_SETUP.mdfor 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 Intelligence
Multi-Language AST Analysis: Full parsing for 12 languages (TypeScript/JavaScript/Python/Java/Go/Rust/C++/PHP/C#/Ruby/Swift/Kotlin/Scala) with function/class extraction
Dynamic Import Detection: Track runtime imports including
import()calls,require()statements, template literals, and variable-based module loading for modern JavaScript/TypeScript applicationsMethod Call Chain Analysis: Advanced call sequence tracking following AโBโCโD execution paths up to 10 levels deep with performance impact assessment and risk analysis
Variable Usage Tracking: Comprehensive variable intelligence tracking declaration, usage, and modification patterns across files with lifecycle analysis and cross-module dependency detection
Cross-Language Dependency Detection: Identifies API calls, FFI, microservices, and shared data patterns across languages
Polyglot Project Analysis: Architectural style detection with multi-language recommendations
Enterprise Framework Detection: React, Vue, Express, Django, Flask, Spring Boot, Laravel, ASP.NET, Rails, SwiftUI, Android, Akka, and 60+ more
Architectural Pattern Detection: 7 pattern types with multi-language interoperability analysis
Predictive Error Detection: Risk analysis system with language-specific pattern matching
Intelligent Fix Suggestions: Context-aware recommendations with cross-language insights
๐ง Integrated Development Tooling
100+ Development Tools: Complete tooling ecosystem across 12 languages with intelligent detection
Smart Tool Execution: Run tests, linters, formatters, and security scanners with issue parsing
Intelligent Recommendations: Get suggestions for missing tools with installation commands
Tool Suite Orchestration: Run multiple tools in parallel with aggregated results
Issue Classification: Parse and categorize tool outputs for actionable insights
Mind Map Integration: Store tool results as nodes/edges for learning and correlation
๐ฏ Enhanced Framework Detection
25+ Framework Detection: Comprehensive framework analysis across 6 categories with confidence scoring
Web Frameworks: React, Vue, Angular, Express, Django, Flask, Spring Boot, Next.js, Nuxt.js detection
Mobile Frameworks: React Native, Flutter, Xamarin with platform-specific pattern analysis
Desktop Frameworks: Electron, Tauri, Qt with configuration and build system detection
Game Engines: Unity, Unreal Engine, Godot with project structure and script analysis
ML/AI Frameworks: TensorFlow, PyTorch, scikit-learn with usage pattern detection
Cloud Platforms: Docker, Kubernetes with manifest analysis and deployment patterns
๐ Advanced Learning System
Task Outcome Learning: Tracks success/failure patterns with confidence scoring
Error Pattern Recognition: Categorizes errors and maps to successful solutions
Cross-Session Intelligence: Maintains knowledge between Claude Code sessions
Performance Learning: Adaptive optimization based on usage patterns
Solution Effectiveness Tracking: Measures and improves recommendation quality
๐ Enterprise Query System
Cypher-like Graph Queries: Advanced querying with complex filtering and relationships
Temporal Analysis: Code evolution tracking and change impact analysis
Aggregate Analytics: Project insights, metrics, and trend analysis
Semantic Search: Multi-factor relevance scoring with confidence weighting
Saved Queries: Template system for common analysis patterns
โก Performance & Scalability
Multi-Index Storage: Optimized indexing for type, path, name, confidence, framework, language
LRU Caching: Memory optimization with intelligent cache management
Performance Monitoring: Real-time operation timing and bottleneck detection
Query Optimization: Execution planning and index hints for complex queries
Installation
# Clone or create the project
npm install
# Build the server
npm run build
# Test the installation
npm startUsage with Claude Code
๐ Automatic Setup (Recommended)
The easiest way to get started is to use the built-in initialization method:
# After installing and building, run any Claude Code session and use:
mcp://mind-map-mcp/init_claude_code
# Or for specific setups:
mcp://mind-map-mcp/init_claude_code?setup_type=desktop&platform=macos
mcp://mind-map-mcp/init_claude_code?setup_type=cli&platform=linuxThis automatically generates:
โ Platform-specific configuration files with correct paths
โ Ready-to-copy JSON configurations for Claude Desktop/CLI
โ Complete setup checklist with verification commands
โ Quick start workflow with essential commands
โ Troubleshooting guide for common issues
โ CLAUDE.md template for project-specific instructions
Manual Configuration
If you prefer manual setup, add this server to your Claude Code MCP configuration:
Claude Desktop Configuration
Edit your Claude Desktop config file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json
{
"mcpServers": {
"mind-map-mcp": {
"command": "node",
"args": ["/path/to/mind-map-mcp/dist/index.js"],
"env": {}
}
}
}CLI Usage
# Start the server directly (for testing)
npm start
# Or use the built binary
node dist/index.jsAvailable MCP Tools (27 Total)
Core Intelligence Tools
scan_project: Initial project analysis with AST parsing and pattern detectionquery_mindmap: Semantic search with confidence scoring and relevance rankingupdate_mindmap: Learning system for task outcomes and error patternssuggest_exploration: Intelligent file/function recommendationsget_context: Project overview and contextual informationget_stats: Comprehensive project statistics and metrics
Advanced Analysis Tools
predict_errors: Risk analysis and error prediction based on patternssuggest_fixes: Context-aware fix recommendations for error patternsanalyze_architecture: Detect architectural patterns and design insightsadvanced_query: Cypher-like graph queries with complex filteringtemporal_query: Code evolution and change impact analysisaggregate_query: Project metrics, insights, and trend analysis
Performance & Utility Tools
get_performance: Real-time performance monitoring and bottleneck detectionget_cache_stats: Query cache performance metrics and memory usage statisticsclear_cache: Intelligent cache invalidation with selective path-based clearingsave_query: Save and manage reusable query templatesexecute_saved_query: Run saved queries with parameter substitutionget_insights: Comprehensive project insights with actionable recommendations
Multi-Language Intelligence Tools
detect_cross_language_deps: Identify cross-language dependencies and communication patternsanalyze_polyglot_project: Analyze multi-language project structure and architecturegenerate_multi_language_refactorings: Generate refactoring suggestions for polyglot codebases
Development Tooling Integration
detect_project_tooling: Detect available development tools across all languages in the projectrun_language_tool: Execute specific development tools with intelligent issue parsingget_tooling_recommendations: Get intelligent recommendations for missing development toolsrun_tool_suite: Run multiple development tools in parallel with aggregated results
Enhanced Framework Detection
detect_enhanced_frameworks: Comprehensive framework detection across web, mobile, desktop, game, ML/AI, and cloud categoriesget_framework_recommendations: Get intelligent recommendations based on detected frameworks and project patterns
Example Usage
{
"name": "scan_project",
"arguments": {
"force_rescan": false,
"include_analysis": true,
"ast_analysis": true
}
}{
"name": "advanced_query",
"arguments": {
"query": "MATCH (f:file)-[:contains]->(func:function) WHERE func.name CONTAINS 'auth' RETURN f.path, func.name",
"limit": 10
}
}{
"name": "predict_errors",
"arguments": {
"file_path": "src/auth/login.ts",
"context": "implementing OAuth integration"
}
}How It Works
1. Advanced Project Analysis
The server performs comprehensive scanning and creates nodes for:
Files & Directories: Complete project structure with metadata
AST Elements: Functions, classes, interfaces, imports/exports with full signatures
Architectural Patterns: 7 pattern types with confidence scoring
Framework Detection: React, Vue, Express, Django, Flask, pandas, NumPy, etc.
Error Patterns: Historical error categorization and solution mapping
2. Multi-Language AST Parsing
Full support for 12 major programming languages:
Original Languages:
TypeScript/JavaScript: Complete AST with function/class extraction via TypeScript compiler API
Python: Full AST parsing with subprocess execution for functions, classes, decorators
Java: Complete AST parsing with java-parser for classes, methods, annotations, Spring Boot detection
Go: Go AST parsing with struct/interface/function extraction and framework detection
Rust: Rust AST analysis with struct/trait/impl extraction and crate dependency mapping
C/C++: C++ parsing with class/function/template extraction and build system analysis
NEW Languages (v1.1.4):
PHP: Complete AST with class/method extraction and Laravel/Symfony framework detection
C#: Full AST parsing with ASP.NET/Entity Framework detection and namespace analysis
Ruby: Ruby AST with class/method extraction and Rails/Sinatra framework detection
Swift: Swift AST parsing with UIKit/SwiftUI framework detection and protocol analysis
Kotlin: Kotlin AST with Android/Compose framework detection and coroutine analysis
Scala: Scala AST parsing with Akka/Play framework detection and trait analysis
3. Brain-Inspired Intelligence (Phase 6) ๐ง
Revolutionary neuromorphic computing principles applied to code intelligence:
Associative Memory Networks: Neural activation spreading replaces linear search (50-70% relevance improvement)
Context-Aware Caching: Intelligent similarity matching with LRU eviction (5-10x performance boost)
Parallel Processing Engine: Worker pool orchestration with chunked analysis (3-5x faster scanning)
Neuromorphic Query Patterns: Brain-like activation across connected code concepts
Intelligent Memory Management: 100MB cache with path-based invalidation and exponential decay
Episodic Memory System (NEW v1.1.4): Store and retrieve programming experiences with 77.1% similarity matching accuracy and experience-based suggestions with 81.1% confidence
4. Intelligent Learning System
As you use Claude Code, the server:
Tracks Task Outcomes: Success/failure patterns with confidence adjustment
Maps Error Solutions: Categorizes errors and associates with successful fixes
Builds Pattern Recognition: Framework usage, naming conventions, architectural insights
Optimizes Performance: LRU caching and multi-index storage for faster queries
5. Enterprise Query Engine
Advanced querying capabilities include:
Cypher-like Syntax: Complex graph traversal with filtering and aggregation
Semantic Search: Multi-factor relevance scoring (exact, path, confidence, recency)
Temporal Analysis: Code evolution tracking and change impact assessment
Predictive Analytics: Error risk assessment and fix suggestion engine
6. Cross-Session Intelligence
All learning persists locally with:
Graph Database: Nodes, edges, and relationship storage in JSON format
Performance Monitoring: Operation timing and bottleneck detection
Query Optimization: Execution planning and index hints
Cache Management: LRU eviction and intelligent memory optimization
Data Storage
The mind map data is stored locally in your project directory:
your-project/
โโโ .mindmap-cache/
โ โโโ mindmap.json # Serialized knowledge graph
โโโ ... (your project files)Privacy & Security
Local-Only: All data stays on your machine
No Network: No external API calls or data transmission
Configurable: Choose what gets tracked
Transparent: All data stored in readable JSON format
Development
# Development with auto-rebuild
npm run dev
# Type checking
npm run type-check
# Linting
npm run lint
# Testing
npm testArchitecture
The server consists of several key components:
MindMapEngine: Core intelligence and query processing
MindMapStorage: Graph database operations and persistence
FileScanner: Project analysis and file classification
MCP Server: Protocol implementation and tool handling
Roadmap
โ Completed (Phases 1-5.9)
Core MCP Server: 25 tools with stdio transport
Multi-Language AST Analysis: 12 languages (TypeScript/JavaScript/Python/Java/Go/Rust/C++/PHP/C#/Ruby/Swift/Kotlin/Scala) with comprehensive parsing
Cross-Language Intelligence: Dependency detection, polyglot analysis, multi-language refactoring
Development Tooling Integration: 100+ tools across 12 languages with intelligent execution and parsing
Enhanced Framework Detection: 60+ frameworks across 6 categories (web, mobile, desktop, game, ML/AI, cloud)
Advanced Intelligence: Predictive errors, fix suggestions, architectural patterns, risk analysis
Enterprise Querying: Cypher-like queries, temporal analysis, aggregates, saved queries
Performance Systems: Multi-index storage, LRU caching, monitoring, insights
๐ง Completed Multi-Language Support (Phase 5)
Phase 5.1: โ Python AST support with Flask/Django detection
Phase 5.2: โ Java AST support with Spring Boot/Maven/Gradle detection
Phase 5.3: โ Go AST support with Gin/Echo framework detection
Phase 5.4: โ Rust AST support with Actix/Tokio/Serde detection
Phase 5.5: โ C/C++ AST support with Qt/Boost/CMake detection
Phase 5.7: โ Multi-Language Intelligence with cross-language dependency detection
Phase 5.8: โ Language-Specific Tooling Integration with 80+ development tools
Phase 5.9: โ Enhanced Framework Detection across 6 categories with 25+ frameworks
๐ Version History
v1.4.0 (Current) ๐
โ Enhanced Query System: Comprehensive improvements to core query functionality
โ Multi-Word Query Support: Perfect handling of queries like "mind map", "pattern analysis"
โ Semantic Language Mapping: "typescript" finds .ts files, "javascript" finds .js files
โ Exact File Path Matching: Direct file queries like "src/core/MindMapEngine.ts"
โ Advanced CamelCase Handling: Full support for camelCase, PascalCase, and mixed case queries
โ Improved Temporal Queries: Enhanced time-based analysis with evolution metrics
โ Better Advanced Query Engine: Cypher-like syntax improvements for complex graph queries
โ Enhanced Aggregate Queries: Improved grouping and field extraction for statistical analysis
v1.3.1
โ Fixed Java Code Structure Recognition: Resolved Java class/method extraction issues
โ Enhanced Java AST Parsing: Complete Java file code intelligence with proper node separation
v1.1.5
โ Advanced Call Pattern Analysis: Complete function call graph construction with 100% test success rate
โ Constructor Call Detection: Accurate class instantiation and constructor pattern recognition
โ Enhanced Complexity Calculation: Improved cyclomatic complexity with callback functions and control flow
โ Code Style Recognition: Comprehensive naming convention and style pattern analysis (camelCase, PascalCase, snake_case)
โ CI/CD Pipeline Infrastructure: Complete automation with testing, security scanning, and performance monitoring
โ Release Automation: Automated NPM publishing with GitHub release workflows
โ Pull Request Validation: Comprehensive PR checks with impact analysis and quality gates
v1.1.4
โ 12 Programming Languages + Episodic Memory System
โ Added comprehensive support for PHP, C#, Ruby, Swift, Kotlin, and Scala
โ Complete AST parsing and framework detection
โ Brain-inspired episodic memory with 77.1% similarity matching accuracy
v1.1.0-1.1.3
โ Multi-modal confidence fusion and brain-inspired intelligence platform
โ Performance optimization and cache improvements
โ Enhanced query description with semantic search capabilities
v1.0.1
โ Enhanced README with comprehensive Claude Code integration guide
โ Added step-by-step installation instructions
โ Included usage examples and workflow guides
โ Added troubleshooting section and verification checklist
v1.0.0
โ Complete brain-inspired intelligence system
โ Enterprise scalability and user customization
โ Organized test suite with proper structure
โ 33 advanced MCP tools fully functional
โ Multi-language support (6 languages)
โ 80+ development tools integration
๐ฎ Future Roadmap
Visual Interface: Mind map visualization and exploration
Team Sharing: Collaborative knowledge base
IDE Integrations: VS Code, IntelliJ, Vim plugins
Advanced ML: Enhanced neural pattern recognition
Contributing
Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request
License
MIT License - see LICENSE file for details.
Support
Report issues on GitHub
Check the troubleshooting guide in docs/
Review the API documentation for integration details
Available Tools
59 toolsadvanced_queryC
Execute advanced Cypher-like graph queries with complex filtering, aggregation, and pattern matching
Inputs: query (required), explain, parameters.
aggregate_queryC
Execute aggregate queries for project insights, statistics, and analytics
Inputs: aggregation (required), limit, filter, group_by, +1 more.
allocate_attentionC
Dynamically allocate attention to specific nodes based on context and cognitive load theory
Inputs: node_ids (required), context, attention_type.
analyze_and_predictC
Trigger immediate pattern analysis and prediction generation based on current project state
Inputs: no named parameters.
analyze_architectureC
Analyze the project architecture and detect design patterns, architectural styles, and structural insights
Inputs: limit, pattern_type, min_confidence.
analyze_call_patternsA
Analyze function call patterns, method invocations, and code relationships within TypeScript/JavaScript files. Creates a comprehensive call graph with complexity metrics, recursion detection, and cross-file relationship mapping.
Inputs: file_paths, min_confidence, include_cross_file.
analyze_configuration_relationshipsC
Analyze configuration file relationships and dependencies across the project. Tracks package.json, tsconfig.json, .env files, and other configuration files to understand project setup and dependencies.
Inputs: config_types, min_confidence, include_recommendations.
analyze_documentC
Analyze a specific document file for structure, links, code relationships, and documentation quality
Inputs: file_path (required).
analyze_error_propagationC
Analyze error handling patterns and exception propagation flows across the codebase. Identifies unhandled errors, error handling coverage, and vulnerable areas for improved error resilience.
Inputs: error_types, min_confidence, severity_filter, include_recommendations.
analyze_polyglot_projectB
Analyze project structure for multi-language patterns, architecture style, and language interoperability
Inputs: detailed_frameworks, include_recommendations.
analyze_project_documentationC
Analyze all documentation files in the project including markdown, restructured text, and configuration files. Provides comprehensive documentation analysis with brain-inspired relationship learning.
Inputs: no named parameters.
analyze_test_coverageA
Analyze test coverage by mapping test files to their corresponding implementation files. Identifies test-to-code relationships through naming patterns, imports, and code references with 95% accuracy target.
Inputs: group_by, min_confidence, include_orphans, include_untested.
clear_cacheB
Clear the query cache to free memory and force fresh results
Inputs: affected_paths.
create_context_windowB
Create a temporal context window for grouping related changes and relationships within a specific time period
Inputs: name (required), valid_time_start (required), description, valid_time_end, +1 more.
create_temporal_snapshotC
Create a temporal snapshot of the current knowledge state for analysis and comparison
Inputs: name.
detect_cross_language_apisA
Detect API endpoints, services, and schemas across all supported languages. Identifies REST APIs, GraphQL schemas, gRPC services, WebSocket endpoints, and WebAssembly modules with framework-specific pattern recognition.
Inputs: api_types, min_confidence, include_schemas.
detect_cross_language_depsC
Detect cross-language dependencies and communication patterns in polyglot projects
Inputs: min_confidence, dependency_types, include_confidence.
detect_enhanced_frameworksC
Comprehensive framework detection across web, mobile, desktop, game, ML/AI, and cloud categories
Inputs: categories, force_refresh, min_confidence.
detect_project_toolingB
Detect available development tools across all languages in the project
Inputs: force_refresh, language_filter.
execute_saved_queryB
Execute a previously saved query template with optional parameter overrides
Inputs: query_id (required), parameters.
generate_multi_language_refactoringsC
Generate intelligent refactoring suggestions for multi-language codebases
Inputs: focus_area, max_effort, include_risks.
get_attention_statsA
Get brain-inspired attention system statistics showing attention allocation, modality distribution, focus efficiency, and cognitive load metrics
Inputs: no named parameters.
get_bi_temporal_statsB
Get bi-temporal knowledge model statistics showing valid time vs transaction time tracking, context windows, and temporal relationship analysis
Inputs: no named parameters.
get_cache_statsA
Get query cache statistics including hit rate, memory usage, and performance metrics
Inputs: no named parameters.
get_contextC
Get contextual information about the current project state and previous interactions
Inputs: context_type (required), limit.
get_context_summaryA
Get current context summary across all hierarchical levels (immediate, session, project, domain) with most relevant context items
Inputs: level.
get_documentation_insightsC
Get intelligent insights about documentation quality, coverage gaps, broken links, and improvement recommendations
Inputs: no named parameters.
get_documentation_statisticsA
Get comprehensive statistics about project documentation including word counts, link analysis, and coverage metrics
Inputs: no named parameters.
get_document_relationshipsA
Get relationships between documentation and code files, including implementation mappings and cross-references
Inputs: no named parameters.
get_emerging_patternsB
Get patterns that are emerging but not yet fully established, with emergence stage and confidence
Inputs: emergence_stage.
get_framework_recommendationsC
Get intelligent recommendations based on detected frameworks and project patterns
Inputs: framework_names, recommendation_type.
get_hebbian_statsA
Get Hebbian learning statistics showing associative connections, co-activation patterns, and neural-inspired relationship strengthening
Inputs: no named parameters.
get_hierarchical_context_statsB
Get hierarchical context system statistics showing multi-level context awareness, context distribution, and brain-inspired context management
Inputs: no named parameters.
get_ignore_statsA
Get statistics about currently active ignore patterns and their effectiveness
Inputs: no named parameters.
get_inhibitory_statsA
Get brain-inspired inhibitory learning statistics including pattern counts, strength distribution, and learning effectiveness
Inputs: no named parameters.
get_insightsC
Generate comprehensive project insights and analytics with actionable recommendations
Inputs: categories, min_confidence, actionable_only.
get_multi_modal_fusion_statsA
Get multi-modal confidence fusion statistics showing evidence combination, modality reliability, and advanced confidence calibration
Inputs: no named parameters.
get_pattern_predictionsB
Get specific pattern predictions with probability, timeframe, and confidence analysis
Inputs: pattern_type.
get_performanceB
Get performance statistics and identify slow operations in the mind map system
Inputs: operation, include_recent, slow_threshold_ms.
get_prediction_engine_statsB
Get pattern prediction engine statistics showing emerging patterns, predictions, and trend analysis
Inputs: no named parameters.
get_statsC
Get statistics about the current mind map and project analysis
Inputs: no named parameters.
get_tooling_recommendationsC
Get intelligent recommendations for missing or beneficial development tools
Inputs: priority_filter, include_install_commands.
init_claude_codeA
Get comprehensive setup instructions and configuration guidance for integrating Mind Map MCP with Claude Code
Inputs: platform, setup_type.
invalidate_relationshipC
Mark a relationship as no longer valid (set valid time end)
Inputs: edge_id (required), reason, evidence, invalidation_date.
predict_errorsC
Analyze code patterns and predict potential errors before they occur based on historical data and code analysis
Inputs: limit, file_path, risk_threshold.
predict_pattern_emergenceC
Predict when a specific pattern will emerge with detailed analysis and alternatives
Inputs: pattern_type (required).
query_bi_temporalC
Query relationships with temporal constraints - valid time, transaction time, and context windows
Inputs: as_of, valid_at, context_window, include_history, +2 more.
query_mindmapB
Query the project mind map with enhanced semantic search, context-aware relevance scoring, and intelligent routing. Supports file path queries, function/class name searches, semantic concept matching, and multi-modal confidence fusion.
Inputs: query (required), type, limit, include_metadata.
run_language_toolC
Execute a specific development tool and return results with issue analysis
Inputs: language (required), tool_name (required), args, timeout.
run_tool_suiteC
Run multiple development tools and aggregate results for comprehensive analysis
Inputs: parallel, fail_fast, languages, tool_types.
save_queryB
Save a query template for reuse with parameters
Inputs: name (required), query (required), description (required), parameters, +1 more.
scan_projectB
Perform a fresh scan of the project to update the mind map with current file structure. Supports multiple project contexts via project_root parameter or MCP_PROJECT_ROOT environment variable.
Inputs: force_rescan, project_root, include_analysis.
suggest_explorationC
Get intelligent suggestions for where to look or what to explore based on a task description
Inputs: task_description (required), current_location, exploration_type.
suggest_fixesA
Get intelligent fix suggestions for errors based on historical data, error patterns, and contextual analysis
Inputs: error_message (required), limit, file_path, error_type, +2 more.
temporal_queryC
Query code evolution over time, track changes, and analyze trends
Inputs: time_range (required), entity, metric, analysis_type.
test_ignore_patternsB
Test ignore patterns against project files to see what would be ignored
Inputs: patterns (required), sample_paths.
update_attentionB
Update attention system from user activity (file access, edits, errors, successes) for dynamic attention learning
Inputs: action_type (required), node_ids, query_text.
update_ignore_patternsC
Update ignore patterns for file scanning with support for .gitignore and .mindmapignore files
Inputs: patterns (required), create_mindmapignore.
update_mindmapB
Update the mind map with new knowledge from completed tasks, errors encountered, or solutions found
Inputs: outcome (required), task_description (required), error_details, files_involved, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogโฆ
TDQS
Scored across 59 tools
Many tools have overlapping purposes, such as multiple analyze_* and get_* tools that target similar aspects (e.g., analyze_project_documentation vs analyze_document, get_insights vs analyze_and_predict). This makes it difficult for an agent to select the correct tool without deep reading.
All tools follow a consistent snake_case verb_noun pattern (e.g., scan_project, query_mindmap, analyze_architecture). There are no deviations or mixed conventions, making the set highly predictable.
With 59 tools, the server is far beyond a well-scoped size of 3-15. The number is excessive for a mind map and project analysis server, likely overwhelming agents and indicating poor feature granularity.
The tool set covers many aspects of analysis, querying, and brain-inspired features, but lacks basic CRUD operations for mind map entities like nodes and relationships. There are overlapping analysis tools, but core creation/deletion is missing, leading to moderate coverage.
Maintenance
Related MCP Connectors
An MCP server that gives your AI access to the source code and docs of all public github repos
A MCP server built for developers enabling Git based project management with project and personalโฆ
Cloud-hosted MCP server for durable AI memory
Repository knowledge graph MCP server for codebase understanding and debugging.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server that transforms codebases into intelligent, queryable knowledge bases, enabling AI assistants to perform semantic search, explore architecture, and analyze code relationships.166-
- AlicenseNot gradedqualityDmaintenanceAn MCP server that gives AI agents structured code understanding and precise code intelligence via local indexing of AST, call graphs, and semantic search.73 npm4Apache 2.0
- -licenseNot gradedqualityNot gradedmaintenanceAn advanced MCP server that provides deep code understanding and analysis using GraphRAG, AST parsing, and semantic memory, enabling AI agents to query and interact with complex codebases.-
- AlicenseBqualityDmaintenanceA high-performance MCP server for intelligent documentation search, proactive bug detection, and semantic analysis of codebases.25MIT