MCP Access Point
A Pingora gateway that turns existing HTTP services into MCP servers from an OpenAPI spec, with no changes to their code
- 185 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The agent gets every backend operation from OpenAPI, including writes and deletes, unless routes are curated
- Backend keys and tokens are stored in `config.yaml` as plain text and added to every call
- The Admin API changes upstreams and routes on the fly and is protected only by an optional key
Install
- Works in
Manual install
docker run -d --name mcp-access-point --rm -p 8080:8080 -e port=8080 -v /path/to/config.yaml:/app/config/config.yaml ghcr.io/sxhxliang/mcp-access-point:mainReplace the path to `config.yaml` with your own. Clients connect to `http://127.0.0.1:8080/mcp` or `/sse`.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The agent gets every backend operation from OpenAPI, including writes and deletes, unless routes are curated
- Backend keys and tokens are stored in `config.yaml` as plain text and added to every call
- The Admin API changes upstreams and routes on the fly and is protected only by an optional key
This is third-party code. Review the repository files before installing.
What it does
MCP Access Point is a gateway in Rust and Pingora that sits between MCP clients and ordinary HTTP services. In `config.yaml` you point it at an OpenAPI spec (a local file or a URL) and the backend nodes. The gateway parses the operations in the spec, publishes them as MCP tools and forwards calls to the HTTP service. The original API needs no changes. Clients connect over SSE (version 2024-11-05) or Streamable HTTP (2025-03-26). All services are reachable at `/sse` and `/mcp`, and a single service at `/api/{id}/sse` and `/api/{id}/mcp`, so each group of users can get its own set. Routes can be described by hand with parameter limits through `inputSchema`. The gateway adds configured headers to the backend call, such as an API key or token, and balances load across nodes. The bundle includes plugins for CORS, JWT and keys, IP and rate limits, compression and Prometheus, plus an Admin API for editing configuration without a restart. Start it with `cargo run -- -c config.yaml` or the container `ghcr.io/sxhxliang/mcp-access-point:main`.
Who it is for. Backend developers and platform teams who already have a REST API with an OpenAPI spec and want to open it to agents in Cursor, Windsurf or VS Code without a dedicated MCP server.
Good fit when
- An internal service speaks HTTP and its operations should reach Cursor as tools in one evening
- Several services are published under one address while each team gets its own `/api/{id}/mcp` address
- A spec is pulled from a link like `https://petstore.swagger.io/v2/swagger.json` to try an idea quickly
- The backend connection needs key headers and it is simpler to keep them on the gateway
- A client supports only SSE and the backend does not need it: the gateway takes the transport on itself
Not a fit when
- There is no OpenAPI spec and routes would have to be written by hand for every operation
- The API has delete and write operations that should not be open to a model without selecting routes
- You need a ready MCP server for a specific product: its official implementation is simpler
- The client can only launch a local server over stdio: the gateway serves just SSE and Streamable HTTP
Example request
Start MCP Access Point with my openapi.json and show which tools appeared in CursorMCP
- Transport
- sse, http
- Authentication
- not required
Environment variables
port- The port the gateway listens on. Default is 8080.
Limitations
- Installation is from source through Cargo or a container: there are no package-manager packages. The port is set by the `port` variable, default 8080.
- Supported transports are SSE version 2024-11-05 and stateless Streamable HTTP version 2025-03-26.
- Backend keys and tokens sit in `config.yaml` as plain text, and the Admin API is protected only by an optional `api_key`.
- The last commit in the repository dates from March 2026, and the README does not describe the plugins.
How to disable. Stop the gateway (`docker stop mcp-access-point` or the `cargo run` process) and remove the server entry from the client config. `config.yaml` with the backend keys stays on disk, so delete it if it is no longer needed.
FAQ
How do I connect Cursor to MCP Access Point?
Start the gateway, then in Cursor's MCP settings use `http://127.0.0.1:8080/sse` for SSE or `http://127.0.0.1:8080/mcp` for Streamable HTTP. For one service take `/api/{id}/sse` or `/api/{id}/mcp` with its identifier from `config.yaml`.
Do I have to change my API code?
No. The gateway reads the OpenAPI spec and turns operations into MCP tools itself. For unusual cases you describe routes by hand under `routes`.
How do I change configuration without a restart?
Enable the Admin API under `access_point.admin` and call `/admin/resources/...` for upstreams, services and routes. `POST /admin/reload/config` rereads the whole file, and `POST /admin/validate/{type}/{id}` validates a resource beforehand.
Can I balance load across nodes?
Yes, an upstream takes several weighted nodes under `nodes` and an algorithm in `type`: `roundrobin`, `random` or `ip_hash`. `scheme` sets the backend protocol, and `pass_host` with `upstream_host` adjusts the Host header.
How does MCP Access Point differ from mcp-proxy?
It does not bridge transports of ready MCP servers; it turns a plain HTTP service into MCP from an OpenAPI spec. Running it takes its own configuration file with upstreams.
Discussion
No questions or reviews yet.
Related
MCP serversAn MCP server that loads a Swagger or OpenAPI spec and turns every API endpoint into a tool the agent can call.
Apollo's MCP server: turns chosen GraphQL operations into tools the agent uses to work with your API
An MCP server and plugin for agents that generate web APIs from OpenAPI, AsyncAPI, GraphQL, gRPC and SQL specs on a Rust core.
A Laravel and Lumen package that adds an MCP endpoint to your app's routes and attaches your own tools to it
A single Go binary turns a SQL database into a REST API with roles and an MCP server for Claude Code, Cursor and VS Code
mcp-graphql: MCP server for GraphQL APIs
mcp-graphql
Two GraphQL tools for MCP clients: the agent fetches your API schema and runs queries against a single endpoint
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| MCP Access Point (this card) | no | not required | 185 | |
| MCP Link | no | not required | 624 | a gateway for APIs with an OpenAPI V3 spec, while Access Point adds multi-tenancy, node balancing, plugins and an Admin API |
| OpenAPI MCP Server | yes | not required | 301 | one process turns OpenAPI operations into tools, while here a gateway serves many services under their own addresses |
README in short
The page explains the gateway idea and its Pingora base. It continues with the HTTP-to-MCP mode and diagram, supported transports and clients, a quick start, multi-tenancy and a detailed `config.yaml` description. It ends with running in Docker, typical use cases and an Admin API section with curl examples.