Java Class Analyzer MCP Server

🚀 Java Class Analyzer MCP Server

A Java class analysis service based on the Model Context Protocol (MCP). It can scan Maven project dependencies, decompile Java class files, obtain detailed information such as class method lists, and provide them to LLMs for code analysis.

🎯 Use Cases

AI tools like Cursor can directly generate code for calling second-party (internal) and third-party (external) package interfaces. However, since AIs cannot read the source code of dependencies not opened in the current project, the generated code often contains errors and may even exhibit hallucinatory coding.

To address this issue, developers usually copy the source code content and feed it to the LLM, or place the source code files in the current project and then reference them in the conversation.

The local decompilation MCP solution is the most effective, as it can accurately parse classes and methods in JAR packages, significantly improving the accuracy and usability of code generation.

✨ Features

• 🚀 Easy to Use: The MCP service is implemented in TypeScript and packaged with npm, making it easy to distribute and install with minimal environment dependencies.
• 🔍 Dependency Scanning: Automatically scans all dependent JAR packages in a Maven project.
• 📦 Class Indexing: Builds a mapping index from the full class name to the JAR package path.
• 🔄 Decompilation: Uses the built - in CFR tool to decompile .class files into Java source code in real - time.
• 📊 Class Analysis: Analyzes the structure, methods, fields, inheritance relationships, etc., of Java classes.
• 💾 Intelligent Caching: Caches decompilation results according to the package name structure and supports cache control.
• 🚀 Automatic Indexing: Automatically checks and creates an index before performing analysis.
• ⚙️ Flexible Configuration: Supports externally specifying the path of the CFR tool.
• 🤖 LLM Integration: Provides Java code analysis capabilities to LLMs through the MCP protocol.

💻 Usage Examples

Register the MCP service in the IDE

Use MCP in the agent conversation

📚 Documentation

Installation of the MCP service

Global installation (recommended)

npm install -g java-class-analyzer-mcp-server

After installation, you can directly use the java-class-analyzer-mcp command.

Local installation

npm install java-class-analyzer-mcp-server

Installation from source code

git clone https://github.com/handsomestWei/java-class-analyzer-mcp-server.git
cd java-class-analyzer-mcp-server
npm install
npm run build

Configuration of the MCP service

Method 1: Use the generated configuration (recommended)

Run the following command to generate a configuration template:

java-class-analyzer-mcp config -o mcp-client-config.json

Then add the generated configuration content to your MCP client configuration file.

Method 2: Manual configuration

Refer to the following configuration example and add it to the MCP client configuration file:

Configuration after global installation:

{
    "mcpServers": {
        "java-class-analyzer": {
            "command": "java-class-analyzer-mcp",
            "args": ["start"],
            "env": {
                "NODE_ENV": "production",
                "MAVEN_REPO": "D:/maven/repository",
                "JAVA_HOME": "C:/Program Files/Java/jdk-11"
            }
        }
    }
}

Configuration after local installation:

{
    "mcpServers": {
        "java-class-analyzer": {
            "command": "node",
            "args": [
                "node_modules/java-class-analyzer-mcp-server/dist/index.js"
            ],
            "env": {
                "NODE_ENV": "production",
                "MAVEN_REPO": "D:/maven/repository",
                "JAVA_HOME": "C:/Program Files/Java/jdk-11"
            }
        }
    }
}

Parameter description

• command: The command to run the MCP server, using node here.
• args: The parameters passed to Node.js, pointing to the file in the dist folder compiled by npm run build.
• env: Environment variable settings.

Environment variable description

• NODE_ENV: Identifier for the running environment.
  • production: Production environment, reduces log output and enables performance optimization.
  • development: Development environment, outputs detailed debugging information.
  • test: Test environment.
• MAVEN_REPO: Path to the local Maven repository (optional).
  • If set, the program will use the specified repository path to scan JAR packages.
  • If not set, the program will use the default ~/.m2/repository path.
• JAVA_HOME: Path to the Java installation (optional).
  • If set, the program will use ${JAVA_HOME}/bin/java to execute Java commands (for CFR decompilation).
  • If not set, the program will use the java command in the PATH.
• CFR_PATH: Path to the CFR decompilation tool (optional, the program will search for it automatically).

Available tools

1. scan_dependencies

Scans all dependencies of a Maven project and builds a mapping index from class names to JAR packages.

Parameters:

• projectPath (string): The root directory path of the Maven project.
• forceRefresh (boolean, optional): Whether to force - refresh the index, default is false.

Example:

{
  "name": "scan_dependencies",
  "arguments": {
    "projectPath": "/path/to/your/maven/project",
    "forceRefresh": false
  }
}

2. decompile_class

Decompiles the specified Java class file and returns the Java source code.

Parameters:

• className (string): The full name of the Java class to be decompiled, e.g., com.example.QueryBizOrderDO.
• projectPath (string): The root directory path of the Maven project.
• useCache (boolean, optional): Whether to use the cache, default is true. This avoids repeated generation each time.
• cfrPath (string, optional): The path to the JAR package of the CFR decompilation tool. It is built - in, and you can specify an additional version.

Example:

{
  "name": "decompile_class",
  "arguments": {
    "className": "com.example.QueryBizOrderDO",
    "projectPath": "/path/to/your/maven/project",
    "useCache": true,
    "cfrPath": "/path/to/cfr-0.152.jar"
  }
}

3. analyze_class

Analyzes information such as the structure, methods, and fields of a Java class.

Parameters:

• className (string): The full name of the Java class to be analyzed.
• projectPath (string): The root directory path of the Maven project.

Example:

{
  "name": "analyze_class",
  "arguments": {
    "className": "com.example.QueryBizOrderDO",
    "projectPath": "/path/to/your/maven/project"
  }
}

Cache files

The following cache directories and files will be generated in the current project:

• .mcp-class-index.json: Class index cache file.
• .mcp-decompile-cache/: Cache directory for decompilation results (structured by package name).
• .mcp-class-temp/: Temporary file directory (structured by package name).

🔄 Workflow

1. Automatic Indexing: When analyze_class or decompile_class is called for the first time, the index is automatically checked and created.
2. Intelligent Caching: Decompilation results are cached according to the package name structure, and cache control is supported.
3. Class Analysis: Use analyze_class or decompile_class to obtain detailed class information.
4. LLM Analysis: Provide the decompiled source code to the LLM for code analysis.

🔧 Technical Architecture

Core Components

• DependencyScanner: Responsible for scanning Maven dependencies and building class indexes.
• DecompilerService: Responsible for decompiling .class files.
• JavaClassAnalyzer: Responsible for analyzing Java class structures.
• MCP Server: Provides standardized MCP interfaces.

Dependency scanning process

1. Execute mvn dependency:tree to obtain the dependency tree.
2. Parse each JAR package and extract all .class files.
3. Build a mapping index from the "full class name -> JAR package path".
4. Cache the index in the .mcp-class-index.json file.

Decompilation process

1. Find the corresponding JAR package path based on the class name.
2. Check the cache. If it exists and caching is enabled, return directly.
3. Extract the .class file from the JAR package to the .mcp-class-temp directory (structured by package name).
4. Use the CFR tool to decompile the .class file.
5. Save the decompilation result to the cache .mcp-decompile-cache directory (structured by package name).
6. Return the Java source code.

🛠️ Troubleshooting

Common issues

1. Maven command fails

   • Ensure that Maven is installed and in the PATH.
   • Check if the project has a valid pom.xml file.

2. CFR decompilation fails

   • Ensure that the CFR JAR package has been downloaded (any version number is supported).
   • Check if the Java environment is correctly configured.
   • You can specify the CFR path through the cfrPath parameter.

3. Class not found

   • The program will automatically check and create an index.
   • Check if the class name is correct.
   • Ensure that the project dependencies are correctly resolved.

🧪 Testing Instructions

Build the project

npm install
npm run build

Use the testing tools

The project provides independent testing tools that can directly test each function of the MCP service without going through the MCP client.

# Test all tools
node test-tools.js

# Test a specific tool
node test-tools.js --tool decompile_class --class com.alibaba.excel.EasyExcelFactory --project /path/to/project

# Do not use the cache
node test-tools.js --tool decompile_class --no-cache

# Specify the CFR path
node test-tools.js --tool decompile_class --cfr-path /path/to/cfr.jar

Testing tool parameters

• -t, --tool <tool name>: Specify the tool to be tested (scan|decompile|analyze|all).
• -p, --project <path>: Project path.
• -c, --class <class name>: Name of the class to be analyzed.
• --no-refresh: Do not force - refresh the dependency index.
• --no-cache: Do not use the decompilation cache.
• --cfr-path <path>: Specify the path to the JAR package of the CFR decompilation tool.
• -h, --help: Display help information.

Log level control

Control the log output through the NODE_ENV environment variable:

• development: Output detailed debugging information.
• production: Only output key information.