Server profile

MCPHub MCP Server

Organize multiple MCP servers behind shared HTTP or SSE endpoints. MCPHub adds a management dashboard, group-level visibility controls, semantic routing, authentication, and a terminal interface.

Server facts

MCPHub MCP Server

Project

License
Apache-2.0

Tech

Runtime / language
nodeTypeScript
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
2,539
Last commit
Data as of

Tags

  • Mcp Gateway
  • Oauth
  • Self Hosted
  • Server Management
  • Tool Routing

Overview

MCPHub is a management and routing layer for multiple MCP servers rather than a single-purpose tool provider. It groups upstream servers behind shared endpoints that can expose everything, one server, or a logical collection. Within a group, tools, prompts, and resources can each have their visibility controlled separately. A dashboard centralizes monitoring and configuration, and changes can be applied without restarting the hub. Smart routing uses vector-based semantic discovery to identify relevant tools instead of requiring clients to work through every available capability.

The project also proxies interactive MCP Apps on individual-server routes and can compress large textual tool results before sending them to clients. Authentication features include bearer keys and OAuth client/server support. Optional social login requires database mode, which stores configuration in PostgreSQL; file-based settings are the default. Docker deployment includes a persistent data directory so credentials and state survive restarts. A command-line interface handles login, server management, tool inspection, calls, and key creation against a running hub. The README says MCP endpoints require authentication by default, while skipping dashboard authentication is a separate setting. On first launch, an unset admin password is generated and printed in the logs. These operational details matter when using the hub as a shared access point rather than simply running an individual MCP server locally.

Install & configure

Requirements

  • Docker
  • An mcp_settings.json file for the custom-config example
  • A persistent data directory
  • An MCP client for routed access
Documented launch / install command
docker run -p 3000:3000 -v ./mcp_settings.json:/app/mcp_settings.json -v ./data:/app/data samanhappy/mcphub

This starts the hub, not a stdio tool server. Open its dashboard on port 3000 and connect clients to /mcp. MCP endpoints require authentication by default. An unset first-launch admin password is printed in logs.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

A supported configuration example is not available for this client and transport. Check the client documentation for its connection flow; do not substitute an undocumented JSON format.

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "mcphub": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "mcphub": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "mcphub": {
      "serverUrl": "http://localhost:3000/mcp"
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "mcphub": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

No individual tool names were confirmed in the source material. Check the repository for its current tool list.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Expose a chosen group of MCP servers through one client endpoint.
  • Manage server configuration and visibility from a dashboard.
  • Discover relevant tools through semantic routing.
  • Inspect and invoke hub tools from terminal workflows.

Strengths

  • Supports all-server, group, and individual-server routing.
  • Allows independent visibility controls for tools, prompts, and resources.
  • Includes authenticated endpoints, a dashboard, and a CLI.
  • Can update server configuration without downtime.

Limitations

  • GitHub and Google social login require database mode.
  • The extended Docker image is larger and includes amd64-only browser support.
  • Disabling endpoint authentication is intended only for trusted environments.

Frequently asked questions

The README describes routing configured upstream servers rather than naming a fixed built-in MCP tool catalog.

Yes. Group endpoints and per-server visibility controls can limit tools, prompts, and resources.

Yes, by default. The README distinguishes endpoint bearer authentication from dashboard login settings.

File-based mcp_settings.json is the default. PostgreSQL database mode is also supported, including optional social login.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers

BlenderMCP

Games & 3D

BlenderMCP links AI assistants to Blender for scene inspection, object and material changes, and Python execution. Optional asset integrations add Poly Haven downloads, Sketchfab models, and generated 3D assets.

Supergateway

MCP Gateways & Proxies

Supergateway bridges MCP transports so stdio servers can reach network clients and remote services can appear locally over stdio. It supports SSE, WebSockets, and Streamable HTTP modes through command-line configuration.

Unla MCP Gateway

MCP Gateways & Proxies

Unla is a Go gateway that exposes existing APIs and MCP servers through MCP endpoints using configuration. It includes a management interface, recoverable sessions, multi-tenant support, and deployment options for containers or Kubernetes.

mcp-proxy

MCP Gateways & Proxies

mcp-proxy bridges MCP transport mismatches between clients and servers. It can connect a stdio client to a remote SSE or Streamable HTTP server, or expose local stdio servers through network endpoints.

mcpo

MCP Gateways & Proxies

mcpo makes MCP tools available through an OpenAPI-compatible HTTP server. It is for agents and applications that consume OpenAPI endpoints rather than communicating with MCP servers directly.

ContextForge

MCP Gateways & Proxies

ContextForge registers and proxies tools, agents, and APIs behind a unified gateway. It targets teams that need discovery, authentication, observability, and policy controls across MCP, A2A, REST, and gRPC services.

MCP Proxy Server

MCP Gateways & Proxies

MCP Proxy Server combines multiple MCP backends behind one HTTP entrypoint. It aggregates tools, prompts, and resources while connecting to stdio, SSE, or streamable HTTP servers.

MCP Hub

MCP Gateways & Proxies

MCP Hub coordinates multiple MCP servers behind one client endpoint. It provides a REST management API and web UI, with server lifecycle controls, authentication handling, and live capability updates.