# 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](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md)
* [Escalado Real-ESRGAN](/guides/guides_v2-es/procesamiento-de-imagenes/real-esrgan-upscaling.md)
* [Entrenamiento Kohya](/guides/guides_v2-es/entrenamiento/kohya-training.md) - Entrenar LoRAs personalizados
* [Fooocus](/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd.md) - Alternativa más simple


---

# Agent Instructions: 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:

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

The question should be specific, self-contained, and written in natural language.
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.