# InvokeAI

InvokeAI es un conjunto de herramientas de nivel profesional para Stable Diffusion que cuenta con un avanzado editor tipo lienzo basado en nodos, soporte completo para SDXL/SD1.5/SD2.x, ControlNet, IP-Adapter, gestión de LoRA y una interfaz web pulida. Está diseñado para artistas y profesionales creativos que necesitan control preciso sobre su flujo de trabajo de generación de imágenes. Las GPU de alto VRAM de CLORE.AI permiten ejecutar SDXL a resolución completa con múltiples ControlNets simultáneamente.

{% 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       | 12 GB                | 32 GB+                   |
| VRAM      | 6 GB                 | 12 GB+                   |
| Disco     | 40 GB                | 200 GB+                  |
| GPU       | NVIDIA GTX 1060 6GB+ | RTX 3090, RTX 4090, A100 |

{% hint style="info" %}
Para SDXL (1024×1024) sin compromisos, se recomienda 12 GB de VRAM. Para SD1.5 (512×512 o 768×768), 6 GB de VRAM son suficientes. Más VRAM = mayor resolución, generación más rápida y más ControlNets simultáneamente.
{% endhint %}

## Despliegue rápido en CLORE.AI

**Imagen Docker:** `ghcr.io/invoke-ai/invokeai:latest`

**Puertos:** `22/tcp`, `9090/http`

**Variables de entorno:**

| Variable        | Ejemplo     | Descripción                            |
| --------------- | ----------- | -------------------------------------- |
| `INVOKEAI_ROOT` | `/invokeai` | Directorio raíz para modelos y salidas |

## Configuración paso a paso

### 1. Alquila un servidor GPU en CLORE.AI

Visita [CLORE.AI Marketplace](https://clore.ai/marketplace) y busca:

* **Trabajo creativo económico**: RTX 3080/3090 (10–24 GB VRAM)
* **SDXL profesional**: RTX 4090 (24 GB VRAM)
* **Calidad máxima**: A100 80GB — ejecuta múltiples modelos simultáneamente

### 2. Conéctate por SSH a tu servidor

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Crea la estructura de directorios de InvokeAI

```bash
mkdir -p /root/invokeai
```

### 4. Descarga la imagen Docker de InvokeAI

```bash
docker pull ghcr.io/invoke-ai/invokeai:latest
```

### 5. Lanza InvokeAI

**Lanzamiento básico:**

```bash
docker run -d \
  --name invokeai \
  --gpus all \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

**Con root personalizado y recursos aumentados:**

```bash
docker run -d \
  --name invokeai \
  --gpus all \
  --shm-size 8g \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -v /root/models:/root/models \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

**Con GPU específica (servidor multi-GPU):**

```bash
docker run -d \
  --name invokeai \
  --gpus '"device=0"' \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  -e CUDA_VISIBLE_DEVICES=0 \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

### 6. Espera a la inicialización

```bash
docker logs -f invokeai
```

Busca: `Uvicorn ejecutándose en http://0.0.0.0:9090`

### 7. Acceso vía proxy HTTP de CLORE.AI

Abre tu panel de CLORE.AI y encuentra el `http_pub` URL para el puerto 9090:

```
https://<order-id>-9090.clore.ai/
```

Esto abre la interfaz web completa de InvokeAI en tu navegador.

### 8. Descarga tu primer modelo

En la UI de InvokeAI:

1. Haz clic **Administrador de modelos** (icono de cubo en la barra lateral izquierda)
2. Haz clic **Agregar modelo → HuggingFace**
3. Introduce el ID del modelo (p. ej., `stabilityai/stable-diffusion-xl-base-1.0`)
4. Haz clic **Agregar modelo**

O descarga directamente desde CivitAI:

1. Ve a **Administrador de modelos → Agregar modelo → URL**
2. Pega la URL de descarga de CivitAI
3. Establece el tipo de modelo (Checkpoint, LoRA, etc.)

***

## Ejemplos de uso

### Ejemplo 1: Generación básica de imagen vía UI web

1. Abre InvokeAI en tu URL http\_pub de CLORE.AI
2. Haz clic **Texto a imagen** en el selector de flujo de trabajo
3. Introduce un prompt: `"un majestuoso dragón posado en una montaña de cristal, arte digital, 4k"`
4. Establece prompt negativo: `"borroso, baja calidad, marca de agua"`
5. Establece la resolución a `1024x1024` (SDXL) o `512x512` (SD1.5)
6. Haz clic **Invocar**

### Ejemplo 2: Usando el lienzo basado en nodos

El editor de flujos de trabajo es la característica distintiva de InvokeAI:

1. Haz clic **Flujos de trabajo** en la navegación superior
2. Haz clic **Nuevo flujo de trabajo**
3. Agregar nodos: **Texto → Imagen**, conectar a **Guardar imagen**
4. Agrega un **ControlNet** nodo para generación guiada:
   * Clic derecho → Agregar nodo → **ControlNet**
   * Conecta tu imagen de referencia
   * Selecciona procesador: `Canny`, `Profundidad`, `Pose`, etc.
5. Haz clic **Invocar** para ejecutar la canalización completa

### Ejemplo 3: Uso de LoRA

1. Descarga una LoRA desde CivitAI (vía Administrador de modelos → importación por URL)
2. En el panel de generación, busca **LoRA** sección
3. Haz clic **+** y selecciona tu LoRA
4. Establece el peso (0.5–1.0 típico)
5. Añade la palabra de activación al prompt (listada en la página del modelo en CivitAI)

Prompt de ejemplo con activador LoRA:

```
retrato de una mujer, <lora:detail-tweaker:0.8>, hiperrealista, iluminación de estudio
```

### Ejemplo 4: Usando IP-Adapter para transferencia de estilo

1. Activa **IP-Adapter** en el panel de generación
2. Sube una imagen de estilo de referencia
3. Establece el peso (0.5 = influencia sutil, 1.0 = influencia fuerte)
4. Genera con cualquier prompt — la salida coincidirá con el estilo de referencia

### Ejemplo 5: Uso de la API (sin interfaz)

InvokeAI expone una API REST para uso programático:

```python
import requests
import time
import base64

BASE_URL = "http://localhost:9090"  # o tu URL http_pub de CLORE.AI

# Lista modelos disponibles
models = requests.get(f"{BASE_URL}/api/v1/models").json()
print("Modelos disponibles:", [m["name"] for m in models.get("items", [])])

# Encolar una generación
payload = {
    "batch": {
        "graph": {
            "nodes": {
                "text_encoder": {
                    "type": "compel",
                    "id": "text_encoder",
                    "prompt": "una ciudad futurista al atardecer, fotorrealista",
                },
                "noise": {
                    "type": "noise",
                    "id": "noise",
                    "width": 1024,
                    "height": 1024,
                    "seed": 42,
                },
                "denoise_latents": {
                    "type": "denoise_latents",
                    "id": "denoise_latents",
                    "steps": 30,
                    "cfg_scale": 7.5,
                    "scheduler": "dpmpp_2m",
                },
                "l2i": {
                    "type": "l2i",
                    "id": "l2i",
                },
            },
            "edges": [],
        }
    }
}

# Más simple: usa la API de cola
response = requests.post(f"{BASE_URL}/api/v1/queue/default/enqueue_batch", json=payload)
print(response.status_code)
```

***

## Configuración

### Archivo de configuración invokeai.yaml

Ubicado en `/root/invokeai/invokeai.yaml`:

```yaml
InvokeAI:
  Servidor web:
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  Características:
    esrgan: true          # escalado ESRGAN
    internet_available: true
    
  Memoria/Rendimiento:
    ram: 12.0             # RAM máxima para la caché de modelos (GB)
    vram: 0.25            # Fracción de VRAM para la caché de modelos
    lazy_offload: true    # Descargar modelos a CPU cuando no estén en uso
    
  Rutas:
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs
```

### Configuración recomendada por GPU

**RTX 3090 / 4090 (24 GB VRAM):**

```yaml
Memoria/Rendimiento:
  ram: 24.0
  vram: 0.5   # Mantener 50% para el modelo activo
  lazy_offload: false  # No descargar — suficiente VRAM
```

**RTX 3080 (10 GB VRAM):**

```yaml
Memoria/Rendimiento:
  ram: 16.0
  vram: 0.25
  lazy_offload: true
```

**GPUs más pequeñas (6-8 GB VRAM):**

```yaml
Memoria/Rendimiento:
  ram: 8.0
  vram: 0.1
  lazy_offload: true
```

***

## Consejos de rendimiento

### 1. Usa SDXL-Turbo o SDXL-Lightning para generación rápida

En lugar de SDXL base (25–50 pasos), usa:

* **SDXL-Turbo**: 1–4 pasos, generación en tiempo real
* **SDXL-Lightning**: 4–8 pasos, calidad casi SDXL

Descargar vía Administrador de modelos → HuggingFace:

* `stabilityai/sdxl-turbo`
* `ByteDance/SDXL-Lightning`

### 2. Elige el programador correcto

| Scheduler      | Calidad   | Velocidad | Mejor para         |
| -------------- | --------- | --------- | ------------------ |
| `euler_a`      | Bueno     | Rápido    | Uso general        |
| `dpmpp_2m`     | Excelente | Rápido    | Fotorrealista      |
| `dpmpp_2m_sde` | Excelente | Medio     | Alto detalle       |
| `ddim`         | Bueno     | Rápido    | Retoque/Inpainting |
| `lms`          | Bueno     | Rápido    | Estilos artísticos |

### 3. Habilita la optimización de memoria xFormers

InvokeAI la habilita automáticamente cuando está disponible. Verifica en los logs:

```
xFormers está disponible
```

### 4. Usa caché de modelos

Mantén tus modelos más usados en la caché. En invokeai.yaml:

```yaml
ram: 32.0  # Más grande = más modelos en caché
```

### 5. Usa tiled para altas resoluciones

Para imágenes más grandes de lo que permite tu VRAM (p. ej., 2048×2048 en GPU de 12 GB):

* Usa **VAE en mosaicos** en el editor de flujos de trabajo
* O genera a 1024×1024 y luego amplía con **ESRGAN**

***

## Solución de problemas

### Problema: "CUDA out of memory"

```
RuntimeError: CUDA out of memory
```

**Soluciones:**

1. Reducir resolución (1024→768 o 512)
2. Reducir tamaño de lote a 1
3. Habilitar lazy offloading en invokeai.yaml
4. Usar un modelo más pequeño (SD1.5 en lugar de SDXL)

### Problema: UI web no accesible

```bash
# Comprueba si el contenedor está en ejecución
docker ps | grep invokeai

# Comprueba los logs por errores
docker logs invokeai 2>&1 | tail -50

# Verifica el mapeo de puertos
docker port invokeai
```

Asegúrate de que el puerto 9090 esté listado en la configuración de puertos de tu orden en CLORE.AI.

### Problema: la descarga del modelo falla dentro del contenedor

```bash
# Descargar manualmente vía exec
docker exec -it invokeai bash
cd /invokeai/models/main
wget "https://civitai.com/api/download/models/XXX" -O mymodel.safetensors
```

### Problema: Generación lenta (< 1 it/s)

* Comprueba la utilización de la GPU: `docker exec -it invokeai nvidia-smi`
* Asegúrate de que xFormers esté habilitado en los logs
* Prueba `euler_a` scheduler (el más rápido)

### Problema: Imágenes negras/rotas

Normalmente es un problema del VAE. Prueba:

1. Administrador de modelos → Editar modelo → Cambiar VAE a `sdxl-vae-fp16-fix`
2. O añade `--fp32-vae` flag

### Problema: El contenedor no arranca

```bash
docker logs invokeai
# Común: el puerto 9090 ya está en uso
# Solución:
docker stop $(docker ps -q --filter "publish=9090")
docker start invokeai
```

***

## Enlaces

* [GitHub](https://github.com/invoke-ai/InvokeAI)
* [Documentación](https://invoke-ai.github.io/InvokeAI/)
* [Docker Hub / GHCR](https://github.com/invoke-ai/InvokeAI/pkgs/container/invokeai)
* [CivitAI (Modelos)](https://civitai.com)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)

***

## Recomendaciones de GPU de Clore.ai

| Caso de uso        | GPU recomendada | Coste estimado en Clore.ai |
| ------------------ | --------------- | -------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Producción         | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Gran escala        | A100 80GB       | \~$1.20/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.