mcp-access-point

Bridge HTTP services with Model Context Protocol (MCP) clients seamlessly.

View on GitHub Visit Website

118

Stars

Forks

118

Watchers

Issues

MCP Access Point acts as a lightweight gateway that enables direct communication between MCP-compatible clients and traditional HTTP services without requiring server-side modifications. Built on the high-performance Pingora proxy library, it supports protocol conversion between HTTP, SSE, and MCP, supporting multi-tenancy and customizable routing. It empowers various MCP clients, such as Cursor Desktop, MCP Inspector, and VS Code, to interact with existing APIs efficiently. Configuration is flexible via YAML, and deployment is possible both locally and through Docker.

Key Features

HTTP to MCP protocol conversion

Support for SSE, Streamable HTTP, and MCP transport types

Zero-intrusive integration with existing HTTP services

Multi-tenant configuration with customizable endpoints

Routing based on OpenAPI specifications

Scalable and efficient performance via Pingora proxy

Configurable via YAML files

Docker deployment support

Client compatibility with MCP Inspector, Cursor Desktop, VS Code, and more

Custom routing and header management for upstream services

Use Cases

Migrating legacy HTTP APIs to be accessible by MCP clients

Enabling AI copilots and IDE plugins to interface with HTTP-based backends using MCP

Building hybrid systems supporting both HTTP and MCP for incremental modernization

Serving context-aware model applications without rewriting existing API servers

Providing a middleware layer for AI/ML tools that require model context protocol support

Optimizing backend communication for large-scale, multi-tenant AI services

Prototyping MCP integrations with minimal backend changes

Enabling OpenAPI-based dynamic routing for API access

Supporting rapid debugging and inspection of MCP endpoints via compatible clients

Facilitating plug-and-play connectivity between modern model context tools and traditional web services

README

MCP Access Point

MCP Access Point is a lightweight protocol conversion gateway tool designed to establish a communication bridge between traditional HTTP services and MCP (Model Context Protocol) clients. It enables MCP clients to interact directly with existing HTTP services without requiring any server-side interface modifications.

Introduction

This project is built on Pingora - an ultra-high performance gateway proxy library capable of supporting massive-scale request proxy services. Pingora has been used to build services that handle core traffic for the Cloudflare platform, consistently serving over 40 million requests per second across the internet for years. It has become the technical cornerstone supporting a significant proportion of traffic on the Cloudflare platform.

HTTP to MCP

This mode allows clients like Cursor Desktop to communicate with remote HTTP servers through SSE, even when the servers themselves don't support the SSE protocol.

Example setup includes two services:
- Service 1 runs locally at 127.0.0.1:8090
- Service 2 runs remotely at api.example.com
Through the MCP Access Point, both services can be converted to MCP services without any code modifications.
Clients communicate with Service 1 and Service 2 via the MCP protocol. The MCP Access Point automatically distinguishes MCP requests and forwards them to the appropriate backend services.

mermaid

graph LR
   A["Cursor Desktop"] <--> |SSE| B["MCP Access Point"]
   A2["Other Desktop"] <--> |Streamable Http| B["MCP Access Point"]
   B <--> |http 127.0.0.1:8090| C1["Existing API Server"]
   B <--> |https//api.example.com| C2["Existing API Server"]
  
   style A2 fill:#ffe6f9,stroke:#333,color:black,stroke-width:2px
   style A fill:#ffe6f9,stroke:#333,color:black,stroke-width:2px
   style B fill:#e6e6af,stroke:#333,color:black,stroke-width:2px
   style C1 fill:#e6ffe6,stroke:#333,color:black,stroke-width:2px
   style C2 fill:#e6ffd6,stroke:#333,color:black,stroke-width:2px

Transport Type (Specification)

Currently supports SSE and Streamable HTTP protocols:

✅ Streamable HTTP (stateless) 2024-03-26
- All services: ip:port/mcp
- Single service: ip:port/api/{service_id}/mcp
✅ SSE 2024-11-05
- All services: ip:port/sse
- Single service: ip:port/api/{service_id}/sse

use IP:PORT/sse for SSE use IP:PORT/mcp for Streamable HTTP

Supported MCP clients

Core Features

Protocol Conversion: Seamless conversion between HTTP and MCP protocols
Zero-Intrusive Integration: Full compatibility with existing HTTP services
Client Empowerment: Enables MCP clients to directly call standard HTTP services
Lightweight Proxy: Minimalist architecture with efficient protocol conversion
Multi-tenancy: Independent configuration and endpoints for each tenant

Quick Start

Installation

bash

# Install from source
git clone https://github.com/sxhxliang/mcp-access-point.git
cd mcp-access-point
cargo run -- -c config.yaml

# Use inspector for debugging (start service first)
npx @modelcontextprotocol/inspector node build/index.js
# Access http://127.0.0.1:6274/
# Select "see" and enter 0.0.0.0:8080/sse, then click connect
# or select "Streamable HTTP" and enter 0.0.0.0:8080/mcp

Multi-tenancy Support

The MCP Access Gateway supports multi-tenancy, where each tenant can configure multiple MCP services accessible via:

/api/{mcp-service-id}/sse (for SSE)
/api/{mcp-service-id}/mcp (for Streamable HTTP)

Example configuration:

yaml

# config.yaml example (supports multiple services)

mcps:
  - id: service-1 # Access via /api/service-1/sse or /api/service-1/mcp
    ... # Service configuration
  - id: service-2 # Access via /api/service-2/sse or /api/service-2/mcp
    ... # Service configuration
  - id: service-3 # Access via /api/service-3/sse or /api/service-3/mcp
    ... # Service configuration

To access all services simultaneously, use:

0.0.0.0:8080/mcp (Streamable HTTP)
0.0.0.0:8080/sse (SSE)

Configuration Details

-c config.yaml
- -c (or --config) specifies the configuration file path (config.yaml).
- This file defines the APIs that the MCP Access Point will proxy and convert.

config.yaml Example

The configuration file supports multi-tenancy, allowing independent configuration of upstream services and routing rules for each MCP service. Key configuration items include:

mcps - MCP service list
- id: Unique service identifier used to generate access paths
- upstream_id: Associated upstream service ID
- path: OpenAPI specification file path (local or remote)
- routes: Custom routing configuration (optional)
- upstream: Upstream service specific configuration (optional)
upstreams - Upstream service configuration
- id: Upstream service ID
- nodes: Backend node addresses and weights
- type: Load balancing algorithm (roundrobin/random/ip_hash)
- scheme: Upstream protocol (http/https)
- pass_host: HTTP Host header handling
- upstream_host: Override Host header value

Complete configuration example:

yaml

# config.yaml example (supports multiple services)
mcps:
  - id: service-1 # Unique identifier, accessible via /api/service-1/sse or /api/service-1/mcp
    upstream_id: 1
    path: config/openapi_for_demo_patch1.json # Local OpenAPI spec path

  - id: service-2 # Unique identifier
    upstream_id: 2
    path: https://petstore.swagger.io/v2/swagger.json # Remote OpenAPI spec

  - id: service-3 
    upstream_id: 3
    routes: # Custom routing
      - id: 1
        operation_id: get_weather
        uri: /points/{latitude},{longitude}
        method: GET
        meta:
          name: Get Weather
          description: Retrieve weather information by coordinates
          inputSchema: # Optional input validation
            type: object
            required:
              - latitude
              - longitude
            properties:
              latitude:
                type: number
                minimum: -90
                maximum: 90
              longitude:
                type: number
                minimum: -180
                maximum: 180

upstreams: # Required upstream configuration
  - id: 1
    headers: # Headers to send to upstream service
      X-API-Key: "12345-abcdef"        # API key
      Authorization: "Bearer token123" # Bearer token
      User-Agent: "MyApp/1.0"          # User agent
      Accept: "application/json"       # Accept header
    nodes: # Backend nodes (IP or domain)
      "127.0.0.1:8090": 1 # Format: address:weight

  - id: 2 
    nodes:
      "127.0.0.1:8091": 1

  - id: 3 
    nodes:
      "api.weather.gov": 1
    type: roundrobin # Load balancing algorithm
    scheme: https # Protocol
    pass_host: rewrite # Host header handling
    upstream_host: api.weather.gov # Override Host

To run the MCP Access Gateway with config file:

bash

cargo run -- -c config.yaml

Running via Docker

Run Locally for quick start

bash

# Note: Replace /path/to/your/config.yaml with actual path
docker run -d --name mcp-access-point --rm \
  -p 8080:8080 \
  -e port=8080 \
  -v /path/to/your/config.yaml:/app/config/config.yaml \
  ghcr.io/sxhxliang/mcp-access-point:main

Build Docker Image (Optional)

install docker
clone repository and build image

bash

# Clone repository
git clone https://github.com/sxhxliang/mcp-access-point.git
cd mcp-access-point

# Build image
docker build -t liangshihua/mcp-access-point:latest .

Run Docker Container

bash

# Using environment variables (service running on host)
# Note: Replace /path/to/your/config.yaml with actual path

docker run -d --name mcp-access-point --rm \
  -p 8080:8080 \
  -e port=8080 \
  -v /path/to/your/config.yaml:/app/config/config.yaml \
  liangshihua/mcp-access-point:latest

Environment Variables

port: MCP Access Point listening port (default: 8080)

Typical Use Cases

Progressive Architecture Migration: Facilitate gradual transition from HTTP to MCP
Hybrid Architecture Support: Reuse existing HTTP infrastructure within MCP ecosystem
Protocol Compatibility: Build hybrid systems supporting both protocols

Example Scenario:
When MCP-based AI clients need to interface with legacy HTTP microservices, the MCP Access Gateway acts as a middleware layer enabling seamless protocol conversion.

Many thanks to @limcheekin for writing an article with a practical example: https://limcheekin.medium.com/building-your-first-no-code-mcp-server-the-fabric-integration-story-90da58cdbe1f

Contribution Guidelines

Fork this repository.
Create a branch and commit your changes.
Create a pull request and wait for it to be merged.
Make sure your code follows the Rust coding standards.

Star History

Repository Owner

sxhxliang

User

Repository Details

Language Rust

Default Branch main

Size 354 KB

Contributors 3

License MIT License

MCP Verified Sep 1, 2025

Programming Languages

Rust

99.72%

Shell

0.14%

Dockerfile

0.14%

RenderScript

Topics

gateway mcp mcp-servers proxy

Join Our Newsletter

Stay updated with the latest AI tools, news, and offers by subscribing to our weekly newsletter.

Related MCPs

Discover similar Model Context Protocol servers

OpenMCP

A standard and registry for converting web APIs into MCP servers.

OpenMCP defines a standard for converting various web APIs into servers compatible with the Model Context Protocol (MCP), enabling efficient, token-aware communication with client LLMs. It also provides an open-source registry of compliant servers, allowing clients to access a wide array of external services. The platform supports integration with local and remote hosting environments and offers tools for configuring supported clients, such as Claude desktop and Cursor. Comprehensive guidance is offered for adapting different API formats including REST, gRPC, GraphQL, and more into MCP endpoints.

⭐ 252
MCP
wegotdocs/open-mcp

pluggedin-mcp-proxy

Unified proxy server for Model Context Protocol data exchanges and AI integrations

Aggregates multiple Model Context Protocol (MCP) servers into a single, unified proxy interface, supporting real-time discovery, management, and orchestration of AI model resources, tools, and prompts. Enables seamless interaction between MCP clients such as Claude, Cline, and Cursor, while integrating advanced document search, AI document exchange, and workspace management. Provides flexible transport modes (STDIO and Streamable HTTP), robust authentication, and comprehensive security measures for safe and scalable AI data exchange.

⭐ 87
MCP
VeriTeknik/pluggedin-mcp-proxy

mcp

Universal remote MCP server connecting AI clients to productivity tools.

WayStation MCP acts as a remote Model Context Protocol (MCP) server, enabling seamless integration between AI clients like Claude or Cursor and a wide range of productivity applications, such as Notion, Monday, Airtable, Jira, and more. It supports multiple secure connection transports and offers both general and user-specific preauthenticated endpoints. The platform emphasizes ease of integration, OAuth2-based authentication, and broad app compatibility. Users can manage their integrations through a user dashboard, simplifying complex workflow automations for AI-powered productivity.

⭐ 27
MCP
waystation-ai/mcp

McGravity

Unified load balancer and proxy for multiple MCP servers

McGravity acts as a scalable unified proxy and load balancer for multiple MCP (Model Context Protocol) servers. It allows clients to connect through a single endpoint to access and manage multiple MCP servers efficiently. The tool offers load balancing, configuration via YAML, CLI and Docker support, and plans to evolve with features such as health checks and a web interface. Designed for modern GenAI infrastructure, it simplifies connection, balancing, and scalability of MCP server deployments.

⭐ 68
MCP
tigranbs/mcgravity

cloudflare/mcp-server-cloudflare

Connect Cloudflare services to Model Context Protocol (MCP) clients for AI-powered management.

Cloudflare MCP Server enables integration between Cloudflare's suite of services and clients using the Model Context Protocol (MCP). It provides multiple specialized servers that allow AI models to access, analyze, and manage configurations, logs, analytics, and other features across Cloudflare's platform. Users can leverage natural language interfaces in compatible MCP clients to read data, gain insights, and perform automated actions on their Cloudflare accounts. This project aims to streamline the orchestration of security, development, monitoring, and infrastructure tasks through standardized MCP connections.

⭐ 2,919
MCP
cloudflare/mcp-server-cloudflare

1mcp-app/agent

A unified server that aggregates and manages multiple Model Context Protocol servers.

1MCP Agent provides a single, unified interface that aggregates multiple Model Context Protocol (MCP) servers, enabling seamless integration and management of external tools for AI assistants. It acts as a proxy, managing server configuration, authentication, health monitoring, and dynamic server control with features like asynchronous loading, tag-based filtering, and advanced security options. Compatible with popular AI development environments, it simplifies setup by reducing redundant server instances and resource usage. Users can configure, monitor, and scale model tool integrations across various AI clients through easy CLI commands or Docker deployment.

⭐ 96
MCP
1mcp-app/agent

View all Alternatives

Didn't find tool you were looking for?

Search AI Tools

mcp-access-point

Key Features

Use Cases

README

MCP Access Point

Introduction

HTTP to MCP

Transport Type (Specification)

Supported MCP clients

Core Features

Quick Start

Installation

Multi-tenancy Support

Configuration Details

config.yaml Example

Running via Docker

Run Locally for quick start

Build Docker Image (Optional)

Environment Variables

Typical Use Cases

Contribution Guidelines

Star History

Repository Owner

Repository Details

Programming Languages

Topics

Related MCPs