Il2cpp Dump Analyzer

IL2CPP Dump Analyzer Agentic RAG MCP System

[](https://opensource.org/licenses/MIT) [](https://nodejs.org/) [](https://www.typescriptlang.org/) [](https://modelcontextprotocol.io/) [](https://www.docker.com/)

A cutting-edge Agentic Retrieval-Augmented Generation (RAG) system for analyzing IL2CPP dump.cs files from Unity games. This system implements the Model Context Protocol (MCP) server specification with intelligent agentic capabilities that provide automated task orchestration, context-aware analysis, and enhanced workflow execution within the MCP framework.

🚀 Key Features

🤖 Agentic Intelligence Layer

• Intelligent MCP Tool Orchestration: Automatically selects and chains MCP tools for complex analysis tasks
• Context-Aware Processing: Preserves analysis context and results across multiple MCP tool calls
• Smart Task Decomposition: Breaks complex IL2CPP analysis requests into manageable subtasks
• Result Synthesis: Intelligently aggregates and correlates results from multiple MCP tools
• Adaptive Caching: Implements smart caching strategies that learn from usage patterns
• Performance Optimization: Monitors and optimizes agentic workflows for speed and efficiency

🔍 Advanced IL2CPP Analysis

• Semantic Code Processing: Specialized IL2CPPCodeChunker preserves code context and meaning
• Vector-Powered Search: Uses Xenova's Transformers.js with all-MiniLM-L6-v2 model (384-dimensional embeddings)
• Supabase Vector Database: High-performance vector search with pgvector extension
• Hash-based Change Detection: Intelligent change detection to avoid reprocessing unchanged files
• Metadata Extraction: Comprehensive assembly metadata, version tracking, and compilation analysis

🛠️ Comprehensive Tool Suite (21 MCP Tools)

• Search Tools (3): Semantic code search, metadata search, and advanced querying
• Analysis Tools (15): MonoBehaviour discovery, class hierarchies, design patterns, dependencies, and asset analysis
• Generation Tools (3): C# wrapper generation, method stubs, and Unity MonoBehaviour templates

🔌 MCP Integration Excellence

• Official MCP SDK: Full compliance with Model Context Protocol specification v1.12.0
• Multiple Transports: Stdio, HTTP, and Server-Sent Events (SSE) support
• Robust Validation: Zod schemas ensure comprehensive parameter validation
• Advanced Error Handling: Intelligent error recovery with detailed logging and retry mechanisms
• Resource Management: Efficient memory usage and connection pooling

Prerequisites

• Node.js 18.x or higher
• TypeScript (for development)
• Supabase account (required for vector database storage)
• IL2CPP dump.cs file from a Unity game

Installation

1. Clone the repository:

``bash git clone https://github.com/yourusername/il2cpp-dump-analyzer-mcp.git cd il2cpp-dump-analyzer-mcp ``

1. Install dependencies:

``bash npm install ``

1. Set up Supabase database:

• Create a new Supabase project at supabase.com
• Run the SQL commands in supabase-setup.sql in the Supabase SQL editor
• This creates the required tables with pgvector extension for vector storage

1. Configure environment variables:

``bash cp simple.env .env ``

Update the .env file with your configuration: ```env # Core Configuration NODEENV=production DUMPFILEPATH=./dump.cs EMBEDDINGMODEL=Xenova/all-MiniLM-L6-v2 LOG_LEVEL=info

# Supabase Configuration (Required) SUPABASEURL=yoursupabaseprojecturl SUPABASEKEY=yoursupabaseanonkey SUPABASETABLENAME=il2cpp_documents

# MCP Server Configuration MCPSERVERPORT=3000 MCPSERVERHOST=0.0.0.0 ```

1. Build the project:

``bash npm run build ``

Usage

Environment Variables

All available environment variables including agentic configuration:

# Core Configuration
NODE_ENV=production|development|test
DUMP_FILE_PATH=./dump.cs
EMBEDDING_MODEL=Xenova/all-MiniLM-L6-v2
LOG_LEVEL=error|warn|info|debug

# Supabase Configuration
SUPABASE_URL=your_supabase_project_url
SUPABASE_KEY=your_supabase_anon_or_service_key
SUPABASE_TABLE_NAME=il2cpp_documents

# MCP Server Configuration
MCP_SERVER_PORT=3000
MCP_SERVER_HOST=0.0.0.0

# Agentic Configuration
AGENTIC_MODE=true                    # Enable intelligent tool orchestration
CONTEXT_CACHE_SIZE=1000             # Maximum cached contexts
TOOL_CHAIN_MAX_DEPTH=5              # Maximum tool chaining depth
INTELLIGENT_CACHING=true            # Enable smart result caching
CONTEXT_PERSISTENCE=true            # Enable context persistence across calls
PERFORMANCE_OPTIMIZATION=true      # Enable performance learning and optimization
ADAPTIVE_BATCHING=true              # Enable adaptive request batching

Quick Start

1. Place your IL2CPP dump.cs file in the root directory (or specify path in .env)

1. Start the MCP server:

``bash npm start ``

1. The server will automatically:

• Parse the IL2CPP dump.cs file
• Extract classes, methods, enums, and interfaces
• Generate semantic embeddings using Xenova Transformers.js
• Store vectors in Supabase with hash-based change detection
• Start the MCP server with stdio transport

1. Connect with MCP clients:

• Claude Desktop: Add to MCP configuration
• Other MCP clients: Use stdio transport connection

MCP Client Configuration

Claude Desktop Configuration

Add to your Claude Desktop MCP configuration file:

{
  "mcpServers": {
    "il2cpp-analyzer": {
      "command": "node",
      "args": ["./bin/il2cpp-mcp-stdio.js"],
      "cwd": "/path/to/il2cpp-dump-analyzer-mcp"
    }
  }
}

Alternative: Direct Node.js Execution

# Run the MCP server directly
node ./bin/il2cpp-mcp-stdio.js

# Or use npm script
npm run mcp:stdio

🛠️ MCP Tools and Resources

The server provides 21 comprehensive MCP tools organized into three categories for IL2CPP analysis and code generation:

🔍 Search Tools (3 tools)

1. search_code - Semantic Code Search

Advanced semantic search through IL2CPP code with intelligent filtering.

Parameters:

• query (string, required): The search query
• filter_type (string, optional): Filter by entity type (class, method, enum, interface)
• filter_namespace (string, optional): Filter by namespace
• filter_monobehaviour (boolean, optional): Filter to only MonoBehaviour classes
• top_k (number, optional, default: 5): Number of results to return

Example:

// Find all Player-related classes with semantic search
search_code({ query: "Player movement controller", filter_type: "class", top_k: 10 })

2. search_metadata - Metadata Search

Search through extracted metadata with flexible filtering and advanced options.

Parameters:

• query (string, required): Search query
• search_type (string, optional): Type of search (assembly, type, method, field)
• assembly_name (string, optional): Filter by assembly name
• unity_version (string, optional): Filter by Unity version
• use_regex (boolean, optional): Enable regex pattern matching
• max_results (number, optional): Maximum results to return

3. query_metadata - Advanced Metadata Querying

Complex metadata queries with aggregations and cross-references.

Parameters:

• filters (object, optional): Complex filtering criteria
• aggregations (array, optional): Aggregation operations (count, group_by, statistics)
• cross_reference (object, optional): Cross-reference analysis configuration

🔬 Analysis Tools (15 tools)

4. find_monobehaviours - Unity Component Discovery

Find and analyze MonoBehaviour classes for Unity component analysis.

Parameters:

• query (string, optional): Optional search query to filter MonoBehaviours
• top_k (number, optional, default: 10): Number of results to return

5. find_class_hierarchy - Class Inheritance Analysis

Analyze class inheritance relationships and structure with detailed metadata.

Parameters:

• class_name (string, required): The name of the class to analyze
• include_methods (boolean, optional, default: true): Include methods in the output

6. find_enum_values - Enum Definition Extraction

Extract enum definitions and their values with type information.

Parameters:

• enum_name (string, required): The name of the enum to find values for

7. analyze_dependencies - Dependency Mapping

Comprehensive dependency analysis with circular dependency detection.

Parameters:

• class_name (string, required): Target class to analyze dependencies for
• analysis_type (enum, optional): Type of analysis (incoming, outgoing, bidirectional, circular)
• depth (number, optional, default: 3): How deep to traverse dependency chains (1-5)
• include_system_types (boolean, optional): Include Unity/System dependencies

8. find_cross_references - Cross-Reference Analysis

Find all references to specific code entities across the codebase.

Parameters:

• target_name (string, required): Name of the target entity
• target_type (enum, required): Type of entity (class, method, field, property, event)
• reference_type (enum, optional): Type of references (usage, inheritance, implementation)
• max_results (number, optional): Maximum number of references to return

9. find_design_patterns - Design Pattern Detection

Detect common design patterns with confidence scoring and examples.

Parameters:

• pattern_types (array, required): Array of patterns to detect (singleton, observer, factory, strategy, etc.)
• confidence_threshold (number, optional): Minimum confidence level (0.1-1.0)
• include_partial_matches (boolean, optional): Include partial pattern implementations

10. extract_metadata - Assembly Metadata Extraction

Extract comprehensive assembly metadata, version information, and compilation flags.

Parameters:

• content (string, optional): IL2CPP dump content
• file_path (string, optional): Path to IL2CPP dump file
• include_generic_instantiations (boolean, optional): Include generic type instantiations
• validate_structure (boolean, optional): Validate extracted metadata structure

11. analyze_type_hierarchies - Type System Analysis

Analyze complex type hierarchies including generics and constraints.

Parameters:

• type_name (string, required): Target type to analyze
• include_constraints (boolean, optional): Include generic constraints
• max_depth (number, optional): Maximum hierarchy depth to analyze

12. analyze_generic_types - Generic Type Analysis

Specialized analysis of generic types and their instantiations.

Parameters:

• type_name (string, required): Generic type to analyze
• include_instantiations (boolean, optional): Include all instantiations
• constraint_analysis (boolean, optional): Analyze type constraints

13. analyze_type_dependencies - Type Dependency Analysis

Analyze dependencies between types with detailed relationship mapping.

Parameters:

• type_name (string, required): Target type for dependency analysis
• dependency_type (enum, optional): Type of dependencies to analyze
• include_indirect (boolean, optional): Include indirect dependencies

14. analyze_type_compatibility - Type Compatibility Analysis

Analyze type compatibility and conversion possibilities.

Parameters:

• source_type (string, required): Source type name
• target_type (string, required): Target type name
• include_implicit_conversions (boolean, optional): Include implicit conversions

15. track_assembly_metadata - Assembly Version Tracking

Track assembly metadata changes and version comparisons.

Parameters:

• tracking_id (string, required): Unique tracking identifier
• comparison_mode (enum, optional): Comparison mode (full, incremental, diff)
• include_dependencies (boolean, optional): Include dependency tracking

16. analyze_asset_references - Asset Reference Analysis

Analyze asset references and dependencies within IL2CPP code.

Parameters:

• asset_type (string, optional): Type of assets to analyze
• include_missing_references (boolean, optional): Include missing asset references
• reference_depth (number, optional): Depth of reference analysis

17. find_unused_assets - Unused Asset Detection

Find potentially unused assets based on IL2CPP code analysis.

Parameters:

• asset_types (array, optional): Types of assets to check for usage
• exclude_patterns (array, optional): Patterns to exclude from analysis
• confidence_threshold (number, optional): Confidence threshold for unused detection

18. analyze_asset_dependencies - Asset Dependency Analysis

Comprehensive analysis of asset dependencies and circular references.

Parameters:

• include_circular_dependencies (boolean, optional): Include circular dependency detection
• asset_type_filter (array, optional): Filter by specific asset types
• dependency_depth (number, optional): Maximum dependency depth to analyze

⚙️ Generation Tools (3 tools)

19. generate_class_wrapper - C# Class Wrapper Generation

Generate C# wrapper classes from IL2CPP class definitions with full type fidelity.

Parameters:

• class_name (string, required): Name of the IL2CPP class to generate wrapper for
• include_methods (boolean, optional): Include method implementations
• include_properties (boolean, optional): Include property implementations
• generate_interfaces (boolean, optional): Generate interface definitions
• custom_namespace (string, optional): Custom namespace for generated code
• unity_version (string, optional): Target Unity version

Example:

// Generate comprehensive wrapper for Player class
generate_class_wrapper({
  class_name: "Player",
  include_methods: true,
  generate_interfaces: true,
  custom_namespace: "Game.Wrappers"
})

20. generate_method_stubs - Method Stub Generation

Generate method stubs and interfaces from IL2CPP class definitions.

Parameters:

• class_name (string, required): Name of the IL2CPP class to generate method stubs for
• method_filter (string, optional): Regex pattern to match specific methods
• include_documentation (boolean, optional): Include XML documentation comments
• include_error_handling (boolean, optional): Include error handling and validation
• generate_async (boolean, optional): Generate async/await patterns where applicable

21. generate_monobehaviour_template - Unity MonoBehaviour Template Generation

Generate Unity-ready MonoBehaviour scripts with common patterns and lifecycle methods.

Parameters:

• class_name (string, required): Name of the IL2CPP MonoBehaviour class
• template_type (string, optional): Template type (basic, ui, gameplay, system)
• include_lifecycle_methods (boolean, optional): Include Unity lifecycle methods
• include_unity_events (boolean, optional): Include UnityEvent implementations
• include_serialized_fields (boolean, optional): Include SerializeField attributes

🤖 Agentic Workflows and Usage Examples

Intelligent Tool Orchestration

The agentic layer automatically chains tools for complex analysis tasks:

// Example: Comprehensive Player class analysis
// The system automatically orchestrates multiple tools:

1. search_code({ query: "Player", filter_type: "class" })
2. find_class_hierarchy({ class_name: "Player" })
3. analyze_dependencies({ class_name: "Player", analysis_type: "bidirectional" })
4. find_design_patterns({ pattern_types: ["singleton", "observer"] })
5. generate_class_wrapper({ class_name: "Player", include_methods: true })

// All executed intelligently with context preservation

Context-Awar

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: djfaizp
• Source: djfaizp/il2cpp-dump-analyzer
• License: MIT

Install and usage instructions live in the source repository linked above.