ComfyUI

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

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

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

Requisitos del servidor

Parámetro

Mínimo

Recomendado

RAM

16GB

32GB+

VRAM

8GB (SDXL)

12GB+

Red

500Mbps

1Gbps+

Tiempo de inicio

5-10 minutos

Tiempo de inicio: El primer inicio descarga dependencias y modelos (5-10 minutos según la velocidad de la red). HTTP 502 durante este tiempo es normal.

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

¿Por qué ComfyUI?

Flujo de trabajo basado en nodos - Programación visual para generación de imágenes
Control máximo - Ajusta cada paso de la tubería
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 Docker:

yanwk/comfyui-boot:cu126-slim

Puertos:

22/tcp
8188/http

Entorno:

CLI_ARGS=--listen 0.0.0.0

Verificar que funciona

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

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

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

El servidor tiene 16GB+ de RAM
El servidor tiene 8GB+ de VRAM para SDXL, 16GB+ para FLUX
La velocidad de la red es adecuada para descargar modelos

Accediendo a tu servicio

Cuando se despliega en CLORE.AI, accede a ComfyUI vía el http_pub URL:

UI 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 a continuación funcionan cuando está conectado vía SSH. Para acceso externo, reemplace con su 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:cu126-slim

Instalación manual

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

# Crear entorno virtual
python -m venv venv
source venv/bin/activate

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

# 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/  # Upscalers
│   └── clip/            # Modelos CLIP
├── input/               # Imágenes de entrada
├── output/              # Imágenes generadas
└── custom_nodes/        # Extensiones

Descargar modelos

Checkpoints 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

# SDXL Refiner
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 (fotorrealista)
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

# Descargar desde CivitAI o HuggingFace
# Coloca archivos .safetensors aquí

Flujo de trabajo básico

Texto a imagen

Agregar nodos:
- Cargar checkpoint → seleccionar modelo
- CLIP Text Encode (x2) → prompts positivos y negativos
- Imagen latente vacía → establecer dimensiones
- KSampler → conectar todo
- VAE Decode → latente a imagen
- Guardar imagen → salida
Conectar:

[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

Reemplazar Imagen latente vacía con:

Cargar imagen → tu imagen fuente
VAE Encode → convertir a latente
Ajustar desruido en KSampler (0.5-0.8)

ComfyUI Manager

ComfyUI Manager es una extensión esencial que añade una GUI 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

Tras el reinicio, un Manager botón aparece en la esquina superior derecha de la interfaz de ComfyUI.

Características clave:

Función

Cómo acceder

Instalar nodos personalizados

Manager → Install Custom Nodes

Actualizar todos los nodos

Manager → Update All

Desactivar/activar nodos

Manager → Custom Nodes Manager

Instalar nodos faltantes

Manager → Install Missing Custom Nodes

Obtener información del modelo

Manager → Model Manager

Restaurar snapshot

Manager → Snapshot Manager

Flujo: instalar un nuevo paquete de nodos

Hacer clic Manager botón
Seleccionar Install Custom Nodes
Buscar por nombre (p. ej., "FLUX", "AnimateDiff")
Hacer clic Instalar en el paquete deseado
Hacer clic Reiniciar cuando se solicite
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 que usa nodos que no tienes, Manager los detecta y ofrece instalarlos automáticamente vía Install Missing Custom Nodes.

Mantener los nodos actualizados

# Desde CLI (alternativa a la GUI):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# O usa Manager → Update All en la UI

Flujo FLUX en ComfyUI

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

Archivos requeridos

Antes de ejecutar el flujo, 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

FLUX.1-dev Workflow JSON

Guardar como flux_dev_workflow.json e importar vía 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": ["A stunning photorealistic landscape, golden hour lighting, 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
}

FLUX.1-schnell Workflow (4 pasos)

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

num_inference_steps: 4
cfg: 1.0
scheduler: "simple"
Archivo de modelo: flux1-schnell.safetensors

O configúralo vía UI: KSampler → steps: 4, cfg: 1.0, sampler: euler, scheduler: simple

Diferencias clave de nodos: FLUX vs SD

Nodo

SD/SDXL

FLUX

Cargador de modelo

Cargar checkpoint

UNETLoader

Codificador de texto

CLIPTextEncode

DualCLIPLoader + CLIPTextEncode

Latente

Imagen latente vacía

EmptySD3LatentImage

Extra

—

ModelSamplingFlux

Prompt negativo

Requerido

Opcional (dejar vacío)

Nodos personalizados esenciales

Paquetes de nodos recomendados

Paquete de nodos

GitHub

Caso de uso

ComfyUI-Manager

ltdrdata/ComfyUI-Manager

Instalar y gestionar todos los demás nodos

ComfyUI-FLUX

XLabs-AI/x-flux-comfyui

Nodos ControlNet para FLUX

was-node-suite

WASasquatch/was-node-suite-comfyui

Más de 100 nodos utilitarios

ComfyUI-Impact-Pack

ltdrdata/ComfyUI-Impact-Pack

Detección de rostros, 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 entrada/salida de video

ComfyUI-GGUF

city96/ComfyUI-GGUF

Ejecutar modelos GGUF cuantizados

ComfyUI-KJNodes

kijai/ComfyUI-KJNodes

Nodos utilitarios y de máscara

rgthree-comfy

rgthree/rgthree-comfy

Ayudantes de flujo, mejor UI

ComfyUI-FLUX (XLabs-AI)

Añade soporte 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), XFlux Sampler

was-node-suite

Más de 100 nodos utilitarios para flujos 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: Image Batch, Text Operations, Image Analyze, Cache Node, Bus Node, Upscale, Mask operations

Instalar vía Manager

Hacer clic Manager botón
Install Custom Nodes
Buscar e instalar
Reiniciar ComfyUI

Flujos de trabajo avanzados

ControlNet

# Descargar modelos ControlNet
cd ComfyUI/models/controlnet

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

# Depth
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:

Cargar imagen → Detector de bordes Canny
Aplicar ControlNet → KSampler
Generar con guía de pose/bordes

Aumento de resolución

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

Flujo:

Generar imagen a menor resolución (768x768)
Nodo Upscale Image (Model)
Opcional: paso img2img para detalle

SDXL + Refiner

Generar con SDXL base (pasos 1-20)
Pasar el latente al refinador SDXL (pasos 21-30)
VAE Decode del 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

Delete

Eliminar seleccionados

Ctrl+M

Silenciar nodo

Ctrl+B

Saltar nodo

Uso de la API

Encolar prompt

import json
import urllib.request

# Para acceso externo, use su 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 de flujo 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"Step {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("¡Hecho!")
        break

Consejos de rendimiento

Habilitar --lowvram para <8GB VRAM
Usar fp16 modelos cuando sea posible
Tamaño de lote 1 para VRAM limitada
VAE en mosaicos para imágenes de alta resolución
Desactivar vista previa para generación más rápida

Requisitos de GPU

Modelo

VRAM mínima

VRAM recomendada

RAM mínima

SD 1.5

4GB

8GB

16GB

SDXL

8GB

12GB

16GB

SDXL + ControlNet

10GB

16GB

FLUX

16GB

24GB

32GB

Preajustes de GPU

RTX 3060 12GB (Económica)

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

# Ajustes recomendados:
# - SDXL: 768x768, lote 1
# - SD 1.5: 512x512, lote 4
# - Usar VAE en mosaico
# - 20-30 pasos

Mejor para: SD 1.5, SDXL (con limitaciones)

RTX 3090 24GB (Óptima)

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

# Ajustes recomendados:
# - SDXL: 1024x1024, lote 2
# - FLUX schnell: 1024x1024, lote 1
# - ControlNet + SDXL funciona bien
# - 30-50 pasos

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

RTX 4090 24GB (Alto rendimiento)

# Lanzamiento a toda velocidad
python main.py

# Ajustes recomendados:
# - SDXL: 1024x1024, lote 4
# - FLUX dev: 1024x1024, lote 1-2
# - Flujos de trabajo complejos con múltiples ControlNets
# - 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

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

Mejor para: Cargas de trabajo de producción, FLUX, generación en 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

40GB

$1.50–3.00

~3 seg/imagen

Precios en USD/día. Las tarifas varían según el proveedor: consulte CLORE.AI Marketplace para las tarifas actuales.

Solución de problemas

HTTP 502 por mucho tiempo

Verificar RAM: El servidor debe tener 16GB+ de RAM
Verificar VRAM: 8GB+ para SDXL, 16GB+ para FLUX
Descargando dependencias: La primera ejecución toma 5-10 min
Descarga del modelo: Los modelos grandes tardan más

Memoria insuficiente

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

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

Imágenes en negro

Verificar que el VAE esté cargado
Probar un VAE diferente
Reduzca el tamaño de la imagen

Generación lenta

Habilitar CUDA
Usar modelos fp16
Reducir pasos (20-30 suele ser suficiente)

Ejemplos de flujo de trabajo

Importa estos flujos de trabajo JSON en ComfyUI:

Próximos pasos

Guía de ControlNet
Escalado Real-ESRGAN
Entrenamiento Kohya - Entrenar LoRAs personalizados
Fooocus - Alternativa más simple

AnteriorStable Diffusion WebUI SiguienteFooocus

Última actualización hace 1 día

¿Te fue útil?

hashtagRequisitos del servidor

hashtag¿Por qué ComfyUI?

hashtagDespliegue rápido en CLORE.AI

hashtagVerificar que funciona

hashtagAccediendo a tu servicio

hashtagInstalación

hashtagUsando Docker (Recomendado)

hashtagInstalación manual

hashtagEstructura de directorios

hashtagDescargar modelos

hashtagCheckpoints de Stable Diffusion

hashtagVAE

hashtagLoRAs

hashtagFlujo de trabajo básico

hashtagTexto a imagen

hashtagImagen a imagen

hashtagComfyUI Manager

hashtagInstalación

hashtagUsando ComfyUI Manager

hashtagMantener los nodos actualizados

hashtagFlujo FLUX en ComfyUI

hashtagArchivos requeridos

hashtagFLUX.1-dev Workflow JSON

hashtagFLUX.1-schnell Workflow (4 pasos)

hashtagDiferencias clave de nodos: FLUX vs SD

hashtagNodos personalizados esenciales

hashtagPaquetes de nodos recomendados

hashtagComfyUI-FLUX (XLabs-AI)

hashtagwas-node-suite

hashtagInstalar vía Manager

hashtagFlujos de trabajo avanzados

hashtagControlNet

hashtagAumento de resolución

hashtagSDXL + Refiner

hashtagAtajos de teclado

hashtagUso de la API

hashtagEncolar prompt

hashtagWebSocket para progreso

hashtagConsejos de rendimiento

hashtagRequisitos de GPU

hashtagPreajustes de GPU

hashtagRTX 3060 12GB (Económica)

hashtagRTX 3090 24GB (Óptima)

hashtagRTX 4090 24GB (Alto rendimiento)

hashtagA100 40GB/80GB (Producción)

hashtagEstimación de costos

hashtagSolución de problemas

hashtagHTTP 502 por mucho tiempo

hashtagMemoria insuficiente

hashtagImágenes en negro

hashtagGeneración lenta

hashtagEjemplos de flujo de trabajo

hashtagPróximos pasos

Requisitos del servidor

¿Por qué ComfyUI?

Despliegue rápido en CLORE.AI

Verificar que funciona

Accediendo a tu servicio

Instalación

Usando Docker (Recomendado)

Instalación manual

Estructura de directorios

Descargar modelos

Checkpoints de Stable Diffusion

VAE

LoRAs

Flujo de trabajo básico

Texto a imagen

Imagen a imagen

ComfyUI Manager

Instalación

Usando ComfyUI Manager

Mantener los nodos actualizados

Flujo FLUX en ComfyUI

Archivos requeridos

FLUX.1-dev Workflow JSON

FLUX.1-schnell Workflow (4 pasos)

Diferencias clave de nodos: FLUX vs SD

Nodos personalizados esenciales

Paquetes de nodos recomendados

ComfyUI-FLUX (XLabs-AI)

was-node-suite

Instalar vía Manager

Flujos de trabajo avanzados

ControlNet

Aumento de resolución

SDXL + Refiner

Atajos de teclado

Uso de la API

Encolar prompt

WebSocket para progreso

Consejos de rendimiento

Requisitos de GPU

Preajustes de GPU

RTX 3060 12GB (Económica)

RTX 3090 24GB (Óptima)

RTX 4090 24GB (Alto rendimiento)

A100 40GB/80GB (Producción)

Estimación de costos

Solución de problemas

HTTP 502 por mucho tiempo

Memoria insuficiente

Imágenes en negro

Generación lenta

Ejemplos de flujo de trabajo

Próximos pasos