> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/comfyui.md).

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

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

{% hint style="warning" %}
**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.
{% endhint %}

{% hint style="danger" %}
**Importante:** ComfyUI con modelos FLUX requiere 16 GB+ de VRAM. Para SDXL con ControlNet, asegúrate de tener al menos 10 GB de VRAM.
{% endhint %}

## ¿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**:

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

{% hint style="info" %}
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
   {% endhint %}

## 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`

{% hint style="info" %}
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.
{% endhint %}

## Instalación

### Usando Docker (recomendado)

```bash
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

```bash
# 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

```bash
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

```bash
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

```bash
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

```bash
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

```bash
# 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:

```bash
# 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:

```json
{
  "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:

```bash
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:

```bash
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

```bash
# 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

```bash
# 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

```python
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

```python
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)

```bash
# 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)

```bash
# 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)

```bash
# 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)

```bash
# 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*](https://clore.ai/marketplace) *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

```bash
# 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](https://comfyworkflows.com)
* [SDXL + Refiner](https://comfyworkflows.com)
* [ControlNet Canny](https://comfyworkflows.com)
* [Video AnimateDiff](https://comfyworkflows.com)

## Siguientes pasos

* [Guía de ControlNet](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md)
* [Escalado con Real-ESRGAN](/guides/guides_v2-es/procesamiento-de-imagenes/real-esrgan-upscaling.md)
* [Entrenamiento de Kohya](/guides/guides_v2-es/entrenamiento/kohya-training.md) - Entrenar LoRAs personalizadas
* [Fooocus](/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd.md) - Alternativa más sencilla


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-imagenes/comfyui.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.