ComfyUI MCP Hub

Give AI agents full control over your local ComfyUI.

Quick Start  •  Supported Clients  •  All 77 Tools  •  Architecture  •  Configuration

MCP Hub is a Model Context Protocol server packaged as a ComfyUI custom node. It exposes 79 tools that let any MCP-compatible AI assistant — Claude, Gemini, Codex, Cursor, and more — interact with your local ComfyUI instance: inspect workflows, generate images, manage models, install packages, and manipulate the canvas in real time.

One install. Zero cloud dependency. Fully local.

Highlights

• Canvas control — AI agents can read the graph, add/remove/connect nodes, update parameters, capture screenshots, execute workflows, and arrange the layout (move, align, collapse, resize, fit view) directly on the canvas.
• CivitAI & HuggingFace integration — Search models, download with progress tracking, content-safety filtering, hash-based exact matching.
• Smart resolver — Submit any workflow: MCP Hub automatically detects missing nodes, missing models, and broken Python dependencies, then fixes them.
• Multi-instance — Register ComfyUI instances across your LAN and route any command to any machine.
• Activity tracking — Real-time log of every agent action, download progress bars, and toast notifications in the ComfyUI UI.
• One-click client setup — Auto-detects 10 AI clients and writes their MCP config for you.

Quick Start

1. Install

Option A — ComfyUI-Manager (recommended)

Search for "MCP Hub" in ComfyUI-Manager's custom node browser, then click Install.

Option B — Git clone

cd /path/to/ComfyUI/custom_nodes
git clone https://github.com/ArboRithmDev/comfyui-arbo-mcp-hub.git

Option C — Download ZIP

Download the latest release, extract into ComfyUI/custom_nodes/comfyui-arbo-mcp-hub/.

Restart ComfyUI. On first load, MCP Hub will automatically:

• Install its Python dependencies (mcp, aiohttp, websockets)
• Install ComfyUI-Manager if not present
• Register a sidebar panel in ComfyUI Desktop

2. Configure your AI client

Open the MCP Hub panel in ComfyUI's sidebar → AI Clients tab → Configure All.

That's it. Your AI clients are ready to talk to ComfyUI.

{
  "mcpServers": {
    "comfyui-arbo-mcp-hub": {
      "command": "/path/to/ComfyUI/.venv/bin/python",
      "args": ["/path/to/ComfyUI/custom_nodes/comfyui-arbo-mcp-hub/mcp_server/main.py"]
    }
  }
}

[mcp_servers.comfyui-arbo-mcp-hub]
command = "/path/to/ComfyUI/.venv/bin/python"
args = ["/path/to/ComfyUI/custom_nodes/comfyui-arbo-mcp-hub/mcp_server/main.py"]

3. Start using it

Ask your AI assistant:

"What models do I have installed?"
"Search CivitAI for a realistic SDXL LoRA"
"Look at my current workflow and describe it"
"Add a KSampler node connected to the checkpoint loader"
"Generate an image of a mountain landscape at sunset"
"Why did my last execution fail?"

Supported AI Clients

MCP Hub auto-detects installed clients and writes the correct config format (JSON or TOML):

Paths shown are for macOS. Linux and Windows equivalents are handled automatically.

Control Panel

MCP Hub adds a sidebar panel to ComfyUI Desktop:

All 77 Tools

Architecture

┌──────────────────────────────────────┐
│          ComfyUI Desktop             │
│                                      │
│   ┌──────────────────────────────┐   │
│   │  MCP Hub Panel (JS)         │   │
│   │  + Bridge (WebSocket + API) │   │
│   └─────────────┬────────────────┘   │
│                 │ REST / WS          │
│   ┌─────────────▼────────────────┐   │
│   │  Backend (Python)            │   │
│   │  Routes, UI Bridge,         │   │
│   │  Activity Log, Process Mgr  │   │
│   └─────────────┬────────────────┘   │
└─────────────────┼────────────────────┘
                  │ subprocess (stdio)
┌─────────────────▼────────────────────┐
│    MCP Server (separate process)     │
│    79 tools · 4 resources            │
│    Auto-detects Manager v1/v2 API    │
└────────┬────────────────┬────────────┘
         │                │
    ┌────▼─────┐    ┌─────▼────┐
    │ ComfyUI  │    │ ComfyUI  │
    │ (local)  │    │ (LAN)    │
    └──────────┘    └──────────┘

The MCP server runs as an isolated subprocess communicating over stdio. It never imports ComfyUI internals — all interaction goes through HTTP and WebSocket APIs. This keeps the server compatible with any ComfyUI version and allows it to target remote instances.

Configuration

MCP Hub generates mcp_server/hub_config.json on first run (git-ignored — contains your tokens):

{
  "comfyui_url": "http://127.0.0.1:8188",
  "autostart": true,
  "civitai_token": "",
  "huggingface_token": "",
  "safety_filter": "soft",
  "auto_resolve_on_execute": true,
  "enabled_tools": {
    "introspection": true,
    "workflows": true,
    "generation": true,
    "models": true,
    "packages": true,
    "instances": true
  },
  "instances": [
    { "name": "local", "host": "127.0.0.1", "port": 8188, "default": true }
  ]
}

The config auto-syncs with ComfyUI's actual address and port on every startup. No manual editing needed.

Content-Safety Filtering

CivitAI results respect your preference:

Set via the Settings tab or directly in hub_config.json.

ComfyUI Desktop Compatibility

MCP Hub is designed for ComfyUI Desktop and handles its differences from standalone ComfyUI:

MCP Hub also works with standalone ComfyUI using legacy Manager routes and the classic .comfy-menu.

Requirements

Python dependencies (mcp, aiohttp, websockets) are installed automatically on first startup.

Changelog

v0.3.0

• Smart layout engine — rules-based L→R flow positioning, context-aware branch coloring, auto-group detection, annotation frames
• Workflow optimizer — detect and merge duplicate model loaders with automatic connection rewiring
• Template system — extract prompts/seeds into {{variables}}, separate creative content from shareable workflow structure
• Git versioning — init, commit, diff, log, restore, remote push/pull for the workflows directory
• Combo tools — get_overview, build_workflow, batch_update_nodes, setup_and_execute to reduce round-trips for interaction-limited clients (Gemini, etc.)
• Pagination — list_nodes now paginated (limit/offset) to avoid context flooding
• 79 MCP tools total

v0.2.0

• CivitAI & HuggingFace integration — search models, download with progress tracking, content-safety filtering, hash-based exact matching
• Resolver pipeline — resolve_workflow auto-detects and fixes missing nodes, models, and Python dependency conflicts (three-tier: auto → diagnose → propose)
• Activity log — real-time tracking of all agent actions with toast notifications and download progress bars in the UI
• UI Bridge — bidirectional canvas control: read/write graph, add/remove/connect nodes, capture screenshots, execute workflows, get previews
• Layout tools — move_node, resize_node, collapse_node, align_nodes, fit_view, refresh_ui
• Debugging tools — get_last_error (validation + execution errors with node detail), get_logs (grouped tracebacks, stderr capture)
• execute_current fixed — uses app.queuePrompt() for full extension hook support (cg-use-everywhere, rgthree GetNode/SetNode)
• ComfyUI Desktop compatibility — Manager V2 auto-detection (/v2/ routes), empty response handling, config auto-sync
• list_models extended — supports any model directory (ultralytics/bbox, text_encoders, LLM, etc.) via filesystem fallback
• list_model_types — discover all model directories with file counts
• Settings tab — CivitAI/HuggingFace tokens, content-safety filter, auto-resolve toggle
• Autostart — MCP server starts with ComfyUI, clean shutdown on exit

v0.1.0

• Initial release: 32 tools across 6 domains
• Introspection, workflows, generation, models, packages, instances
• Sidebar panel with Server, Tools, AI Clients, Instances tabs
• Auto-detection and configuration of 10 AI CLIs
• Auto-install dependencies on startup

Contributing

Issues and pull requests are welcome at github.com/ArboRithmDev/comfyui-arbo-mcp-hub.

License

MIT

_{Built with Claude Code}