ComfyUI

Interfaz de Stable Diffusion basada en nodos con ComfyUI en Clore.ai

Interfaz basada en nodos para Stable Diffusion con máxima flexibilidad en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Requisitos del servidor

Parámetro	Mínimo	Recomendado
RAM	16GB	32 GB+
VRAM	8 GB (SDXL)	12 GB+
Red	500 Mbps	1 Gbps+
Tiempo de inicio	5-10 minutos	-

Tiempo de inicio: En el primer inicio se descargan dependencias y modelos (5-10 minutos según la velocidad de red). Es normal ver HTTP 502 durante este tiempo.

Importante: ComfyUI con modelos FLUX requiere 16 GB+ de VRAM. Para SDXL con ControlNet, asegúrate de tener al menos 10 GB de VRAM.

¿Por qué ComfyUI?

• Flujo de trabajo basado en nodos - Programación visual para la generación de imágenes

• Control máximo - Ajusta con precisión cada paso del flujo

• Eficiente - Menor uso de VRAM que las alternativas

• Extensible - Enorme ecosistema de nodos personalizados

• Compartir flujos de trabajo - Importar/exportar como JSON

Despliegue rápido en CLORE.AI

Imagen de Docker:

yanwk/comfyui-boot:cu130-slim

Puertos:

22/tcp
8188/http

Entorno:

CLI_ARGS=--listen 0.0.0.0

Verifica que funciona

Después del despliegue, encuentra tu http_pub URL en Mis pedidos:

# Comprueba si la interfaz es accesible (puede tardar 5-10 min en la primera ejecución)
curl https://your-http-pub.clorecloud.net/

Si obtienes HTTP 502 durante más de 15 minutos, verifica:

1. El servidor tiene 16 GB+ de RAM

2. El servidor tiene 8 GB+ de VRAM para SDXL, 16 GB+ para FLUX

3. La velocidad de red es adecuada para descargar modelos

Accediendo a tu servicio

Cuando se despliegue en CLORE.AI, accede a ComfyUI mediante la http_pub URL:

• Interfaz web: https://your-http-pub.clorecloud.net/

• API: https://your-http-pub.clorecloud.net/prompt

• WebSocket: wss://your-http-pub.clorecloud.net/ws

Todo localhost:8188 los ejemplos siguientes funcionan cuando te conectas por SSH. Para acceder externamente, sustitúyelo por tu https://your-http-pub.clorecloud.net/ URL.

Instalación

Usando Docker (recomendado)

docker run -d --gpus all \
  -p 8188:8188 \
  -v comfyui-data:/root \
  -e CLI_ARGS="--listen 0.0.0.0" \
  yanwk/comfyui-boot:cu130-slim

Instalación manual

# Clonar repositorio
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Crea un entorno virtual
python -m venv venv
source venv/bin/activate

# Instala PyTorch con CUDA
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128

# Instalar dependencias
pip install -r requirements.txt

# Ejecutar
python main.py --listen 0.0.0.0

Estructura de directorios

ComfyUI/
├── models/
│   ├── checkpoints/     # Modelos SD (.safetensors)
│   ├── loras/           # Modelos LoRA
│   ├── vae/             # Modelos VAE
│   ├── controlnet/      # Modelos ControlNet
│   ├── upscale_models/  # Escaladores
│   └── clip/            # Modelos CLIP
├── input/               # Imágenes de entrada
├── output/              # Imágenes generadas
└── custom_nodes/        # Extensiones

Descargar modelos

Puntos de control de Stable Diffusion

cd ComfyUI/models/checkpoints

# SDXL Base
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# Refiner SDXL
wget https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors

# SD 1.5 (más pequeño, más rápido)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (fotorealista)
wget https://huggingface.co/SG161222/Realistic_Vision_V6.0_B1_noVAE/resolve/main/Realistic_Vision_V6.0_B1_fp16.safetensors

VAE

cd ComfyUI/models/vae

# VAE de SDXL
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors

# VAE de SD 1.5 (mejores colores)
wget https://huggingface.co/stabilityai/sd-vae-ft-mse-original/resolve/main/vae-ft-mse-840000-ema-pruned.safetensors

LoRAs

cd ComfyUI/models/loras

# Descarga desde CivitAI o HuggingFace
# Coloca aquí los archivos .safetensors

Flujo de trabajo básico

Texto a imagen

1. Añade nodos:

   • Cargar punto de control → selecciona el modelo

   • Codificación de texto CLIP (x2) → prompts positivo y negativo

   • Imagen latente vacía → establece las dimensiones

   • KSampler → conecta todo

   • Decodificación VAE → latente a imagen

   • Guardar imagen → salida

2. Conecta:

[Checkpoint] → MODEL → [KSampler]
[Checkpoint] → CLIP → [CLIP Text Encode +]
[Checkpoint] → CLIP → [CLIP Text Encode -]
[Checkpoint] → VAE → [VAE Decode]
[Text Encode +] → CONDITIONING → [KSampler]
[Text Encode -] → CONDITIONING → [KSampler]
[Empty Latent] → LATENT → [KSampler]
[KSampler] → LATENT → [VAE Decode]
[VAE Decode] → IMAGE → [Save Image]

Imagen a imagen

Reemplaza Imagen latente vacía con:

1. Cargar imagen → tu imagen de origen

2. Codificación VAE → convertir a latente

3. Ajusta reducción de ruido en KSampler (0.5-0.8)

ComfyUI Manager

ComfyUI Manager es una extensión esencial que añade una interfaz gráfica para instalar, actualizar y gestionar nodos personalizados. Es la forma estándar de ampliar ComfyUI.

Instalación

cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# Reinicia ComfyUI — aparecerá un botón "Manager" en la barra de herramientas

Usando ComfyUI Manager

Después de reiniciar, un Manager botón aparece en la esquina superior derecha de la interfaz de ComfyUI.

Características principales:

Función	Cómo acceder
Instalar nodos personalizados	Manager → Instalar nodos personalizados
Actualizar todos los nodos	Manager → Actualizar todo
Deshabilitar/habilitar nodos	Manager → Gestor de nodos personalizados
Instalar nodos faltantes	Manager → Instalar nodos personalizados faltantes
Obtener información del modelo	Manager → Gestor de modelos
Restaurar instantánea	Manager → Gestor de instantáneas

Flujo de trabajo: instalación de un nuevo paquete de nodos

1. Haz clic en Manager botón

2. Selecciona Instalar nodos personalizados

3. Busca por nombre (p. ej., "FLUX", "AnimateDiff")

4. Haz clic en Instalar en el paquete deseado

5. Haz clic en Reiniciar cuando se te solicite

6. Los nuevos nodos aparecen en el menú de añadir con clic derecho

Instalación automática de nodos faltantes: Cuando importas un JSON de flujo de trabajo que usa nodos que no tienes, Manager los detecta y ofrece instalarlos automáticamente mediante Instalar nodos personalizados faltantes.

Mantener los nodos actualizados

# Desde la CLI (alternativa a la interfaz gráfica):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# O usa Manager → Actualizar todo en la interfaz

---

Flujo de trabajo FLUX en ComfyUI

FLUX usa una estructura de nodos diferente a la de los modelos SD estándar. A continuación se muestra un flujo de trabajo completo de FLUX.1-dev.

Archivos requeridos

Antes de ejecutar el flujo de trabajo, descarga:

# Modelo FLUX (dev o schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# Codificadores de texto
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

# VAE
cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/ae.safetensors

JSON del flujo de trabajo FLUX.1-dev

Guardar como flux_dev_workflow.json e importar mediante Cargar botón en ComfyUI:

{
  "last_node_id": 12,
  "last_link_id": 20,
  "nodes": [
    {
      "id": 1,
      "type": "UNETLoader",
      "pos": [100, 100],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [1]}],
      "properties": {},
      "widgets_values": ["flux1-dev.safetensors", "default"]
    },
    {
      "id": 2,
      "type": "DualCLIPLoader",
      "pos": [100, 200],
      "size": [350, 80],
      "inputs": [],
      "outputs": [{"name": "CLIP", "type": "CLIP", "links": [2, 3]}],
      "properties": {},
      "widgets_values": ["clip_l.safetensors", "t5xxl_fp16.safetensors", "flux"]
    },
    {
      "id": 3,
      "type": "CLIPTextEncode",
      "pos": [500, 150],
      "size": [425, 180],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 2}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [4]}],
      "properties": {},
      "widgets_values": ["Un paisaje fotorrealista impresionante, iluminación de hora dorada, 8K"]
    },
    {
      "id": 4,
      "type": "EmptySD3LatentImage",
      "pos": [100, 350],
      "size": [300, 100],
      "inputs": [],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [5]}],
      "properties": {},
      "widgets_values": [1024, 1024, 1]
    },
    {
      "id": 5,
      "type": "ModelSamplingFlux",
      "pos": [500, 350],
      "size": [300, 80],
      "inputs": [{"name": "model", "type": "MODEL", "link": 1}],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [6]}],
      "properties": {},
      "widgets_values": [1.15, 0.5, 1024, 1024]
    },
    {
      "id": 6,
      "type": "KSampler",
      "pos": [850, 250],
      "size": [350, 240],
      "inputs": [
        {"name": "model", "type": "MODEL", "link": 6},
        {"name": "positive", "type": "CONDITIONING", "link": 4},
        {"name": "negative", "type": "CONDITIONING", "link": 7},
        {"name": "latent_image", "type": "LATENT", "link": 5}
      ],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [8]}],
      "properties": {},
      "widgets_values": [42, "fixed", 20, 3.5, "euler", "simple", 1.0]
    },
    {
      "id": 7,
      "type": "CLIPTextEncode",
      "pos": [500, 500],
      "size": [300, 60],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 3}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [7]}],
      "properties": {},
      "widgets_values": [""]
    },
    {
      "id": 8,
      "type": "VAELoader",
      "pos": [100, 500],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "VAE", "type": "VAE", "links": [9]}],
      "properties": {},
      "widgets_values": ["ae.safetensors"]
    },
    {
      "id": 9,
      "type": "VAEDecode",
      "pos": [1250, 300],
      "size": [210, 46],
      "inputs": [
        {"name": "samples", "type": "LATENT", "link": 8},
        {"name": "vae", "type": "VAE", "link": 9}
      ],
      "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}],
      "properties": {}
    },
    {
      "id": 10,
      "type": "SaveImage",
      "pos": [1500, 300],
      "size": [300, 270],
      "inputs": [{"name": "images", "type": "IMAGE", "link": 10}],
      "outputs": [],
      "properties": {},
      "widgets_values": ["flux_output"]
    }
  ],
  "links": [
    [1, 1, 0, 5, 0, "MODEL"],
    [2, 2, 0, 3, 0, "CLIP"],
    [3, 2, 0, 7, 0, "CLIP"],
    [4, 3, 0, 6, 1, "CONDITIONING"],
    [5, 4, 0, 6, 3, "LATENT"],
    [6, 5, 0, 6, 0, "MODEL"],
    [7, 7, 0, 6, 2, "CONDITIONING"],
    [8, 6, 0, 9, 0, "LATENT"],
    [9, 8, 0, 9, 1, "VAE"],
    [10, 9, 0, 10, 0, "IMAGE"]
  ],
  "groups": [],
  "config": {},
  "extra": {"ds": {"scale": 0.8, "offset": [0, 0]}},
  "version": 0.4
}

Flujo de trabajo FLUX.1-schnell (4 pasos)

Para schnell, cambia los ajustes de KSampler en el JSON anterior:

• num_inference_steps: 4

• cfg: 1.0

• programador: "simple"

• Archivo del modelo: flux1-schnell.safetensors

O configúralo mediante la interfaz: KSampler → pasos: 4, cfg: 1.0, muestreador: euler, programador: simple

Diferencias clave de nodos: FLUX vs SD

Nodo	SD/SDXL	FLUX
Cargador del modelo	Cargar punto de control	UNETLoader
Codificador de texto	CLIPTextEncode	DualCLIPLoader + CLIPTextEncode
Latente	Imagen latente vacía	EmptySD3LatentImage
Extra	—	ModelSamplingFlux
Prompt negativo	Requerido	Opcional (déjalo vacío)

---

Nodos personalizados esenciales

Paquetes de nodos recomendados

Paquete de nodos	GitHub	Caso de uso
ComfyUI-Manager	ltdrdata/ComfyUI-Manager	Instala y gestiona todos los demás nodos
ComfyUI-FLUX	XLabs-AI/x-flux-comfyui	Nodos ControlNet de FLUX
was-node-suite	WASasquatch/was-node-suite-comfyui	Más de 100 nodos de utilidad
ComfyUI-Impact-Pack	ltdrdata/ComfyUI-Impact-Pack	Detección facial, SAM, ADetailer
ComfyUI-Inspire-Pack	ltdrdata/ComfyUI-Inspire-Pack	Samplers avanzados, flujos de trabajo
ComfyUI-AnimateDiff	Kosinkadink/ComfyUI-AnimateDiff-Evolved	Generación de video / animación
ComfyUI-VideoHelperSuite	Kosinkadink/ComfyUI-VideoHelperSuite	Manejo de E/S de video
ComfyUI-GGUF	city96/ComfyUI-GGUF	Ejecuta modelos GGUF cuantizados
ComfyUI-KJNodes	kijai/ComfyUI-KJNodes	Nodos de utilidad y máscara
rgthree-comfy	rgthree/rgthree-comfy	Ayudas para flujos de trabajo, mejor interfaz

ComfyUI-FLUX (XLabs-AI)

Añade compatibilidad con ControlNet para FLUX dentro de ComfyUI:

cd ComfyUI/custom_nodes
git clone https://github.com/XLabs-AI/x-flux-comfyui
cd x-flux-comfyui
pip install -r requirements.txt

Añade nodos: Aplicar ControlNet (FLUX), Cargar modelo ControlNet (FLUX), Muestreador XFlux

was-node-suite

Más de 100 nodos de utilidad para flujos de trabajo avanzados:

cd ComfyUI/custom_nodes
git clone https://github.com/WASasquatch/was-node-suite-comfyui
cd was-node-suite-comfyui
pip install -r requirements.txt

Nodos clave: lotes de imágenes, operaciones de texto, análisis de imágenes, nodo de caché, nodo de bus, escalado, operaciones de máscara

Instalar mediante el gestor

1. Haz clic en Manager botón

2. Instalar nodos personalizados

3. Buscar e instalar

4. Reiniciar ComfyUI

Flujos de trabajo avanzados

ControlNet

# Descargar modelos de ControlNet
cd ComfyUI/models/controlnet

# Canny
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth

# Profundidad
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth

# OpenPose
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth

Flujo de trabajo:

1. Cargar imagen → Detector de bordes Canny

2. Aplicar ControlNet → KSampler

3. Generar con guía de pose/bordes

Escalado

# Descargar escalador
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth

Flujo de trabajo:

1. Generar imagen a resolución más baja (768x768)

2. nodo Escalar imagen (modelo)

3. Opcional: paso img2img para detalles

SDXL + Refiner

1. Generar con la base de SDXL (pasos 1-20)

2. Pasar el latent al refinador de SDXL (pasos 21-30)

3. Decodificar VAE resultado final

Atajos de teclado

Tecla	Acción
Ctrl+Enter	Encolar prompt
Ctrl+Shift+Enter	Encolar prompt (al frente)
Ctrl+Z	Deshacer
Ctrl+Y	Rehacer
Ctrl+S	Guardar flujo de trabajo
Ctrl+O	Cargar flujo de trabajo
Ctrl+A	Seleccionar todo
Supr	Eliminar seleccionados
Ctrl+M	Silenciar nodo
Ctrl+B	Omitir nodo

Uso de la API

Encolar prompt

import json
import urllib.request

# Para acceso externo, usa tu URL http_pub:
SERVER = "your-http-pub.clorecloud.net"
# O vía SSH: SERVER = "localhost:8188"

def queue_prompt(prompt, server=SERVER):
    data = json.dumps({"prompt": prompt}).encode('utf-8')
    req = urllib.request.Request(f"https://{server}/prompt", data=data)
    urllib.request.urlopen(req)

# Cargar JSON del flujo de trabajo y encolar
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)

WebSocket para progreso

import websocket
import json

# Para acceso externo, usa wss:// con tu URL http_pub
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

while True:
    msg = json.loads(ws.recv())
    if msg['type'] == 'progress':
        print(f"Paso {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("¡Hecho!")
        break

Consejos de rendimiento

1. Activar --lowvram para menos de 8 GB de VRAM

2. Usa fp16 modelos cuando sea posible

3. Tamaño de lote 1 para VRAM limitada

4. VAE en mosaico para imágenes de alta resolución

5. Desactivar vista previa para una generación más rápida

Requisitos de GPU

Modelo	VRAM mínima	VRAM recomendada	RAM mín.
SD 1.5	4GB	8GB	16GB
SDXL	8GB	12GB	16GB
SDXL + ControlNet	10GB	16GB	16GB
FLUX	16GB	24GB	32GB

Preajustes de GPU

RTX 3060 12GB (económica)

# Iniciar con optimizaciones
python main.py --lowvram --force-fp16

# Configuración recomendada:
# - SDXL: 768x768, lote 1
# - SD 1.5: 512x512, lote 4
# - Usar mosaico VAE
# - 20-30 pasos

Mejor para: SD 1.5, SDXL (con límites)

RTX 3090 24GB (óptima)

# Inicio estándar
python main.py --force-fp16

# Configuración recomendada:
# - SDXL: 1024x1024, lote 2
# - FLUX schnell: 1024x1024, lote 1
# - ControlNet + SDXL funciona bien
# - 30-50 pasos

Mejor para: SDXL, flujos de trabajo ControlNet, FLUX moderado

RTX 4090 24GB (rendimiento)

# Inicio a máxima velocidad
python main.py

# Configuración recomendada:
# - SDXL: 1024x1024, lote 4
# - FLUX dev: 1024x1024, lote 1-2
# - Flujos de trabajo complejos con múltiples ControlNet
# - 50+ pasos para calidad

Mejor para: FLUX, flujos de trabajo complejos, generación por lotes

A100 40GB/80GB (producción)

# Rendimiento máximo
python main.py --highvram

# Configuración recomendada:
# - SDXL: 1024x1024, lote 8+
# - FLUX: 1024x1024, lote 2-4
# - Múltiples modelos cargados simultáneamente
# - Salidas de alta resolución (2048x2048)

Mejor para: Tareas de producción, FLUX, generación de alta resolución

Estimación de costos

Tarifas típicas del mercado de CLORE.AI:

GPU	VRAM	Precio/día	Velocidad SDXL
RTX 3060	12GB	$0.15–0.30	~15 seg/imagen
RTX 3090	24GB	$0.30–1.00	~8 seg/imagen
RTX 4090	24GB	$0.50–2.00	~4 seg/imagen
A100	40 GB	$1.50–3.00	~3 seg/imagen

Los precios en USD/día. Las tarifas varían según el proveedor — consulta Marketplace de CLORE.AI las tarifas actuales.

Solución de problemas

HTTP 502 durante mucho tiempo

1. Verifica la RAM: El servidor debe tener 16 GB+ de RAM

2. Verifica la VRAM: 8 GB+ para SDXL, 16 GB+ para FLUX

3. Descargando dependencias: La primera ejecución tarda 5-10 min

4. Descargando modelo: Los modelos grandes tardan más

Sin memoria

# Ejecutar en modo de baja VRAM
python main.py --lowvram

# O forzar fp16
python main.py --force-fp16

Imágenes negras

• Comprueba que el VAE esté cargado

• Prueba otro VAE

• Reduce el tamaño de la imagen

Generación lenta

• Habilitar CUDA

• Usar modelos fp16

• Reduce los pasos (20-30 suele ser suficiente)

Ejemplos de flujo de trabajo

Importa estos flujos de trabajo JSON en ComfyUI:

• txt2img básico

• SDXL + Refiner

• ControlNet Canny

• Video AnimateDiff

Siguientes pasos

• Guía de ControlNet

• Escalado con Real-ESRGAN

• Entrenamiento de Kohya - Entrenar LoRAs personalizadas

• Fooocus - Alternativa más sencilla