Shimmy - MCP Inspector

Shimmy is a debugging and inspection tool for Model Context Protocol (MCP) servers. It intercepts traffic between MCP clients and servers, letting you see every request, response, and notification in real time.

How It Works

Shimmy has two components:

• Shimmy App - A desktop GUI (built with Tauri + SvelteKit) that displays captured MCP traffic in a three-panel inspector view.
• Shimmy CLI - A command-line proxy that sits between an MCP client and server, forwarding all messages to the Shimmy App for inspection.

MCP Client <──> Shimmy CLI (proxy) <──> MCP Server
                     │
                     ▼
               Shimmy App (inspector UI)

The CLI intercepts all JSON-RPC messages and sends them to the app over HTTP (127.0.0.1:13579). The app displays them in real time with a timeline view, request details, and response details.

Installation

Download the latest release for your platform from the GitHub Releases page. Each release includes:

• Shimmy App - Desktop application installer (macOS, Linux, Windows)
• Shimmy CLI - Standalone binary

Alternatively, you can build from source.

Please note that the app is built without signing in the release, need some tricks to bypass the security check on eash OS. If you don't feel comfortable doing that just check the source code and build from it.

Getting Started

1. Launch the Shimmy App

Open the Shimmy desktop application. It starts an HTTP listener on port 13579 and waits for incoming connections from the CLI.

2. Run the CLI to inspect an MCP server

Stdio transport

For MCP servers that communicate over standard input/output (the most common case):

shimmy-cli stdio <server_command> [server_args...]

Examples:

# Inspect a Python MCP server
shimmy-cli stdio python my_server.py

# Inspect a Node.js MCP server with arguments
shimmy-cli stdio node server.js --port 3000

# Pass environment variables to the server
shimmy-cli -e API_KEY=sk-xxx -e DEBUG=true stdio python my_server.py

HTTP transport

For MCP servers that communicate over HTTP/SSE:

shimmy-cli http <url>

Example:

shimmy-cli http http://127.0.0.1:8080

3. Inspect traffic in the App

Once the CLI connects, the Shimmy App shows all MCP traffic in real time:

• Timeline panel (left) - A chronological list of all messages, color-coded by origin (client vs. server) and status (success, error, pending, notification).
• Request panel (center) - Full JSON payload of the selected request, plus any stderr output.
• Response panel (right) - The corresponding response JSON.

You can filter messages by method name using the search bar and switch between multiple active connections using the connection selector.

CLI Reference

Usage: shimmy-cli [OPTIONS] <COMMAND>

Commands:
  stdio  Spawn the MCP server via standard input/output
  http   Spawn the MCP server over HTTP/SSE

Options:
  -v, --verbose  Enable verbose logging
  -h, --help     Print help
  -V, --version  Print version

shimmy-cli stdio

Usage: shimmy-cli stdio [OPTIONS] <SERVER_COMMAND> [SERVER_ARGS]...

Arguments:
  <SERVER_COMMAND>  The executable command to run the MCP server (e.g., 'node', 'python')
  [SERVER_ARGS]...  Arguments and flags to pass to the server command

Options:
  -e, --env <KEY=VALUE>  Environment variables to pass to the server (format: KEY=VALUE)

shimmy-cli http

Usage: shimmy-cli http <URL>

Arguments:
  <URL>  URL of the MCP server (e.g., http://127.0.0.1:8080)

Using Shimmy with MCP Clients

To use Shimmy with an MCP client (such as Claude Desktop), replace your server command with shimmy-cli wrapping the original command. For example, if your MCP client config looks like:

{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["my_server.py"]
    }
  }
}

Change it to:

{
  "mcpServers": {
    "my-server": {
      "command": "shimmy-cli",
      "args": ["stdio", "python", "my_server.py"]
    }
  }
}

Now all traffic between the client and server will be visible in the Shimmy App.

If you encounter any path resolution issue, just use the absolute path.

Supported MCP Methods

Shimmy proxies and inspects MCP protocol messages. Below is the current coverage of MCP methods.

Client-to-Server Requests

Method	Status
initialize	Supported
ping	Supported
tools/list	Supported
tools/call	Supported
resources/list	Supported
resources/read	Supported
prompts/list	Supported
prompts/get	Supported
resources/templates/list	Supported
resources/subscribe	Supported
resources/unsubscribe	Supported
completion/complete	Supported
logging/setLevel	Supported

Client-to-Server Notifications

Method	Status
notifications/initialized	Supported
notifications/cancelled	Supported
notifications/progress	Supported
notifications/roots/list_changed	Supported

Server-to-Client Requests

Method	Status
ping	Supported
elicitation/create	Supported
sampling/createMessage	Supported
roots/list	Supported

Server-to-Client Notifications

Method	Status
notifications/tools/list_changed	Supported
notifications/cancelled	Supported
notifications/progress	Supported
notifications/message	Supported
notifications/resources/updated	Supported
notifications/resources/list_changed	Supported
notifications/prompts/list_changed	Supported

Building from Source

Prerequisites

• Rust (stable)
• Node.js (for the frontend)
• Tauri prerequisites

Build the CLI

cargo build --release -p shimmy-cli

The binary will be at target/release/shimmy-cli.

Build the App

cd tauri-app
npm install
npm run tauri build

License

MIT