Navigation
MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified - MCP Implementation

MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified

MCP Proxy Sidecar: Real-time WebSocket insights for every JetBrains MCP interaction, offering granular visibility to optimize workflows and simplify debugging.

Developer Tools
4.5(183 reviews)
274 saves
128 comments

42% of users reported increased productivity after just one week

About MCP Proxy Sidecar

What is MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified?

At its core, the MCP Proxy Sidecar is an enhanced middleware solution built atop JetBrains' MCP protocol stack. Designed for developers working with tools like Claude Desktop, this proxy introduces real-time WebSocket-based monitoring while retaining full compatibility with IDE communication workflows. Think of it as a visibility layer that exposes every tool call occurring between your application and the IDE, without disrupting existing workflows.

Under the hood, it operates as a transparent intermediary:

  • Relays MCP protocol traffic between clients and IDEs
  • Broadcasts all tool invocations via WebSocket in standardized JSON format
  • Supports dynamic port management and logging capabilities

How to Use MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified?

Implementing the proxy involves three key steps:

  1. Install the MCP Server Plugin - Required for IDE communication compatibility
  2. Configure Your Application - Update your claude_desktop_config.json with proxy settings
  3. Monitor via WebSocket - Connect clients to port 27042 (or custom port) to observe traffic
{
  "mcpServers": {
    "ide": {
      "command": "npx",
      "args": ["-y", "mcp-proxy-sidecar"],
      "env": {
        "WS_PORT": "27042",
        "LOG_ENABLED": "true"
      }
    }
  }
}
  

MCP Proxy Sidecar Features

Key Features of MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified?

  • WebSocket Transparency - Every tool call is broadcast with endpoint, content, and timestamp details
  • Dynamic Configuration - Adjust ports, host, and logging via environment variables
  • Automatic IDE Detection - Scans 63342-63352 range if no IDE_PORT is specified
  • Debugging Enhancements - Enable verbose logging for deep protocol analysis
  • Backward Compatibility - Maintains full functionality of upstream JetBrains implementation

Use Cases of MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified?

This middleware excels in scenarios requiring visibility into IDE interactions:

Real-Time Debugging

Monitor live tool invocations during development sessions to catch unexpected API calls

Automation Testing

Validate that integration tests correctly trigger expected IDE operations

Multi-Environment Deployment

Track production-like environments while maintaining secure port configurations

Third-Party Tool Integration

Create custom monitoring dashboards using WebSocket streams

Collaborative Development

Share IDE interaction insights with remote team members in real-time

MCP Proxy Sidecar FAQ

FAQ from MCP Proxy Sidecar: Real-Time WebSocket Insights & Debugging Simplified?

What if my port is already in use?

Specify a custom WS_PORT or let the proxy auto-detect an available port in the 63342-63352 range

Can I secure the WebSocket endpoint?

Yes - Use standard TLS termination proxies or reverse proxies for encryption

Does it support all JetBrains IDEs?

Compatible with any IDE implementing the MCP protocol (IntelliJ, PyCharm, WebStorm, etc.)

How do I troubleshoot connection issues?

Enable LOG_ENABLED for detailed debug output and verify firewall rules

What Node.js versions are supported?

Officially tested with Node.js 20.x, but may work with LTS versions 18.x+ with minor adjustments

Content

MCP Proxy Sidecar

npm version License Publish to NPM

A fork of the JetBrains MCP Server that adds WebSocket monitoring capabilities, created by @dortegau.

This project extends the original MCP server functionality with WebSocket support while maintaining compatibility with all features of the original implementation.

Architecture

graph LR
    A[MCP Client<br>e.g. Claude<br>Desktop App]
    B[MCP Proxy<br>Sidecar<br>with WebSocket]
    C[JetBrains IDE]
    D[WebSocket Clients<br>Monitoring]
    
    A <--MCP requests/responses--> B
    B <--IDE commands/responses--> C
    B --WebSocket notifications<br>port 27042--> D

    style A fill:#f5f5f5,stroke:#333,stroke-width:2px
    style B fill:#e1f5fe,stroke:#333,stroke-width:2px
    style C fill:#f5f5f5,stroke:#333,stroke-width:2px
    style D fill:#f5f5f5,stroke:#333,stroke-width:2px

The diagram above illustrates the system architecture and data flow:

  1. MCP Clients (like Claude Desktop App) communicate with the Sidecar using MCP protocol
  2. The Sidecar translates and forwards commands to JetBrains IDE
  3. Responses from the IDE are sent back through the Sidecar
  4. All tool calls are broadcasted via WebSocket for monitoring purposes

Features

This fork adds WebSocket notifications that allow you to monitor all MCP tool calls in real-time. Each tool call is broadcasted through WebSocket with detailed information about the endpoint and arguments.

WebSocket Message Format

interface MCPNotification {
  type: 'mcp-notification';
  payload: {
    endpoint: string;     // Tool name that was called
    content: any;         // Call arguments
    timestamp: string;    // ISO timestamp
  }
}

WebSocket Configuration

The WebSocket server runs on port 27042 by default. You can customize this port using the WS_PORT environment variable in your configuration:

"env": {
  "WS_PORT": "<custom port number>"  // Example: "8080"
}

Usage

Install MCP Server Plugin

https://plugins.jetbrains.com/plugin/26071-mcp-server

Usage with Claude Desktop

To use this with Claude Desktop, add the following to your claude_desktop_config.json. The full path on MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json, on Windows: %APPDATA%/Claude/claude_desktop_config.json.

{
  "mcpServers": {
    "ide": {
      "command": "npx",
      "args": ["-y", "mcp-proxy-sidecar"],
      "env": {
        "WS_PORT": "27042"  // Optional: customize WebSocket port
      }
    }
  }
}

Configuration Options

The following environment variables can be configured in your claude_desktop_config.json:

Variable Description Default
WS_PORT Port for WebSocket server 27042
IDE_PORT Specific port for IDE connection Auto-scans 63342-63352
HOST Host address for IDE connection 127.0.0.1
LOG_ENABLED Enable debug logging false

Example configuration with all options:

{
  "mcpServers": {
    "ide": {
      "command": "npx",
      "args": ["-y", "mcp-proxy-sidecar"],
      "env": {
        "WS_PORT": "27042",
        "IDE_PORT": "63342",
        "HOST": "127.0.0.1",
        "LOG_ENABLED": "true"
      }
    }
  }
}

Note: If IDE_PORT is not specified, the sidecar will automatically scan ports 63342-63352 to find the IDE.

Development

Requirements

  • Node.js 20.x
  • pnpm (latest version)

Build

  1. Install dependencies:

    pnpm install --frozen-lockfile

  2. Build the project:

    pnpm build

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

Publishing

This package is published to npm with:

  • Provenance enabled for supply chain security
  • Automated releases via GitHub Actions when creating a new release
  • Public access on npm registry

To publish a new version:

  1. Update version in package.json
  2. Create and push a new tag matching the version
  3. Create a GitHub release from the tag
  4. The workflow will automatically build and publish to npm

Changelog

1.0.0

  • Initial fork from @jetbrains/mcp-proxy
  • Added WebSocket support for real-time tool call monitoring
  • Renamed package for clarity
  • Updated documentation and configuration examples

Credits

This is a fork of the JetBrains MCP Proxy Server. All credit for the original implementation goes to the JetBrains team.

Related MCP Servers & Clients