MCP HUB

MCP Hubis a self-hosted AI operations platform with a unified MCP gateway, semantic tool routing, persistent vector memory, automation scheduler, multi-agent flows, and a full ReAct orchestration engine.

ConnectClaude Desktop,ChatGPT,Cursor,Telegram, or any MCP client to130+ toolsacross 12 integrations — throughjust 3 hub endpoints. The AI never drowns in schemas. It searches, finds, and acts.

Most MCP setups dump every tool schema into the AI's context window on every call. With 10 integrations and 130+ tools, that's thousands of tokens wasted before the AI even starts thinking.

AI sees: hub.integrations.list hub.tools.search ← semantic vector search hub.tools.call Behind the scenes: 130+ tools across 12 integrations Local embedding model routes queries to the right tools ReAct loop executes multi-step tasks autonomously

The AI callshub.tools.search("teamwork create task; add task to project")and gets back exactly the 3-5 tools it needs. Nothing else enters the context. Token usage drops by 60-80% on complex tasks.

The centerpiece of MCP Hub's architecture. Instead of loading all 130+ tool schemas on every call, a localsentence-transformersmodel runs on CPU and routes each request to the 3-5 most relevant tools.

User: "create a task in teamwork for the design review" ↓ LLM generates search phrases: "teamwork create task; add task to project; teamwork tasks" ↓ Embedding model finds: teamwork.tasks.bulk_create (score: 0.94) teamwork.tasklists.list (score: 0.87) teamwork.projects.list (score: 0.85) ↓ AI calls hub.tools.call → done

- On startup, every tool is embedded:tool name + description + use cases + tags
- Per request,_expand_semantic_intentsgenerates 3-5 action phrases from the user query
- Cosine similarity ranks all tools → top N sent to LLM
- Result: the AI only ever sees tools it actually needs

Token impact:A complex 5-step automation that previously consumed ~60K tokens now uses ~20-30K. The AI still has full access to all 130+ tools — it just fetches them on demand.

Persistent AI memory that works across conversations, automations, and agents. Now withdual search: FTS5 full-text + semantic embedding search.

Saved: "prefer concise summaries, not bullet points" Search: "formatting style preference" → found (semantic, no exact keyword match) Saved: "BNB target price $700" Search: "my crypto goals binance" → found (semantic scope match)

- Auto-vectorized on save — every upsert computes and stores embedding
- Hybrid search — FTS5 keywords + vector similarity, results merged and deduplicated
- memory.summarize_context(query="...")— semantic context pack: returns only relevant memories for the current task instead of dumping everything
- Secret detection — blocks auto-saving passwords, API keys, tokens
- Scope filtering — memories can be scoped to specific integrations (binance, teamwork, etc.)

Every chat message, automation payload, and agent run goes through the built-in ReAct loop:

Step 1: Understand intent, detect provider, generate semantic search phrases Step 2: hub.tools.search → find relevant tools Step 3: hub.tools.call → execute Step 4: Observe result → verify → iterate if needed Step 5: Synthesize final answer

- Identity bootstrap— for "my tasks" requests, auto-fetchesusers.mebefore listing
- Progressive tool disclosure— new providers loaded only when actually needed
- Repeated call guard— prevents identical tool calls from looping
- Send short-circuit— for action requests, returns immediately after success
- Web search fallback— if a URL fetch times out, retries with next search result
- Multi-LLM— OpenAI, Anthropic, Google, DeepSeek — configured per user

Schedule any LLM workflow. The automation engine is itself accessible via MCP tools, so AI agents can create, update, and monitor their own scheduled tasks.

- interval— run every N seconds (with optionalstart_at/end_atwindow for one-shot runs)
- cron— full cron expression with timezone (0 8 for 08:00 daily)
- event— trigger on named event emitted from tools or webhooks

Daily BNB market report at 08:00 cron: "0 8   " payload: llm_tool_agent prompt: "Fetch BNBUSDT 1h and 4h klines with RSI/MACD/SMA indicators. Read my BNB goals from memory. Generate concise analysis. Send to Telegram." Weekly Teamwork summary every Monday 09:00 cron: "0 9   1" prompt: "List my overdue tasks and tasks due this week. Summarize in bullet points. Send to Slack #general." One-shot reminder in 5 minutes interval_sec: 60, start_at: now+5min, end_at: start_at+90sec payload: telegram_bot_message

Build graphs of specialized agents that delegate to each other. Each agent has:

- Its own system prompt
- Allowed tool set (policy per integration/tool)
- Mounted skills from the global catalog
- Optional custom MCP server connections

Flow: "Morning Operations" Orchestrator Agent ├── delegates to → Market Agent (Binance tools only) ├── delegates to → Calendar Agent (Google Calendar tools only) └── delegates to → Notifier Agent (Telegram Bot only)

Flows can be triggered manually, via automation scheduler, or through MCP.

The hub exposes 4 meta-tools that give AI clients full access to everything without schema bloat:

1. hub.tools.search(query="teamwork create task; add task to project") → returns: teamwork.tasks.bulk_create, teamwork.projects.list, teamwork.tasklists.list 2. hub.tools.call(provider="teamwork", tool_name="teamwork.tasks.bulk_create", arguments={...}) → done

- Use 2-4 short action phrases separated by;
- Include provider name + action verb + entity type
- Examples:

- "slack send message; post to channel"
- "telegram list dialogs; my chats"
- "binance get ticker BNBUSDT; market price"
- "memory save preference; remember this"

┌──────────────────────────────────────────────────────────────────────┐ │ AI Clients │ │ Claude Desktop │ ChatGPT │ Cursor │ Telegram Bot │ Web UI │ └──────────────────────┬───────────────────────────────────────────────┘ │ JSON-RPC 2.0 + Bearer Token ▼ ┌──────────────────────────────────────────────────────────────────────┐ │ MCP Hub │ │ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ Semantic Tool Router │ │ │ │ sentence-transformers (CPU) · cosine similarity │ │ │ │ intent expansion · provider ranking · tool ranking │ │ │ └───────────────────────────┬─────────────────────────────────┘ │ │ │ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ ReAct Orchestration Engine │ │ │ │ hub.tools.search · hub.tools.call · multi-step loop │ │ │ │ identity bootstrap · retry logic · answer synthesis │ │ │ └───────────────────────────┬─────────────────────────────────┘ │ │ │ │ │ ┌──────┬──────┬──────┬──────┴──────┬──────┬──────┬──────┬───────┐ │ │ │Team- │Slack │Miro │Figma │Bin- │Tele- │Mem- │Auto- │ │ │ │work │ │ │ │ance │gram │ory │mation │ │ │ │47 │19 │18 │20 │11 │5+2 │7 │11 │ │ │ │tools │tools │tools │tools │tools │tools │tools │tools │ │ │ └──────┴──────┴──────┴─────────────┴──────┴──────┴──────┴───────┘ │ │ │ │ ┌─────────────────────────────────────────────────────────────┐ │ │ │ SQLite │ FTS5 │ Vector Embeddings │ AES-256 Tokens │ │ │ │ Audit Log │ OAuth 2.0 + PKCE │ Auto Migrations │ │ │ └─────────────────────────────────────────────────────────────┘ │ └──────────────────────────────────────────────────────────────────────┘

git clone https://github.com/Vangardo/mcp_hub.git cd mcp_hub cp .env.example .env # Set: ADMIN_EMAIL, ADMIN_PASSWORD, JWT_SECRET, TOKENS_ENCRYPTION_KEY cd docker docker-compose up -d # Open http://localhost:8000

python -m venv venv source venv/bin/activate # Windows: venv\Scripts\activate pip install -r requirements.txt cp .env.example .env uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

Generate aPersonal Access Tokenin MCP Hub → Settings → Tokens, then add toclaude_desktop_config.json:

{ "mcpServers": { "mcp-hub": { "url": "https://your-domain.com/mcp", "headers": { "Authorization": "Bearer YOUR_PAT_TOKEN" } } } }

- ClickGet GPT Configin MCP Hub
- Use theOAuthtab — ChatGPT auto-discovers endpoints via RFC 8414
- Server URL:https://your-domain.com/mcp

Same as Claude Desktop — Bearer token + MCP endpoint URL.

AddX-MCP-Providerheader to expose a single integration directly (bypasses hub meta-tools):

{ "mcpServers": { "mcp-hub-teamwork": { "url": "https://your-domain.com/mcp", "headers": { "Authorization": "Bearer YOUR_TOKEN", "X-MCP-Provider": "teamwork" } } } }

Navigate toAdminin the top nav (admin users only):

- Users— Approve/reject signups, manage roles, reset passwords, view per-user connections
- Audit Log— Filter by user, provider, action, status, date range. Full request/response payloads
- Settings— Configure public URL, LLM defaults, OAuth credentials for all integrations

ADMIN_EMAIL=admin@example.com # Auto-created on first run ADMIN_PASSWORD=your-secure-password JWT_SECRET=your-jwt-secret-min-32-chars TOKENS_ENCRYPTION_KEY=your-32-char-encryption-key BASE_URL=http://localhost:8000

SEMANTIC_TOOL_ROUTING_ENABLED=true EMBEDDING_MODEL_NAME=intfloat/multilingual-e5-small # Downloads on first run SEMANTIC_TOP_PROVIDERS=3 SEMANTIC_TOP_TOOLS=5 SEMANTIC_INTENT_EXPANSION_ENABLED=true SEMANTIC_INTENT_PHRASE_COUNT=5

# Teamwork (https://developer.teamwork.com/) TEAMWORK_CLIENT_ID= TEAMWORK_CLIENT_SECRET= # Slack (https://api.slack.com/apps) SLACK_CLIENT_ID= SLACK_CLIENT_SECRET= # Miro (https://miro.com/app/settings/user-profile/apps) MIRO_CLIENT_ID= MIRO_CLIENT_SECRET= # Figma (https://www.figma.com/developers/apps) FIGMA_CLIENT_ID= FIGMA_CLIENT_SECRET= # Google Calendar (https://console.cloud.google.com/apis/credentials) GOOGLE_CLIENT_ID= GOOGLE_CLIENT_SECRET= # Telegram personal account (https://my.telegram.org/) TELEGRAM_API_ID= TELEGRAM_API_HASH= # Binance — users connect via their own API Key in the UI # No server-side credentials needed

All credentials can also be configured viaAdmin > Settingsin the web UI.

Personal account (MTProto)— send as yourself, read history, search:

Built-in — always available, no connection needed.

SQLite with automatic migrations on startup. Zero configuration required.

Interactive docs at/docs(Swagger) and/redoc.
- Createapp/integrations/your_integration/
- ImplementBaseIntegration(seeapp/integrations/base.py):

- name,display_name,description,auth_type
- get_tools()→ list ofToolDefinitionwithuse_casesandtagsfor semantic routing
- execute_tool()→ dispatch to tool handlers

Tools are automatically embedded into the semantic index on next startup — no additional configuration.

MCP Hub— 130+ tools. 3 endpoints. One server. Semantic routing, vector memory, ReAct orchestration, multi-agent flows, and automation — all self-hosted.

Unified MCP & skill management gateway with progressive disclosure. Manages multiple MCP servers as Agent Apps, loading tool schemas on demand for 99% context token savings. Shared across Claude Code, Codex, OpenCode and more.

Agent-native developer Q&A API with MCP + A2A endpoints for citations, job pickup, and answer submission.

Open-source, self-hosted AI gateway with built-in MCP client and server support for connecting MCP tools to AI applications.

Integrate with the Flowise API to create predictions and manage chatflows and assistants.

Unified MCP gateway that gives AI agents access to 100+ tools, marketplace MCPs, and custom MCP servers through simple search and execute workflows.

a complete and intuitive SDK for building MCP Servers, MCP Agents, and LLM integrations (OpenAI, Claude, Gemini) with minimal effort. It abstracts all the complexity of the MCP protocol, provides an intelligent agent with automatic model routing, and includes a universal client for external APIs all through a single, simple, and powerful interface. Perfect for chatbots, enterprise automation, internal system integrations, and rapid development of MCP-based ecosystems.

Meta-MCP gateway: search ~75k MCP servers from the public registries via five meta-tools and call any of them on the fly — local-first, with SSRF guard and stdio allowlist.

A Node.js server for AI agents to discover, install, and manage new capabilities on demand via the MCP protocol.

A web app for managing MCP servers, offering a unified interface to discover, configure, and utilize AI tools.

Expose your local AI agent CLIs through one MCP endpoint