Runner

v1.0.0Developer Toolsstable

A WebSocket server implementation for running Model Context Protocol (MCP) servers. This application enables MCP servers to be accessed via WebSocket connections, facilitating integration with web applications and other network-enabled clients.

runnermcpai-integration
Share:
20
Stars
0
Downloads
0
Weekly
0/5

What is Runner?

Runner is a Model Context Protocol (MCP) server that allows AI assistants like Claude, Cursor, and VS Code to websocket server implementation for running model context protocol (mcp) servers. this application enables mcp servers to be accessed via websocket connections, facilitating integration with web appli...

A WebSocket server implementation for running Model Context Protocol (MCP) servers. This application enables MCP servers to be accessed via WebSocket connections, facilitating integration with web applications and other network-enabled clients.

This server falls under the Developer Tools category on MCPgee, the world's largest MCP server directory with 33,000+ servers.

Features

  • A WebSocket server implementation for running Model Context

Use Cases

Access MCP servers via WebSocket connections for web application integration. Enable network-enabled client communication with MCP infrastructure.
yonaka15

Maintainer

LicenseMIT
Languagerust
Versionv1.0.0
UpdatedDec 29, 2025
Statushealthy
Maintenanceactive

Works with

ClaudeOpenAIwindowsmacoslinux

Installation

Manual Installation

npx runner

Configuration

Configuration Details

Config File

claude_desktop_config.json

Performance

Response Metrics

Response Time< 200ms
ThroughputMedium

Resource Usage

Memory UsageLow
CPU UsageLow

How to Set Up and Use Runner

MCP Server Runner is a WebSocket bridge written in Rust that launches MCP server processes locally and exposes them over a WebSocket connection, making stdio-based MCP servers accessible to web applications and network-enabled clients that cannot spawn local processes. It manages process lifecycle, handles bidirectional message routing between WebSocket clients and the spawned MCP server, and supports multiple server configurations via a JSON config file. Developers use it to integrate MCP servers into browser-based tools, web applications, or any client that communicates over WebSocket rather than stdio.

Prerequisites

  • Rust toolchain (cargo) installed — https://rustup.rs
  • The MCP server binary or npx-runnable package you want to expose over WebSocket
  • An MCP-compatible client or web application that can connect via WebSocket
  • Optional: Docker and docker-compose for containerized deployment
1

Clone the repository and build the binary

Clone the mcp-server-runner repository and build it with cargo. The build produces a native binary that starts and manages MCP server child processes.

git clone https://github.com/yonaka15/mcp-server-runner.git
cd mcp-server-runner
cargo build --release
2

Create a configuration file for your MCP servers

Create a config.json file specifying the MCP server(s) you want to expose. Each entry under 'servers' defines the command and arguments to launch the server process, plus any environment variables it needs.

{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": {}
    }
  },
  "default_server": "filesystem",
  "host": "0.0.0.0",
  "port": 8080
}
3

Start the runner with the configuration file

Run the binary and point it at your config file. The runner will bind to the configured host and port and wait for WebSocket connections. Enable debug logging with RUST_LOG=debug for verbose output.

RUST_LOG=info ./target/release/mcp-server-runner config.json
4

Connect a WebSocket client to the runner

Any WebSocket client can now connect to the runner endpoint. The runner forwards MCP JSON-RPC messages between the client and the spawned server process bidirectionally.

// JavaScript WebSocket client example
const ws = new WebSocket('ws://localhost:8080');
ws.onmessage = (event) => console.log('MCP message:', event.data);
5

Alternative: use environment variables instead of a config file

For simple single-server setups, configure the runner entirely via environment variables without a config file. PROGRAM sets the executable and ARGS is a comma-separated list of arguments.

export PROGRAM=npx
export ARGS=-y,@modelcontextprotocol/server-github
export PORT=8080
./target/release/mcp-server-runner

Runner Examples

Client configuration

JSON configuration file for mcp-server-runner exposing a filesystem MCP server over WebSocket on port 8080.

{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
      "env": {}
    }
  },
  "default_server": "filesystem",
  "host": "0.0.0.0",
  "port": 8080
}

Prompts to try

Once a web application connects to the runner via WebSocket, it can interact with the underlying MCP server capabilities.

- "List all files in the /home/user/projects directory"
- "Read the contents of config.json"
- "Search for all TypeScript files containing 'useState'"
- "Connect to ws://localhost:8080 and list available MCP tools"

Troubleshooting Runner

cargo build fails with missing dependencies

Ensure you have the latest stable Rust toolchain by running 'rustup update stable'. The project requires Rust 1.70 or later. Also verify that standard build tools (gcc/clang on Linux/macOS, MSVC on Windows) are installed.

WebSocket connections are immediately dropped

Check that the PROGRAM path is correct and the target MCP server starts successfully in isolation. Run 'RUST_LOG=debug cargo run config.json' to see detailed process spawn and message routing logs. Verify the port is not already in use.

MCP server process crashes after receiving first message

Some MCP servers expect specific initialization sequences. Verify that the args in your config.json are correct by running the server command directly (e.g., npx -y @modelcontextprotocol/server-filesystem /tmp) and confirming it starts without errors before using the runner.

Frequently Asked Questions about Runner

What is Runner?

Runner is a Model Context Protocol (MCP) server that websocket server implementation for running model context protocol (mcp) servers. this application enables mcp servers to be accessed via websocket connections, facilitating integration with web applications and other network-enabled clients. It connects AI assistants to external tools and data sources through a standardized interface.

How do I install Runner?

Follow the installation instructions on the Runner GitHub repository. Clone the repo, install dependencies, and add the server config to your AI client.

Which AI clients work with Runner?

Runner works with all major MCP-compatible AI clients including Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf, and Cline.

Is Runner free to use?

Yes, Runner is open source and available under the MIT license. You can use it freely in both personal and commercial projects.

Browse More Developer Tools MCP Servers

Explore all developer tools servers available in the MCPgee directory. Each server includes setup guides for Claude, Cursor, and VS Code.

Quick Config Preview

{ "mcpServers": { "runner": { "command": "npx", "args": ["-y", "runner"] } } }

Add this to your claude_desktop_config.json or .cursor/mcp.json

Read the full setup guide →

Ready to use Runner?

Browse our complete directory of 33,000+ MCP servers, read setup guides for your editor, and start building with the Model Context Protocol.

33,000+ ServersFree & Open SourceStep-by-Step Guides