Comfy Cloud MCP

Servidor MCP oficial do Comfy Cloud - gere imagens, vídeo, áudio e 3D, execute workflows do ComfyUI e pesquise modelos diretamente do Claude e outros agentes de IA

Ver em comfy.orgExperimente este MCPPatrocinado

Documentação

Comfy MCP: Conecte Agentes de IA ao ComfyUI

Conecte agentes de IA ao ComfyUI através do Model Context Protocol. Gere imagens, vídeo, áudio e 3D, e execute fluxos de trabalho reais no Comfy Cloud ou na sua própria máquina.

Informação

Beta pública. O Comfy MCP está em beta pública. APIs, ferramentas e comportamentos podem mudar enquanto iteramos. Veja Feedback para relatar problemas ou compartilhar sugestões.

Visão Geral

Comfy MCP conecta agentes de IA ao ComfyUI através do Model Context Protocol. Uma vez conectado, você pode gerar imagens, vídeo, áudio e 3D, pesquisar modelos, nós e templates, e executar fluxos de trabalho reais do ComfyUI a partir de um chat com seu agente.

Ele vem com duas conexões: uma conexão Comfy Cloud e uma conexão ComfyUI local, sendo a local totalmente open source.

Dica

Preso em algo abaixo? A melhor maneira é entregar esta página ao seu agente e pedir ajuda.

Qual conexão eu quero?

Para novos usuários, recomendamos começar com a conexão na nuvem — é a configuração mais simples. Se você usa claude.ai, ChatGPT ou o aplicativo de chat Claude Desktop, a conexão na nuvem também é a opção mais compatível.

Se você já executa o ComfyUI localmente ou em seu próprio ambiente implantado, ou trabalha principalmente em um agente de codificação como Claude Code, Cursor ou Codex, comece com a conexão local.

Informação

Para usuários de Mac, se você planeja executar modelos open-source, recomendamos a conexão na nuvem. Os modelos de peso aberto atuais — as versões locais do MiniMax H3, LTX-2.3 e similares — são grandes e não rodarão em velocidade utilizável na GPU da Apple.

Executar ambos ao mesmo tempo é normal, e a maioria dos clientes hospeda dois servidores MCP sem problemas. Eles fazem login na mesma conta Comfy, mas separadamente — um login não cobre o outro.

Conexão Comfy Cloud MCP

A conexão hospedada, ligando seu agente à sua conta Comfy Cloud. Nada para instalar, e os fluxos de trabalho rodam nas GPUs do Comfy Cloud. Para saber mais sobre o Comfy Cloud, veja Comfy Cloud.

Configurar a conexão na nuvem

Informação

Você precisa de uma conta Comfy Cloud antes de conectar. Cadastre-se se ainda não tiver uma; novos usuários ganham 5 execuções gratuitas para experimentar. O login OAuth durante a configuração usa sua conta Comfy.

O Comfy Cloud MCP roda em:

https://cloud.comfy.org/mcp

Escolha seu cliente:

O Claude Desktop adiciona o Comfy Cloud como um **conector personalizado** através de sua interface, e então executa o login 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">
    Na barra lateral, clique em **Personalizar** (rotulado 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">
    Clique em **Conectores** (rotulado 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. Clique no botão **+** (rotulado como **3**) no cabeçalho de Conectores.
    2. Escolha **Adicionar conector personalizado** (rotulado 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. Digite um nome como **Comfy Cloud MCP** no campo **Nome** (rotulado como **5**).
    2. Defina a **URL do servidor MCP remoto** como `https://cloud.comfy.org/mcp` (rotulado como **6**).
    3. Clique em **Adicionar** (rotulado 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. Quando o navegador abrir, escolha seu espaço de trabalho (por exemplo, **Espaço de Trabalho Pessoal**).
    2. Clique em **Continuar** para autorizar o conector. Você está 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>

Instale o plugin **comfy-cloud**. Ele adiciona a conexão MCP e comandos de barra em um único passo. O plugin é publicado através do repositório [Comfy Skills](https://github.com/Comfy-Org/comfy-skills/), que hospeda plugins do Claude Code e habilidades de agente da comunidade para o Comfy.

<Steps>
  <Step title="Add the marketplace">
    Registre o marketplace Comfy Skills (uma única 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">
    Execute `/mcp`, selecione **comfy-cloud** → **Autenticar**. Seu navegador abre para fazer login, e os tokens são renovados automaticamente.
  </Step>
</Steps>

O plugin adiciona estes comandos de barra:

| Comando | O que faz |
| - | - |
| `/comfy-cloud:generate-image` | Gerar, editar ou modificar uma imagem |
| `/comfy-cloud:generate-video` | Gerar, editar ou estender um vídeo |
| `/comfy-cloud:generate-audio` | Gerar áudio, música ou efeitos sonoros |
| `/comfy-cloud:generate-3d` | Gerar um modelo 3D a partir de texto ou imagem |
| `/comfy-cloud:remove-background` | Remover o fundo de uma imagem |
| `/comfy-cloud:upscale-image` | Aumentar a resolução de uma imagem |
| `/comfy-cloud:search-templates` | Encontrar templates de fluxo de trabalho prontos em [comfy.org](https://comfy.org) |
| `/comfy-cloud:search-models` | Pesquisar modelos disponíveis |
| `/comfy-cloud:search-nodes` | Pesquisar nós e obter sugestões de conexão |
| `/comfy-cloud:help` | Ver o que você pode fazer com o ComfyUI Cloud |

<Accordion title="Prefer just the connection, without the plugin?">
  Adicione o servidor diretamente:

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

  Em seguida, execute `/mcp`, selecione **comfy-cloud** → **Autenticar**. Adicione `-s user` para disponibilizá-lo em todos os seus projetos.

  Este caminho ainda expõe os mesmos fluxos de trabalho como prompts MCP: `/mcp__comfy-cloud__generate-image`, `/mcp__comfy-cloud__search-models` e assim por diante (o prefixo `/mcp__<name>__` usa o nome que você passou para `claude mcp add`). O plugin acima é recomendado porque os envolve como os comandos mais amigáveis `/comfy-cloud:*`.
</Accordion>

O Cursor conecta-se a servidores MCP remotos via HTTP. O Cursor **não** suporta OAuth MCP hoje. Adicione o Comfy Cloud com uma chave de API do Comfy Cloud na sua configuração MCP.

<Steps>
  <Step title="Open Cursor Settings">
    Clique no ícone de engrenagem **Configurações** no canto superior direito (rotulado 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. Na barra lateral, clique em **Ferramentas e MCPs** (rotulado como **2**).
    2. Clique em **+ Novo Servidor MCP** (rotulado como **3**) → **Adicionar um 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">
    Edite `~/.cursor/mcp.json` (global) ou `.cursor/mcp.json` (projeto). Defina a URL do servidor e passe sua chave de API do Comfy Cloud no cabeçalho `X-API-Key`. Crie uma chave em [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (começa com `comfyui-`):

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

    Defina `COMFY_API_KEY` no seu shell ou ambiente do sistema. Prefira `${env:COMFY_API_KEY}` em vez de codificar a chave em um arquivo que você possa enviar ao 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">
    Peça em linguagem natural ("gere uma imagem de um astronauta gato", "encontre um template de vídeo Wan 2.2"). O Cursor invoca as ferramentas MCP em seu nome.
  </Step>
</Steps>

O [Codex](https://developers.openai.com/codex/cli) conecta-se ao Comfy Cloud via Streamable HTTP. Adicione o servidor nas Configurações e faça login com 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. Clique em **Configurações** (rotulado como **1**) em *Conectado com chave de API*.
    2. Clique em **Configurações** (rotulado como **2**) para abrir o painel completo de configurações.

               <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. Clique em **Servidores MCP** (rotulado como **3**) na lista de configurações.
    2. Clique em **+ Adicionar servidor** (rotulado como **4**) para adicionar um novo 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. Escolha **Streamable HTTP** como o tipo de conexão.
    2. Digite um nome como **Comfy Cloud MCP** no campo **Nome** (rotulado como **5**).
    3. Digite a URL `https://cloud.comfy.org/mcp` no campo **URL** (rotulado como **6**).
    4. Clique em **Salvar** (rotulado 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. Clique em **Autenticar** (rotulado como **8**) na entrada do servidor salvo.

               <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. No pop-up do navegador, escolha seu espaço de trabalho e clique em **Continuar** para concluir o login. Você está 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>

Peça em linguagem natural ("gere uma imagem de um astronauta gato", "encontre um template de vídeo Wan 2.2"). O Codex invoca as ferramentas MCP em seu nome.

<Accordion title="Prefer the CLI instead?">
  Registre e faça login pelo terminal:

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

  Isso grava uma entrada em `~/.codex/config.toml` (ou `.codex/config.toml` em um projeto confiável).
</Accordion>

<Accordion title="API key instead of OAuth (headless or CI)">
  Quando não houver navegador disponível, adicione o servidor com um cabeçalho obtido de uma variável de ambiente. Crie uma chave em [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (começa com `comfyui-`) e adicione 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" }
  ```

  Defina `COMFY_API_KEY` no seu shell ou ambiente do sistema. Não envie a chave para o controle de versão.
</Accordion>

Instale a habilidade **Comfy Cloud** do [ClawHub](https://clawhub.ai/comfy-org/skills/comfy). Ela conecta o OpenClaw ao servidor MCP hospedado (`cloud.comfy.org/mcp`). Somente nuvem: não aciona uma instalação local do ComfyUI.

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

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

  <Step title="Connect with OAuth (recommended)">
    Registre o servidor MCP e faça login com sua conta 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 uma URL de autorização. Abra-a, faça login e conclua o fluxo conforme o CLI orientar (pode pedir para você executar novamente com um valor `--code`). Verifique com `openclaw mcp status --verbose`.

Nota

Quando auth: "oauth" está definido, o OpenClaw ignora headers estático nessa entrada de servidor. Não combine OAuth com um cabeçalho de chave de API codificado.

  <Step title="Start generating">
    Peça em linguagem natural ("gere uma imagem de um astronauta gato", "encontre um template de vídeo Wan 2.2"). O OpenClaw invoca as ferramentas MCP em seu nome.
  </Step>
</Steps>

<Accordion title="API key instead of OAuth (headless or CI)">
  Crie uma chave em [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) (começa com `comfyui-`), exporte-a e registre o 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
  ```

  Prefira `Authorization: Bearer` em vez de um cabeçalho `X-API-Key` personalizado para o OpenClaw. Algumas versões do OpenClaw descartam cabeçalhos personalizados em transportes streamable-http; o Bearer sobrevive a proxies de forma mais confiável. Coloque `COMFY_API_KEY` no seu perfil de shell ou no ambiente do OpenClaw. Não envie a chave.
</Accordion>

Qualquer cliente MCP que suporte transporte **HTTP remoto** pode conectar-se ao Comfy Cloud. A URL do servidor é sempre `https://cloud.comfy.org/mcp`.

<Steps>
  <Step title="Add the server URL">
    Adicione uma entrada MCP remota apontando para `https://cloud.comfy.org/mcp`. A maioria dos clientes usa uma configuração JSON com um campo `url`:

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

    **Windsurf** usa `serverUrl` em vez de `url`. **Amp** usa a mesma forma `mcpServers` em **Configurações → Servidores MCP** ou `~/.config/amp/settings.json`.
  </Step>

  <Step title="Authenticate">
    Se seu cliente suporta OAuth MCP, faça login pelo navegador quando solicitado. Caso contrário, adicione um cabeçalho de chave de API (veja abaixo).
  </Step>

  <Step title="Restart and verify">
    Reinicie seu cliente. Você deve ver as ferramentas do Comfy Cloud (`search_templates`, `submit_workflow`, `get_output` e outras) registradas sob o servidor **comfy-cloud**.
  </Step>
</Steps>

**Headless / CI (chave de API):** quando o OAuth não estiver disponível, crie uma chave em [platform.comfy.org/profile/api-keys](https://platform.comfy.org/profile/api-keys) e passe-a como cabeçalho `X-API-Key`:

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

Para Claude Code pelo terminal:

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

Prefer ${env:COMFY_API_KEY} ou a interpolação de segredos do seu cliente em vez de codificar chaves em arquivos de configuração que você envia para o Git.

O que seu agente pode fazer

Você não chama as ferramentas MCP diretamente. Seu agente escolhe a ferramenta certa com base no que você pede. Comandos de barra e prompts (abaixo) são atalhos que orientam o agente para tarefas comuns, mas linguagem natural também funciona ("gere uma imagem de um astronauta gato", "aumente a resolução desta foto", "encontre um modelo de vídeo Wan 2.2").

Fluxo típico:

Descubra o que está disponível (search_templates, search_models, search_nodes ou cql para perguntas em formato de grafo).
Execute uma geração: run_template para um modelo pré-construído correspondente, submit_workflow para um workflow personalizado (com upload_file quando uma imagem de entrada for necessária) ou partner_generate para modelos de parceiros como Flux, Grok, Gemini, OpenAI, Ideogram e Seedance.
Aguarde e recupere as saídas (wait_for_job, e então get_output retorna um comando de download que seu agente executa no seu shell).

O servidor prefere corresponder a modelos pré-construídos antes de construir um workflow do zero, o que tende a produzir melhores resultados mais rapidamente.

Ferramentas Cloud MCP

Estas são as ferramentas às quais seu agente tem acesso após a conexão. Os nomes correspondem ao que aparece nos logs do cliente MCP e na saída de depuração.

Descoberta

Ferramenta	Descrição
`search_templates`	Pesquisar modelos de workflow pré-construídos do comfy.org por texto, tag, tipo de mídia ou modelo
`get_template`	Buscar o JSON completo do workflow de um modelo para inspeção ou edição manual
`get_template_schema`	Ver quais parâmetros de um modelo podem ser sobrescritos em tempo de execução
`search_models`	Pesquisar o catálogo de modelos por texto, tipo, modelo base ou fonte
`search_nodes`	Pesquisar nós disponíveis por texto, categoria ou tipos de entrada/saída. Também exibe blueprints de subgrafo (grupos de nós pré-conectados, como Texto para Imagem ou Remover Fundo)
`get_node`	Obter a especificação completa de entrada para nós específicos, incluindo listas completas de opções
`cql`	Executar uma consulta de grafo CQL para perguntas estruturais (por exemplo, quais nós produzem imagens ou caminhos entre tipos de nós). Use `search_nodes` quando precisar de especificações completas de entrada para um nó específico
`get_prompting_guide`	Estilo de prompt e configurações recomendadas (passos, cfg, sampler, resolução) por família de modelo

Geração

Ferramenta	Descrição
`run_template`	Executar um modelo pré-construído pelo nome, com sobrescritas opcionais de parâmetros — o caminho preferido quando um modelo corresponde
`submit_workflow`	Enviar um workflow no formato de API do ComfyUI para execução no Comfy Cloud
`partner_generate`	Gerar com modelos de API de parceiros (Flux/BFL, Grok, Gemini, OpenAI, Ideogram, Seedream/Seedance e outros)
`upload_file`	Enviar uma imagem ou arquivo de entrada para uso em workflows (por exemplo, com LoadImage)
`apply_slots`	Aplicar sobrescritas de parâmetros aos valores internos de um workflow e retornar o workflow modificado

Trabalhos e lotes

Ferramenta	Descrição
`get_job_status`	Consultar o status de execução de um workflow enviado
`wait_for_job`	Aguardar até que um trabalho termine em vez de consultar repetidamente
`get_output`	Recuperar imagens, vídeos ou áudio de saída de um workflow concluído
`use_previous_output`	Encadear workflows reutilizando a saída de uma execução como entrada de outra
`cancel_job`	Cancelar um trabalho pendente ou em execução
`get_queue`	Verificar quantos trabalhos estão em execução e pendentes
`submit_batch`, `get_batch_status`, `get_batch_output`, `wait_for_batch`	Enviar muitas gerações em uma única chamada e coletá-las depois — o ID do lote permanece válido entre sessões

Workflows salvos

Ferramenta	Descrição
`list_saved_workflows`	Navegar pelos seus workflows salvos do Comfy Cloud
`get_saved_workflow`	Inspecionar os nós, entradas e configurações personalizáveis de um workflow salvo
`save_workflow`	Salvar um workflow na sua conta do Comfy Cloud
`update_workflow`	Atualizar um workflow existente como uma nova versão (versões anteriores permanecem recuperáveis)
`run_saved_workflow`	Executar um workflow salvo pelo nome do arquivo — o servidor o converte automaticamente do formato do editor para o formato executável

Compartilhamento de workflows

Ferramenta	Descrição
`share_workflow`	Publicar um workflow salvo e retornar uma URL `?share=<id>` que qualquer pessoa pode abrir
`import_shared_workflow`	Resolver uma URL de compartilhamento ou ID de compartilhamento simples em JSON de workflow, opcionalmente salvando-o na sua conta

IDs de compartilhamento de URL do Hub: o token hexadecimal separado por hífens no final de uma URL do hub comfy.org/workflows/<slug>-<hex> é o ID de compartilhamento. Por exemplo, comfy.org/workflows/topaz-starlight-upscale-1c77e82713b7 tem o ID de compartilhamento 1c77e82713b7. Passe esse token para import_shared_workflow como share_id. O parâmetro share_url aceita apenas URLs de consulta ?share=<id> como https://cloud.comfy.org/?share=..., não URLs de página do hub.

Aplicativos e links

Ferramenta	Descrição
`create_app`	Transformar um workflow salvo em um aplicativo do Modo App — uma visão simplificada de "executar este workflow" com entradas e saídas escolhidas
`get_app_mode_url`	Obter o link estável que abre um workflow como um aplicativo executável
`get_workflow_canvas_url`	Obter um link que abre um workflow diretamente no canvas do Comfy Cloud, pronto para visualizar, editar ou executar

Conta e sessão

Ferramenta	Descrição
`get_billing_status`	Verificar seu saldo de créditos, nível de assinatura e link de cobrança
`get_server_info`	Confirmar qual servidor o agente alcançou: ambiente, host, versão e estado de autenticação
`submit_feedback`	Obter o link da pesquisa de feedback beta
`report_session_summary`	Compartilhar um resumo anônimo da sessão com a equipe Comfy — somente com seu consentimento explícito; o agente deve perguntar primeiro, e nenhum prompt, caminho de arquivo ou informação pessoal é incluído

Prompts (Claude Desktop)

O Claude Desktop não suporta comandos de barra do Claude Code. Em vez disso, abra o seletor de prompts para os mesmos workflows:

Prompt	Descrição
`generate-image`	Gerar uma imagem a partir de uma descrição em texto
`generate-video`	Gerar um vídeo a partir de texto ou uma imagem
`generate-audio`	Gerar áudio, música ou efeitos sonoros
`generate-3d`	Gerar um modelo 3D a partir de texto ou uma imagem
`upscale-image`	Aumentar a resolução de uma imagem
`remove-background`	Remover o fundo de uma imagem
`search-templates`	Encontrar modelos de workflow pré-construídos
`search-models`	Pesquisar modelos (checkpoints, LoRAs, VAEs)
`search-nodes`	Pesquisar nós e obter sugestões de conexão
`help`	Ver o que você pode fazer com o ComfyUI Cloud

Você também pode pular os prompts e perguntar em linguagem natural. As ferramentas MCP funcionam da mesma forma.

Créditos e gastos

A descoberta é gratuita: search_templates, search_models e search_nodes funcionam apenas com uma conta Comfy. Executar gerações requer uma assinatura ativa do Comfy Cloud. Um saldo de créditos ou recarga sozinho não concede acesso: você precisa de uma assinatura ativa para executar gerações, mesmo que tenha créditos não utilizados.

Uploads e downloads

O servidor MCP roda na nuvem e o próprio MCP não grava arquivos na sua máquina. Quando uma geração é concluída, seu agente chama get_output, que retorna:

Uma URL de download assinada temporária (válida por um curto período).
Um comando de shell pronto para executar (curl no macOS e Linux, curl.exe no Windows).

Seu agente deve executar esse comando no seu shell. O comando inclui o caminho de destino e o nome do arquivo.

Aviso

Execute o comando retornado exatamente como está. Não re-codifique ou edite a URL assinada. A assinatura está na string de consulta e quebra se a URL for modificada.

Se o seu cliente MCP não puder executar comandos de shell (algumas configurações apenas com GUI), copie o comando e execute-o você mesmo em um terminal.

O upload e download de arquivos dependem do acesso a arquivos do cliente. Se o Claude Desktop ou outro cliente agente tiver problemas com uploads ou downloads de arquivos, isso pode estar relacionado ao acesso do agente aos seus diretórios de arquivos locais. Para usuários do Claude, recomendamos o Claude Code (aplicativo de desktop ou terminal), que tem mais capacidades. Da mesma forma, para outras famílias de agentes, o agente de codificação geralmente é melhor que a versão de chat web.

Limitações conhecidas

O Comfy Cloud MCP é um lançamento inicial. Estas limitações são conhecidas e estão sendo trabalhadas:

Workflows

Arquivos gerados via submit_workflow podem não incorporar metadados do workflow. Eles podem não reabrir o workflow de origem quando abertos no ComfyUI.
A construção de workflows depende da precisão do agente. Workflows complexos com vários nós podem precisar de uma nova tentativa ou refinamento.

Manipulação de arquivos

As saídas exigem uma etapa de download via shell. Consulte Uploads e downloads.
Limites de tamanho de upload podem ser aplicados dependendo do seu cliente MCP. Alguns clientes impõem seus próprios limites em uploads de arquivos.

Autenticação

OAuth ou chave de API. O Claude Code e o Claude Desktop usam um fluxo OAuth de navegador único. Cursor requer uma chave de API do Comfy Cloud na sua configuração MCP (sem OAuth). Outros clientes headless podem passar uma chave de API do Comfy Cloud pelo cabeçalho X-API-Key. Um fluxo OAuth com código de dispositivo para clientes que não podem abrir um navegador está planejado.

Conexão Local Comfy MCP

A conexão de código aberto: seu cliente inicia o servidor na sua máquina e ele controla o ComfyUI instalado ali.

comfy-mcp é o servidor MCP local de primeira parte da Comfy — a forma oficial de controlar uma instalação local do ComfyUI a partir de agentes de IA (Claude Code, Claude Desktop, Cursor e outros clientes MCP).

Ao contrário dos servidores de nuvem e parceiros, ele fala com o ComfyUI rodando na sua própria máquina — então pode executar seus workflows e inspecionar os nós, nós personalizados e modelos que sua instalação realmente possui.

Dica

A configuração mais rápida: entregue ao seu agente. Cole https://docs.comfy.org/agent-tools/mcp#installation no seu cliente de IA e peça para ele configurar a conexão local para você.

Requisitos

Python 3.10+
comfy-cli no seu PATH (pip install "comfy-cli>=1.14.0") — o mecanismo que todas as ferramentas encapsulam
Um workspace ComfyUI — crie um com comfy install se você não tiver um (um checkout existente funciona via comfy set-default <path>)
Um ComfyUI em execução para ferramentas de execução. Inicie-o com comfy launch, ou chame launch_comfyui. O servidor não inicia o ComfyUI implicitamente.

Instalação

Do PyPI:

pip install comfy-mcp

Isso coloca um script de console comfy-mcp no seu PATH — esse comando é o servidor MCP (ele fala MCP via stdio). Aponte seu cliente de IA para ele abaixo. (Quer desenvolver o próprio servidor? Use pip install -e . a partir de um checkout do repositório em vez disso.)

Nota

COMFY_BIN (opcional). Os clientes MCP iniciam o servidor com seu próprio ambiente, que muitas vezes não inclui o PATH do seu shell. Se comfy estiver em um virtualenv ou em um local não padrão, defina COMFY_BIN para o caminho absoluto (por exemplo, /path/to/venv/bin/comfy). Cada exemplo de cliente abaixo mostra onde ele vai; remova-o se comfy já estiver no ambiente com o qual seu cliente inicia o servidor.

Configuração manual

Todos os clientes falam o mesmo contrato MCP stdio: execute o comando comfy-mcp como servidor. Escolha seu cliente:

Edite `claude_desktop_config.json` (Configurações → Desenvolvedor → Editar Config; no macOS ele fica em `~/Library/Application Support/Claude/claude_desktop_config.json`), adicione o servidor e reinicie o Claude Desktop:

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

Um comando registra o servidor:

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

Ou registre-o em um projeto com um `.mcp.json` na raiz do repositório:

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

Adicione o servidor ao `~/.cursor/mcp.json` (global) ou `.cursor/mcp.json` (por projeto): ```json theme={null} { "mcpServers": { "comfy-mcp": { "command": "comfy-mcp", "env": { "COMFY_BIN": "/path/to/venv/bin/comfy" } } } } ```

Início rápido

Do zero a uma imagem gerada:

```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 ``` Use o trecho de código para o seu cliente acima e reinicie/recarregue-o para que as ferramentas apareçam. Por exemplo:

> "Confirme se meu ComfyUI local está em execução, depois execute o workflow em `~/workflows/txt2img.json` e me mostre a imagem."

Nos bastidores, o agente chama `server_info` para confirmar que o ComfyUI está ativo, `run_workflow` para executar o JSON do workflow e `fetch_outputs` para coletar o resultado.

Ferramentas

Cada ferramenta mapeia para um comando comfy-cli, executado com --where local. Destaques:

Ferramenta	Finalidade
`server_info()`	Verifica se um ComfyUI local está em execução, onde e qual workspace. Chame primeiro.
`run_workflow(workflow_path, wait=True)`	Executa um JSON de workflow; `wait=False` envia de forma assíncrona e retorna um `prompt_id`.
`job_status` / `wait_for_job` / `watch_job`	Consulta, aguarda ou transmite um trabalho enviado.
`fetch_outputs(prompt_id, out_dir)`	Copia as saídas de um trabalho concluído para `out_dir`.
`launch_comfyui` / `stop_comfyui`	Inicia ou interrompe o ComfyUI local.
`search_templates` / `fetch_template`	Encontra um template integrado e grava seu JSON de workflow executável.
`search_nodes` / `get_node` / `list_nodes`	Inspeciona as classes de nós na sua instalação local ativa (incluindo nós personalizados).
`search_models`	Lista os arquivos de modelo no disco.
`validate_workflow`	Pré-valida um workflow contra o `object_info` ativo antes de uma execução lenta.

A introspecção de nós e a busca de modelos leem sua instalação ativa — incluindo nós personalizados —, o que é o diferencial local em relação à conexão na nuvem. Consulte o repositório para a lista completa de ferramentas e referência.

Recursos relacionados

Recurso	Para que serve
Comfy Skills	Marketplace de plugins do Claude Code e biblioteca de skills da comunidade. O plugin comfy-cloud usado acima é distribuído aqui; navegue ou contribua com skills adicionais para workflows do Comfy.
Comfy Cloud no ClawHub	Skill do OpenClaw (`openclaw skills install @comfy-org/comfy`) para o servidor MCP hospedado Comfy Cloud MCP.
Comfy CLI	Ferramenta de linha de comando para instalar/iniciar o ComfyUI local e para chamar nós parceiros hospedados a partir de scripts ou CI (`comfy generate`, em beta). Complementa o MCP quando você precisa de terminal ou automação.
Compartilhe um workflow no Comfy Cloud	Compartilhe workflows pela interface do Comfy Cloud (a ferramenta `share_workflow` do MCP faz isso a partir de uma sessão de agente).

Relacionado: Comfy Agent

Quer a experiência de agente dentro do ComfyUI, e não em um cliente MCP externo?

Assistente integrado do ComfyUI para criar, editar e executar workflows. **Disponível de forma geral na nuvem.** Local (Comfy Desktop) em breve.

Feedback

O Comfy MCP está em beta público. Experimente e conte-nos o que funciona e o que não funciona:

Pesquisa de feedback: relate bugs, solicite recursos ou compartilhe impressões gerais.
Discord: #comfy-mcp-and-cli no Discord do Comfy para perguntas e discussões.

FAQ

Primeiros passos

Qualquer cliente compatível com MCP.

A **conexão na nuvem** precisa de suporte HTTP remoto. **Claude Code**, **Claude Desktop**, **Cursor**, **Codex** e **OpenClaw** têm configuração de primeira classe acima; **Windsurf**, **Amp** e outros usam a mesma URL com OAuth ou uma chave de API.

A **conexão local** precisa de um cliente que possa iniciar um servidor stdio local como subprocesso. Isso exclui clientes baseados em navegador. [claude.ai](https://claude.ai) e ChatGPT aceitam apenas conectores remotos.

A conexão na nuvem roda em `https://cloud.comfy.org/mcp`.

A conexão local não tem URL. Seu cliente inicia o comando `comfy-mcp` diretamente e conversa com ele via stdio.

Sim. Essa é a [Conexão MCP Comfy Local](#local-comfy-mcp-connection). Ela aciona o ComfyUI instalado na sua própria máquina, então seu agente vê os modelos, LoRAs e nós personalizados que você realmente tem, e roda na sua GPU. Sim, e recomendamos se você roda o ComfyUI localmente. A maioria dos clientes hospeda dois servidores MCP sem problemas, e seu agente os mantém separados. Cada conexão executa seus próprios workflows e retorna seus próprios resultados.

Os dois logins são **separados**, no entanto. Entrar em um não faz login no outro, mesmo sendo a mesma conta Comfy.

Pergunte ao seu agente. Ele lê seu hardware antes de iniciar qualquer coisa pesada.

Em um **Mac**, use a conexão na nuvem para gerar: os modelos open-weight de hoje são grandes demais para rodar em velocidade utilizável na GPU da Apple. Em um **PC com placa de vídeo dedicada**, 24 GB ou mais de VRAM lidam com a maioria das coisas, incluindo vídeo; 8–24 GB é suficiente para imagens, mas vídeo será lento ou não caberá; abaixo de 8 GB, use a nuvem.

A conexão na nuvem está em **beta público**. APIs, ferramentas e comportamento podem mudar enquanto iteramos. A conexão local está disponível para instalações locais do ComfyUI. Veja [Feedback](#feedback) para relatar problemas.

Custo e acesso

A descoberta é gratuita em ambas as conexões: buscar templates, modelos e nós exige apenas uma conta Comfy.

Na **conexão na nuvem**, executar gerações exige uma assinatura ativa do Comfy Cloud; novos usuários ganham 5 execuções gratuitas. Na **conexão local**, as execuções são gratuitas porque acontecem no seu hardware, com uma exceção: modelos parceiros executam na infraestrutura do parceiro e gastam créditos.

Não para clientes interativos que suportam OAuth, incluindo Claude Code, Claude Desktop, Codex e OpenClaw.

**Cursor** exige uma chave de API do Comfy Cloud na sua configuração MCP; ainda não há OAuth MCP lá. Configurações headless e de CI sem navegador também precisam de uma. Veja as abas **Cursor** e **Outros clientes** em [Configurar a conexão na nuvem](#set-up-the-cloud-connection).

Usando

Você não chama as ferramentas MCP diretamente — seu agente as escolhe com base no que você pede. Normalmente ele **descobre** o que está disponível (`search_templates`, `search_models`, `search_nodes`), **executa** uma geração e depois **aguarda e recupera** a saída. Veja [O que seu agente pode fazer](#what-your-agent-can-do). Na **conexão na nuvem**, o servidor nunca grava na sua máquina: `get_output` retorna uma URL assinada temporária e um comando de download pronto para execução para seu agente rodar no seu shell. Veja [Uploads e downloads](#uploads-and-downloads).

Na **conexão local**, o ComfyUI grava no diretório `output/` do seu workspace, e `fetch_outputs(prompt_id, out_dir)` copia os arquivos de um trabalho concluído para qualquer lugar que você indicar.

Nada para desfazer — adicione a segunda conexão junto com a primeira.

Indo de **local → nuvem** (você precisa de GPUs na nuvem ou modelos parceiros): peça ao seu agente para fazer login e adicione `https://cloud.comfy.org/mcp` ao seu cliente.

Indo de **nuvem → local** (você quer seus próprios modelos e nós personalizados): instale o ComfyUI e o servidor local, depois aponte seu cliente para ele. Seu agente pode fazer a maior parte disso por você.

Basta pedir ao seu agente. Com ambas as conexões adicionadas, diga onde você quer que um trabalho rode — "rode este no Comfy Cloud", "faça isso localmente" — e ele usa a conexão certa. Não há modo para alternar nem nada para reconfigurar entre execuções.

Se um workflow for pesado demais para sua máquina, seu agente pode avisar e oferecer para rodá-lo no Comfy Cloud. E se apenas uma conexão estiver configurada, peça para adicionar a outra — veja [Configurar a conexão na nuvem](#set-up-the-cloud-connection) ou a [Conexão MCP Comfy Local](#local-comfy-mcp-connection).

Na **conexão na nuvem**, nada a fazer — é hospedada, então você está sempre na versão atual.

Na **conexão local**, peça ao seu agente para cuidar disso. Depois, **reinicie seu cliente** ou inicie uma nova sessão: os servidores MCP carregam quando uma sessão começa, então um em execução continua servindo a versão antiga até você fazer isso.

Solução de problemas

Não. Os comandos de barra vêm no plugin do Claude Code. O Claude Desktop se conecta ao mesmo servidor MCP — as ferramentas funcionam se você pedir em linguagem natural ou usar o seletor de prompts —, mas ele não suporta plugins do Claude Code nem comandos de barra. Não existe comando `/comfy` nem `/cloud`. Os comandos aparecem sob um de dois prefixos, dependendo de como você se conectou:

* **Plugin (recomendado):** `/comfy-cloud:generate-image`, `/comfy-cloud:generate-video`, … — digite `/comfy-cloud:` para ver todos.
* **Conexão direta (sem plugin):** `/mcp__comfy-cloud__generate-image`, … — digite `/mcp__` para vê-los.

De qualquer forma, você pode simplesmente pedir em linguagem natural ("gere uma imagem de …"). As ferramentas MCP são invocadas por modelo e não exigem um comando de barra.

No Claude Code, execute `/mcp`, selecione **comfy-cloud** e escolha **Autenticar**. No Claude Desktop, reabra o conector em **Personalizar → Conectores** e acione o login.