M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
M

MetaMCP

Community
Gateway / proxy
A self-hosted gateway that aggregates MCP servers into unified endpoints.

This gateway aggregates or proxies other MCP servers; it only becomes useful once you connect real servers behind it.

How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #121 of 438
Stars
★ 2.7k Very popular
Transport
SSE · Streamable HTTP
Runtime
Docker · Node.js
Credentials
Optional API key
License
MIT
Last commit
60FMRS · C

The source describes MetaMCP as an MIT-licensed, self-hosted MCP aggregation and gateway project with support for tools, resources, and prompts. It provides namespaces, endpoints, authentication, OIDC, rate limiting, tool overrides, and middleware. No named tools or cached server manifest are provided in the source; search, additional middleware, and a headless admin API remain roadmap items.

Strongest · Documentation 15/20 Weakest · Reliability 10/20

Reliability
10/20
Security and permissions
12/20
Maintenance
10/20
Documentation
15/20
Setup experience
13/20
Why each score
Reliability 10/20
The README describes the main MCP initialization, aggregation, forwarding, SSE, and Streamable HTTP paths, making the happy path plausible. However, no cached server manifest, execution evidence, committed tests, or CI coverage is provided; some middleware capabilities are marked as forthcoming, so error handling, edge behavior, and actual tool consistency cannot be verified. Score reduced accordingly.
Security and permissions 12/20
The documentation shows API-key and Bearer authentication, OAuth/OIDC with PKCE, multi-tenancy, private/public scopes, and rate limiting, and recommends environment-variable references for secrets. However, the configurable gateway launches STDIO commands and connects to external MCP services; privilege isolation, dangerous-operation confirmation, data boundaries, and secret-leak protections are not sufficiently evidenced. Rate limits are also process-local in clusters, so the score is limited.
Maintenance 10/20
The project has an MIT license, a repository and contribution path, and the README mentions continuing to merge PRs. However, the author explicitly notes recent maintenance delays, and the supplied material does not verify release cadence, commit activity, dependency updates, vulnerability response, or a clear maintenance commitment. Missing evidence is deducted.
Documentation 15/20
The README covers Docker Compose, local development, client connections, authentication, OIDC, rate limiting, logging, proxy configuration, cold starts, and stated limitations, with several configuration examples. It lacks complete tool parameters, cost information, data-flow boundaries, dangerous-side-effect confirmation details, and reviewable test evidence; some capabilities are explicitly marked coming soon. Score reduced for these gaps.
Setup experience 13/20
Docker Compose, environment preparation, dev containers, local development, and Cursor, Claude Desktop, and proxy configurations are documented, making the main connection path reasonably clear. However, Docker, Postgres, external network access, possible custom dependencies, and reverse-proxy configuration may be required; STDIO-only clients need an additional proxy, so setup is not low-friction. No CI or test evidence supports a higher score.

Static review · not runListed 2026-07-29

Read the FMRS scoring method →

Fit and risk

What it can accessUses the network

Best for

  • Developers and organizations that need self-hosted MCP infrastructure.
  • Teams that centrally manage multiple MCP servers, namespaces, endpoints, and access keys.
  • Deployments that need authentication, rate limiting, and tool-selection controls around MCP access.

Not for

  • Users who only need a single MCP server without aggregation or gateway features.
  • Deployments that cannot run Docker or provide the required runtime environment.
  • STDIO-only client environments where a local proxy cannot be used.

Required permissions

  • Access to configured upstream MCP servers.
  • Permission to start configured commands and dependencies for STDIO MCP servers.
  • Access to container environment variables containing secrets and other configuration.
  • Handling of sessions, API keys, or OIDC login data when authentication is enabled.
  • Network access, Docker, and persistent PostgreSQL storage for deployment.

Risks and side effects

  • Misconfiguration can expose multiple upstream MCP servers or tools through one public endpoint.
  • Poor handling of environment variables or API keys can disclose credentials.
  • Public endpoints may face unauthorized calls, excessive traffic, or misuse of upstream tools.
  • Rate-limit counters are stored in memory, and each cluster machine counts traffic independently.
  • Running STDIO servers and their dependencies expands the container's execution and network-access scope.

Setup

Before you start

Runtime：Docker · Node.js

API_ACCESS_TOKEN optionalsecret Your MetaMCP API key (format sk_mt_...) used for external endpoint access; generate it in the MetaMCP admin interface.
OIDC_CLIENT_SECRET optionalsecret Client secret for OIDC sign-in, obtained from your identity provider; sensitive credential.
Other optional settings (7)
APP_URL optional The application URL; MetaMCP enforces CORS policy on this URL, so only access from it.
LOG_LEVEL optional Controls which log levels mirror to the console: all, info, errors-only, or none; defaults to errors-only.
OIDC_CLIENT_ID optional Client ID for OIDC SSO sign-in, obtained from your identity provider (e.g., Auth0, Keycloak).
OIDC_DISCOVERY_URL optional Your provider's OpenID discovery URL, typically ending in /.well-known/openid-configuration.
OIDC_PROVIDER_ID optional Optional OIDC provider identifier, defaults to oidc.
OIDC_SCOPES optional Optional OAuth scopes, defaults to openid email profile.
OIDC_PKCE optional Optional; enables PKCE (enabled by default).

Clone the repository, copy example.env to .env, and run docker compose up -d. Docker Compose is the recommended setup. After configuring namespaces and endpoints, add the resulting SSE or Streamable HTTP URL to a client configuration. STDIO-only clients require a local proxy such as mcp-proxy.

.cursor/mcp.json 
{"mcpServers":{"MetaMCP":{"url":"http://localhost:12008/metamcp/<YOUR_ENDPOINT_NAME>/sse"}}}

Shown for Cursor. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "MetaMCP": {
      "url": "http://localhost:12008/metamcp/<YOUR_ENDPOINT_NAME>/sse"
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add --transport http MetaMCP 'http://localhost:12008/metamcp/<YOUR_ENDPOINT_NAME>/sse'

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Connect your MCP client to the endpoint URL http://localhost:12008/metamcp/<YOUR_ENDPOINT_NAME>/sse and check that the aggregated tool list from your configured MCP servers appears, or use MetaMCP's built-in Inspector to confirm the endpoint responds.

Troubleshooting

  1. Verify the endpoint name and the exact SSE or Streamable HTTP path used by the client.
  2. SSE does not support api_key query-parameter authentication; prefer Authorization: Bearer <API_KEY>.
  3. Use mcp-proxy for STDIO-only clients; the README says mcp-remote does not work with MetaMCP API-key authentication.
  4. Ensure APP_URL matches the URL used for access because MetaMCP enforces CORS against it.
  5. Check Docker, Docker Compose, PostgreSQL, upstream-server dependencies, and environment variables.
  6. For cold-start issues, review idle-session settings and consider preinstalling dependencies in a custom Dockerfile.
  7. When using a reverse proxy, check Nginx settings for long-lived SSE connections.

Things to try

Once connected, you can ask your AI assistant things like:

  • List all the tools available through my MetaMCP endpoint.
  • Call the HackerNews tool through the aggregated endpoint and summarize the top stories.
  • Show which tools are currently inactive so I can filter them out.
  • Inspect the tools exposed by my MetaMCP namespace to confirm they load correctly.

Use cases

Compose multiple MCP servers behind a unified MCP endpoint.
Select servers and tools by namespace and override tool names, titles, descriptions, and annotations.
Protect MCP endpoints with API keys or MCP OAuth.
Filter tools and process MCP requests and responses with middleware.
Debug endpoints with an Inspector that saves server configurations.
Expose OpenAPI endpoints for clients such as Open WebUI.

Supported clients

Cursor
Claude DesktopPartial support

Listed from the project's documentation, not tested by this site.

Overview

MetaMCP is an MCP proxy, aggregator, orchestrator, middleware layer, and gateway. It combines multiple MCP servers into namespaces, enables or disables servers and tools, overrides tool metadata, and exposes unified SSE, Streamable HTTP, or OpenAPI endpoints. MetaMCP is itself an MCP server and can connect to MCP clients that support these transports.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision ff4ff2de9d25 Data synced 2026-10-19 Read the FMRS scoring method