Which integrations are available for this server?

Search and read academic papers from arXiv. Perform web searches using the Brave Search API. Manage Cloudflare DNS, pages, and other services. Interact with Discord servers, messages, and channels. Manage containers, images, volumes, and Docker resources. Access GitHub repositories, issues, pull requests, actions, and code search. Manage GitLab repositories, projects, and CI/CD (local tool). Access and manage files on Google Drive. Query and manage Grafana dashboards and alerts. Manage Kubernetes clusters, deployments, and resources (local tool). Manage issues, projects, and teams via Linear API. Interact with S3-compatible object storage (MinIO). Access and manage Notion workspaces and databases. Utilize OpenAI models for text generation and analysis. Query and manage PostgreSQL databases. Query metrics and manage Prometheus monitoring. Control headless Chrome for web scraping and automation. Interact with Redis key-value store. Track errors and performance via Sentry. Send messages, manage channels, and interact with Slack workspace. Query and manage SQLite databases. Manage infrastructure as code with Terraform. Search and read articles from Wikipedia. Access computational knowledge via Wolfram Alpha.

How do I use mcp-hub?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-hub search GitHub for 'mcp-server' and fetch the top result" 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

by LemonWasTakenAgain

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

MCP Hub

Internal MCP (Model Context Protocol) server and AI tools platform for the homelab. Acts as a single gateway that aggregates dozens of upstream MCP servers — your AIs connect once and get access to everything.

How It Works

Claude Code / Claude Desktop / Any MCP Client
            │
            ▼
    ┌───────────────┐
    │   MCP Hub     │  ← single SSE connection
    │  (FastAPI)    │
    └──────┬────────┘
           │
    ┌──────┴────────────────────────────────┐
    │                                       │
    ▼              ▼              ▼         ▼
 Local Tools    GitHub MCP    Brave MCP   Wikipedia MCP
 (GitLab,K8s,   (stdio)       (stdio)     (stdio)
  Homelab)        ...           ...         ...

Your AI connects to one endpoint and gets access to:

15 built-in local tools (GitLab, Kubernetes, Homelab)
30+ upstream MCP servers (search, databases, code, AI, monitoring, communication)

Related MCP server: MCP Gateway

Quick Start

cd ~/projects/homelab/mcp-hub
export MH_GITLAB_TOKEN=<your-gitlab-pat>
export MH_GITHUB_TOKEN=<your-github-token>
docker compose up -d

# Dashboard: http://localhost:8500
# MCP SSE:   http://localhost:8500/mcp/sse

Connect Your AI

Add to Claude Code settings.json:

{
  "mcpServers": {
    "mcp-hub": {
      "type": "sse",
      "url": "http://mcp-hub.steelcanvas.dev/mcp/sse"
    }
  }
}

That's it. One connection, all tools.

Available Upstream Servers

Configured in upstreams.yaml. Enabled by default (no API key needed):

Server	Prefix	Description
fetch	`web__`	Fetch web pages, convert to markdown
github	`github__`	Repos, issues, PRs, actions, code search
docker	`docker__`	Container, image, volume management
arxiv	`arxiv__`	Search and read academic papers
wikipedia	`wiki__`	Search and read encyclopedia articles
filesystem	`fs__`	Read, write, search files
memory	`memory__`	Persistent knowledge graph
time	`time__`	Time, timezone conversions
sequential-thinking	`think__`	Structured reasoning

Set an API key to enable:

Server	Prefix	Env Var
Brave Search	`brave__`	`MH_BRAVE_API_KEY`
Tavily	`tavily__`	`MH_TAVILY_API_KEY`
Exa	`exa__`	`MH_EXA_API_KEY`
Puppeteer	`browser__`	(just enable)
PostgreSQL	`pg__`	`MH_PROXY_POSTGRES_URL`
SQLite	`sqlite__`	`MH_SQLITE_PATH`
Redis	`redis__`	`MH_REDIS_URL`
Qdrant	`qdrant__`	`MH_QDRANT_URL`
Wolfram Alpha	`wolfram__`	`MH_WOLFRAM_APP_ID`
Slack	`slack__`	`MH_SLACK_BOT_TOKEN`
Discord	`discord__`	`MH_DISCORD_TOKEN`
Linear	`linear__`	`MH_LINEAR_API_KEY`
Notion	`notion__`	`MH_NOTION_API_KEY`
HuggingFace	`hf__`	`MH_HF_TOKEN`
OpenAI	`openai__`	`MH_OPENAI_API_KEY`
Prometheus	`prom__`	`MH_PROMETHEUS_URL`
Grafana	`grafana__`	`MH_GRAFANA_URL` + `MH_GRAFANA_API_KEY`
Sentry	`sentry__`	`MH_SENTRY_TOKEN`
S3/MinIO	`s3__`	`MH_S3_ACCESS_KEY` + `MH_S3_SECRET_KEY`
Cloudflare	`cf__`	`MH_CLOUDFLARE_TOKEN`
Terraform	`tf__`	(just enable)
Google Drive	`gdrive__`	(OAuth setup)

Adding Custom Upstream Servers

Edit upstreams.yaml:

upstreams:
  # stdio-based (spawns a local process)
  my-server:
    transport: stdio
    enabled: true
    description: "My custom MCP server"
    command: npx
    args: ["-y", "my-mcp-package"]
    env:
      API_KEY: "${MH_MY_API_KEY}"
    prefix: my

  # SSE-based (connects to a remote HTTP endpoint)
  remote-server:
    transport: sse
    enabled: true
    description: "Remote MCP server"
    url: "http://192.168.1.50:9000/mcp/sse"
    headers:
      Authorization: "Bearer ${MH_REMOTE_TOKEN}"
    prefix: remote

API Endpoints

Endpoint	Description
`GET /`	Web dashboard
`GET /health`	Health check (DB + proxy status)
`GET /api/tools`	All tools (local + proxied) with source
`GET /api/logs`	Tool invocation logs
`GET /api/proxy/status`	Upstream connection status
`GET /api/proxy/tools`	Proxied tool name -> source mapping
`POST /api/proxy/reconnect/{name}`	Reconnect a specific upstream
`GET /mcp/sse`	MCP SSE endpoint
`GET /docs`	OpenAPI docs

Architecture

mcp-hub/
├── mcp_hub/
│   ├── main.py            # FastAPI app + dashboard + proxy lifecycle
│   ├── mcp_server.py      # MCP server (FastMCP) with local tools
│   ├── config.py          # Pydantic settings (MH_* env vars)
│   ├── database.py        # SQLAlchemy async engine
│   ├── models/            # ORM models (ToolLog)
│   ├── tools/             # Built-in local tools
│   │   ├── gitlab_tools.py
│   │   ├── k8s_tools.py
│   │   └── homelab_tools.py
│   └── proxy/             # Upstream MCP proxy engine
│       ├── manager.py     # Orchestrates connections, registers proxied tools
│       ├── connector.py   # MCP client for a single upstream (stdio/SSE)
│       ├── registry.py    # Server config dataclass + YAML loader
│       ├── defaults.py    # Built-in default upstream configs
│       └── env_resolver.py # ${VAR} placeholder resolution
├── upstreams.yaml         # User-editable upstream config
├── templates/             # Jinja2 dashboard
├── static/css/            # Dark-themed dashboard styles
├── Dockerfile             # Multi-stage (Python + Node.js for npx)
├── docker-compose.yml     # Local dev stack
└── .gitlab-ci.yml         # CI/CD pipeline

Development

python -m venv .venv
source .venv/bin/activate
pip install -e .[dev]

# Run locally
export MH_DATABASE_URL=postgresql+asyncpg://mcphub:mcphub@localhost:5432/mcphub
uvicorn mcp_hub.main:app --reload --port 8500

# Lint & test
ruff check .
pytest -v

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivityStale

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

nexusOAuth
com.civic
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Agent Orchestration Developer Tools App Automation
2
Unyly GatewayOAuth
org.unyly
One connector for 15,000+ MCP servers plus your team's private MCPs, from any AI client.
Agent Orchestration AI & Machine Learning
2
ToolRouter B
io.github.Humanleap
The OpenRouter for tools. One MCP connection gives any AI agent 254 hosted tools, pay per call.
Agent Orchestration Autonomous Agents
471
SandBase
io.github.sandbaseai
Connect MCP clients to 2,000+ AI models without managing provider API keys.
AI & Machine Learning Agent Orchestration
1157

Related MCP Servers

MCP Gateway
Developer Tools Agent Orchestration App Automation
LunFengChen
F
license
A
quality
C
maintenance
Aggregates multiple MCP servers into a single gateway with unified top-level tools, reducing LLM context usage and enabling IDE compatibility by consolidating many tools into fewer interface functions.
Updated 2 months ago (2026-07-12 14:16 UTC)
4
17
-
MCP Gateway
Developer Tools Agent Orchestration Autonomous Agents
abdullah1854
A
license
Not graded
quality
C
maintenance
A universal gateway that aggregates multiple MCP servers into a single interface while providing advanced token optimization, result filtering, and automated summarization. It enables efficient management of large tool catalogs and reduces context usage by up to 95% for major AI clients.
Updated 3 months ago (2026-06-25 13:17 UTC)
13 npm
15
MIT
MCPHubs
Developer Tools Agent Orchestration
7-e1even
A
license
Not graded
quality
C
maintenance
A unified gateway and web dashboard that aggregates multiple MCP servers into a single Streamable HTTP endpoint. It supports stdio, SSE, and HTTP protocols, featuring optimized tool exposure modes to reduce token consumption for AI clients.
Updated 6 months ago (2026-03-23 02:05 UTC)
5
MIT
Shared MCP Gateway
Developer Tools Agent Orchestration
xfn-jjw
F
license
Not graded
quality
C
maintenance
Aggregates multiple shared MCP servers into a single HTTP gateway, providing a unified, observable, and reusable MCP access layer for multiple AI clients like Codex, OpenCode, and OpenClaw. It centralizes configuration management, logging, health checks, and circuit breaking to simplify multi-client MCP deployments.
Updated 3 months ago (2026-06-23 01:46 UTC)
5
-