Connect your agents to anything.

One local MCP endpoint for every API and MCP server you use, with a web UI to manage them. Your many tools to one mcpmaster tool.

127.0.0.1:7437/integrations

Integrations

Everything here is served to every connected agent.

+ Add

https://api.github.com/openapi.json ↵ add

NameTypeToolsStatus

GHgithubapi.github.comopenapi1,081read-only

STstripeapi.stripe.comopenapi512active

LNlinearmcp.linear.app/mcpmcp · oauth24active

CTcountriescountries.trevorblades.comgraphql9active

FSfilesnpx server-filesystem ~/codestdio16active

execute · called by Claude Code

const { items } = await tools.search({
  query: "open issues",
});
const issues = await tools[items[0].path]({
  repo: "acme/api", state: "open",
});
return issues.map(i => i.title);
// only the titles reach the agent

Claude CodeCodexCursorClaude DesktopVS CodeWindsurfOpenCodeStreamable HTTP

Code mode

One tool, not a thousand.

Three large APIs add up to well over a thousand tool schemas. None of them land in your agent's context up front. It gets a single execute tool and writes a snippet to find what it needs.

Every schema, up front

401,000tokens

1,600+ tool definitions from GitHub, Stripe and friends, loaded before the first message.

mcpmaster, default mode

~515tokens

One execute tool whose description lists your integrations. Tools are searched on demand.

Integrations you add later show up in agents already connected. No reconfiguring. ≈ 779× less context

Capabilities

Paste it in. Your agents can use it.

mcpmaster works out what you pasted, turns it into tools and serves them through one connection.

01 Add anything

OpenAPI, GraphQL, remote MCP or a local command.

Each integration gets a short name that becomes its tool prefix, so agents see github_list_repos and countries_country.

OAuth sign-in opens in your browser when a server needs it
OAuth2 with your own client, endpoints discovered (RFC 8414, OIDC, RFC 9728)
mcpmaster sync re-reads tools after an API changes

OpenAPIadd ./openapi.yaml

GraphQLadd …/graphql

Remote MCPadd https://mcp…/mcp

Local stdioadd -- npx -y …

One endpoint127.0.0.1:7437/mcp

02 Code mode

Agents write a snippet. Only the answer comes back.

The agent searches, reads a schema, calls the tool and returns just the part it wants. The full API response never reaches its context.

QuickJS sandbox compiled to WebAssembly
No network, filesystem or host access, only your tools
Bounded in time (30 s), memory, calls and result size

snippet.ts · run by the agent

const { items } = await tools.search({ query: "open issues" });
const path = items[0].path;   // "github_list_issues"
const { inputSchema } = await tools.describe.tool({ path });
const issues = await tools[path]({
  repo: "acme/api",
  state: "open",
});
return issues.map((i) => ({
  title: i.title,
  url: i.html_url,
}));  // only this goes back

03 Guardrails

Decide what agents can reach. Even tools that don't exist yet.

Block rules, read-only and review are evaluated on every listing and every call. A github_delete_* rule hides a delete endpoint the moment a sync brings it in.

Per-tool switches and glob rules with live match counts
--read-only: only GET, queries and read-only MCP tools
--hide-new-tools: new tools wait for your review

github_delete_*blocked · 14

github_delete_branchallowed

github · policyread-only

stripe_refunds_createwaiting review

linear_create_issueexposed

files_write_fileswitched off

04 Web UI

Stays fast with thousands of tools.

Search and filters run on the server, the list loads 50 rows at a time and parameters load only when you open a tool. Run any tool with your own arguments, or try snippets the way an agent writes them.

Bulk hide or expose every tool matching a filter
Connect snippets for each agent, one click away
Everything the UI does, the CLI does too

terminal

$ mcpmaster tools --integration github --access write
  github_create_issue      write   exposed
  github_merge_pull        write   exposed
  github_delete_repo       write   blocked by github_delete_*
  … 50 of 212 · --offset 50 for more

$ mcpmaster call countries_country '{"code":"DE"}' | jq .name
"Germany"

Set up mcpmaster so every tool I use is behind one MCP endpoint.

1. Install it (needs Node 20+; no sudo):
   curl -fsSL https://raw.githubusercontent.com/mcpmastersh/mcpmaster/main/install.sh | MCPMASTER_SKILL=1 sh
2. Run `mcpmaster status`, then `mcpmaster connect` and apply the snippet for my client
   (for Claude Code: `mcpmaster connect claude-code | sh`).
3. Read the skill it saved (~/.claude/skills/mcpmaster/SKILL.md) or run `mcpmaster help`.
4. Ask me which API, GraphQL endpoint or MCP server to add first, then `mcpmaster add <url> --name <slug>`
   and show me `mcpmaster list`.

Rules:
- Pass credentials by variable name (--token-env) or stdin (--token-stdin). Never as an argument, never ask me to paste one here.
- The endpoint advertises one `execute` tool on purpose. Do not try to list every tool instead.
- Do not turn on private-network access without asking me and saying why.
- Do not guess flags. Run `mcpmaster --help` and use what it lists.
- If a step fails, quote what it printed and give me the next thing to try.

Security

Built as if the browser tab next door is hostile.

mcpmaster runs on your machine. Credentials are used, never shown, and every outbound call takes one audited path.

Loopback only

Binds to 127.0.0.1 and rejects any other Host header, which blocks DNS rebinding.

Token on every call

The UI API and HTTP endpoint require your local token, passed in the URL fragment. Strict CSP, no cross-origin writes.

Used, never shown

Credentials live in an owner-only file or an env var. If an API echoes one back, it's removed before the agent sees it.

One egress path

Pins the validated DNS answer, never follows redirects, caps time and size. Private networks stay blocked until you opt in.

No stale OAuth clients

OAuth state is kept per integration, not per URL. Each sign-in registers a fresh client; sign-out deletes all of it.

Consent stays local

Callbacks land on 127.0.0.1 with a single-use state from the last 10 minutes. PKCE always, https token URLs only.

Listens on 127.0.0.1 only and blocks DNS rebinding
Local token on every call, strict CSP
Credentials are used, never shown to the agent
One audited outbound path, private networks off by default
Fresh OAuth client per sign-in, PKCE, callbacks stay local

Pairs with mcpv

Keep the keys out of the chat, too.

mcpv is the offline, encrypted vault for the secrets your app needs. Your .env holds addresses, not values, and your agent runs the app without ever reading a key. Self-hosted addresses use mcpm://.

Explore mcpv

.env · safe to commit

DATABASE_URL=mcpm://acme/api/dev/DATABASE_URL
STRIPE_KEY=mcpm://acme/api/dev/STRIPE_KEY
PORT=3000

$ mcpv run -- npm run dev
  connected to postgres://app:[redacted]@db

mcpmaster Cloud

Same engine. Hosted for your team.

Self-hosted

Free, forever. Runs on your machine.

Unified MCP endpoint
Code mode, guardrails, web UI
Secret vault with mcpv
Team roles and workspaces
Audit trail and instant revocation

Get it on GitHub

Cloud

Hosted at mcpmaster.sh. Nothing to install.

Hosted endpoint for every agent
Workspaces, team roles, private workspaces behind OAuth
Agent Secrets with vibepass:// addresses (mcpm:// is for self-hosted)
Website crawling and a chat widget
Audit trail and instant access revocation

Join the Cloud waitlist

Mix both, either direction. Agents can connect to local and mcpmaster.sh/api/mcp/<workspace> at once. Or add a Cloud workspace to local mcpmaster as a remote MCP integration.

FAQ

Questions, answered.

Anything else? Open an issue on GitHub or send us a message.

What is mcpmaster?

A local MCP server that wraps every API and MCP server you use and serves them all through one connection. Add an OpenAPI spec, a GraphQL endpoint, a remote MCP server or a local stdio command, and every connected agent can use it.

Why only one execute tool?

Loading every schema up front can cost hundreds of thousands of tokens. With code mode the agent searches for tools and returns only what it needs. If your client can't run code, mcpmaster settings tools all lists every tool individually.

Where are my credentials stored?

In ~/.mcpmaster/secrets.json with owner-only permissions, or read from an environment variable. The CLI and UI never display them, and they're stripped from any response that echoes them. Pass them with --token-env or --token-stdin, never as an argument.

How is this different from mcpmaster Cloud?

Self-hosted is the open-source core. Cloud runs the same engine and adds a hosted endpoint, team workspaces, private workspaces behind OAuth, Agent Secrets, crawling, a chat widget and an audit trail. You can use both at once.

How do I upgrade?

Run the installer again, or mcpmaster update. It pulls the newest version from npm, restarts the background server and keeps your integrations and credentials.

Contact

Get in touch.

Questions about mcpmaster or Cloud, a partnership, or something else. We read every message and reply by email.