Unified MCP Server Plugin for JavaScript Build Tools

Overview

The Unified MCP Server Plugin is a powerful tool designed to integrate the Model Context Protocol (MCP) into JavaScript build tools. It creates and manages an MCP server, enabling AI assistants to gain deeper insights into your codebase, build tools, and even control the build process. This plugin is compatible with multiple build tools supported by unplugin, including Rollup, Vite, Webpack, and more.

Features

• Cross-Platform MCP Integration: Seamlessly integrates MCP across multiple build tools.
• Bi-directional AI Integration: Provides context to AI assistants and allows AI to modify and control the build process.
• Rich Built-in Tools: Includes tools for analyzing module dependencies, inspecting build configurations, and debugging error messages.
• Extensible Tool Framework: Create custom MCP tools using the UnpluginMcpTool interface.
• Build Process Integration: Integrates at any point in the plugin chain and hooks of your build tools.
• Persistent Server: Keeps running after build completion in watch mode for continuous AI interaction.
• Standard Transport Layer: Uses HTTP and Server-Sent Events (SSE) for broad compatibility with AI assistants.

Installation

# Install the plugin
pnpm add -D unplugin-mcp

# Or install bundler-specific one
pnpm add -D rollup-plugin-mcp

Usage

Build Tool Integration

Here’s an example of how to use the plugin with Rollup:

// rollup.config.js
import { defineConfig } from 'rollup';
import { rollupPlugin as mcp } from 'unplugin-mcp';
import { ModuleTool, BuildConfigTool, BuildErrorTool } from 'unplugin-mcp/tools';

export default defineConfig({
  plugins: [
    // other plugins...
    mcp({
      provideUnpluginMcpTools: () => [
        new ModuleTool(),
        new BuildConfigTool(),
        new BuildErrorTool()
      ]
    }),
    // other plugins...
  ]
});

Usage in Cursor

Add an MCP Server to Cursor Settings:

{
  "mcpServers": {
    "rollup": {
      "url": "http://localhost:14514/mcp/sse"
    }
  }
}

Options

Check McpPluginOptions in the types file for all available options.

Built-in Tools Compatibility

• ✅ = Supported
• ❌ = Not yet implemented

Custom Tools

Extend the plugin with custom tools using the UnpluginMcpTool interface:

import { InputOptions } from "rollup";
import { UnpluginMcpTool, UnpluginMcpToolSetupOptions } from "unplugin-mcp";
import DeferredCtor, { Deferred } from 'promise-deferred';
import { UnpluginOptions } from "unplugin";

export class BuildConfigTool implements UnpluginMcpTool {
  private buildConfig: Deferred<InputOptions>;
  affectsBuildProcess: boolean = false;

  constructor() {
    this.buildConfig = new DeferredCtor<InputOptions>();
  }

  setupMcpServer(mcpServer: any, options?: any) {
    mcpServer.tool(
      `get-build-config`,
      "Get build configuration",
      {},
      async () => {
        const cfg = await this.buildConfig.promise;
        return {
          content: [
            {
              type: 'text',
              text: `Build configuration: ${JSON.stringify(cfg)}`
            }
          ]
        };
      }
    );
    return mcpServer;
  }

  registerPlugins(options?: UnpluginMcpToolSetupOptions): UnpluginOptions {
    let self = this;
    return {
      name: 'build-config-tool',
      rollup: {
        options(config) {
          self.buildConfig.resolve(config);
        }
      }
    }
  }
}

Register the custom tool in the plugin options:

// rollup.config.js
// ... 
plugins: [
  mcp({
    provideUnpluginMcpTools: () => [
      new BuildConfigTool()
    ]
  })
]
// ...

Examples

Check out the examples directory for working examples, including:

• simple-hello: A basic example demonstrating MCP integration with Rollup.

How It Works

1. Creates and Sets Up a Singleton MCP Server: Initializes an MCP server instance.
2. Registers UnpluginMcpTool Instances: Adds tools to the MCP server.
3. Creates an HTTP Server: Sets up HTTP routes for the MCP server.
4. Starts the HTTP Server: Listens on the specified port and host.
5. Registers Hooks: Adds hooks created by UnpluginMcpTool instances to build tools.

After setup, the plugin can:
- Handle incoming requests from MCP clients.
- React to hooks triggered by the build tool.
- Provide build contextual information to the MCP client.

License

MIT License. Copyright (c) 2025 situ2001.

About

A unified MCP (Model Context Protocol) server plugin for any JavaScript build tools.

Topics

• mcp
• rollup
• rollup-plugin
• unplugin
• mcp-server
• modelcontextprotocol

Resources

• Readme
• License