Runner
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.
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
Maintainer
Works with
Installation
Manual Installation
npx runnerConfiguration
Configuration Details
claude_desktop_config.json
Performance
Response Metrics
Resource Usage
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
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 --releaseCreate 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
}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.jsonConnect 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);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-runnerRunner 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.
Runner Alternatives — Similar Developer Tools Servers
Looking for alternatives to Runner? Here are other popular developer tools servers you can use with Claude, Cursor, and VS Code.
Ecc
★ 188.2kThe agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Javaguide
★ 155.8kJava 面试 & 后端通用面试指南,覆盖计算机基础、数据库、分布式、高并发、系统设计与 AI 应用开发
Gemini CLI
★ 104.5kA secure MCP server that wraps the Google Gemini CLI, allowing clients to query Gemini models using local OAuth sessions without requiring an API key. It provides tools for model interaction and diagnostics with built-in protection against command in
Awesome MCP Servers
★ 87.3k⭐ Curated list of Model Context Protocol (MCP) servers - tools that extend Claude Desktop, Cursor, Windsurf, and other MCP clients with custom capabilities.
MCP Servers
★ 86.0kModel Context Protocol Servers
CC Switch
★ 77.5kA cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode, OpenClaw, Gemini CLI & Hermes Agent. Only official website: ccswitch.io
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.
Set Up Runner in Your Editor
Choose your AI client for step-by-step setup instructions.
Quick Config Preview
Add this to your claude_desktop_config.json or .cursor/mcp.json
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.