# ComfyUI

Interfaz basada en nodos para Stable Diffusion con la 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 [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Requisitos del servidor

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

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

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

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

```bash
# Comprueba si la UI 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 por más de 15 minutos, verifica:

1. El servidor tiene 16GB+ de RAM
2. El servidor tiene 8GB+ de VRAM para SDXL, 16GB+ para FLUX
3. La velocidad de la red es adecuada para descargar modelos
   {% endhint %}

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

{% hint style="info" %}
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.
{% 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:cu126-slim
```

### Instalación manual

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

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

# 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

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

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

## Flujo de trabajo básico

### Texto a imagen

1. 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
2. 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:

1. **Cargar imagen** → tu imagen fuente
2. **VAE Encode** → convertir a latente
3. 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

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

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

1. Hacer clic **Manager** botón
2. Seleccionar **Install Custom Nodes**
3. Buscar por nombre (p. ej., "FLUX", "AnimateDiff")
4. Hacer clic **Instalar** en el paquete deseado
5. Hacer clic **Reiniciar** cuando se solicite
6. 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

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

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

### FLUX.1-dev Workflow JSON

Guardar como `flux_dev_workflow.json` e importar vía **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": ["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:

```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)`, `XFlux Sampler`

### was-node-suite

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

### Instalar vía Manager

1. Hacer clic **Manager** botón
2. **Install Custom Nodes**
3. Buscar e instalar
4. Reiniciar ComfyUI

## Flujos de trabajo avanzados

### ControlNet

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

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

### Aumento de resolución

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

Flujo:

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

### SDXL + Refiner

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

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

```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"Step {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("¡Hecho!")
        break
```

## Consejos de rendimiento

1. **Habilitar --lowvram** para <8GB VRAM
2. **Usar fp16** modelos cuando sea posible
3. **Tamaño de lote 1** para VRAM limitada
4. **VAE en mosaicos** para imágenes de alta resolución
5. **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             | 16GB       |
| FLUX              | 16GB        | 24GB             | 32GB       |

## Preajustes de GPU

### RTX 3060 12GB (Económica)

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

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

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

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

## Solución de problemas

### HTTP 502 por mucho tiempo

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

### Memoria insuficiente

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

* [txt2img básico](https://comfyworkflows.com)
* [SDXL + Refiner](https://comfyworkflows.com)
* [ControlNet Canny](https://comfyworkflows.com)
* [Video AnimateDiff](https://comfyworkflows.com)

## Próximos pasos

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