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.org

Documentación

Comfy MCP

Conecta cualquier agente de IA a ComfyUI en las GPUs de Comfy Cloud o en tu propia máquina. Genera imágenes, vídeo, audio y 3D, busca modelos, nodos y plantillas, y ejecuta flujos de trabajo reales.

**Beta pública.** Comfy MCP está en beta pública. Las APIs, herramientas y el comportamiento pueden cambiar mientras iteramos. Consulta [Comentarios](#feedback) para informar de problemas o compartir sugerencias.

Resumen

Comfy MCP conecta agentes de IA a ComfyUI mediante el Protocolo de Contexto de Modelo. Una vez conectado, puedes generar imágenes, vídeo, 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, y la local es completamente de código abierto.

**¿Atascado en algo de abajo? La mejor forma es pasar esta página a tu agente y pedirle ayuda.**

¿Qué conexión quiero?

Para usuarios nuevos, recomendamos empezar 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 desplegado, o si trabajas principalmente con un agente de codificación como Claude Code, Cursor o Codex, empieza con la conexión local.

**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 ambos a la vez 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 de 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 GPUs de Comfy Cloud. Para obtener más información sobre Comfy Cloud, consulta Comfy Cloud.

Configurar la conexión en la nube

Necesitas una cuenta de [Comfy Cloud](https://cloud.comfy.org) antes de conectar. [Regístrate](https://cloud.comfy.org) si aún no tienes una; los nuevos usuarios reciben **5 ejecuciones gratuitas** para probarla. 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 añade 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 **Añadir 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. Introduce un nombre como **Comfy Cloud MCP** en el campo **Nombre** (etiquetado como **5**).
    2. Establece la **URL del servidor MCP remoto** en `https://cloud.comfy.org/mcp` (etiquetado como **6**).
    3. Haz clic en **Añadir** (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. Ya 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**. Añade 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 de la comunidad 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 renuevan automáticamente.
  </Step>
</Steps>

El plugin añade estos comandos de barra:

| Comando                          | Qué hace                                                        |
| -------------------------------- | ------------------------------------------------------------------- |
| `/comfy-cloud:generate-image`    | Generar, editar o modificar una imagen                                  |
| `/comfy-cloud:generate-video`    | Generar, editar o ampliar un vídeo                                   |
| `/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`     | Ampliar una imagen a mayor resolución                               |
| `/comfy-cloud:search-templates`  | Encontrar plantillas de flujo de trabajo predefinidas 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 lo que puedes hacer con ComfyUI Cloud                              |

<Accordion title="Prefer just the connection, without the plugin?">
  Añade 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**. Añade `-s user` para que esté disponible en todos tus proyectos.

  Esta vía sigue exponiendo los mismos flujos de trabajo que los avisos 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 de `/comfy-cloud:*`.
</Accordion>

Cursor se conecta a servidores MCP remotos a través de HTTP. Cursor **no** admite OAuth de MCP hoy en día. Añade 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**) → **Añadir 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) (empieza 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 en el 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">
    Pide en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de vídeo 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 HTTP Streamable. Añade 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**) en *Registrado con clave de API*.
    2. Haz clic en **Configuración** (etiquetado como **2**) para abrir el panel de configuración completo.

               <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 **+ Añadir servidor** (etiquetado como **4**) para añadir 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 **HTTP Streamable** como tipo de conexión.
    2. Introduce un nombre como **Comfy Cloud MCP** en el campo **Nombre** (etiquetado como **5**).
    3. Introduce 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 terminar de iniciar sesión. Ya 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>

Pide en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de vídeo 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 haya navegador disponible, añade 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) (empieza con `comfyui-`) y luego añádela 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 en el 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 impulsa 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 completa el flujo como indique la CLI (puede pedirte que vuelvas a ejecutar con un valor de `--code`). Verifica con `openclaw mcp status --verbose`.

    <Note>
      Cuando `auth: "oauth"` esté establecido, OpenClaw ignora el `headers` estático en esa entrada del servidor. No combines OAuth con un encabezado de clave de API codificado.
    </Note>
  </Step>

  <Step title="Start generating">
    Pide en lenguaje natural ("genera una imagen de un astronauta gato", "encuentra una plantilla de vídeo 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) (empieza 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` en lugar de un encabezado `X-API-Key` personalizado para OpenClaw. Algunas versiones de OpenClaw eliminan encabezados personalizados en transportes streamable-http; Bearer sobrevive a los proxies de forma más fiable. Pon `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">
    Añade 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>

Si tu cliente admite MCP OAuth, inicia sesión a través del navegador cuando se te solicite. De lo contrario, añade un encabezado de clave API (ver más abajo).

  <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 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 el 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ías a Git.

Lo que tu agente puede hacer

Tú no llamas a las herramientas MCP directamente. Tu agente elige la herramienta adecuada según lo que pidas. Los comandos de barra y los prompts (más abajo) son atajos que orientan al agente hacia tareas comunes, pero el lenguaje natural también funciona ("genera una imagen de un astronauta gato", "mejora 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 flujo de trabajo personalizado (con upload_file cuando se necesite 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 coincidir con plantillas preconstruidas antes de construir un flujo de trabajo desde cero, lo que tiende a producir mejores resultados más rápido.

Herramientas de 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 flujo de trabajo preconstruidas de comfy.org por texto, etiqueta, tipo de medio o modelo
`get_template`	Obtén el JSON completo del flujo de trabajo de una plantilla para inspeccionarlo o editarlo manualmente
`get_template_schema`	Ve 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 subgrafo (grupos de nodos preconfigurados como Texto a Imagen o Eliminar Fondo)
`get_node`	Obtén la especificación completa de entrada para nodos específicos, incluyendo listas de opciones completas
`cql`	Ejecuta una consulta de grafo CQL para preguntas estructurales (por ejemplo, qué nodos producen imágenes, o rutas entre tipos de nodo). Usa `search_nodes` cuando necesites especificaciones de entrada completas para un nodo específico
`get_prompting_guide`	Estilo de prompt y configuraciones recomendadas (pasos, cfg, muestreador, resolución) por familia de modelos

Generación

Herramienta	Descripción
`run_template`	Ejecuta una plantilla preconstruida por nombre, con sobrescrituras opcionales de parámetros — la vía preferida cuando una plantilla coincide
`submit_workflow`	Envía un flujo de trabajo en formato API de ComfyUI para ejecutarlo 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 flujos de trabajo (por ejemplo, con LoadImage)
`apply_slots`	Aplica sobrescrituras de parámetros a los valores internos de un flujo de trabajo y devuelve el flujo modificado

Trabajos y lotes

Herramienta	Descripción
`get_job_status`	Consulta el estado de ejecución de un flujo de trabajo 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 flujo de trabajo completado
`use_previous_output`	Encadena flujos de trabajo 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 recupéralas juntas más tarde — el ID del lote permanece válido entre sesiones

Flujos de trabajo guardados

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

Compartir flujos de trabajo

Herramienta	Descripción
`share_workflow`	Publica un flujo guardado y devuelve una URL de `?share=<id>` que cualquiera puede abrir
`import_shared_workflow`	Resuelve una URL de uso compartido o un ID de uso compartido en el JSON del flujo, y opcionalmente lo guarda en tu cuenta

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

Apps y enlaces

Herramienta	Descripción
`create_app`	Convierte un flujo guardado en una app de Modo App — una vista simplificada de "ejecutar este flujo" con entradas y salidas elegidas
`get_app_mode_url`	Obtén el enlace estable que abre un flujo como una app ejecutable
`get_workflow_canvas_url`	Obtén un enlace que abre un flujo 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, tu nivel de suscripción y el enlace de facturación
`get_server_info`	Confirma qué servidor alcanzó el agente: entorno, host, versión y estado de autenticación
`submit_feedback`	Obtén el enlace de la encuesta de comentarios beta
`report_session_summary`	Comparte un resumen de sesión anónimo 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 flujos:

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 flujo de trabajo preconstruidas
`search-models`	Busca modelos (checkpoints, LoRAs, VAEs)
`search-nodes`	Busca nodos y obtén sugerencias de conexión
`help`	Descubre qué 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 breve período).
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.

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

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:

Flujos de trabajo

Los archivos generados mediante submit_workflow pueden no incluir metadatos del flujo de trabajo. Es posible que no reabran el flujo de trabajo original al abrirlos en ComfyUI.
La construcción de flujos de trabajo depende de la precisión del agente. Los flujos de trabajo complejos de varios 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 en su lugar. Está planificado un flujo OAuth de código de dispositivo para clientes que no pueden abrir un navegador.

Conexión local de 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 en la nube y de socios, se comunica con el ComfyUI que se ejecuta en tu propia máquina, por lo que puede ejecutar tus flujos de trabajo e inspeccionar los nodos, nodos personalizados y modelos que tu instalación realmente tiene.

**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 (un checkout 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. (¿Trabajando en el propio servidor? Usa pip install -e . desde un checkout del repositorio en su lugar.)

**`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 a continuación 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` (Settings → Developer → Edit Config; en macOS se encuentra en `~/Library/Application Support/Claude/claude_desktop_config.json`), añade 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 solo comando registra el servidor:

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

O inclúyelo 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" }
    }
  }
}
```

Añade 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 / 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."

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

Herramientas

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

Tool	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` lo 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 terminado 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 modelo en disco.
`validate_workflow`	Verifica 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), que es el diferenciador local frente a la conexión en la nube. Consulta el repositorio para ver la lista completa de herramientas y la referencia.

Recursos relacionados

Recurso	Para qué sirve
Comfy Skills	Mercado de plugins de Claude Code y biblioteca comunitaria de skills. El plugin comfy-cloud utilizado arriba se distribuye aquí; explora o contribuye con skills adicionales para flujos de trabajo de Comfy.
Comfy Cloud on ClawHub	Skill 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/iniciar 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.
Share a workflow on Comfy Cloud	Comparte flujos de trabajo desde la interfaz de Comfy Cloud (la herramienta MCP `share_workflow` hace esto desde una sesión de agente).

Relacionado: Agente integrado de Comfy

¿Quieres la experiencia de agente dentro de Comfy Cloud (chat que construye y edita tu grafo), no un cliente MCP externo?

Alfa privada en Comfy Cloud. Únete a la lista de espera para solicitar acceso.

Comentarios

Comfy MCP está en beta pública. Pruébalo 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 iniciar 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 inicia el comando `comfy-mcp` directamente y se comunica con él a través de stdio.

Sí. Esa es la [Conexión local de Comfy MCP](#local-comfy-mcp-connection). Controla 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 problema, y tu agente los mantiene diferenciados. 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.

Pregunta a tu agente. Lee tu hardware antes de iniciar cualquier tarea pesada.

En una **Mac**, usa la conexión en la nube para generar: los modelos de pesos abiertos actuales son demasiado grandes para ejecutarse a una velocidad aceptable 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 el 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.

La conexión en la nube está en **beta pública**. Las API, herramientas y el comportamiento pueden cambiar mientras iteramos. La conexión local está disponible para instalaciones locales de ComfyUI. Consulta [Comentarios](#feedback) para informar problemas.

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 admiten OAuth, incluidos Claude Code, Claude Desktop, Codex y OpenClaw.

**Cursor** requiere una clave de API de Comfy Cloud en tu configuración de MCP; todavía no hay OAuth de MCP allí. Las configuraciones headless y de CI sin navegador también la necesitan. 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 MCP tú mismo: tu agente las elige según lo que pides. Normalmente **descubre** lo que está disponible (`search_templates`, `search_models`, `search_nodes`), **ejecuta** una generación y luego **espera y recupera** el resultado. 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 ejecutará 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 terminado a cualquier ubicación que indiques.

No hay nada que deshacer: agrega la segunda conexión junto a la primera.

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

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

Solo pregunta a tu agente. Con ambas conexiones agregadas, indica dónde quieres que se ejecute un trabajo — "ejecuta este en Comfy Cloud", "haz esto localmente" — y usará la conexión correcta. No hay 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 configurada una conexión, pídele que agregue la otra — consulta [Configurar la conexión en la nube](#set-up-the-cloud-connection) o la [Conexión local de Comfy MCP](#local-comfy-mcp-connection).

En la **conexión en la nube**, no hay nada que hacer: está alojada, así que siempre estás en la versión actual.

En la **conexión local**, pide 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 seguirá sirviendo la versión anterior hasta que lo hagas.

Solución de problemas

No. Los comandos de barra se incluyen 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 prompts — pero no admite plugins de Claude Code ni comandos de barra. No existe el comando `/comfy` ni `/cloud`. Los comandos aparecen bajo uno de dos prefijos según cómo te hayas conectado:

* **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 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.