mcpField
M
MCP Local Router

MCP Local Router

Local
github.com/kaichenDeveloper Tools19Updated 57w ago

About MCP Local Router

MCP Local Router is a local aggregation proxy that connects to multiple upstream MCP servers and combines their functions into one interface for downstream clients. It suits developers who want to manage several MCP servers through a single entry point.

Key features

  1. 01Configuration file passed via command line arguments
  2. 02Multiple upstream MCP server configuration
  3. 03stdio transport with environment variable injection
  4. 04SSE transport with aggregated and per-upstream endpoints

Use cases

  1. 01Exposing tools from several MCP servers through one entry point
  2. 02Giving a client access to the tools of a single upstream server

MCP support

The router runs as an MCP proxy that connects to several upstream MCP servers and presents their aggregated tools to downstream MCP clients.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

No install method listed yet

We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.

Repository

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

MCP Local Router

This project is an MCP (Model Context Protocol) local router that serves as an aggregation proxy for MCP servers. It can connect to multiple upstream MCP servers and aggregate their functionalities into a single interface for downstream clients.

Features

  • Supports specifying a configuration file via command line arguments
  • Supports configuring multiple upstream MCP servers
  • Supports stdio transport
  • Supports injecting environment variables into stdio transport
  • Supports SSE transport with aggregated /sse and per-upstream /sse/{serverName} endpoints

Usage

Running

It must be run with a configuration file:

cargo run -- --config mcp-config.json --transport sse
SSE Routing

When the router runs with --transport sse, it exposes two kinds of endpoints:

  • /sse streams the aggregated tool surface area from every configured upstream server.
  • /sse/{serverName} streams only the tools from a single upstream. The {serverName} segment must match the key from mcpServers in your configuration file (for example /sse/filesystem or /sse/workspace-search).

The server name keys should be URL-safe because they are used directly as path segments.

Each SSE connection emits an initial endpoint event containing the HTTP path clients should use for POST requests. All streaming endpoints share the same POST /message?sessionId=… channel.

Configuration File Format

The configuration file is in JSON format; an example is shown below:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop"
      ],
      "env": {
        "LINEAR_ACCESS_TOKEN": "your_personal_access_token"
      }
    },
    "workspace-search": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-everything"
      ],
      "env": {}
    }
  }
}

Description:

  • mcpServers: a mapping of multiple server configurations
    • Each key is the server's name (used for logging and the /sse/{serverName} path)
    • Each value is an object containing the following fields:
      • command: the command to execute
      • args: an array of command arguments
      • env: a mapping of environment variables to inject

Build and Installation

# Build the project
cargo build --release

# Run
cargo run --release -- --config mcp-config.json --transport stdio

Dependencies

  • Rust 2021 Edition
  • tokio async runtime
  • MCP-related libraries: rmcp

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.