Provides a secure proxy to discover, connect to, and manage MCP servers from a central registry with scoped environment variables.
Also known as mcprating/mcp-gateway, mcp-gateway, @mcp-rating/gateway
- Stars
- 1
- Tools
- 13
- Downloads, 30 days
- —
- Latest version
- 0.6.0
- Last commit
- Nov 9, 2026
- License
- MIT
What is Gateway MCP?
Gateway provides a secure proxy to discover, connect to, and manage MCP servers from a central registry with scoped environment variables. It exposes 13 tools, such as mcp_discover, mcp_connect, mcp_disconnect.
Summary generated from the project's README
About Gateway MCP server
Managing multiple MCP servers while protecting sensitive credentials is what this gateway enables for developers using clients like Claude Desktop, Cursor, or Windsurf. It acts as a secure proxy that sits between your AI client and the various servers you want to use. Instead of passing your entire system environment to every server, the gateway spawns them with a strictly controlled environment containing only a specific allowlist and the exact variables you define.
This meta-server simplifies your configuration by providing a single entry point to a central registry. Through thirteen built-in tools, you can discover new servers using mcp_discover, connect to them on demand with mcp_connect, and manage active connections via mcp_list_active. It also provides security oversight through mcp_audit and mcp_sandbox, allowing you to monitor what sandboxed servers are doing. For those needing more isolation, it supports containerization via Docker to prevent servers from reading local files like SSH keys or environment files.
What you can do with it
- 1Securely manage API keysRun MCP servers without exposing your entire system environment to potentially malicious code.
- 2Discover new toolsSearch a central registry to find and connect to specific MCP servers directly through your AI client.
- 3Centralize server managementUse a single configuration entry to access an entire registry of servers on demand.
Written from the project's README. Every use case is checked against a quote from it.
How to install Gateway MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Gateway MCP in Claude Code
$ claude mcp add mcp-gateway -- npx -y @mcp-rating/gatewayInstall Gateway MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"mcp-gateway": {
"command": "npx",
"args": [
"-y",
"@mcp-rating/gateway"
]
}
}
}Install Gateway MCP in VS Code
.vscode/mcp.json
{
"servers": {
"mcp-gateway": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@mcp-rating/gateway"
]
}
}
}Install Gateway MCP in VS Code CLI
$ code --add-mcp '{"name":"mcp-gateway","type":"stdio","command":"npx","args":["-y","@mcp-rating/gateway"]}'Install Gateway MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"mcp-gateway": {
"command": "npx",
"args": [
"-y",
"@mcp-rating/gateway"
]
}
}
}Install Gateway MCP in Codex
$ codex mcp add mcp-gateway -- npx -y @mcp-rating/gatewayInstall Gateway MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.mcp-gateway] command = "npx" args = ["-y", "@mcp-rating/gateway"]
Install Gateway MCP in Gemini CLI
$ gemini mcp add -s user mcp-gateway npx -- -y @mcp-rating/gatewayInstall Gateway MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"mcp-gateway": {
"command": "npx",
"args": [
"-y",
"@mcp-rating/gateway"
]
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for @mcp-rating/gateway 0.6.0 in an isolated container with no network and no keys. It answered and listed 13 tools.
Gateway MCP tools 13
Read from the server with tools/listmcp_discoverSearch the configured MCP registries (MCP Rating by default) for MCP servers. Returns servers with trust tiers, install information, and MCP Rating's quality scores where it has rated them. Use this to find servers before connecting them with mcp_connect.
mcp_connectConnect to an MCP server and make its tools available. Provide either a server slug (from mcp_discover) to look up in the registry, OR an explicit command + args to spawn directly, OR a url for remote servers. An explicit command needs the person's approval, which the gateway asks for itself.
mcp_disconnectDisconnect from a connected MCP server and remove its tools. Use mcp_list_active to see connected servers.
mcp_list_activeList all currently connected MCP servers and their tools.
mcp_server_infoGet detailed information about an MCP server from the registry or a currently connected server.
mcp_call_toolCall a tool on a connected MCP server. Use this when dynamically connected tools aren't directly available. Pass the namespaced tool name (slug__toolName) and arguments.
mcp_gateway_healthGet gateway diagnostics: version, uptime, connection status, registry reachability, and per-server health.
mcp_sandboxView or customize a server's sandbox capability manifest (env/network/filesystem/subprocess access). Use action 'view' to inspect, 'set' to tighten or loosen grants (only the fields you pass change, the rest keep what the server has now or would get by default; applies on next connect), or 'reset' to revert to defaults.
mcp_auditView the safety audit trail — a forensics log of what sandboxed MCP servers did and what the sandbox blocked (tool calls, blocked tools, blocked/allowed network egress, connects with granted capabilities). Use `securityOnly: true` to see only blocks and errors.
mcp_profilesManage named connection profiles. Profiles are presets of server connections that can be switched between (e.g., 'work', 'personal').
mcp_groupsManage server groups for atomic connect/disconnect of sets of servers.
mcp_usageView usage analytics for connected MCP servers — call counts, latency, error rates, and recent activity.
Show all 13 toolsShow fewer tools
mcp_recommendGet MCP server recommendations. Pass `query` to describe a goal or task (e.g. "file sync with cloud storage", "manage GitHub issues"). Omit `query` to get suggestions based on your recent tool-call patterns.
Configuration
GITHUB_TOKENMCP_GATEWAY_REGISTRIES
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledPass
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHub@mcp-rating/gateway
Run MCP servers without handing them the API keys in your environment.
Whether a server you add can read your environment (AWS_SECRET_ACCESS_KEY,
OPENAI_API_KEY, DATABASE_URL) depends on how your client starts it. The
official MCP SDKs pass a short allowlist by default: HOME, PATH, USER and a
few more. A client or script that passes its whole environment, often just to
forward the one token a server needs, hands over everything. We haven't yet
measured which popular clients do which, so we don't name any. The gateway
doesn't leave it to the client: it spawns every server with a constructed
environment, the SDK's short allowlist (PATH, HOME, USER and a few
more) plus only the variables you or its manifest name. Nothing else from your
environment is there to read.
Files are a different matter. By default a server still runs as you, so it
can read what you can — ~/.ssh, ~/.aws/credentials, a project's .env. Only
container isolation (opt-in, needs Docker) closes that. See
what each level protects.

| Started with the whole environment | Through the gateway | |
|---|---|---|
| Environment visible to the server | everything the client had | a short allowlist (PATH, HOME, USER and a few more), and what you name |
| Credentials in environment variables | all of them | none you didn't name |
Credential files (~/.ssh, ~/.aws, .env) |
readable | still readable, unless container isolation is on |
Reproduce it yourself in about ten seconds: node demo/run-demo.mjs plants two fake
credentials and runs the server both ways. It prints the planted values in full and,
for anything real it finds in your environment, only the variable's name, never its
value. The GIF is generated by node demo/render-gif.mjs from a clean, synthetic
environment, so it shows nothing from any real machine.
It is also a meta-server: one entry in your config gives you the whole registry, connected on demand rather than pre-loaded.
{ "mcpServers": { "gateway": { "command": "npx", "args": ["-y", "@mcp-rating/gateway"] } } }
What it costs in context
Context used to be this README's lead argument: 13 meta-tools in place of every configured server's full schema. That assumed the client sends every tool definition on every request. Claude Code, Cursor and Kiro don't by default: they give the model your tools' names and load a definition when it's needed.
We measured all three in October 2026 with ten popular servers' real tool lists, replayed through a stub so that no third-party code ran. Added to every request, compared with no MCP servers:
| tools | Claude Code | Claude Code, tool search off | Cursor | Kiro (chars) | |
|---|---|---|---|---|---|
| 3 servers | 45 | +1,050 | +14,143 | +266 | +3,974 |
| 9 servers | 125 | +3,085 | +77,656 | +910 | +7,693 |
| 10 servers | 500 | +14,853 | +183,889 | +4,330 | +26,398 |
| the gateway | 13 | +716 | +5,595 | +342 | +3,797 |
Claude Code 2.1.308 (tokens as the API counts them), Cursor 3.17.21 (its own estimate), Kiro 1.4.26 (characters, from its log). Compare within a column. Most of the ten-server cost is one server with 375 tools.
The gateway also takes more requests: it has to find and connect a server before calling it, and those steps stay in the conversation, so every later request sends them again. Over an eight-turn Claude Code session with default settings, the gateway used about 597,000 prompt tokens. Three servers configured directly used 475,000, nine used 510,000 and ten used 710,000. The gateway drew level with ten at the third or fourth turn, and never with three or nine.
So in these clients, don't use the gateway to save context. It still does when your client sends every definition upfront (Claude Code with tool search off), or against a server with hundreds of tools over a longer session. With a few typical servers, configuring them directly is cheaper.
The full write-up, with the method, the one-task bill and what we don't claim:
MCP clients now load tool names, not schemas.
Reproduce it with the scripts in
demo/:
claude-code-tokens.mjs (standing cost), claude-code-whole-bill.mjs (one
task), claude-code-session.mjs (eight turns), cursor-standing.mjs and
kiro-standing.mjs. Earlier versions of this section claimed 10× less context,
then about 3×. Both came from our own harness, which sent every definition, like
a client with tool search off.
How It Works
┌────────────────────┐ ┌──────────────┐ ┌──────────────────┐
│ Claude Desktop / │ stdio │ │ stdio │ MCP Server A │
│ Cursor / Windsurf │◄─────►│ MCP Gateway │◄──────►│ (e.g. filesystem)│
│ (host client) │ │ │◄──┐ └──────────────────┘
└────────────────────┘ └──────────────┘ │ ┌──────────────────┐
│ └───►│ MCP Server B │
▼ │ (e.g. github) │
┌──────────────┐ └──────────────────┘
│ MCP-Rating │
│ Registry API │
└──────────────┘
Instead of manually configuring each MCP server in your client, the Gateway:
- Discovers servers via the MCP-Rating registry, listing first the ones it can start right now (see below)
- Connects to them on-demand: spawns local ones as child processes, and connects hosted ones to the endpoint the registry lists
- Proxies their tools through namespaced names (
servername__toolname) - Notifies your client when tools are added/removed
Quick Start
With Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"gateway": {
"command": "npx",
"args": ["-y", "@mcp-rating/gateway"]
}
}
}
Then ask Claude:
- "Search for MCP servers that work with databases" (uses
mcp_discover) - "Connect to the sqlite server" (uses
mcp_connect) - "Query my database" (calls the proxied tool directly)
Cursor
~/.cursor/mcp.json (or .cursor/mcp.json in a project):
{
"mcpServers": {
"gateway": { "command": "npx", "args": ["-y", "@mcp-rating/gateway"] }
}
}
Claude Code
claude mcp add gateway -- npx -y @mcp-rating/gateway
Windsurf
~/.codeium/windsurf/mcp_config.json, same shape as Cursor:
{
"mcpServers": {
"gateway": { "command": "npx", "args": ["-y", "@mcp-rating/gateway"] }
}
}
Kiro
Add to Kiro
(Kiro asks before installing), or ~/.kiro/settings/mcp.json (.kiro/settings/mcp.json
in a workspace), same shape as Cursor:
{
"mcpServers": {
"gateway": { "command": "npx", "args": ["-y", "@mcp-rating/gateway"] }
}
}
Kiro runs MCP servers only when you are signed in, and if its MCP Servers panel shows Enable MCP, click it first.
Kiro ignores tools/list_changed. It reads the gateway's tool list once, when it
connects, so the tools of a server you connect later are never offered to the
agent directly. Ask the agent to call them through mcp_call_tool, using the
full slug__tool name that mcp_connect prints. Measured on Kiro 1.4.26 with
demo/client-probe.mjs.
Any other MCP client
{ "command": "npx", "args": ["-y", "@mcp-rating/gateway"] }
Restart the client after editing its config — most read it only at startup.
What mcp_discover puts first
An agent can only use a server the gateway can start, so results are ordered by that, keeping relevance order within each group:
- Verified: the registry's own harness started it and it listed its tools
(
✓ Started in our test). - Ready, untested: installable here, or a hosted endpoint that needs no header, and any key it declares is set.
- Needs setup: a declared key isn't set, its launcher (
uvx,docker) isn't installed, or the hosted endpoint needs a header the gateway can't send yet. - Failed in our test: it didn't start when the registry tried it, with no
credentials (
✗ Didn't start in our test). - Can't start by slug: no install command and no endpoint recorded.
"Verified" means it started and listed tools, not that every tool works without a key. The harness supplies none. Most of the index has never been tried; that says nothing either way.
Meta-Tools
The gateway exposes 13 built-in tools:
| Tool | Description |
|---|---|
mcp_discover |
Search the MCP-Rating registry; servers the gateway can start now come first |
mcp_connect |
Connect to a server and make its tools available |
mcp_disconnect |
Disconnect a server and remove its tools |
mcp_list_active |
List connected servers and their tools |
mcp_server_info |
Detailed info about a server, from the registry or a live connection |
mcp_call_tool |
Call a tool on a connected server |
mcp_gateway_health |
Diagnostics: version, uptime, connection and registry status |
mcp_sandbox |
View or customise a server's sandbox manifest (env/network/filesystem) |
mcp_audit |
The safety audit trail — what sandboxed servers actually did |
mcp_profiles |
Named connection profiles (work, personal, …) |
mcp_groups |
Atomic connect/disconnect of server sets |
mcp_usage |
Call counts, latency and error rates for connected servers |
mcp_recommend |
Server recommendations based on usage |
Trust Tiers
Every connected server is labeled with a trust tier based on its MCP-Rating quality score:
- [Verified] — High quality + officially verified
- [Trusted] — Good quality with repository, and an install command or a remote endpoint
- [Community] — Listed in registry with basic quality
- [Unverified] — A package MCP Rating doesn't know, from any registry or started by command
A safety score in the risk band caps the tier, as it does on the site: below 50 a server is at most [Community], below 30 it is [Unverified].
What mcp_connect shows, and when it stops
Before anything starts, mcp_connect looks up what MCP Rating knows about the
package that would run — from the registry entry, or, for an explicit command
or url, from the package itself (npx pkg, uvx pkg, docker run image,
the endpoint). A known package started by command is judged as itself, not as
[Unverified]. Shown in the confirmation and again once connected:
- score and trust tier, with the server's page;
- safety score and each flag with its reason;
- MCP Rating's own start test: started, didn't start, needs credentials, or not tested;
- last release and last code push, with where each date comes from.
It stops for a [Community] or [Unverified] server, and, whatever the tier, when
the safety score is in the risk band, MCP Rating has delisted the
package, or a registry name points at a different package than MCP Rating knows
by that name. Where your client supports MCP elicitation, the gateway asks you
directly, in a dialog the model can't see or answer (see
What needs a person). Elsewhere the warning goes to the
agent, and confirmed: true on the retry is a field the model fills in, so it
protects you only as far as the model passes it on.
A minimum score
MCP_GATEWAY_MIN_SCORE=60 (or "minQualityScore": 60 in config.json) refuses
to connect anything MCP Rating scores below 60, or hasn't scored — by slug,
registry name, command or URL alike, so a local node server.js is refused too.
confirmed: true doesn't lift it, since an agent can set that itself; only the
setting does. It needs MCP Rating among the registries. A value that isn't a
whole number from 0 to 100 refuses everything until it is fixed, rather than
quietly meaning "no rule".
Registries
By default the gateway searches MCP Rating. It can search any registry that speaks the official MCP Registry API (v0.1) instead, or as well: the official registry, a company's own registry, or MCP Rating's mirror of it.
{
"mcpServers": {
"gateway": {
"command": "npx",
"args": ["-y", "@mcp-rating/gateway"],
"env": {
"MCP_GATEWAY_REGISTRIES": "https://mcprating.io/api/v1,https://registry.acme.internal"
}
}
}
}
- The list replaces the default. Leave MCP Rating out and the gateway never contacts it for discovery.
- Each entry is a URL. One ending in
/api/v1is taken as MCP Rating's own API, and anything else as the MCP Registry API. To say which explicitly, writemcprating=URLormcp-registry=URL. - Searches go to every registry and are merged. A server two registries both list appears once, as the first-listed registry has it. A search waits up to 15 seconds; a registry that hasn't answered by then is named in the results, and the rest are shown.
- Connecting by name. A server from an MCP Registry API registry connects by
its registry name,
mcp_connect({slug: "io.github.owner/server"}). That works in any later session too. - Scores come from MCP Rating only. Quality scores, safety flags and start
tests are MCP Rating's. When MCP Rating is one of your registries, a server
found in another one gets MCP Rating's record of the same package — the
same npm or PyPI package, Docker image or hosted endpoint — in one request per
search. It is matched by package, never by name: any registry can give any
package a well-known name. Otherwise the server shows as unrated and
[Unverified], so connecting it stops first. Numbers another
registry puts in its own entries (
_meta) are not read: anyone can write them. - Warnings that stop a connect. If MCP Rating knows a server's registry name
as a different package, or has delisted the package,
mcp_discoversays so, lists it last, andmcp_connectstops whatever its trust tier. - The partner key goes to MCP Rating only, never to another registry.
The official registry's search matches server names only and was slow when this was written (7–40 s per search on 2026-10-14). The gateway asks it for the query's longest word and ranks what comes back by how many of your words match.
Configuration
The gateway reads config from ~/.mcp-gateway/config.json:
{
"registryApiUrl": "https://mcprating.io/api/v1",
"proxyTimeoutMs": 30000,
"maxConnections": 10,
"logLevel": "info"
}
Environment Variables
| Variable | Description | Default |
|---|---|---|
MCP_GATEWAY_REGISTRY_URL |
MCP-Rating API base URL | https://mcprating.io/api/v1 |
MCP_GATEWAY_REGISTRIES |
Comma-separated registries to search instead (see Registries) | MCP Rating alone |
MCP_GATEWAY_MIN_SCORE |
Refuse anything MCP Rating scores below this, or hasn't scored (see A minimum score) | no rule |
MCP_GATEWAY_TIMEOUT |
Proxy timeout (ms) | 30000 |
MCP_GATEWAY_MAX_CONNECTIONS |
Max simultaneous connections | 10 |
MCP_GATEWAY_LOG_LEVEL |
Log level (debug/info/warn/error) | info |
MCP_GATEWAY_CONTAINER_ISOLATION |
Force L2 container isolation on/off | manifest decides |
MCP_GATEWAY_AUDIT_LOG |
Path for the forensic audit log | disabled |
MCP_GATEWAY_HUMAN_APPROVAL |
off lets the model decide what otherwise needs a person (see What needs a person) |
on |
MCP_GATEWAY_PARTNER_KEY |
Partner attribution key — enables ad telemetry | unset |
MCP_GATEWAY_AD_TRACKING |
Set to false to disable ad telemetry outright |
unset |
MCP_GATEWAY_HTTP_TOKEN |
Bearer token for HTTP daemon mode | unset |
Security model
The gateway exists so that what a server can see doesn't depend on how your client happens to start it. Two layers push back, and it is worth being precise about what each one does and does not do.
L1 — environment scoping (always on, for stdio servers)
A downstream server receives the MCP SDK's default allowlist (HOME, LOGNAME,
PATH, SHELL, TERM, USER on macOS and Linux; PATH, USERPROFILE,
APPDATA, TEMP and a few more on Windows), plus only the variable names
its manifest allowlists or you pass at connect time. Everything else in
the parent environment — AWS_*, OPENAI_API_KEY, DATABASE_URL — is withheld.
Exported shell functions (BASH_FUNC_*) are dropped rather than forwarded.
This is genuine enforcement: the child process is spawned with a constructed environment, so there is nothing to opt out of or bypass.
L1 does not restrict files or the network. The server runs as your user: it
can read anything you can, including ~/.ssh, ~/.aws/credentials and .env
files, and it can connect to any host. A manifest can declare network and
filesystem limits, but outside a container nothing enforces them, and the
connect summary says "not restricted" rather than listing them.
L2 — container isolation (opt-in)
With MCP_GATEWAY_CONTAINER_ISOLATION=true, community and unknown servers run
under docker/podman in an ephemeral container. You can also opt one server
in with mcp_sandbox({action: "set", slug: "…", enforcement: "l2-container"}).
Inside, the server gets a read-only root, a scratch /tmp, and only the paths
its manifest declares mounted from the host. network: "none" gives the
container no network at all. Without Docker or Podman, the gateway falls back to
L1 and logs that it did.
Network allowlists: read this before relying on them
Allowlists apply only under L2. network: "allowlist" starts a forward
proxy and points the container at it via HTTP_PROXY/HTTPS_PROXY. The proxy
accepts only tunnels that carry a random credential generated for that
connection, which the container receives in those variables. With Docker Desktop
it listens on loopback. With Docker on Linux it has to listen on all interfaces,
because the container reaches it over the bridge, and the credential is what
keeps other machines from using it.
This filters proxy-aware clients only. Node's fetch/undici, axios, and Python
requests all honour those variables, which covers most real servers. A program
that opens raw TCP sockets, or a compiled binary that ignores proxy environment
variables, is not filtered. Treat an allowlist as a guard rail against honest
code, not a containment boundary against hostile code. For that, use
network: "none".
Giving a server an API key
Put the key in the gateway's env in your client config, not in the chat:
{
"mcpServers": {
"gateway": {
"command": "npx",
"args": ["-y", "@mcp-rating/gateway"],
"env": { "GITHUB_TOKEN": "ghp_…" }
}
}
}
A server receives it only if its registry entry declares that variable. For one
that doesn't, allowlist the name, never the value:
mcp_sandbox({action: "set", slug: "…", envAllow: ["GITHUB_TOKEN"]}). That widens
what the server gets, so the gateway asks you first.
mcp_connect also accepts env: { NAME: "value" }. That works, but the model has
to write the secret into a tool call, which puts it in your chat transcript and
your model provider's logs.
When a server asks the model for personal data
A hosted server can ask for an email, a phone number or a card number in an ordinary tool result, and the model is what answers. During our own test runs, a local 31B was asked for an email "to record your free quota" and made one up. No sandbox can see that: it's a request in the content channel.
Since 0.2.6 the gateway checks each tool result for a personal-data term next to
a verb of handing it over, in English and Chinese, within its first 1,500
characters. On a match it appends a warning the model reads with the result:
ask the user, and never make up a value. It also records
personal_data_requested in the audit trail (mcp_audit). It's a heuristic,
and it only adds: the server's reply is never changed or blocked.
A missing runtime is an error, not a substitution
If a server's launcher (uvx, docker, python, …) isn't installed, the connect
fails with a message naming what to install. Before 0.2.4, a missing launcher was
rewritten to npx -y <name>, which ran whatever npm package shared its name. On a
machine without Docker, that was the unrelated npm package docker.
Allowlist patterns fail closed: a malformed pattern such as *example.com
(missing dot) matches nothing rather than everything. The gateway warns at
startup about patterns that will not do what their author intended, including
over-broad ones like *.com.
What it doesn't stop: tool poisoning
A server doesn't have to run anything to attack you. Its tool descriptions and results are text that goes straight to your model, and that text can tell the model to read a file through another server and send it somewhere. The data moves through tools you trust, so L1 and L2 don't touch it: they limit what a server's code can do.
A November 2026 measurement ran 45 of these attacks through 12 agent
frameworks and 18 models. In 22.9% of runs the model made a call the attacker asked
for, from 0.4% to 49.7% depending on the model, and no framework defended against it
on purpose. It didn't test this gateway or a client such as Claude Code or Cursor.
Our own scenarios and harness are in demo/poison.
The gateway passes descriptions and results on as the server wrote them, with a trust label in front of each description. It doesn't scan them, and when a server changes its tool list it forwards the new one without comparing it to the old. What it does watch is a secret on its way out: see What needs a person.
What helps:
- Connect only what you need.
- Keep your client's approval prompt on for tool calls.
- Which model you run matters: in that measurement it mattered far more than which framework.
Gateway MCP questions
How do I add Gateway MCP to Claude Code?
Run claude mcp add mcp-gateway -- npx -y @mcp-rating/gateway in your terminal. Add --scope user to make it available in every project.
How do I add Gateway MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Gateway MCP provide?
It exposes 13 tools, including mcp_discover, mcp_connect, mcp_disconnect, mcp_list_active, mcp_server_info.
How does the gateway protect my API keys?
The gateway spawns every server with a constructed environment containing only the SDK's short allowlist and the specific variables you define, preventing servers from reading your entire environment.
Can the gateway protect my local files?
By default, servers run as your user and can read files like ~/.ssh or .env. To close this gap, you must opt-in to container isolation using Docker.
Does using the gateway save context window space?
Not necessarily. While it can reduce context if your client sends every tool definition upfront, it may actually use more tokens in clients like Claude Code or Cursor that load tool definitions on demand.