dnSpy MCP Server

MCP (Model Context Protocol) server extension for dnSpy, enabling AI agents to decompile and analyze .NET assemblies directly through dnSpy.

How It Works

dnSpy loads extension → MCP Server menu → Start → HttpListener on :5150
                                                        ↕
                                              AI agent (Claude, etc.)
                                              HTTP POST (JSON-RPC 2.0)

The server runs as a dnSpy extension using System.Net.HttpListener — no ASP.NET Core or external dependencies required. AI agents connect via standard MCP protocol over HTTP.

Tools (36)

Decompiler

Search

Analysis

UI & Navigation

Rename

Namespace

Type Inspection

Custom Attributes

Constants & Enums

Cross-References

Assembly

Resources & Metadata

Quick Start

Prerequisites

• dnSpy (.NET 8.0 build)
• .NET 8.0 SDK
• deps/ folder with these DLLs copied from dnSpy:
  • dnSpy.Contracts.DnSpy.dll
  • dnSpy.Contracts.Logic.dll
  • ICSharpCode.Decompiler.dll
  • dnlib.dll

Configure DnSpyBin path

The project resolves dnSpy contract DLLs via the `` MSBuild property in dnSpy.MCP.csproj:

..\..\deps

Default path resolves to /deps/. To change it, edit this property or pass it at the command line:

dotnet build -p:DnSpyBin="D:\path\to\dnSpy\bin"

Build & Deploy

# 1) Build only (Release mặc định)
pwsh scripts/build.ps1

# 2) Clean + build
pwsh scripts/build.ps1 -Clean

# 3) Build + deploy to staging (build/Extensions/)
pwsh scripts/build.ps1 -Deploy

# 4) Build + deploy directly to dnSpy runtime
pwsh scripts/build.ps1 -Deploy -DeployDir "D:\tools\dnSpy\Extensions"

# 5) Override sang Debug khi cần debug
pwsh scripts/build.ps1 -Configuration Debug -Deploy -DeployDir "D:\tools\dnSpy\Extensions"

This builds the extension DLL and deploys it. dnSpy must be closed before running.

Options:

pwsh scripts/build.ps1 -Clean                        # Clean before build
pwsh scripts/build.ps1 -Deploy                       # Deploy after build
pwsh scripts/build.ps1 -DeployDir ""          # Custom deploy target (used with -Deploy)
pwsh scripts/build.ps1 -Configuration Debug          # Build Debug instead of Release
pwsh scripts/build.ps1 -Configuration Release        # Build Release (default)

Build output paths

• Build output (Release default): src/dnSpy.MCP/bin/Release/net8.0-windows/dnSpy.MCP.x.dll
• Build output (Debug override): src/dnSpy.MCP/bin/Debug/net8.0-windows/dnSpy.MCP.x.dll
• Staging deploy: build/Extensions/dnSpy.MCP.x.dll
• Runtime deploy: /Extensions/dnSpy.MCP.x.dll

Only these files should be copied to dnSpy’s Extensions folder:

• dnSpy.MCP.x.dll
• dnSpy.MCP.x.deps.json
• dnSpy.MCP.x.pdb (optional for debugging)

Do not copy the whole build/Extensions folder recursively into dnSpy (avoid nested Extensions/Extensions/ and stale dependency files).

Usage

1. Start dnSpy.exe
2. Open a .NET assembly (.exe/.dll)
3. Menu → MCP Server → Start
4. Open View → Output (Alt+2) → select MCP Server to see logs
5. Connect from an AI agent via http://127.0.0.1:5150/

Menu Options

Project Structure

dnspy_mcp/
├── src/
│   └── dnSpy.MCP/             # Standalone extension project (recommended)
│       ├── Mcp/
│       │   ├── McpServerHost.cs     # HTTP transport + JSON-RPC 2.0 dispatch
│       │   ├── ToolRegistry.cs      # Reflection-based tool discovery
│       │   ├── McpLogger.cs         # Logging: file + Output Window
│       │   └── McpServerOptions.cs  # Port/host configuration
│       ├── Tools/                   # 13 tool classes, 36 tools total
│       ├── Helpers/
│       │   ├── MethodResolver.cs    # Resolve methods/types by name/token
│       │   └── TextDecompilerOutput.cs
│       ├── TheExtension.cs          # MEF entry point
│       ├── DnSpyContext.cs          # Static service bridge
│       └── MenuCommands.cs          # dnSpy menu items
├── deps/                        # dnSpy contract DLLs (for standalone build)
├── build/Extensions/           # Deployed extension DLLs
├── skills/                     # AI agent workflow guides (install to .claude/skills/)
│   └── deobfuscate-dotnet/     # .NET deobfuscation skill
│       └── SKILL.md
└── scripts/
    └── build.ps1           # Build & deploy script

Adding New Tools

Tools are discovered at runtime via reflection. To add a new tool:

1. Create a public static class in src/dnSpy.MCP/Tools/ under the dnSpy.MCP.Tools namespace
2. Add public static methods with a [Description("...")] attribute
3. Parameters use [Description("...")] for documentation

using System.ComponentModel;

namespace dnSpy.MCP.Tools {
    public static class MyTools {
        [Description("Describe what this tool does")]
        public static string MyTool(
            [Description("Parameter description")] string param1) {
            // Access dnSpy services via DnSpyContext
            var module = DnSpyContext.DocumentService?
                .GetAssemblies().FirstOrDefault()?.ModuleDef;
            return $"Result: {param1}";
        }
    }
}

Method names are automatically converted to snake_case for the MCP protocol (e.g., MyTool → my_tool).

Configuration

Default configuration in McpServerOptions.cs:

• Host: 127.0.0.1
• Port: 5150

Logging

Logs are written to three destinations:

• File: build/Extensions/mcp-server.log
• In-memory: Viewable via MCP Server → Show Log
• Output Window: View → Output → MCP Server (in dnSpy)

Architecture Notes

Why HttpListener instead of MCP SDK?

The official MCP SDK (ModelContextProtocol 1.2.0) pulls Microsoft.Extensions.* 10.x dependencies, but dnSpy runs on .NET 8.0 with Microsoft.Extensions.* 8.x. This is a hard version conflict that cannot be resolved with binding redirects. The solution is a custom HTTP transport using System.Net.HttpListener.

Standalone Build

The project references pre-built DLLs from deps/, enabling fast iteration without cloning the full dnSpy source. For integrated builds as part of dnSpy.sln, clone dnSpyEx and copy src/dnSpy.MCP/ into Extensions/.

Connecting AI Agents

This MCP server exposes dnSpy’s decompilation and analysis tools via the standard MCP protocol over HTTP at http://127.0.0.1:5150/. Most modern AI agents support HTTP MCP servers natively — no bridge package needed.

Claude Code (recommended)

Use the claude mcp add command to add the server. Choose a scope:

# Local scope (default) — only this project, stored in ~/.claude.json
claude mcp add --transport http dnspy http://127.0.0.1:5150

# Project scope — shared with team via .mcp.json (check into git)
claude mcp add --transport http dnspy --scope project http://127.0.0.1:5150

# User scope — all your projects
claude mcp add --transport http dnspy --scope user http://127.0.0.1:5150

Project scope generates a .mcp.json at the project root:

{
  "mcpServers": {
    "dnspy": {
      "type": "http",
      "url": "http://127.0.0.1:5150"
    }
  }
}

Local/User scope writes to ~/.claude.json under the project path:

{
  "projects": {
    "/path/to/your/project": {
      "mcpServers": {
        "dnspy": {
          "type": "http",
          "url": "http://127.0.0.1:5150"
        }
      }
    }
  }
}

Other useful commands:

claude mcp list          # list all configured servers
claude mcp get dnspy     # show config for a server
claude mcp remove dnspy  # remove a server

Other AI Editors

Verification

1. Start dnSpy and open an assembly
2. Menu → MCP Server → Start
3. In your AI agent, verify the connection:

You should see 36 MCP tools available:
- decompile_method
- decompile_type
- search_types
- grep
- get_xrefs_to
- assembly_overview
- ...and more

If the agent does not auto-discover the tools, tell it: “Use the dnSpy MCP server at http://127.0.0.1:5150/ to access decompilation and analysis tools.”

Skills

The skills/ directory contains reusable workflow guides for AI agents working with this MCP server. These skills teach the AI how to think about common analysis tasks — it dynamically picks tools based on what it discovers, rather than following rigid steps.

Available Skills

Skill Structure

Each skill is a folder containing a SKILL.md file:

skills/
└── deobfuscate-dotnet/
    └── SKILL.md          # Skill definition (YAML frontmatter + instructions)

Installing Skills for Claude Code

Claude Code auto-discovers skills from .claude/skills/. To install:

# Install a specific skill
cp -r skills/deobfuscate-dotnet .claude/skills/

# Or install all skills
cp -r skills/* .claude/skills/

After installing, the skill activates automatically when you describe a matching task — for example:

# These will trigger the deobfuscation skill:
"Giúp tôi decrypt các string trong binary này"
"Rename lại các class/method bị obfuscate"
"Binary này bị protect bằng gì? Phân tích giúp tôi"

No restart needed — Claude Code picks up new skills on the next message.

For Other AI Editors

If your AI editor supports custom instructions or system prompts, paste the content of SKILL.md directly into your configuration. The skill content is self-contained and editor-agnostic.

License

This project is licensed under GPLv3, consistent with dnSpy’s license.