MixinMCP

Extends IntelliJ's built-in MCP Server with tools for Minecraft mod development, with the goal of improving mixin writing and inter-mod compatibility.

GitHub: https://github.com/muon-rw/MixinMCP

For all features, you will also need the Gradle plugin - see https://github.com/muon-rw/MixinMCP#Setup

Key features:

1. Broad-scoped search:

• Full type hierarchy: supertypes, subtypes, and all implementations of an interface or abstract class
• Find all overrides of a method, plus its original super-method declaration
• Call hierarchy: callers and callees of any method
• All references to a class, method, or field
• All @Mixin classes targeting a given class method. Helps identify cross-mod conflicts
• Symbol search by name pattern, plus regex grep across all dependency sources

Regex search across your entire classpath including dependencies:

• Alternative tools have a central problem: You can not perform broad, text-based search like regex on files that aren't in your project's own source. This is exactly the use case that Minecraft development (and mixin writing) needs so desparately - 100 other projects might be interacting with what you are, and you need to know what and how. While other tools might be able to read individual files in Minecraft sources, loader or mod APIs, libraries, or other mods you've added for integration or compatibility, they don't have a good way to search through them.
• With this plugin, agents can easily scan the whole project dependency network on their own, including dependencies without published sources.
• Circumvents the need to manually copy and paste snippets into context, or for agents to find jars in your gradle cache and unzip/analyze them manually one by one.

2. Class/Method Bytecode lookup:

• Get the actual compiled bytecode for a given class or method
• Useful to find a precise target when writing mixins, especially for ordinals or synthetic lambdas

3. Built-in Agent Skills for enhanced Mixin Writing:

• Improve compatibility of written mixins by favoring MixinExtras injectors which LLMs often hallucinate or fail to use in the first place
• Favor precise modification for the exact target for the task without workarounds, slices, or shift by's, thanks to MixinExtras' robust @Expression annotation

4. Automatic Mappings lookup:

• Easily convert any class, method, or field name between SRG, Intermediary, Yarn, Mojmap, and obf
• Mappings are downloaded on demand (Mojang launcher meta, Fabric Maven, Forge/NeoForge Maven) and cached under ~/.cache/mixinmcp/mappings/
• This allows you to retrieve mapping data for (almost) any version or loader, even those not present in the current project

Setup

MixinMCP has two parts. You need both for full-classpath search to work:

• IntelliJ plugin: registers the mixin_* tools on IntelliJ's built-in MCP Server.
• Gradle plugin: decompiles dependencies that don't publish sources so the search tools cover every JAR on your classpath.

Prerequisites: IntelliJ IDEA 2025.3+

1. Install the IntelliJ plugin

From IntelliJ: Settings → Plugins → Marketplace → search "MixinMCP" → Install

2. Enable IntelliJ's MCP Server

• Settings → Plugins → search "MCP Server" and confirm it's enabled. (Bundled by default on recent IntelliJ versions.)
• Settings → Tools → MCP Server → check Enable MCP Server.

3. Connect your MCP client

Use IntelliJ's Auto-Configure option for your client (or configure manually using the ip address), then restart the client. The auto-configured server name is usually user-jetbrains

[!CAUTION] MixinMCP exposes full project and dependency source, classpath metadata, and bytecode to whatever connects to the MCP server. These tools aren't hardened for remote access. IntelliJ binds the server to localhost by default — leave it that way unless you have a specific reason, and expose it more broadly at your own risk.

For adherence and other optimizations, see Bundled Rules and Skills.

4. Set up the Gradle plugin

[!IMPORTANT] Without this step, mixin_search_in_deps and mixin_get_dep_source can only see dependencies that published a -sources.jar. This means that local jar dependencies, Cursemaven dependencies, and many from Modrinth Maven dependencies are totally invisible. The Gradle plugin decompiles these via Vineflower into a local cache that the IntelliJ plugin indexes automatically.

1. Add the MixinMCP maven repository to your mod project's settings.gradle or settings.gradle.kts:

// .kts format
pluginManagement {
    repositories {
        maven { url = uri("https://maven.muon.rip/releases") }
        gradlePluginPortal()
        // ... your existing repos (maven, fabricmc, neoforged, etc.)
    }
}

2. Apply the plugin in your mod project's build.gradle or build.gradle.kts:

plugins {
    // ... your existing plugins ...
    id("dev.mixinmcp.decompile") version "0.9.0"
}

3. Increase Gradle process memory: (Strongly Recommended)

[!CAUTION] If you skip this step, you might experience OOM errors during gradle sync

Add to your project level gradle.properties:

org.gradle.jvmargs=-Xmx4g
# You may need to set this as high as 6g if you need 
# to decompile an extremely large jar (e.g. Cataclysm)

[!WARNING] Setting org.gradle.parallel=true (default for Neoforge template) can increase likelihood of OOMs during big decomps

For more info, see Decompilation cache details

4. Run decompilation:

./gradlew genDependencySources

(This task already runs automatically after every gradle sync, but it can sometimes need to rerun manually)

The IntelliJ plugin reads the dependency sources cache on project open and after every Gradle sync/task run.

MixinMCP warns on project open when the Gradle plugin is missing. If you don't need full-classpath decompilation and want to silence this, disable Warn when Gradle plugin is not detected in Settings → Tools → MixinMCP.

For local development against an unpublished build, see Decompilation cache details below.

5. Verify

Ask the model to list MCP tools from the JetBrains server. The mixin_* tools should appear. If they don't: (1) confirm MixinMCP is installed, (2) confirm the MCP Server plugin is enabled, (3) confirm your client is connected (most common failure)

Bundled Rules and Skills

Tool reference

Decompilation cache details

# Manually set thread count. Setting threads=1 may cause decompilation to freeze entirely.
./gradlew genDependencySources --threads=3 # Default=2

# Skip OOM pre-flight confirmation (e.g. when you know heap is sufficient)
./gradlew genDependencySources --force

# Increase memory available to Gradle
org.gradle.jvmargs=-Xmx4g

# Disable parallelization (which may increase risk of OOM)
org.gradle.parallel=false

# In the MixinMCP project
./gradlew :mixinmcp-gradle:publishToMavenLocal

Building from Source

git clone https://github.com/muon-rw/mixin-mcp.git
cd mixin-mcp
./gradlew buildPlugin # IntelliJ plugin
./gradlew build # Gradle Plugin

./gradlew publishToMavenLocal

./gradlew runIde