MCP Access Point is a lightweight gateway that translates between HTTP services and MCP clients. It runs as a Rust-based proxy built on Pingora, enabling MCP clients to access existing HTTP endpoints without modifying the HTTP services themselves. The gateway supports two transport modes: SSE for streaming server-sent events and Streamable HTTP for standard HTTP requests routed via MCP paths. Each MCP service is exposed under tenant-specific paths such as /api/{service-id}/sse (for SSE) or /api/{service-id}/mcp (for Streamable HTTP). The tool is designed for multi-tenancy, allowing independent configuration and routing per MCP service, and it can be configured at runtime via a YAML file specified with -c config.yaml. You can also debug and inspect MCP traffic with the Inspector tool when needed.

To use it, clone the repository, build the project, and run the server with a reference config.yaml. After starting, use the configured endpoints to route requests to your HTTP backends. For debugging or development, you can connect an MCP client such as Cursor Desktop to IP:PORT/sse or IP:PORT/mcp depending on the transport mode you’re using, and point it at the appropriate service id under /api. The gateway will proxy and convert the protocols automatically, enabling MCP clients to invoke standard HTTP APIs transparently.

Prerequisites:

• Rust toolchain (Rustup, cargo)
• Git
• A supported OpenAPI specification or upstream HTTP services to proxy (as referenced in your config.yaml)

Installation steps:

1. Install Rust and Git (if not already installed)
   • macOS: install Xcode Command Line Tools and run: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   • Linux: sudo apt-get update && sudo apt-get install -y build-essential curl; curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   • Windows: install Rust via rustup from https://rustup.rs
2. Clone the repository git clone https://github.com/sxhxliang/mcp-access-point.git cd mcp-access-point
3. Build and run with your config
   • Create or edit config.yaml with your mcps and upstreams configuration
   • Run the server (from project root): cargo run -- --help

     Then start with your config:

     cargo run -- -c config.yaml
4. Optional: validate with Inspector
   • In another terminal, start the Inspector and connect to the gateway to observe MCP traffic: npx @modelcontextprotocol/inspector node build/index.js

     Access http://127.0.0.1:6274/ and connect to your gateway via SSE at /sse or mcp at /mcp

Notes:

• The -c flag controls the path to the YAML configuration file that defines mcps and upstreams.
• The gateway supports multi-tenancy so you can define multiple mcps in a single config.yaml and expose them under /api/{service-id}/sse and /api/{service-id}/mcp.

Tips and common issues:

• Ensure the config.yaml correctly references upstreams and that the host/port definitions in the upstreams match your backends.
• When using SSE, make sure clients connect to ip:port/sse and target the correct /api/{service-id}/sse endpoint.
• For Streamable HTTP, the endpoint is ip:port/mcp with the corresponding /api/{service-id}/mcp path.
• If you modify config.yaml at runtime, you can often avoid restarting the service depending on your runtime configuration features; otherwise, a restart will reload the configuration.
• If you run behind a firewall or NAT, expose the correct IP:PORT in config and ensure TLS termination is handled if needed.
• You can enable runtime configuration management and Admin API features from your config to adjust routes and upstreams without downtime.