mcp-hub
mcp-hub's /hub endpoint is an aggregate gateway that lets you discover and call tools across every registered MCP server through six meta-tools, without loading all their schemas into context.
list_servers— see every server behind the hub, with status (up, down, sleeping, unauthorized, …), tool count, description, and any locked/hidden markers. Call this first.list_tools— list one server's tools with one-line descriptions and their annotations, instead of flooding context with N×tools schemas.get_tool_schema— fetch a single tool's full description plus JSON input (and output) schema, so you can construct valid arguments.call_tool— invoke any tool on any server, passing arguments that match the schema you just fetched; on-demand servers wake automatically.wake_server— start an on-demand (stdio or docker) server ahead of time so the first call is fast; a no-op if it is already running.sleep_server— stop an on-demand server immediately rather than waiting for its idle timeout; it restarts on the next tool call.
Also worth knowing: filtered tools (allowTools/denyTools) never appear here, "hub": false servers are hidden from the aggregate but still manageable via wake/sleep, and "unlock" servers return an unlock link instead of a result until a person approves the call.
Provides access to Audiobookshelf libraries, listening progress, collections, and playlists through the hub.
Provides read-only access to a Calibre-Web library through its OPDS feed.
Enables access to Google Search Console properties, sitemaps, search analytics, and URL inspection.
Enables management of Hetzner Cloud DNS zones and related DNS resources.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-hub search paperless for documents tagged 'invoice' from March"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-hub
A dual-era Model Context Protocol (MCP) gateway: it
serves many stdio MCP servers from one container, published over HTTPS, and speaks
both MCP revisions on every endpoint — 2026-07-28 and 2025-11-25. The client
picks, and cannot tell which one it is on from the answers. On the 2026 revision that
includes elicitation — a child server's question reaches the person at the far end
instead of dying at the gateway
(how) — and subscriptions: the hub
serves subscriptions/listen to its clients and subscribes to its children on
whichever revision they speak, so a server that has never heard of it still reaches
a client that speaks nothing else
(how).
Lets MCP clients that cannot spawn a local process — ChatGPT connectors, Claude on the Web and in Code, Mistral Le Chat, Cursor, LibreChat and any other Streamable-HTTP client — reach every server behind it, with a built-in OAuth 2.1 login protected by a single password, plus long-lived API tokens for clients that cannot do OAuth (OpenAI Responses API, xAI API, Gemini API). Per-client recipes: client compatibility.

Want to poke at it first? demo/ is a throwaway hub with three
fake servers — docker compose up -d, then point the
MCP Inspector or
MCPJam at it. Nothing to
configure, nothing to clean up but a volume.
Why
Wrapping each stdio MCP server in its own auth-proxy container costs a full image, an OAuth stack, a hostname and a compose stack per server. mcp-hub replaces N containers with one process:
Config is exactly Claude Code's
mcpServersformat — copy entries 1:1.Path-based routing:
https://host/paperless,https://host/homeassistant, …/hubaggregate: register a single connector and reach every server through 6 meta-tools (list_servers,list_tools,get_tool_schema,call_tool,wake_server,sleep_server) without flooding the model context with N×tools schemas.Per-server tool filtering:
allowTools/denyToolson any server decide which of its tools the hub exposes — exact names orlist_*prefixes. A filtered tool is hidden fromtools/listand refused if a client calls it anyway, before the server is even woken, so a client holding a stale schema cannot reach it.Also without HTTP:
mcp-hub --stdioserves that same aggregate on stdin/stdout for clients that can only spawn a local process (Claude Desktop, Codex, …) — samemcp.json, no TLS, no reverse proxy, no login. Auth exists for the network endpoints; over stdio the trust boundary is the local user.On-demand lifecycle: stdio and docker servers start when used and sleep after 60 idle minutes, answering
initialize/tools/listfrom a persistent snapshot meanwhile — a dozen servers cost only the memory of the ones in use.keepAlive: trueexempts a server,IDLE_TIMEOUT_MINUTES=0the hub.Servers that stay locked until you say so:
"unlock": trueon a shell, a mailbox or your DNS, and a model that calls it gets a link instead of a result. You unlock it on the hub's page with your password (and code) for one call or 15 minutes to four hours, for the connection that asked and nobody else. Clients that open pages themselves get the link as a URL elicitation, every other client as text, and a whole-locked server is put to sleep when its last unlock ends.Optional two-factor login:
TWO_FACTOR=totpadds a code from any authenticator app to the password on the OAuth login. Codes work once, wrong ones pause further attempts, and switching it on retires every token that a password alone had issued.mcp-hub-admin totp initdraws the QR code in the terminal.CIMD-first OAuth 2.1: clients identify themselves with a Client ID Metadata Document — the registration-free path the MCP spec now prefers — including
private_key_jwtagainst the keys in their own document (metadata-document clients only). RFC 7591 dynamic registration stays advertised beside it for older clients,mcp-hub-admin clients addissues credentials by hand for anything that can do neither, andCLIENT_REGISTRATIONturns either mechanism off.OAuth outwards, too: a remote server that speaks OAuth gets an
oauthblock instead of a static header. The hub registers itself — with credentials the upstream issued, via RFC 7591, or with its own client metadata document — then obtains and refreshes the token.client_credentialsupstreams need no attention at all; where a person must sign in,mcp-hub-admin upstream loginprints one URL. An upstream that needs re-authorizing shows up as one serverunauthorized, not as a confusing 401 in your client.Supervision: children are pinged and restarted with exponential backoff when they die. A down server answers 503, not silence; a crash-looping server nobody uses is parked instead of restarted forever.
Hot reload: edits to
mcp.jsonstart/stop/restart only the affected servers.Stateless Streamable HTTP: no session state, so claude.ai's reconnect-without-DELETE behaviour cannot leak processes or memory.
Dual-era: every endpoint —
/hub,/<name>/mcpand--stdio— answers MCP2026-07-28and2025-11-25alike; the client picks and cannot tell from the answers which it got. On the 2026 revision that includes elicitation: a server asking the user something returns the question rather than pushing it, so it reaches the person at the far end instead of dying at the gateway. The hub attributes it to the server that asked, strips what could lie about that, drops embedded sampling and roots requests, and seals the resumption state against the call it belongs to.passthrough: "off"withdraws one server's right to ask; details.Change notifications, in both eras: a client opens a
subscriptions/listenstream and hears when a child's tools, prompts or resources change. The hub subscribes to each child the way that child understands —subscriptions/listento a 2026 server,resources/subscribeto a 2025 one — so the era gap is the gateway's problem rather than either end's. The state is the open response, not a session table, so this costs the stateless design nothing. A sleeping server watches nothing and is told to re-read on waking;subscriptions: "off"withdraws one server's right to push; details.Lightweight by design: one Node process, no database (state is one JSON file plus a signing key under
/data), ten runtime dependencies, and multi-arch images — a stated project goal is to run comfortably on a single-board computer like a Raspberry Pi.
Related MCP server: mcphub
Servers to run behind it
The hub is server-agnostic — it serves any stdio MCP server whose entry fits
Claude Code's mcpServers format, which is most of them. These nineteen are
built and maintained alongside it, so their documentation carries the hub entry
you need and their tool filters line up with the hub's own allowTools /
denyTools:
Server | npm | What it reaches |
| Audiobookshelf — libraries, listening progress, collections and playlists | |
| CalDAV — events, tasks and journal entries on any server that speaks it | |
| Calibre-Web — read-only library access through the OPDS feed | |
| CardDAV — contacts, groups and photos on any server that speaks it | |
| FreshRSS — feeds, categories and articles as plain text, not stream ids | |
| Google Search Console — properties, sitemaps, search analytics, URL inspection | |
| Healthchecks — cron and uptime checks, and why one failed | |
| Hetzner Cloud DNS — zones, record sets and BIND import/export | |
| IMAP mailboxes — read, search, organise and draft mail; it cannot send | |
| Linkwarden — bookmarks, collections and the article text it preserved | |
| Mealie — recipes, meal plans, shopping lists and cookbooks | |
| ntfy — publish and update notifications, manage users and topic access | |
| Opengist — gists, revisions, commit history and raw files | |
| OpenStreetMap — geocoding, routing, isochrones and POI search | |
| Rustpad — collaborative pads edited through real OT, not overwrites | |
| SMTP — sends mail, behind a recipient allowlist and a human confirmation | |
| wg-easy v15+ — the full WireGuard client lifecycle | |
| Wiki.js — search, read and edit pages, plus assets, users and groups | |
| Woodpecker CI — repositories, pipelines, logs, secrets and crons |
Each one runs perfectly well on its own over stdio. Put them behind the hub when you want them reachable from a client that cannot spawn a local process, or when you would rather register one connector than nineteen.
Configuration
/config/mcp.json — identical to Claude Code (${VAR} expands from the
container environment; unknown fields are ignored by Claude Code, so the file
stays interchangeable). Install stdio server binaries at a reviewed, exact
version in your image; do not download mutable packages at runtime:
{
"mcpServers": {
"paperless": {
"command": "paperless-mcp",
"args": [],
"env": { "PAPERLESS_API_TOKEN": "${PAPERLESS_API_TOKEN}" }
},
"homeassistant": {
"type": "http",
"url": "http://homeassistant:8123/api/mcp",
"headers": { "Authorization": "Bearer ${HA_TOKEN}" }
},
"private-thing": { "command": "some-mcp", "args": [], "hub": false },
"paperless-readonly": {
"command": "paperless-mcp",
"allowTools": ["search_*", "get_document"],
"denyTools": ["delete_document"]
},
"untrusted": {
"type": "docker",
"image": "ghcr.io/example/untrusted-mcp@sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
"network": "none",
"memory": "256m"
}
}
}Stdio servers (command/args/env) are spawned as supervised child
processes. Remote servers (type: "http" or "sse" with url and optional
headers) are connected as MCP clients with the configured headers injected
on every request — the same supervision (ping, backoff reconnect, hot reload)
applies. An upstream that speaks OAuth gets an oauth block instead of a
header: the hub registers itself (statically, via RFC 7591 or via a client
metadata document), obtains the token and refreshes it, with one browser visit
started from the admin CLI where the grant needs a person.
"hub": false hides a server from the /hub aggregate; its own path keeps
working. "unlock" keeps a server's tools locked until a person unlocks them
(locked servers). allowTools / denyTools cut finer and apply to every kind of
server: a filtered tool is absent from both tools/list and /hub, and is
refused if called anyway — before the server is woken.
Reserved names: mcp, hub, authorize, token, register,
login, consent, health, livez, revoke, jwks, interaction,
session, userinfo, upstream, .well-known, unlock.
All stdio children share the hub's Unix user and can read its mounted files. Only install fully trusted stdio servers. A server with a different trust level belongs in its own container — and it does not have to speak HTTP to get there:
type: "docker"— the hub creates the container and talks stdio across the container boundary over the Docker API. No HTTP listener, no bearer token, no bridge process in the image. The hub itself never gets the Docker socket: a separatemcp-hub-docker-proxycontainer holds it and allows only the container operationsmcp.jsondescribes — nothing privileged, no host mounts, no other images. Credentials can live with the proxy (secretsFrom) so the hub process never holds them — and rotating one is just an edit: the proxy watches the file and recreates the sandbox with the new values.type: "unix"/"tcp"— you start the container, the hub connects to a socket. Costs the hub no privileges at all, and a Unix socket reaches a sandbox running withnetwork_mode: none.
Both carry the newline-delimited JSON-RPC the specification asks custom transports to reuse. See sandboxing and SECURITY.md.
For a custom image, pin every package to an exact version:
FROM ghcr.io/ni-c/mcp-hub:0.10.0 # pin @sha256:<digest> in production
USER root
RUN npm install -g your-mcp-package@1.2.3
USER nodeEnvironment
Without a non-empty PASSWORD or a bcrypt PASSWORD_HASH the HTTP hub still
starts, but its login is disabled: the startup log says so, the sign-in page
answers 503 with the reason, and no client can be approved — so no token can
be issued. A configured hash takes precedence, and a hash that is not a bcrypt
hash disables the login the same way rather than falling back to PASSWORD.
The local --stdio mode uses neither variable.
Variable | Required | Description |
| yes | Public base URL, e.g. |
| one of | bcrypt hash of the login password ( |
| one of | plain-text alternative to |
| no |
|
| with | Base32 secret from |
| no | comma-separated IPs/CIDRs allowed to set |
| no | RFC 8707 tokens bound to |
| no | server name (or |
| no | authenticated MCP JSON body limit, default |
| no | limit per OAuth client, default |
| no | in-flight request limit per OAuth client, default |
| no | open SSE listening streams per OAuth client — one per connected session, default |
| no | Node HTTP header timeout, default |
| no | how long a client may take to send a request, default |
| no | listen port (default 80 in the image, 3000 outside) |
| no | default |
| no | default |
| no | additionally mirror all log output into this file, e.g. |
| no | which mechanisms a client may use for a |
| no | bare https origins whose metadata documents are accepted; unset → any |
| no | local development only; relaxes the SSRF guard, warns on every start |
| no | ceiling on stored dynamic registrations, default |
| no | how long a never-approved registration is kept, default |
| no | how long an unused approved registration is kept, default |
| no | idle minutes before an on-demand server sleeps, default |
| no | snapshots of sleeping servers, default |
| no | deadline for one forwarded call, default |
| no | let progress notifications restart that deadline, default |
| no | upper bound for a call while progress restarts the deadline, default |
| with docker servers | the policy proxy's socket; a direct daemon socket fails closed |
The full table, including what applies in stdio mode, is in the environment reference.
/data holds the Ed25519 JWT key, registered OAuth clients, approvals and
refresh tokens. Mount it as a volume — recreating it invalidates every
connector authorization.
Every access token is bound to one resource. The OAuth client includes the
resource advertised by the endpoint's RFC 9728 document — no client-side
configuration needed — and the resulting token is valid only there: a token for
/paperless/mcp cannot call /hub, /health or another server. The shorter
/<name> route is canonicalized to /<name>/mcp.
RESOURCE_BOUND_TOKENS=false turns this off and is a migration mode for
deployments from 0.4 and earlier, where tokens were issued without a resource
and reach every path. The hub logs a warning while it is set. Removing it
invalidates those unbound tokens, so every connector authorizes once more.
TRUSTED_PROXIES decides what req.ip is, and therefore what the login rate
limiter counts. List only your own reverse proxy, and make sure it
overwrites X-Forwarded-For rather than appending to it — otherwise a
client can supply its own address and rotate it to sidestep the per-IP limit.
If the variable is unset, every request appears to come from the proxy and
per-IP limiting degrades to a single global counter (the hub logs a warning
at startup). A global cap of 100 failures per 15 minutes applies either way.
Running
Option A — prebuilt image from GHCR (recommended)
Published on every push to main and every vX.Y.Z release tag, for
linux/amd64 and linux/arm64. Browse the versions on the
package page.
docker pull ghcr.io/ni-c/mcp-hub:0.10.0Tags: latest (tip of main), X.Y.Z and X.Y (releases), and
sha-<commit> for a specific build.
Use a version tag instead of latest for controlled updates. For an immutable
deployment, record the resolved digest from docker image inspect and use
ghcr.io/ni-c/mcp-hub:<version>@sha256:<digest> in Compose.
With compose, copy the example and point it at the image instead of building:
services:
mcp-hub:
image: ghcr.io/ni-c/mcp-hub:0.10.0 # replaces `build: .`; pin a digest in production
# ...rest of docker-compose.example.yml unchangedcp docker-compose.example.yml docker-compose.yml # adjust, swap build → image
mkdir -p config && cp mcp.json.example config/mcp.json # adjust
mkdir -p data && sudo chown -R 1000:1000 data # container runs as uid 1000
docker compose up -dOr without compose:
mkdir -p data && sudo chown -R 1000:1000 data # container runs as uid 1000
docker run -d --name mcp-hub \
-p 127.0.0.1:7690:80 \
-e EXTERNAL_URL="https://mcp.example.net" \
-e PASSWORD_HASH="$(htpasswd -bnBC 10 '' 'yourpassword' | tr -d ':\n')" \
-e TRUSTED_PROXIES="192.168.1.0/24" \
-v "$PWD/config:/config:ro" \
-v "$PWD/data:/data" \
ghcr.io/ni-c/mcp-hub:0.10.0Update to a newer image with docker compose pull && docker compose up -d
(or docker pull …, then recreate the container).
Option B — build from source
cp docker-compose.example.yml docker-compose.yml # adjust
mkdir -p config && cp mcp.json.example config/mcp.json # adjust
docker compose up -d --buildOption C — npm (without a container)
CONFIG_PATH=./mcp.json DATA_PATH=./data PASSWORD_HASH='...' \
npx @ni-c/mcp-hubInstalls as @ni-c/mcp-hub
(the unscoped npm name belongs to an unrelated project) and provides the
mcp-hub and mcp-hub-admin binaries. The container remains the recommended
deployment — it provides the isolation, read-only root filesystem and resource
limits that SECURITY.md assumes.
Reverse-proxy requirements: TLS termination, WebSockets/SSE allowed (proxy
buffering off, a read timeout above 310 seconds, a request-body limit at or
below MCP_BODY_LIMIT, and pass X-Forwarded-Proto/Host.
Connect a client: add https://<host>/hub (or https://<host>/<name>/mcp
for one server) as a custom connector — in ChatGPT (developer mode), Claude
Web, Mistral Le Chat, Cursor, LibreChat or any other OAuth-capable MCP client —
and log in once with the password. Claude Code:
claude mcp add -t http name https://<host>/<name>/mcp. API-only clients
(OpenAI Responses API, xAI, Gemini API) use an admin-minted token instead —
see client compatibility.
Each client is confirmed once per server it asks for. Entering the password approves the client that asked, for the server shown on the page; while a login session is still valid, a client you have not seen before — or one asking for another server — gets an explicit Approve / Deny page instead of a code. Approved clients reconnect silently from then on.
List clients or revoke one. The CLI shares /data with the running hub and
both sides re-read the state file before they touch it, so this works against a
live container — a revocation takes effect on the next request:
docker exec mcp-hub node /app/dist/admin.js clients list
docker exec mcp-hub node /app/dist/admin.js clients revoke CLIENT_ID
docker exec mcp-hub node /app/dist/admin.js clients delete CLIENT_ID
docker exec mcp-hub node /app/dist/admin.js clients prune --dry-runRevocation removes the approval and all refresh tokens and immediately rejects
already-issued access tokens. The next connection needs explicit approval.
delete goes further and removes the registration itself, and prune applies
the registration lifecycle rules
on demand — registrations that were never approved expire after a day, unused
ones after 90 days, and a dynamically registered client can also remove its own
registration through RFC 7592.
For clients that cannot do OAuth at all — the OpenAI Responses API, the xAI
API, Gemini's mcp_server tool, plain-header clients — the same CLI mints
long-lived, resource-bound API tokens:
docker exec mcp-hub node /app/dist/admin.js tokens create --resource hub --days 90 --label "openai"
docker exec mcp-hub node /app/dist/admin.js tokens list
docker exec mcp-hub node /app/dist/admin.js tokens revoke TOKEN_IDThe token is printed once and never stored; tokens revoke takes effect
immediately. Per-client recipes:
client compatibility.
Endpoints
Path | Auth | Purpose |
| Bearer | Streamable HTTP endpoint of one server |
| Bearer | aggregate endpoint with the 6 meta-tools |
| none | minimal process liveness ( |
| Bearer | per-server status ( |
| — | OAuth 2.1 · CIMD + DCR; the login and consent pages live under |
| registration token | RFC 7592: a client reads, changes or removes its own registration |
| signed state + hub session | where an upstream returns after |
| none | the hub's own client metadata document, one per |
| none | RFC 8414 metadata |
| none | RFC 9728 metadata (path-scoped) |
Notes & limitations
Change notifications (
listChanged, resource updates) are carried on2026-07-28viasubscriptions/listen, whose state is the open response rather than a session table. A2025-11-25client is offered neither, because that revision needs a channel the stateless transport does not keep — so the capability is withheld instead of announced and dropped. An on-demand server watches nothing while it sleeps; the subscription is re-established on the next wake and the client is told to re-read.Elicitation travels end to end on
2026-07-28: it is a result rather than a push. Sampling and log messages are not forwarded.Access tokens are opaque and last 15 minutes. Revoking a client takes effect on its next request rather than when the token expires — the token is a reference to a stored record, so withdrawing it is a deletion. Refresh tokens rotate; replaying one that was already rotated away is treated as a leak and revokes the whole grant, access tokens included.
Upstream auth is fully decoupled from the hub's own OAuth: an expired upstream token just marks that one server
unauthorized(503 on its path, visible in/health) — clients never see the upstream's 401.One login can approve multiple connectors, but each token is valid only for its requested server or
/hub. Registration remains open as the MCP specification intends; a client only receives codes after confirmation and only at the confirmed redirect target.Failed logins are rate-limited (10/15 min per IP) and logged as
mcp-hub: authentication failure from <ip>for fail2ban.Auth pages deny framing and carry a restrictive CSP. MCP bodies are parsed only after bearer verification and are bounded by size, per-client request rate and per-client concurrency.
Logging to a file for fail2ban
LOG_FILE=/data/mcp-hub.log mirrors every log line into that file, one line
per entry with an ISO-8601 UTC prefix, while leaving the console output alone —
so docker logs keeps working. A jail then reads the file directly:
# /etc/fail2ban/filter.d/mcp-hub-auth.conf
[Definition]
failregex = mcp-hub: authentication failure from <HOST>\s*$
mcp-hub: login rate limit exceeded from <HOST>\s*$
mcp-hub: consent with an invalid CSRF token from <HOST>\s*$
ignoreregex =Only the hub's own lines are mirrored — the stdio children inherit stderr
directly, so their output stays in the container log and the file stays small.
Rotate it with logrotate (copytruncate, since the hub holds the file open).
Why not read the container's own logs instead: the Docker json-file path
contains the container ID and changes on every recreate, and the journald
driver maps all stderr to priority err — since an MCP server must keep
stdout free for the protocol and therefore logs to stderr, every ordinary line
would show up as a system error and drown out host monitoring.
Bans belong in the DOCKER-USER chain (banaction = iptables-allports) when
the hub is published through a container-based reverse proxy: that traffic
arrives via DNAT and FORWARD, and never passes INPUT.
Development
npm install
npm test # vitest: config, OAuth flow, proxy E2E, hub, hot reload
npm run dev # tsx, needs EXTERNAL_URL/PASSWORD/CONFIG_PATH/DATA_PATHAvailable Tools
6 toolscall_toolCall a tool on a serverADestructive
Call a tool on one of the MCP servers. Arguments must match the schema from get_tool_schema.
Inputs: tool (required), server (required), arguments.
get_tool_schemaGet the full schema of a toolARead-onlyIdempotent
Get the full description and JSON input schema of one tool, needed to construct arguments for call_tool.
Inputs: tool (required), server (required). Returns: name, server, annotations, description, +2 more
list_serversList MCP serversARead-onlyIdempotent
List all MCP servers available through this hub, with their status. Call this first to see what is available. Servers marked "hidden" serve their tools only via their own endpoint, but wake_server/sleep_server still manage them.
Inputs: no named parameters. Returns: servers
list_toolsList tools of a serverARead-onlyIdempotent
List the tools of one MCP server with one-line descriptions. Use get_tool_schema before calling a tool for the first time.
Inputs: server (required). Returns: tools, server
sleep_serverPut a server to sleepAIdempotent
Stop an on-demand server immediately instead of waiting for its idle timeout. It restarts automatically on the next tool call.
Inputs: server (required). Returns: name, status
wake_serverWake a sleeping serverAIdempotent
Start an on-demand server now so its first tool call is fast. No-op if it is already running.
Inputs: server (required). Returns: name, status, toolCount
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool targets a distinct resource+action pair: list_servers (servers), list_tools (tools of a server), get_tool_schema, call_tool, wake_server, sleep_server. The only surface overlap (list_servers vs list_tools) is explicitly disambiguated by descriptions and different scopes.
All names follow a consistent snake_case verb-first pattern (list_, get_, call_, wake_, sleep_) with the noun clearly indicating the target. get_tool_schema is slightly longer but still fits the same convention.
Six tools is well-scoped for a hub/gateway: discovery, schema introspection, invocation, and lifecycle control. Each tool earns its place with no obvious filler.
The gateway lifecycle is fully covered (discover servers → discover tools → get schema → call → wake/sleep). Minor gaps exist, such as searching tools across all servers at once or bulk status/health reporting, but agents can work around these via list_servers + list_tools.
Maintenance
Related MCP Connectors
Self-hosted federated MCP gateway: one OAuth 2.1 MCP server in front of N apps, user-level scopes.
One OAuth connector for your team's remote MCP servers, with Tool Packs, guardrails and logs.
MCP Hub: AI service discovery, per-user OAuth, and multi-service workflow orchestration
Governed MCP gateway: one endpoint for your tools, with credential custody and audit log.
Related MCP Servers
- AlicenseAqualityDmaintenanceA hub server that connects to and manages other MCP (Model Context Protocol) servers.761MIT
- AlicenseNot gradedqualityAmaintenanceA unified hub for centrally managing and dynamically orchestrating multiple MCP servers/APIs into separate endpoints with flexible routing strategies.2,729Apache 2.0
- FlicenseNot gradedqualityNot gradedmaintenanceMCP Hub aggregates and proxies multiple Model Context Protocol servers into a unified Streamable HTTP interface. It allows users to combine diverse stdio, SSE, and HTTP-based servers while providing tool namespacing, health monitoring, and secure authentication.497 npm-
- AlicenseNot gradedqualityCmaintenanceA self-hosted MCP hub that unifies multiple MCP server configurations behind a single local endpoint, with a web dashboard for management, live tool-call logging, and per-person access tokens.4MIT