Comfy Cloud MCP

Servidor MCP oficial para Comfy Cloud: genera imágenes, video, audio y 3D, ejecuta flujos de trabajo de ComfyUI y busca modelos directamente desde Claude y otros agentes de IA.

Ver en comfy.orgPrueba este MCPPatrocinado

Documentación

Comfy MCP: Conecta Agentes de IA a ComfyUI

Conecta agentes de IA a ComfyUI mediante el Protocolo de Contexto de Modelos. Genera imágenes, video, audio y 3D, y ejecuta flujos de trabajo reales en Comfy Cloud o en tu propia máquina.

Descripción general

Comfy MCP conecta agentes de IA a ComfyUI mediante el Protocolo de Contexto de Modelos. Una vez conectado, puedes generar imágenes, video, audio y 3D, buscar modelos, nodos y plantillas, y ejecutar flujos de trabajo reales de ComfyUI desde un chat con tu agente.

Incluye dos conexiones: una conexión de Comfy Cloud y una conexión de ComfyUI local, siendo la local completamente de código abierto.

Consejo

¿Estás atascado en algo de lo siguiente? La mejor manera es entregar esta página a tu agente y pedir ayuda.

¿Qué conexión quiero?

Para nuevos usuarios, recomendamos comenzar con la conexión en la nube — es la configuración más sencilla. Si usas claude.ai, ChatGPT o la aplicación de escritorio Claude Desktop, la conexión en la nube también es la opción más compatible.

Si ya ejecutas ComfyUI localmente o en tu propio entorno implementado, o trabajas principalmente en un agente de codificación como Claude Code, Cursor o Codex, comienza con la conexión local.

Información

Para usuarios de Mac, si planeas ejecutar modelos de código abierto, recomendamos la conexión en la nube. Los modelos de pesos abiertos actuales — las versiones locales de MiniMax H3, LTX-2.3 y similares — son grandes y no se ejecutarán a una velocidad aceptable en la GPU de Apple.

Ejecutar ambas al mismo tiempo es normal, y la mayoría de los clientes alojan dos servidores MCP sin problemas. Inician sesión en la misma cuenta de Comfy, pero por separado — un inicio de sesión no cubre al otro.

Conexión Comfy Cloud MCP

La conexión alojada, que vincula tu agente a tu cuenta de Comfy Cloud. No hay nada que instalar, y los flujos de trabajo se ejecutan en las GPU de Comfy Cloud. Para obtener más información sobre Comfy Cloud, consulta Comfy Cloud.

Configurar la conexión en la nube

Información

Necesitas una cuenta de Comfy Cloud antes de conectarte. Regístrate si aún no tienes una; los nuevos usuarios reciben 5 ejecuciones gratuitas para probarlo. El inicio de sesión OAuth durante la configuración utiliza tu cuenta de Comfy.

Comfy Cloud MCP se ejecuta en:

https://cloud.comfy.org/mcp

Elige tu cliente:

Claude Desktop agrega Comfy Cloud como un **conector personalizado** a través de su interfaz, y luego ejecuta el inicio de sesión OAuth.

<video controls className="w-full aspect-video rounded-xl" src="https://mintcdn.com/dripart/UM6LYOmx4pqCW3H7/images/agent_tools/Claude_desktop.mp4?fit=max&auto=format&n=UM6LYOmx4pqCW3H7&q=85&s=6bb8cfd8fcf2c004809bf23f7a42ee41" data-path="images/agent_tools/Claude_desktop.mp4" />

<Steps>
  <Step title="Open Customize">
    En la barra lateral, haz clic en **Personalizar** (etiquetado como **1**).

    <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/claude_desktop_mcp_setup_step1.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=3ecfb670bf79af89d160544ed2352e3c" alt="Claude Desktop — open Customize" width="712" height="842" data-path="images/agent_tools/claude_desktop_mcp_setup_step1.png" />
  </Step>

  <Step title="Open Connectors">
    Haz clic en **Conectores** (etiquetado como **2**).

    <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/claude_desktop_mcp_setup_step2.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=b38a899b51042ea6142dc4bf34c23582" alt="Claude Desktop — open Connectors" width="856" height="811" data-path="images/agent_tools/claude_desktop_mcp_setup_step2.png" />
  </Step>

  <Step title="Add a custom connector">
    1. Haz clic en el botón **+** (etiquetado como **3**) en el encabezado de Conectores.
    2. Elige **Agregar conector personalizado** (etiquetado como **4**).

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/claude_desktop_mcp_setup_step3.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=fc8a799aa218a2cf10de4cbd9d6d060f" alt="Claude Desktop — add custom connector" width="1314" height="792" data-path="images/agent_tools/claude_desktop_mcp_setup_step3.png" />
  </Step>

  <Step title="Enter server details">
    1. Ingresa un nombre como **Comfy Cloud MCP** en el campo **Nombre** (etiquetado como **5**).
    2. Establece la **URL del servidor MCP remoto** a `https://cloud.comfy.org/mcp` (etiquetado como **6**).
    3. Haz clic en **Agregar** (etiquetado como **7**).

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/claude_desktop_mcp_setup_step4.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=7b3f175799b8a02ecdbd1e73feb37831" alt="Claude Desktop — connector details" width="1535" height="955" data-path="images/agent_tools/claude_desktop_mcp_setup_step4.png" />
  </Step>

  <Step title="Sign in">
    1. Cuando se abra el navegador, elige tu espacio de trabajo (por ejemplo, **Espacio de trabajo personal**).
    2. Haz clic en **Continuar** para autorizar el conector. Estás conectado.

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/auth.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=a98bd22924e6fcaf791f72e02dc0bd5c" alt="Comfy Cloud MCP authorization" width="2718" height="1480" data-path="images/agent_tools/auth.png" />
  </Step>
</Steps>

Instala el plugin **comfy-cloud**. Agrega la conexión MCP y los comandos de barra en un solo paso. El plugin se publica a través del repositorio [Comfy Skills](https://github.com/Comfy-Org/comfy-skills/), que aloja plugins de Claude Code y habilidades de agente comunitarias para Comfy.

<Steps>
  <Step title="Add the marketplace">
    Registra el marketplace de Comfy Skills (una sola vez):

    ```
    /plugin marketplace add Comfy-Org/comfy-skills
    ```
  </Step>

  <Step title="Install the plugin">
    ```
    /plugin install comfy-cloud@comfy-skills
    ```
  </Step>

  <Step title="Sign in">
    Ejecuta `/mcp`, selecciona **comfy-cloud** → **Autenticar**. Tu navegador se abre para iniciar sesión y los tokens se actualizan automáticamente.
  </Step>
</Steps>

El plugin agrega estos comandos de barra:

| Comando | Qué hace |
| - | - |
| `/comfy-cloud:generate-image` | Generar, editar o modificar una imagen |
| `/comfy-cloud:generate-video` | Generar, editar o extender un video |
| `/comfy-cloud:generate-audio` | Generar audio, música o efectos de sonido |
| `/comfy-cloud:generate-3d` | Generar un modelo 3D a partir de texto o una imagen |
| `/comfy-cloud:remove-background` | Eliminar el fondo de una imagen |
| `/comfy-cloud:upscale-image` | Aumentar la resolución de una imagen |
| `/comfy-cloud:search-templates` | Encontrar plantillas de flujos de trabajo preconstruidas en [comfy.org](https://comfy.org) |
| `/comfy-cloud:search-models` | Buscar modelos disponibles |
| `/comfy-cloud:search-nodes` | Buscar nodos y obtener sugerencias de cableado |
| `/comfy-cloud:help` | Ver qué puedes hacer con ComfyUI Cloud |

<Accordion title="Prefer just the connection, without the plugin?">
  Agrega el servidor directamente:

  ```bash theme={null}
  claude mcp add --transport http comfy-cloud https://cloud.comfy.org/mcp
  ```

  Luego ejecuta `/mcp`, selecciona **comfy-cloud** → **Autenticar**. Agrega `-s user` para que esté disponible en todos tus proyectos.

  Esta ruta aún expone los mismos flujos de trabajo como prompts de MCP: `/mcp__comfy-cloud__generate-image`, `/mcp__comfy-cloud__search-models`, y así sucesivamente (el prefijo `/mcp__<name>__` usa el nombre que pasaste a `claude mcp add`). Se recomienda el plugin anterior porque los envuelve como los comandos más amigables `/comfy-cloud:*`.
</Accordion>

Cursor se conecta a servidores MCP remotos a través de HTTP. Cursor **no** admite OAuth de MCP actualmente. Agrega Comfy Cloud con una clave de API de Comfy Cloud en tu configuración de MCP.

<Steps>
  <Step title="Open Cursor Settings">
    Haz clic en el engranaje de **Configuración** en la esquina superior derecha (etiquetado como **1**).

    <img src="https://mintcdn.com/dripart/mACqBeflyHg8jsn0/images/agent_tools/cursor_mcp_setup_step1.png?fit=max&auto=format&n=mACqBeflyHg8jsn0&q=85&s=29b7a2b1e73d952bdd243730c876319b" alt="Cursor — open Settings" width="2150" height="1516" data-path="images/agent_tools/cursor_mcp_setup_step1.png" />
  </Step>

  <Step title="Open Tools & MCP">
    1. En la barra lateral, haz clic en **Herramientas y MCPs** (etiquetado como **2**).
    2. Haz clic en **+ Nuevo servidor MCP** (etiquetado como **3**) → **Agregar un servidor MCP personalizado**.

               <img src="https://mintcdn.com/dripart/mACqBeflyHg8jsn0/images/agent_tools/cursor_mcp_setup_step2.png?fit=max&auto=format&n=mACqBeflyHg8jsn0&q=85&s=286ee00e070b36f5f6c741f38171b13e" alt="Cursor — Tools & MCPs" width="2150" height="1516" data-path="images/agent_tools/cursor_mcp_setup_step2.png" />
  </Step>

  <Step title="Add your API key">
    Edita `~/.cursor/mcp.json` (global) o `.cursor/mcp.json` (proyecto). Establece la URL del servidor y pasa tu clave de API de Comfy Cloud en el encabezado `X-API-Key`. Crea una clave en [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (comienza con `comfyui-`):

    ```json theme={null}
    {
      "mcpServers": {
        "comfy-cloud": {
          "url": "https://cloud.comfy.org/mcp",
          "headers": {
            "X-API-Key": "${env:COMFY_API_KEY}"
          }
        }
      }
    }
    ```

    Establece `COMFY_API_KEY` en tu shell o entorno del sistema. Prefiere `${env:COMFY_API_KEY}` en lugar de codificar la clave en un archivo que podrías enviar a Git.

    <img src="https://mintcdn.com/dripart/mACqBeflyHg8jsn0/images/agent_tools/cursor_mcp_setup_step3.png?fit=max&auto=format&n=mACqBeflyHg8jsn0&q=85&s=8e39c284d270a2035b438e10175c256e" alt="Cursor — mcp.json with API key" width="2150" height="1516" data-path="images/agent_tools/cursor_mcp_setup_step3.png" />
  </Step>

  <Step title="Start generating">
    Pregunta en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de video Wan 2.2"). Cursor invoca las herramientas MCP en tu nombre.
  </Step>
</Steps>

[Codex](https://developers.openai.com/codex/cli) se conecta a Comfy Cloud a través de Streamable HTTP. Agrega el servidor en Configuración y luego inicia sesión con OAuth.

<video controls className="w-full aspect-video rounded-xl" src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/CodeX_Oauth_mcp.mp4?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=c09f1520aadfb3f325d7a166a56ba5a7" data-path="images/agent_tools/CodeX_Oauth_mcp.mp4" />

<Steps>
  <Step title="Open the settings panel">
    1. Haz clic en **Configuración** (etiquetado como **1**) bajo *Conectado con clave de API*.
    2. Haz clic en **Configuración** (etiquetado como **2**) para abrir el panel completo de configuración.

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/codex_mcp_setup_step1.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=da14a7540351620e759010debe90dab8" alt="Codex settings panel — step 1" width="1868" height="1278" data-path="images/agent_tools/codex_mcp_setup_step1.png" />
  </Step>

  <Step title="Open MCP server settings">
    1. Haz clic en **Servidores MCP** (etiquetado como **3**) en la lista de configuración.
    2. Haz clic en **+ Agregar servidor** (etiquetado como **4**) para agregar un nuevo servidor MCP.

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/codex_mcp_setup_step2.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=1ea1244dd7f937a81b8fa058775872bf" alt="Codex MCP servers — step 2" width="1888" height="1364" data-path="images/agent_tools/codex_mcp_setup_step2.png" />
  </Step>

  <Step title="Connect to Comfy Cloud">
    1. Elige **Streamable HTTP** como tipo de conexión.
    2. Ingresa un nombre como **Comfy Cloud MCP** en el campo **Nombre** (etiquetado como **5**).
    3. Ingresa la URL `https://cloud.comfy.org/mcp` en el campo **URL** (etiquetado como **6**).
    4. Haz clic en **Guardar** (etiquetado como **7**).

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/codex_mcp_setup_step3.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=f704ee542861064b3dd0e373babeea02" alt="Codex add MCP server — step 3" width="1888" height="1364" data-path="images/agent_tools/codex_mcp_setup_step3.png" />
  </Step>

  <Step title="Authenticate">
    1. Haz clic en **Autenticar** (etiquetado como **8**) en la entrada del servidor guardado.

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/codex_mcp_setup_step4.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=1afe7051207daa053cbadba8e620aa72" alt="Codex authenticate MCP server — step 4" width="1888" height="1364" data-path="images/agent_tools/codex_mcp_setup_step4.png" />

    2. En la ventana emergente del navegador, elige tu espacio de trabajo y haz clic en **Continuar** para finalizar el inicio de sesión. Estás conectado.

               <img src="https://mintcdn.com/dripart/oeEoB3PP1mIk3aIP/images/agent_tools/auth.png?fit=max&auto=format&n=oeEoB3PP1mIk3aIP&q=85&s=a98bd22924e6fcaf791f72e02dc0bd5c" alt="Comfy Cloud MCP authorization" width="2718" height="1480" data-path="images/agent_tools/auth.png" />
  </Step>
</Steps>

Pregunta en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de video Wan 2.2"). Codex invoca las herramientas MCP en tu nombre.

<Accordion title="Prefer the CLI instead?">
  Regístrate e inicia sesión desde la terminal:

  ```bash theme={null}
  codex mcp add comfy-cloud --url https://cloud.comfy.org/mcp
  codex mcp login comfy-cloud
  ```

  Esto escribe una entrada en `~/.codex/config.toml` (o `.codex/config.toml` en un proyecto de confianza).
</Accordion>

<Accordion title="API key instead of OAuth (headless or CI)">
  Cuando no hay navegador disponible, agrega el servidor con un encabezado extraído de una variable de entorno. Crea una clave en [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (comienza con `comfyui-`), luego agrega a `~/.codex/config.toml`:

  ```toml theme={null}
  [mcp_servers.comfy-cloud]
  url = "https://cloud.comfy.org/mcp"
  env_http_headers = { "X-API-Key" = "COMFY_API_KEY" }
  ```

  Establece `COMFY_API_KEY` en tu shell o entorno del sistema. No envíes la clave al control de versiones.
</Accordion>

Instala la habilidad **Comfy Cloud** desde [ClawHub](https://clawhub.ai/comfy-org/skills/comfy). Conecta OpenClaw al servidor MCP alojado (`cloud.comfy.org/mcp`). Solo nube: no controla una instalación local de ComfyUI.

<Steps>
  <Step title="Install the skill">
    ```bash theme={null}
    openclaw skills install @comfy-org/comfy
    ```

    Página de la habilidad: [clawhub.ai/comfy-org/skills/comfy](https://clawhub.ai/comfy-org/skills/comfy).
  </Step>

  <Step title="Connect with OAuth (recommended)">
    Registra el servidor MCP e inicia sesión con tu cuenta de Comfy:

    ```bash theme={null}
    openclaw mcp set comfy '{"url":"https://cloud.comfy.org/mcp","transport":"streamable-http","auth":"oauth"}'
    openclaw mcp login comfy
    openclaw gateway restart
    ```

    `openclaw mcp login` imprime una URL de autorización. Ábrela, inicia sesión y finaliza el flujo como indique la CLI (puede pedirte que vuelvas a ejecutar con un valor de `--code`). Verifica con `openclaw mcp status --verbose`.

Nota

Cuando auth: "oauth" está establecido, OpenClaw ignora headers estático en esa entrada del servidor. No combines OAuth con un encabezado de clave de API codificado.

  <Step title="Start generating">
    Pregunta en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de video Wan 2.2"). OpenClaw invoca las herramientas MCP en tu nombre.
  </Step>
</Steps>

<Accordion title="API key instead of OAuth (headless or CI)">
  Crea una clave en [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (comienza con `comfyui-`), expórtala y luego registra el servidor:

  ```bash theme={null}
  export COMFY_API_KEY="comfyui-..."
  openclaw mcp set comfy '{"url":"https://cloud.comfy.org/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer ${COMFY_API_KEY}"}}'
  openclaw gateway restart
  ```

  Prefiere `Authorization: Bearer` sobre un encabezado `X-API-Key` personalizado para OpenClaw. Algunas compilaciones de OpenClaw eliminan encabezados personalizados en transportes streamable-http; Bearer sobrevive a los proxies de manera más confiable. Coloca `COMFY_API_KEY` en tu perfil de shell o en el entorno de OpenClaw. No envíes la clave.
</Accordion>

Cualquier cliente MCP que admita transporte **HTTP remoto** puede conectarse a Comfy Cloud. La URL del servidor es siempre `https://cloud.comfy.org/mcp`.

<Steps>
  <Step title="Add the server URL">
    Agrega una entrada MCP remota que apunte a `https://cloud.comfy.org/mcp`. La mayoría de los clientes usan una configuración JSON con un campo `url`:

    ```json theme={null}
    {
      "mcpServers": {
        "comfy-cloud": {
          "url": "https://cloud.comfy.org/mcp"
        }
      }
    }
    ```

    **Windsurf** usa `serverUrl` en lugar de `url`. **Amp** usa la misma forma de `mcpServers` en **Configuración → Servidores MCP** o `~/.config/amp/settings.json`.
  </Step>

  <Step title="Authenticate">
    Si tu cliente admite OAuth de MCP, inicia sesión a través del navegador cuando se te solicite. De lo contrario, agrega un encabezado de clave de API (ver más abajo).
  </Step>

  <Step title="Restart and verify">
    Reinicia tu cliente. Deberías ver las herramientas de Comfy Cloud (`search_templates`, `submit_workflow`, `get_output` y otras) registradas bajo el servidor **comfy-cloud**.
  </Step>
</Steps>

**Headless / CI (clave de API):** cuando OAuth no está disponible, crea una clave en [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) y pásala como encabezado `X-API-Key`:

```json theme={null}
{
  "mcpServers": {
    "comfy-cloud": {
      "url": "https://cloud.comfy.org/mcp",
      "headers": {
        "X-API-Key": "comfyui-…"
      }
    }
  }
}
```

Para Claude Code desde la terminal:

```bash theme={null}
claude mcp add --transport http comfy-cloud https://cloud.comfy.org/mcp -H "X-API-Key: comfyui-…"
```

Prefiere `${env:COMFY_API_KEY}` o la interpolación de secretos de tu cliente en lugar de codificar claves en archivos de configuración que envíes a Git.

Qué puede hacer tu agente

No llamas a las herramientas MCP tú mismo. Tu agente elige la herramienta adecuada según lo que pidas. Los comandos de barra y los prompts (abajo) son atajos que orientan al agente hacia tareas comunes, pero el lenguaje natural también funciona ("genera una imagen de un astronauta gato", "aumenta la resolución de esta foto", "encuentra una plantilla de video Wan 2.2").

Flujo típico:

Descubre lo que está disponible (search_templates, search_models, search_nodes, o cql para preguntas de tipo grafo).
Ejecuta una generación: run_template para una plantilla preconstruida que coincida, submit_workflow para un workflow personalizado (con upload_file cuando se necesita una imagen de entrada), o partner_generate para modelos de socios como Flux, Grok, Gemini, OpenAI, Ideogram y Seedance.
Espera y recupera las salidas (wait_for_job, luego get_output devuelve un comando de descarga que tu agente ejecuta en tu shell).

El servidor prefiere hacer coincidir plantillas preconstruidas antes de construir un workflow desde cero, lo que tiende a producir mejores resultados más rápido.

Herramientas Cloud MCP

Estas son las herramientas a las que tu agente tiene acceso una vez conectado. Los nombres coinciden con lo que aparece en los registros del cliente MCP y en la salida de depuración.

Descubrimiento

Herramienta	Descripción
`search_templates`	Busca plantillas de workflow preconstruidas de comfy.org por texto, etiqueta, tipo de medio o modelo
`get_template`	Obtiene el JSON completo del workflow de una plantilla para inspección o edición manual
`get_template_schema`	Muestra qué parámetros de una plantilla se pueden sobrescribir en tiempo de ejecución
`search_models`	Busca en el catálogo de modelos por texto, tipo, modelo base o fuente
`search_nodes`	Busca nodos disponibles por texto, categoría o tipos de entrada/salida. También muestra planos de subgrafos (grupos de nodos precableados como Texto a Imagen o Eliminar Fondo)
`get_node`	Obtiene la especificación completa de entrada para nodos específicos, incluyendo listas completas de opciones
`cql`	Ejecuta una consulta de grafo CQL para preguntas estructurales (por ejemplo, qué nodos producen imágenes, o rutas entre tipos de nodos). Usa `search_nodes` cuando necesites especificaciones completas de entrada para un nodo específico
`get_prompting_guide`	Estilo de prompt y configuraciones recomendadas (pasos, cfg, sampler, resolución) por familia de modelo

Generación

Herramienta	Descripción
`run_template`	Ejecuta una plantilla preconstruida por nombre, con sobrescrituras de parámetros opcionales — la vía preferida cuando una plantilla coincide
`submit_workflow`	Envía un workflow en formato API de ComfyUI para ejecución en Comfy Cloud
`partner_generate`	Genera con modelos de API de socios (Flux/BFL, Grok, Gemini, OpenAI, Ideogram, Seedream/Seedance, y más)
`upload_file`	Sube una imagen o archivo de entrada para usar en workflows (por ejemplo, con LoadImage)
`apply_slots`	Aplica sobrescrituras de parámetros a los valores internos de un workflow y devuelve el workflow modificado

Trabajos y lotes

Herramienta	Descripción
`get_job_status`	Consulta el estado de ejecución de un workflow enviado
`wait_for_job`	Espera hasta que un trabajo termine en lugar de consultar repetidamente
`get_output`	Recupera imágenes, videos o audio de salida de un workflow completado
`use_previous_output`	Encadena workflows reutilizando la salida de una ejecución como entrada de otra
`cancel_job`	Cancela un trabajo pendiente o en ejecución
`get_queue`	Comprueba cuántos trabajos están en ejecución y pendientes
`submit_batch`, `get_batch_status`, `get_batch_output`, `wait_for_batch`	Envía muchas generaciones en una sola llamada y recógelas juntas más tarde — el ID del lote sigue siendo válido entre sesiones

Workflows guardados

Herramienta	Descripción
`list_saved_workflows`	Explora tus workflows guardados de Comfy Cloud
`get_saved_workflow`	Inspecciona los nodos, entradas y configuraciones personalizables de un workflow guardado
`save_workflow`	Guarda un workflow en tu cuenta de Comfy Cloud
`update_workflow`	Actualiza un workflow existente como una nueva versión (las versiones anteriores siguen siendo recuperables)
`run_saved_workflow`	Ejecuta un workflow guardado por nombre de archivo — el servidor lo convierte automáticamente de formato de editor a formato ejecutable

Compartir workflows

Herramienta	Descripción
`share_workflow`	Publica un workflow guardado y devuelve una URL `?share=<id>` que cualquiera puede abrir
`import_shared_workflow`	Resuelve una URL de compartir o un ID de compartir simple en JSON de workflow, opcionalmente guardándolo en tu cuenta

IDs de compartir de URL de Hub: el token hexadecimal separado por guiones al final de una URL de hub comfy.org/workflows/<slug>-<hex> es el ID de compartir. Por ejemplo, comfy.org/workflows/topaz-starlight-upscale-1c77e82713b7 tiene el ID de compartir 1c77e82713b7. Pasa ese token a import_shared_workflow como share_id. El parámetro share_url solo acepta URLs de consulta ?share=<id> como https://cloud.comfy.org/?share=..., no URLs de páginas de hub.

Aplicaciones y enlaces

Herramienta	Descripción
`create_app`	Convierte un workflow guardado en una aplicación de Modo App — una vista simplificada de "ejecutar este workflow" con entradas y salidas elegidas
`get_app_mode_url`	Obtiene el enlace estable que abre un workflow como aplicación ejecutable
`get_workflow_canvas_url`	Obtiene un enlace que abre un workflow directamente en el lienzo de Comfy Cloud, listo para ver, editar o ejecutar

Cuenta y sesión

Herramienta	Descripción
`get_billing_status`	Comprueba tu saldo de créditos, nivel de suscripción y enlace de facturación
`get_server_info`	Confirma a qué servidor llegó el agente: entorno, host, versión y estado de autenticación
`submit_feedback`	Obtiene el enlace de la encuesta de comentarios
`report_session_summary`	Comparte un resumen de sesión anonimizado con el equipo de Comfy — solo con tu consentimiento explícito; el agente debe preguntar primero, y no se incluyen prompts, rutas de archivos ni información personal

Prompts (Claude Desktop)

Claude Desktop no admite comandos de barra de Claude Code. En su lugar, abre el selector de prompts para los mismos workflows:

Prompt	Descripción
`generate-image`	Genera una imagen a partir de una descripción de texto
`generate-video`	Genera un video a partir de texto o una imagen
`generate-audio`	Genera audio, música o efectos de sonido
`generate-3d`	Genera un modelo 3D a partir de texto o una imagen
`upscale-image`	Aumenta la resolución de una imagen
`remove-background`	Elimina el fondo de una imagen
`search-templates`	Encuentra plantillas de workflow preconstruidas
`search-models`	Busca modelos (checkpoints, LoRAs, VAEs)
`search-nodes`	Busca nodos y obtén sugerencias de cableado
`help`	Ve lo que puedes hacer con ComfyUI Cloud

También puedes omitir los prompts y preguntar en lenguaje natural. Las herramientas MCP funcionan de la misma manera.

Créditos y gastos

El descubrimiento es gratuito: search_templates, search_models y search_nodes funcionan solo con una cuenta de Comfy. Ejecutar generaciones requiere una suscripción activa a Comfy Cloud. Un saldo de créditos o recargas por sí solo no otorga acceso: necesitas una suscripción activa para ejecutar generaciones, incluso si tienes créditos sin usar.

Subidas y descargas

El servidor MCP se ejecuta en la nube y el propio MCP no escribe archivos en tu máquina. Cuando una generación se completa, tu agente llama a get_output, que devuelve:

Una URL de descarga firmada temporal (válida por un período corto).
Un comando de shell listo para ejecutar (curl en macOS y Linux, curl.exe en Windows).

Tu agente debe ejecutar ese comando en tu shell. El comando incluye la ruta de destino y el nombre del archivo.

Advertencia

Ejecuta el comando devuelto textualmente. No vuelvas a codificar ni edites la URL firmada. La firma vive en la cadena de consulta y se rompe si la URL se modifica.

Si tu cliente MCP no puede ejecutar comandos de shell (algunas configuraciones solo de GUI), copia el comando y ejecútalo tú mismo en una terminal.

La subida y descarga de archivos dependen del acceso a archivos del cliente. Si Claude Desktop u otro cliente de agente tiene problemas para manejar subidas o descargas de archivos, puede estar relacionado con el acceso del agente a tus directorios de archivos locales. Para usuarios de Claude recomendamos Claude Code (aplicación de escritorio o terminal), que tiene más capacidades. De manera similar, para otras familias de agentes, el agente de codificación suele ser mejor que la versión de chat web.

Limitaciones conocidas

Comfy Cloud MCP es una versión temprana. Estas limitaciones son conocidas y se están trabajando:

Workflows

Los archivos generados mediante submit_workflow pueden no incluir metadatos del workflow. Puede que no reabran el workflow de origen cuando se abren en ComfyUI.
La construcción de workflows depende de la precisión del agente. Los workflows complejos de múltiples nodos pueden necesitar un reintento o refinamiento.

Manejo de archivos

Las salidas requieren un paso de descarga por shell. Consulta Subidas y descargas.
Pueden aplicarse límites de tamaño de subida según tu cliente MCP. Algunos clientes imponen sus propios límites en las subidas de archivos.

Autenticación

OAuth o clave de API. Claude Code y Claude Desktop usan un flujo OAuth de navegador de una sola vez. Cursor requiere una clave de API de Comfy Cloud en tu configuración de MCP (sin OAuth). Otros clientes sin interfaz pueden pasar una clave de API de Comfy Cloud mediante el encabezado X-API-Key. Está planificado un flujo OAuth con código de dispositivo para clientes que no pueden abrir un navegador.

Conexión Local Comfy MCP

La conexión de código abierto: tu cliente inicia el servidor en tu máquina y este controla el ComfyUI instalado allí.

comfy-mcp es el servidor MCP local de primera parte de Comfy — la forma oficial de controlar una instalación local de ComfyUI desde agentes de IA (Claude Code, Claude Desktop, Cursor y otros clientes MCP).

A diferencia de los servidores de nube y de socios, habla con el ComfyUI que se ejecuta en tu propia máquina — por lo que puede ejecutar tus workflows e inspeccionar los nodos, nodos personalizados y modelos que tu instalación realmente tiene.

Consejo

La configuración más rápida: entrégasela a tu agente. Pega https://docs.comfy.org/agent-tools/mcp#installation en tu cliente de IA y pídele que configure la conexión local por ti.

Requisitos

Python 3.10+
comfy-cli en tu PATH (pip install "comfy-cli>=1.14.0") — el motor que envuelve cada herramienta
Un espacio de trabajo de ComfyUI — crea uno con comfy install si no tienes uno (una copia existente funciona mediante comfy set-default <path>)
Un ComfyUI en ejecución para las herramientas de ejecución. Inícialo con comfy launch, o llama a launch_comfyui. El servidor no inicia ComfyUI implícitamente.

Instalación

Desde PyPI:

pip install comfy-mcp

Esto coloca un script de consola comfy-mcp en tu PATH — ese comando es el servidor MCP (habla MCP sobre stdio). Apunta tu cliente de IA hacia él a continuación. (¿Estás hackeando el propio servidor? Usa pip install -e . desde una copia del repositorio en su lugar.)

Nota

COMFY_BIN (opcional). Los clientes MCP inician el servidor con su propio entorno, que a menudo no incluye el PATH de tu shell. Si comfy vive en un virtualenv o en una ubicación no estándar, establece COMFY_BIN a su ruta absoluta (por ejemplo /path/to/venv/bin/comfy). Cada ejemplo de cliente abajo muestra dónde va; omítelo si comfy ya está en el entorno con el que tu cliente inicia el servidor.

Configuración manual

Todos los clientes hablan el mismo contrato MCP stdio: ejecuta el comando comfy-mcp como servidor. Elige tu cliente:

Edita `claude_desktop_config.json` (Configuración → Desarrollador → Editar Config; en macOS se encuentra en `~/Library/Application Support/Claude/claude_desktop_config.json`), agrega el servidor y luego reinicia Claude Desktop:

```json theme={null}
{
  "mcpServers": {
    "comfy-mcp": {
      "command": "comfy-mcp",
      "env": { "COMFY_BIN": "/path/to/venv/bin/comfy" }
    }
  }
}
```

Un comando registra el servidor:

```bash theme={null}
claude mcp add comfy-mcp -e COMFY_BIN=/path/to/venv/bin/comfy -- comfy-mcp
```

O verifícalo en un proyecto con un `.mcp.json` en la raíz del repositorio:

```json theme={null}
{
  "mcpServers": {
    "comfy-mcp": {
      "command": "comfy-mcp",
      "env": { "COMFY_BIN": "/path/to/venv/bin/comfy" }
    }
  }
}
```

Agrega el servidor a `~/.cursor/mcp.json` (global) o `.cursor/mcp.json` (por proyecto):

```json theme={null}
{
  "mcpServers": {
    "comfy-mcp": {
      "command": "comfy-mcp",
      "env": { "COMFY_BIN": "/path/to/venv/bin/comfy" }
    }
  }
}
```

Inicio rápido

De cero a una imagen generada:

```bash theme={null} pip install "comfy-cli>=1.14.0" # the engine comfy install # create a ComfyUI workspace (skip if you have one) pip install comfy-mcp # this MCP server → the `comfy-mcp` command ``` ```bash theme={null} comfy launch ``` Usa el fragmento para tu cliente de arriba y luego reinícialo o recárgalo para que aparezcan las herramientas. Por ejemplo:

> "Confirma que mi ComfyUI local está en ejecución, luego ejecuta el flujo de trabajo en `~/workflows/txt2img.json` y muéstrame la imagen."

Bajo el capó, el agente llama a `server_info` para confirmar que ComfyUI está activo, `run_workflow` para ejecutar el JSON del flujo de trabajo y `fetch_outputs` para recopilar el resultado.

Herramientas

Cada herramienta se asigna a un comando comfy-cli, ejecutado con --where local. Destacados:

Herramienta	Propósito
`server_info()`	¿Está ejecutándose un ComfyUI local, dónde y en qué espacio de trabajo? Llámalo primero.
`run_workflow(workflow_path, wait=True)`	Ejecuta un JSON de flujo de trabajo; `wait=False` envía de forma asíncrona y devuelve un `prompt_id`.
`job_status` / `wait_for_job` / `watch_job`	Consulta, espera o transmite un trabajo enviado.
`fetch_outputs(prompt_id, out_dir)`	Copia las salidas de un trabajo finalizado en `out_dir`.
`launch_comfyui` / `stop_comfyui`	Inicia o detiene el ComfyUI local.
`search_templates` / `fetch_template`	Encuentra una plantilla integrada y escribe su JSON de flujo de trabajo ejecutable.
`search_nodes` / `get_node` / `list_nodes`	Inspecciona las clases de nodos en tu instalación local en vivo (incluidos los nodos personalizados).
`search_models`	Lista los archivos de modelos en el disco.
`validate_workflow`	Pre-valida un flujo de trabajo contra el `object_info` en vivo antes de una ejecución lenta.

La introspección de nodos y la búsqueda de modelos leen tu instalación en vivo — incluidos los nodos personalizados —, lo cual es el diferenciador local frente a la conexión en la nube. Consulta el repositorio para la lista completa de herramientas y referencias.

Recursos relacionados

Recurso	Para qué sirve
Comfy Skills	Mercado de plugins y biblioteca de habilidades de la comunidad para Claude Code. El plugin comfy-cloud usado arriba se distribuye aquí; explora o contribuye con habilidades adicionales para flujos de trabajo de Comfy.
Comfy Cloud en ClawHub	Habilidad de OpenClaw (`openclaw skills install @comfy-org/comfy`) para el servidor MCP alojado de Comfy Cloud.
Comfy CLI	Herramienta de línea de comandos para instalar/lanzar ComfyUI local y para llamar a nodos de socios alojados desde scripts o CI (`comfy generate`, en beta). Complementa a MCP cuando necesitas flujos de trabajo de terminal o automatización.
Comparte un flujo de trabajo en Comfy Cloud	Comparte flujos de trabajo desde la interfaz de Comfy Cloud (la herramienta `share_workflow` de MCP hace esto desde una sesión de agente).

Relacionado: Comfy Agent

¿Quieres la experiencia de agente dentro de ComfyUI, no en un cliente MCP externo?

Asistente integrado de ComfyUI para construir, editar y ejecutar flujos de trabajo. **Generalmente disponible en Cloud.** Local (Comfy Desktop) próximamente.

Comentarios

Prueba Comfy MCP y cuéntanos qué funciona y qué no:

Encuesta de comentarios: reporta errores, solicita funciones o comparte impresiones generales.
Discord: #comfy-mcp-and-cli en el Discord de Comfy para preguntas y discusión.

Preguntas frecuentes

Primeros pasos

Cualquier cliente compatible con MCP.

La **conexión en la nube** necesita soporte HTTP remoto. **Claude Code**, **Claude Desktop**, **Cursor**, **Codex** y **OpenClaw** tienen configuración de primera clase arriba; **Windsurf**, **Amp** y otros usan la misma URL con OAuth o una clave de API.

La **conexión local** necesita un cliente que pueda lanzar un servidor stdio local como subproceso. Eso descarta a los clientes basados en navegador. [claude.ai](https://claude.ai) y ChatGPT solo aceptan conectores remotos.

La conexión en la nube se ejecuta en `https://cloud.comfy.org/mcp`.

La conexión local no tiene URL. Tu cliente lanza el comando `comfy-mcp` directamente y se comunica con él a través de stdio.

Sí. Esa es la [Conexión MCP local de Comfy](#local-comfy-mcp-connection). Impulsa el ComfyUI instalado en tu propia máquina, por lo que tu agente ve los modelos, LoRAs y nodos personalizados que realmente tienes, y se ejecuta en tu GPU. Sí, y lo recomendamos si ejecutas ComfyUI localmente. La mayoría de los clientes alojan dos servidores MCP sin problemas, y tu agente los mantiene separados. Cada conexión ejecuta sus propios flujos de trabajo y devuelve sus propios resultados.

Sin embargo, los dos inicios de sesión son **separados**. Iniciar sesión en uno no te inicia sesión en el otro, aunque sea la misma cuenta de Comfy.

Pregúntale a tu agente. Lee tu hardware antes de comenzar cualquier tarea pesada.

En una **Mac**, usa la conexión en la nube para generar: los modelos de peso abierto actuales son demasiado grandes para ejecutarse a una velocidad práctica en la GPU de Apple. En una **PC con tarjeta gráfica dedicada**, 24 GB o más de VRAM manejan la mayoría de las cosas, incluido video; 8–24 GB es suficiente para imágenes, pero el video será lento o no cabrá; por debajo de 8 GB, usa la nube.

Sí. La conexión en la nube está generalmente disponible, y la conexión local está disponible para instalaciones locales de ComfyUI. Consulta [Comentarios](#feedback) para reportar problemas o compartir sugerencias.

Costo y acceso

El descubrimiento es gratuito en ambas conexiones: buscar plantillas, modelos y nodos solo requiere una cuenta de Comfy.

En la **conexión en la nube**, ejecutar generaciones requiere una suscripción activa a Comfy Cloud; los nuevos usuarios obtienen 5 ejecuciones gratuitas. En la **conexión local**, las ejecuciones son gratuitas porque ocurren en tu hardware, con una excepción: los modelos de socios se ejecutan en la infraestructura de los socios y gastan créditos.

No para clientes interactivos que soporten OAuth, incluidos Claude Code, Claude Desktop, Codex y OpenClaw.

**Cursor** requiere una clave de API de Comfy Cloud en tu configuración de MCP; no hay OAuth de MCP allí todavía. Las configuraciones headless y de CI sin navegador también necesitan una. Consulta las pestañas **Cursor** y **Otros clientes** en [Configurar la conexión en la nube](#set-up-the-cloud-connection).

Uso

No llamas a las herramientas de MCP tú mismo — tu agente las elige según lo que pidas. Típicamente **descubre** lo que está disponible (`search_templates`, `search_models`, `search_nodes`), **ejecuta** una generación, y luego **espera y recupera** la salida. Consulta [Lo que tu agente puede hacer](#what-your-agent-can-do). En la **conexión en la nube**, el servidor nunca escribe en tu máquina: `get_output` devuelve una URL firmada temporal y un comando de descarga listo para ejecutar que tu agente ejecuta en tu shell. Consulta [Cargas y descargas](#uploads-and-downloads).

En la **conexión local**, ComfyUI escribe en el directorio `output/` de tu espacio de trabajo, y `fetch_outputs(prompt_id, out_dir)` copia los archivos de un trabajo finalizado a cualquier lugar que nombres.

Nada que deshacer — agrega la segunda conexión junto a la primera.

Yendo de **local → nube** (necesitas GPUs en la nube o modelos de socios): pídele a tu agente que inicie sesión por ti, luego agrega `https://cloud.comfy.org/mcp` a tu cliente.

Yendo de **nube → local** (quieres tus propios modelos y nodos personalizados): instala ComfyUI y el servidor local, luego apunta tu cliente hacia él. Tu agente puede hacer la mayor parte de esto por ti.

Solo pídele a tu agente. Con ambas conexiones agregadas, di dónde quieres que se ejecute un trabajo — "ejecuta este en Comfy Cloud", "haz esto localmente" — y usará la conexión correcta. No hay un modo que alternar ni nada que reconfigurar entre ejecuciones.

Si un flujo de trabajo resulta demasiado pesado para tu máquina, tu agente puede decírtelo y ofrecerte ejecutarlo en Comfy Cloud en su lugar. Y si solo tienes una conexión configurada, pídele que agregue la otra — consulta [Configurar la conexión en la nube](#set-up-the-cloud-connection) o la [Conexión MCP local de Comfy](#local-comfy-mcp-connection).

En la **conexión en la nube**, no hay nada que hacer — está alojada, por lo que siempre estás en la versión actual.

En la **conexión local**, pídele a tu agente que lo maneje. Después, **reinicia tu cliente** o inicia una nueva sesión: los servidores MCP se cargan cuando comienza una sesión, por lo que uno en ejecución sigue sirviendo la versión anterior hasta que lo hagas.

Solución de problemas

No. Los comandos de barra vienen en el plugin de Claude Code. Claude Desktop se conecta al mismo servidor MCP — las herramientas funcionan si preguntas en lenguaje natural o usas el selector de indicaciones — pero no soporta plugins de Claude Code ni comandos de barra. No hay un comando `/comfy` ni `/cloud`. Los comandos aparecen bajo uno de dos prefijos según cómo te conectes:

* **Plugin (recomendado):** `/comfy-cloud:generate-image`, `/comfy-cloud:generate-video`, … — escribe `/comfy-cloud:` para verlos todos.
* **Conexión directa (sin plugin):** `/mcp__comfy-cloud__generate-image`, … — escribe `/mcp__` para verlos.

De cualquier manera, puedes simplemente preguntar en lenguaje natural ("genera una imagen de …"). Las herramientas de MCP son invocadas por el modelo y no requieren un comando de barra.

En Claude Code, ejecuta `/mcp`, selecciona **comfy-cloud** y elige **Autenticar**. En Claude Desktop, vuelve a abrir el conector desde **Personalizar → Conectores** y activa el inicio de sesión.