> ## Documentation Index
> Fetch the complete documentation index at: https://docs.comfy.org/llms.txt
> Use this file to discover all available pages before exploring further.
# Comfy MCP: conecta agentes de IA con ComfyUI
> Conecta agentes de IA con ComfyUI mediante Model Context Protocol y genera imágenes, video, audio y 3D, o ejecuta flujos de trabajo en Comfy Cloud o tu equipo.
## Descripción general
**Comfy MCP** conecta agentes de IA con ComfyUI a través del [Model Context Protocol](https://modelcontextprotocol.io). 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**, y la local es totalmente de código abierto.
> [!TIP]
>
> **¿Tienes dudas con algo de lo que aparece a continuación? La mejor forma es darle esta página a tu agente y pedirle ayuda.**
### ¿Qué conexión quiero?
**Si eres nuevo, te recomendamos empezar con la conexión en la nube**, ya que es la configuración más sencilla. Si usas claude.ai, ChatGPT o la aplicación de chat Claude Desktop, la conexión en la nube también es la opción más compatible.
**Si ya ejecutas ComfyUI de forma local o en tu propio entorno desplegado, o si trabajas sobre todo en un agente de programación** como Claude Code, Cursor o Codex, empieza con la conexión **local**.
> [!NOTE]
>
> **Si usas Mac y planeas ejecutar modelos de código abierto, te recomendamos la conexión en la nube.** Los modelos abiertos de hoy, como las versiones locales de MiniMax H3, LTX-2.3 y similares, son grandes y no se ejecutarán a una velocidad utilizable en la GPU de Apple.
Ejecutar ambas a la vez es normal, y la mayoría de los clientes alojan dos servidores MCP sin problema. Inician sesión en la misma cuenta de Comfy, pero de forma **separada**: una sesión no cubre la otra.
## Conexión MCP de Comfy Cloud
La conexión alojada que vincula tu agente con tu cuenta de **Comfy Cloud**. No hay nada que instalar y los flujos de trabajo se ejecutan en las GPU en la nube de Comfy Cloud. Para obtener más información sobre Comfy Cloud, consulta [Comfy Cloud](https://docs.comfy.org/es/get_started/cloud.md).
### Configurar la conexión a la nube
> [!NOTE]
>
> Necesitas una cuenta de [Comfy Cloud](https://cloud.comfy.org) antes de conectarte. [Regístrate](https://cloud.comfy.org) si aún no tienes una; los usuarios nuevos obtienen **5 ejecuciones gratis** para probarlo. El inicio de sesión OAuth durante la configuración usa tu cuenta de Comfy.
Comfy Cloud MCP se ejecuta en:
```
https://cloud.comfy.org/mcp
```
Elige tu cliente:
**Claude Desktop**
Claude Desktop agrega Comfy Cloud como un **custom connector** a través de su interfaz y luego ejecuta el inicio de sesión OAuth.
**1. Abrir Personalizar**
En la barra lateral, haz clic en **Customize** (marcado con **1**).
**2. Abrir Connectors**
Haz clic en **Connectors** (marcado con **2**).
**3. Agregar un conector personalizado**
1. Haz clic en el botón **+** (marcado con **3**) en el encabezado de Connectors.
2. Elige **Add custom connector** (marcado con **4**).
**4. Introducir los datos del servidor**
1. Escribe un nombre como **Comfy Cloud MCP** en el campo **Name** (marcado con **5**).
2. Define **Remote MCP server URL** como `https://cloud.comfy.org/mcp` (marcado con **6**).
3. Haz clic en **Add** (marcado con **7**).
**5. Iniciar sesión**
1. Cuando se abra el navegador, elige tu espacio de trabajo (por ejemplo, **Personal Workspace**).
2. Haz clic en **Continue** para autorizar el conector. Ya estás conectado.
**Claude Code**
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 de la comunidad para Comfy.
**1. Agregar el marketplace**
Registra el marketplace Comfy Skills (una sola vez):
```
/plugin marketplace add Comfy-Org/comfy-skills
```
**2. Instalar el plugin**
```
/plugin install comfy-cloud@comfy-skills
```
**3. Iniciar sesión**
Ejecuta `/mcp`, selecciona **comfy-cloud** → **Authenticate**. Tu navegador se abre para iniciar sesión y los tokens se actualizan automáticamente.
El plugin agrega estos comandos de barra:
| Comando | Qué hace |
| - | - |
| `/comfy-cloud:generate-image` | Genera, edita o modifica una imagen |
| `/comfy-cloud:generate-video` | Genera, edita o extiende un video |
| `/comfy-cloud:generate-audio` | Genera audio, música o efectos de sonido |
| `/comfy-cloud:generate-3d` | Genera un modelo 3D a partir de texto o de una imagen |
| `/comfy-cloud:remove-background` | Elimina el fondo de una imagen |
| `/comfy-cloud:upscale-image` | Aumenta la resolución de una imagen |
| `/comfy-cloud:search-templates` | Busca plantillas de flujos de trabajo prediseñadas en [comfy.org](https://comfy.org) |
| `/comfy-cloud:search-models` | Busca los modelos disponibles |
| `/comfy-cloud:search-nodes` | Busca nodos y obtén sugerencias de conexión |
| `/comfy-cloud:help` | Descubre lo que puedes hacer con ComfyUI Cloud |
> **¿Prefieres solo la conexión, sin el 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** → **Authenticate**. Agrega `-s user` para que esté disponible en todos tus proyectos.
>
> Esta vía tambié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____` 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:*`.
**Cursor**
Cursor se conecta a servidores MCP remotos por HTTP. Hoy Cursor **no** admite OAuth de MCP. Agrega Comfy Cloud con una clave API de Comfy Cloud en tu configuración de MCP.
**1. Abrir Configuraciones de Cursor**
Haz clic en el engranaje de **Settings** en la esquina superior derecha (marcado con **1**).
**2. Abrir Tools & MCP**
1. En la barra lateral, haz clic en **Tools & MCPs** (marcado con **2**).
2. Haz clic en **+ New MCP Server** (marcado con **3**) → **Add a Custom MCP Server**.
**3. Agregar tu clave API**
Edita `~/.cursor/mcp.json` (global) o `.cursor/mcp.json` (del proyecto). Configura la URL del servidor y pasa tu clave 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}"
}
}
}
}
```
Configura `COMFY_API_KEY` en tu shell o en el entorno del sistema. Prefiere `${env:COMFY_API_KEY}` antes que escribir la clave directamente en un archivo que podrías confirmar en Git.
**4. Comenzar a generar**
Pregunta en lenguaje natural (“genera una imagen de un astronauta gato”, “busca una plantilla de video de Wan 2.2”). Cursor invoca las herramientas MCP por ti.
**Codex**
[Codex](https://developers.openai.com/codex/cli) se conecta a Comfy Cloud mediante Streamable HTTP. Agrega el servidor en Settings y luego inicia sesión con OAuth.
**1. Abrir el panel de configuración**
1. Haz clic en **Settings** (etiquetado como **1**) debajo de *Logged in with API key*.
2. Haz clic en **Settings** (etiquetado como **2**) para abrir el panel completo de configuración.
**2. Abrir la configuración del servidor MCP**
1. Haz clic en **MCP servers** (etiquetado como **3**) en la lista de configuración.
2. Haz clic en **+ Add server** (etiquetado como **4**) para agregar un nuevo servidor MCP.
**3. Conectarse a Comfy Cloud**
1. Elige **Streamable HTTP** como tipo de conexión.
2. Escribe un nombre como **Comfy Cloud MCP** en el campo **Name** (etiquetado como **5**).
3. Escribe la URL `https://cloud.comfy.org/mcp` en el campo **URL** (etiquetado como **6**).
4. Haz clic en **Save** (etiquetado como **7**).
**4. Autenticarse**
1. Haz clic en **Authenticate** (etiquetado como **8**) en la entrada del servidor guardada.
2. En la ventana emergente del navegador, elige tu espacio de trabajo y haz clic en **Continue** para finalizar el inicio de sesión. Ya estás conectado.
Pídelo en lenguaje natural ("genera una imagen de un gato astronauta", "encuentra una plantilla de video Wan 2.2"). Codex invoca las herramientas MCP en tu nombre.
> **¿Prefieres la CLI?**
>
> Registra 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).
> **Clave API en lugar de OAuth (sin interfaz gráfica o CI)**
>
> Cuando no haya un navegador disponible, agrega el servidor con un encabezado tomado 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 agrégala en `~/.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" }
> ```
>
> Configura `COMFY_API_KEY` en tu shell o en el entorno del sistema. No incluyas la clave en el control de versiones.
> **Codex te pide iniciar sesión nuevamente una y otra vez (invalid\_grant o reutilización del token de actualización)**
>
> **Síntoma:** Codex cierra tu sesión de Comfy Cloud y te pide volver a autenticarte una y otra vez, a veces cada pocos minutos. Los avisos o registros de Codex pueden mencionar `invalid_grant`, un token de actualización que ya se usó o se revocó, o un error al actualizar el token de OAuth.
>
> **Causa:** Esto proviene de cómo Codex almacena y actualiza las credenciales OAuth de MCP, no de Comfy Cloud. Cuando varios procesos de Codex (sesiones TUI, el servidor de la aplicación, comandos `codex mcp`) comparten un servidor OAuth, un proceso puede actualizar con un token que otro ya rotó. El servidor de autorización lo interpreta como reutilización de tokens y finaliza la sesión. Los usuarios de otros servidores MCP con OAuth reportan el mismo comportamiento. Estos problemas están abiertos en el repositorio de Codex, así que puedes consultar su estado actual:
>
> * [openai/codex#46028](https://github.com/openai/codex/issues/46028): los clientes de larga duración reutilizan tokens de actualización rotados
> * [openai/codex#48507](https://github.com/openai/codex/issues/48507): los procesos concurrentes compiten en la rotación del token de actualización y el siguiente arranque da `invalid_grant`
> * [openai/codex#41133](https://github.com/openai/codex/issues/41133): el apagado puede perder un token de actualización rotado
> * [openai/codex#17265](https://github.com/openai/codex/issues/17265): Codex no actualiza los tokens OAuth de MCP almacenados
>
> **Solución alternativa 1: activa la marca de coordinación de actualizaciones de Codex.** Codex tiene una marca de función, `mcp_oauth_refresh_coordination`, que coordina las actualizaciones de tokens OAuth entre procesos de Codex. Es una configuración de Codex, no de Comfy. Codex la indica como en desarrollo y desactivada de forma predeterminada, y ni Codex ni Comfy la admiten como solución oficial. En openai/codex#46028, activarla detuvo la reutilización de tokens obsoletos en la prueba de quien reportó el problema. Si tu versión de Codex aún la tiene desactivada, agrégala a `~/.codex/config.toml`:
>
> ```toml theme={null}
> [features]
> mcp_oauth_refresh_coordination = true
> ```
>
> Cierra y reinicia todas las sesiones de Codex en ejecución para que todas apliquen la marca. Si Codex ya muestra **comfy-cloud** como sesión cerrada, inicia sesión una vez más (`codex mcp login comfy-cloud`, o **Authenticate** en Settings). Si una versión posterior de Codex la activa de forma predeterminada o elimina la marca, puedes saltarte este paso.
>
> **Solución alternativa 2: mantén un solo proceso de Codex actualizando cada servidor.** Si la marca no está disponible o no ayuda, mueve la entrada `[mcp_servers.comfy-cloud]` del archivo global `~/.codex/config.toml` a un `.codex/config.toml` en un proyecto de confianza, para que solo las sesiones de ese proyecto la carguen y la actualicen. Evita ejecutar muchas sesiones de Codex contra Comfy Cloud al mismo tiempo y cierra las sesiones de Codex antes de reiniciar tu computadora. Esta es la solución alternativa reportada en openai/codex#48507.
>
> Mover la entrada no detiene los procesos de Codex que ya cargaron la configuración global, y esos siguen actualizando la definición anterior del servidor. Después de moverla, cierra todas las sesiones de Codex en ejecución y detén el servidor de la aplicación de Codex; luego inicia Codex solo en el proyecto que contiene la entrada.
>
> Si no necesitas OAuth, la configuración de la Clave API anterior no usa tokens de actualización.
>
> Estos pasos reducen los cierres de sesión, pero es posible que no los detengan por completo. También estamos trabajando en cambios del lado de Comfy Cloud para reducir la frecuencia con la que ocurre esto.
**OpenClaw**
Instala la habilidad **Comfy Cloud** desde [ClawHub](https://clawhub.ai/comfy-org/skills/comfy). Conecta OpenClaw con el servidor MCP alojado (`cloud.comfy.org/mcp`). Solo Cloud: no controla una instalación local de ComfyUI.
**1. Instalar la habilidad**
```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).
**2. Conectar con OAuth (recomendado)**
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 (es posible que te pida volver a ejecutar con un valor `--code`). Verifica con `openclaw mcp status --verbose`.
> [!NOTE]
>
> Cuando se establece `auth: "oauth"`, OpenClaw ignora los `headers` estáticos en esa entrada del servidor. No combines OAuth con un encabezado de clave API escrito directamente en el código.
**3. Comenzar a generar**
Pregunta en lenguaje natural ("genera una imagen de un gato astronauta", "busca una plantilla de video de Wan 2.2"). OpenClaw invoca las herramientas MCP por ti.
> **Clave API en lugar de OAuth (sin interfaz gráfica o 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
> ```
>
> Para OpenClaw, prefiere `Authorization: Bearer` en lugar de un encabezado `X-API-Key` personalizado. Algunas compilaciones de OpenClaw descartan los encabezados personalizados en los transportes streamable-http; Bearer atraviesa los proxies de forma más fiable. Coloca `COMFY_API_KEY` en el perfil de tu shell o en el entorno de OpenClaw. No incluyas la clave en un commit.
**Otros clientes**
Cualquier cliente MCP que admita el transporte **HTTP remoto** puede conectarse a Comfy Cloud. La URL del servidor siempre es `https://cloud.comfy.org/mcp`.
**1. Agregar la URL del servidor**
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 estructura `mcpServers` en **Settings → MCP Servers** o en `~/.config/amp/settings.json`.
**2. Autenticar**
Si tu cliente admite MCP OAuth, inicia sesión a través del navegador cuando se te solicite. De lo contrario, agrega un encabezado de clave API (ver abajo).
**3. Reiniciar y verificar**
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**.
**Sin interfaz gráfica / 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 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 las claves directamente en archivos de configuración que confirmas en Git.
### Qué puede hacer tu agente
Tú no llamas a las herramientas MCP directamente. Tu agente elige la herramienta adecuada según lo que pidas. Los comandos de barra diagonal y las indicaciones (a continuación) son atajos que orientan al agente hacia tareas comunes, pero el lenguaje natural también funciona ("genera una imagen de un gato astronauta", "haz upscale de esta foto", "encuentra una plantilla de video Wan 2.2").
Flujo típico:
1. **Descubrir** lo que está disponible (`search_templates`, `search_models`, `search_nodes` o `cql` para preguntas de tipo gráfico).
2. **Ejecutar** una generación: `run_template` para una plantilla prediseñada compatible, `submit_workflow` para un flujo de trabajo 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.
3. **Esperar y recuperar** las salidas (`wait_for_job`, luego `get_output` devuelve un comando de descarga que tu agente ejecuta en tu shell).
El servidor prefiere las [plantillas prediseñadas](https://comfy.org/workflows) antes de construir un flujo de trabajo desde cero, lo que tiende a producir mejores resultados más rápido.
### Herramientas MCP de la nube
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](https://comfy.org/workflows) 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 a mano |
| `get_template_schema` | Consulta cuáles de los 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 preconectados como Text to Image o Remove Background) |
| `get_node` | Obtén la especificación completa de entrada de nodos específicos, incluidas las listas completas de opciones |
| `cql` | Ejecuta una consulta de grafo [CQL](https://github.com/Comfy-Org/cql) para preguntas estructurales (por ejemplo, qué nodos producen imágenes o las rutas entre tipos de nodos). Usa `search_nodes` cuando necesites las especificaciones completas de entrada de un nodo específico |
| `get_prompting_guide` | Estilo de prompt y configuraciones recomendadas (steps, cfg, sampler, resolución) por familia de modelos |
**Generación**
| Herramienta | Descripción |
| - | - |
| `run_template` | Ejecuta una plantilla preconstruida por nombre, con sobrescritura opcional de parámetros: la ruta preferida cuando una plantilla coincide |
| `submit_workflow` | Envía un flujo de trabajo en formato API de ComfyUI para su 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 un archivo de entrada para usarlo 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 de trabajo 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 a que un trabajo termine en lugar de consultar repetidamente |
| `get_output` | Obtén las imágenes, los videos o el 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` | Consulta cuántos trabajos están en ejecución y cuántos pendientes |
| `submit_batch`, `get_batch_status`, `get_batch_output`, `wait_for_batch` | Envía muchas generaciones en una sola llamada y recógelas después en conjunto: el ID del lote sigue siendo válido entre sesiones |
**Flujos de trabajo guardados**
| Herramienta | Descripción |
| - | - |
| `list_saved_workflows` | Explora tus flujos de trabajo guardados en Comfy Cloud |
| `get_saved_workflow` | Inspecciona los nodos, las entradas y las configuraciones personalizables de un flujo de trabajo guardado |
| `save_workflow` | Guarda un flujo de trabajo en tu cuenta de Comfy Cloud |
| `update_workflow` | Actualiza un flujo de trabajo existente en su lugar como una nueva versión (las versiones anteriores siguen siendo recuperables) |
| `run_saved_workflow` | Ejecuta un flujo de trabajo guardado por nombre de archivo: el servidor lo convierte automáticamente del formato del editor al formato ejecutable |
**Compartir flujos de trabajo**
| Herramienta | Descripción |
| - | - |
| `share_workflow` | Publica un flujo de trabajo guardado y devuelve una URL `?share=` que cualquiera puede abrir |
| `import_shared_workflow` | Convierte una URL para compartir o un ID para compartir aislado en el JSON del flujo de trabajo y, de forma opcional, lo guarda en tu cuenta |
**IDs para compartir de URL del hub:** el token hexadecimal final delimitado por guiones en una URL del hub `comfy.org/workflows/-` es el ID para compartir. Por ejemplo, `comfy.org/workflows/topaz-starlight-upscale-1c77e82713b7` tiene el ID para compartir `1c77e82713b7`. Pasa ese token a `import_shared_workflow` como `share_id`. El parámetro `share_url` solo acepta URL de consulta con `?share=` como `https://cloud.comfy.org/?share=...`, no URL de páginas del hub.
**Aplicaciones y enlaces**
| Herramienta | Descripción |
| - | - |
| `create_app` | Convierte un flujo de trabajo guardado en una app de modo aplicación: una vista simplificada de «ejecutar este flujo de trabajo» con las entradas y salidas que elijas |
| `get_app_mode_url` | Obtén el enlace estable que abre un flujo de trabajo como una app ejecutable |
| `get_workflow_canvas_url` | Obtén un enlace que abre un flujo de trabajo directamente en el lienzo de Comfy Cloud, listo para ver, editar o ejecutar |
**Cuenta y sesión**
| Herramienta | Descripción |
| - | - |
| `get_billing_status` | Consulta tu saldo de créditos, tu nivel de suscripción y el 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` | Obtén el enlace de la encuesta de retroalimentación |
| `report_session_summary` | Comparte un resumen anonimizado de la sesión con el equipo de Comfy, **solo con tu consentimiento explícito**; el agente debe preguntar primero y no se incluye ningún prompt, ruta de archivo ni información personal |
**Prompts (Claude Desktop)**
Claude Desktop no admite los comandos de barra de Claude Code. En su lugar, abre el **selector de prompts** para los mismos flujos de trabajo:
| 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 de una imagen |
| `generate-audio` | Genera audio, música o efectos de sonido |
| `generate-3d` | Genera un modelo 3D a partir de texto o de 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 igual.
### Créditos y gastos
La exploración es gratis: `search_templates`, `search_models` y `search_nodes` funcionan con solo una [cuenta de Comfy](https://cloud.comfy.org). Ejecutar generaciones requiere una suscripción activa a Comfy Cloud. Tener solo un saldo de créditos o de recarga no da 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 MCP en sí no escribe archivos en tu máquina. Cuando una generación termina, tu agente llama a `get_output`, que devuelve:
1. Una **URL de descarga firmada temporal** (válida durante una ventana breve).
2. 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 de archivo.
> [!WARNING]
>
> Ejecuta el comando devuelto **tal cual**. No vuelvas a codificar ni edites la URL firmada. La firma está en la cadena de consulta y se rompe si modificas la URL.
Si tu cliente MCP no puede ejecutar comandos de shell (algunas configuraciones solo con GUI), copia el comando y ejecútalo tú mismo en una terminal.
La subida y la descarga de recursos dependen del acceso a archivos del cliente. Si Claude Desktop u otro cliente de agente tiene problemas para manejar la subida o descarga de recursos, puede estar relacionado con el acceso del agente a tus directorios locales. Para usuarios de Claude recomendamos **Claude Code** (aplicación de escritorio o terminal), que tiene más capacidades. Del mismo modo, para otras familias de agentes, el agente de programación suele ser mejor que la versión de chat web.
### Limitaciones conocidas
Comfy Cloud MCP es una versión preliminar. Estas limitaciones son conocidas y se está trabajando en ellas:
**Flujos de trabajo**
* **Los recursos generados mediante `submit_workflow` pueden no incluir los metadatos del flujo de trabajo.** Es posible que no vuelvan a abrir el flujo de trabajo de origen cuando se abren en ComfyUI.
* **La creación de flujos de trabajo depende de la precisión del agente.** Los flujos de trabajo complejos con varios nodos pueden necesitar un reintento o un ajuste.
**Manejo de archivos**
* **Las salidas requieren un paso de descarga por shell.** Consulta [Subidas y descargas](#subidas-y-descargas).
* **Pueden aplicarse límites de tamaño de subida** según tu cliente MCP. Algunos clientes imponen sus propios límites a la subida de archivos.
**Autenticación**
* **OAuth o clave API.** Claude Code y Claude Desktop usan un flujo OAuth de una sola vez en el navegador. **Cursor** requiere una clave API de Comfy Cloud en tu configuración de MCP (sin OAuth). Otros clientes sin interfaz gráfica pueden pasar una clave API de Comfy Cloud mediante el encabezado `X-API-Key` en su lugar. Está previsto un flujo OAuth con código de dispositivo para los clientes que no pueden abrir un navegador.
## Conexión local a Comfy MCP
La conexión de código abierto: tu cliente lanza el servidor en tu máquina y este controla el ComfyUI instalado allí.
[**comfy-mcp**](https://github.com/Comfy-Org/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**, así que puede ejecutar tus flujos de trabajo e inspeccionar los nodos, nodos personalizados y modelos que tu instalación realmente tiene.
> [!TIP]
>
> **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](https://github.com/Comfy-Org/comfy-cli)** en tu `PATH` (`pip install "comfy-cli>=1.14.0"`): el motor sobre el que se apoya cada herramienta
* **Un espacio de trabajo de ComfyUI**: crea uno con `comfy install` si no tienes ninguno (un checkout existente funciona con `comfy set-default `)
* **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 de forma implícita.
***
### Instalación
Desde [PyPI](https://pypi.org/project/comfy-mcp/):
```bash theme={null}
pip install comfy-mcp
```
Esto coloca un script de consola `comfy-mcp` en tu `PATH`: ese comando es el servidor MCP (habla MCP por stdio). Apunta tu cliente de IA hacia él a continuación. (¿Vas a modificar el servidor? Ejecuta `pip install -e .` desde un checkout del [repositorio](https://github.com/Comfy-Org/comfy-mcp) en su lugar.)
> [!NOTE]
>
> **`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` está en un virtualenv o en una ubicación no estándar, define `COMFY_BIN` con su ruta absoluta (por ejemplo `/path/to/venv/bin/comfy`). Todos los ejemplos de cliente a continuación muestran 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 por stdio: ejecutan el comando `comfy-mcp` como servidor. Elige tu cliente:
**Claude Desktop**
Edita `claude_desktop_config.json` (Settings → Developer → Edit 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" }
}
}
}
```
**Claude Code**
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 regístralo 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" }
}
}
}
```
**Cursor**
Agrega el servidor a `~/.cursor/mcp.json` (global) o a `.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:
**1. Instala los componentes**
```bash theme={null}
pip install "comfy-cli>=1.14.0" # el motor
comfy install # crea un espacio de trabajo de ComfyUI (omítelo si ya tienes uno)
pip install comfy-mcp # este servidor MCP → el comando `comfy-mcp`
```
**2. Inicia ComfyUI y déjalo en ejecución**
```bash theme={null}
comfy launch
```
**3. Agrega el servidor a tu cliente**
Usa el fragmento correspondiente a tu cliente que aparece arriba y luego reinícialo o recárgalo para que aparezcan las herramientas.
**4. Pide a tu agente que ejecute un flujo de trabajo**
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 corresponde con un comando de `comfy-cli`, ejecutado con `--where local`. Lo más destacado:
| Herramienta | Propósito |
| - | - |
| `server_info()` | Si hay un ComfyUI local en ejecución, dónde está y con qué espacio de trabajo. **Llámala primero.** |
| `run_workflow(workflow_path, wait=True)` | Ejecuta un flujo de trabajo JSON; `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 finalizado en `out_dir`. |
| `launch_comfyui` / `stop_comfyui` | Inicia o detiene el ComfyUI local. |
| `search_templates` / `fetch_template` | Busca una plantilla integrada y escribe su flujo de trabajo JSON ejecutable. |
| `search_nodes` / `get_node` / `list_nodes` | Inspecciona las clases de nodo en tu instalación **local activa** (incluidos los nodos personalizados). |
| `search_models` | Lista los archivos de modelo en el disco. |
| `validate_workflow` | Verifica previamente un flujo de trabajo contra el `object_info` activo antes de una ejecución lenta. |
La introspección de nodos y la búsqueda de modelos leen tu **instalación activa**, incluidos los nodos personalizados, que es lo que diferencia a la conexión local de la conexión en la nube. Consulta el [repositorio](https://github.com/Comfy-Org/comfy-mcp) para ver la lista completa de herramientas y la referencia.
***
## Recursos relacionados
| Recurso | Para qué sirve |
| - | - |
| [Comfy Skills](https://github.com/Comfy-Org/comfy-skills/) | Mercado de plugins de Claude Code y biblioteca de habilidades de la comunidad. El plugin **comfy-cloud** que se usó arriba se distribuye aquí; explora o contribuye con habilidades adicionales para flujos de trabajo de Comfy. |
| [Comfy Cloud en ClawHub](https://clawhub.ai/comfy-org/skills/comfy) | Habilidad de OpenClaw (`openclaw skills install @comfy-org/comfy`) para el servidor MCP de Comfy Cloud alojado. |
| [Comfy CLI](https://docs.comfy.org/es/agent-tools/cli.md) | Herramienta de línea de comandos para instalar e iniciar ComfyUI de forma local y para llamar nodos asociados alojados desde scripts o CI (`comfy generate`, en beta). Complementa a MCP cuando necesitas flujos de trabajo de terminal o de automatización. |
| [Compartir un flujo de trabajo en Comfy Cloud](https://docs.comfy.org/es/cloud/share-workflow.md) | 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 del agente **dentro de** ComfyUI, en lugar de un cliente MCP externo?
> **[Comfy Agent](https://docs.comfy.org/es/agent-tools/in-app-agent.md)**
>
> Asistente integrado de ComfyUI para crear, editar y ejecutar flujos de trabajo. **Disponible de forma general en Cloud.** La versión local (Comfy Desktop) estará disponible próximamente.
## Comentarios
Prueba Comfy MCP y cuéntanos qué funciona y qué no:
* **[Encuesta de comentarios](https://links.comfy.org/cloudmcpbeta)**: reporta errores, solicita funciones o comparte tus impresiones generales.
* **Discord**: [#comfy-mcp-and-cli](https://discord.gg/xWJn6nhE3R) en el Discord de Comfy para preguntas y conversación.
## FAQ
### Primeros pasos
> **¿Qué clientes son compatibles?**
>
> Cualquier cliente compatible con MCP.
>
> La **conexión en la nube** necesita soporte HTTP remoto. **Claude Code**, **Claude Desktop**, **Cursor**, **Codex** y **OpenClaw** tienen una configuración específica más arriba; **Windsurf**, **Amp** y otros usan la misma URL con OAuth o una clave 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.
> **¿Cuál es la URL del servidor?**
>
> La conexión en la nube funciona en `https://cloud.comfy.org/mcp`.
>
> La conexión local no tiene URL. Tu cliente ejecuta el comando `comfy-mcp` directamente y se comunica con él por stdio.
> **¿Puedo usarlo con mi ComfyUI local?**
>
> Sí. Esa es la [Conexión local de Comfy MCP](#conexión-local-a-comfy-mcp). Controla el ComfyUI instalado en tu propia máquina, así tu agente ve los modelos, los LoRA y los nodos personalizados que realmente tienes, y se ejecuta en tu GPU.
> **¿Puedo conectar la nube y la conexión local al mismo tiempo?**
>
> Sí, y te lo recomendamos si ejecutas ComfyUI de forma local. La mayoría de los clientes alojan dos servidores MCP sin problema y tu agente los distingue. Cada conexión ejecuta sus propios flujos de trabajo y devuelve sus propios resultados.
>
> Sin embargo, los dos inicios de sesión son **independientes**. Iniciar sesión en una no te inicia sesión en la otra, aunque sea la misma cuenta de Comfy.
> **¿Cómo sé si mi máquina puede ejecutar la conexión local?**
>
> Pregúntale a tu agente. Lee tu hardware antes de iniciar algo pesado.
>
> En una **Mac**, usa la conexión en la nube para generar: los modelos de pesos abiertos de hoy son demasiado grandes para ejecutarse a una velocidad aceptable en la GPU de Apple. En un **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 alcanza para imágenes, pero el video será lento o no cabrá; con menos de 8 GB, usa la nube.
> **¿Está disponible de forma general?**
>
> Sí. La conexión en la nube está disponible de forma general y la conexión local está disponible para instalaciones locales de ComfyUI. Consulta [Retroalimentación](#comentarios) para reportar problemas o compartir sugerencias.
### Costo y acceso
> **¿Tiene algún costo?**
>
> La exploración es gratis 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 de Comfy Cloud; los usuarios nuevos obtienen 5 ejecuciones gratis. En la **conexión local**, las ejecuciones son gratis porque ocurren en tu hardware, con una excepción: los modelos de socios se ejecutan en la infraestructura de los socios y consumen créditos.
> **¿Necesito una clave API?**
>
> No en los clientes interactivos que admiten OAuth, incluidos Claude Code, Claude Desktop, Codex y OpenClaw.
>
> **Cursor** requiere una clave API de Comfy Cloud en tu configuración de MCP; allí todavía no hay OAuth de MCP. 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](#configurar-la-conexión-a-la-nube).
### Uso
> **¿Qué puede hacer mi agente una vez conectado?**
>
> Tú no llamas a las herramientas de MCP por tu cuenta: tu agente las elige según lo que le pidas. Por lo general **descubre** lo que hay disponible (`search_templates`, `search_models`, `search_nodes`), **ejecuta** una generación y luego **espera y recupera** la salida. Consulta [Qué puede hacer tu agente](#qué-puede-hacer-tu-agente).
> **¿A dónde van mis salidas?**
>
> 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](#subidas-y-descargas).
>
> 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 una tarea finalizada a donde tú indiques.
> **Empecé con una conexión y ahora necesito la otra. ¿Qué hago?**
>
> No hay nada que deshacer: agrega la segunda conexión además de la primera.
>
> Para pasar de **local → nube** (necesitas GPU 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.
>
> Para pasar de **nube → local** (quieres tus propios modelos y Nodos personalizados): instala ComfyUI y el servidor local, luego apunta tu cliente a él. Tu agente puede hacer casi todo esto por ti.
> **¿Cómo cambio entre la conexión local y la de nube?**
>
> Solo pregúntale a tu agente. Con ambas conexiones agregadas, indica dónde quieres que se ejecute una tarea ("ejecuta esta en Comfy Cloud", "haz esta en local") y usará la conexión correcta. No hay ningún modo que alternar ni nada que reconfigurar entre ejecuciones.
>
> Si un flujo de trabajo resulta demasiado pesado para tu máquina, tu agente puede avisarte y ofrecerte ejecutarlo en Comfy Cloud. Y si solo tienes una conexión configurada, pídele que agregue la otra: consulta [Configurar la conexión en la nube](#configurar-la-conexión-a-la-nube) o la [Conexión local de Comfy MCP](#conexión-local-a-comfy-mcp).
> **¿Cómo actualizo Comfy MCP?**
>
> En la **conexión en la nube**, no hay nada que hacer: está alojada, así que siempre tienes la versión actual.
>
> En la **conexión local**, pide a tu agente que se encargue. Después, **reinicia tu cliente** o inicia una sesión nueva: los servidores MCP se cargan al iniciar una sesión, así que uno en ejecución sigue sirviendo la versión anterior hasta que lo hagas.
### Solución de problemas
> **¿Los comandos de barra funcionan en Claude Desktop?**
>
> No. Los comandos de barra vienen incluidos 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 prompt picker), pero no admite plugins de Claude Code ni comandos de barra.
> **Escribí /comfy o /cloud y no apareció nada.**
>
> No existe ningún 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.
>
> En cualquier caso, puedes simplemente preguntar en lenguaje natural («genera una imagen de …»). Las herramientas MCP las invoca el modelo y no requieren un comando de barra.
> **El inicio de sesión no abrió un navegador.**
>
> En Claude Code, ejecuta `/mcp`, selecciona **comfy-cloud** y elige **Authenticate**. En Claude Desktop, vuelve a abrir el conector desde **Personalizar → Conectores** y activa el inicio de sesión.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.