> 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/invokeai.md).

# InvokeAI

Ejecuta la herramienta profesional de Stable Diffusion InvokeAI con lienzo basado en nodos en GPUs de Clore.ai

InvokeAI es un kit de herramientas Stable Diffusion de nivel profesional que cuenta con un editor de lienzo avanzado basado en nodos, compatibilidad completa con SDXL/SD1.5/SD2.x, ControlNet, IP-Adapter, gestión de LoRA y una pulida interfaz web. Está diseñado para artistas y profesionales creativos que necesitan un control preciso sobre su flujo de trabajo de generación de imágenes. Las GPU de gran VRAM de CLORE.AI te 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 [Marketplace de CLORE.AI](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 recomiendan 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 de 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 [Marketplace de CLORE.AI](https://clore.ai/marketplace) y busca:

* **Trabajo creativo económico**: RTX 3080/3090 (10–24 GB de VRAM)
* **SDXL profesional**: RTX 4090 (24 GB de VRAM)
* **Máxima calidad**: A100 80 GB — ejecuta varios 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. Inicia InvokeAI

**Inicio 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 raíz personalizada 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 una 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. Accede a través del proxy HTTP de CLORE.AI

Abre tu panel de CLORE.AI y encuentra la `http_pub` URL del 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 interfaz de InvokeAI:

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

O descarga directamente desde CivitAI:

1. Ve a **Gestor de modelos → Añadir 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 imágenes mediante la interfaz web

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

### Ejemplo 2: Uso del lienzo basado en nodos

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

1. Haz clic en **Flujos de trabajo** en la navegación superior
2. Haz clic en **Nuevo flujo de trabajo**
3. Añade nodos: **Texto → Imagen**, conéctalo a **Guardar imagen**
4. Añade un **ControlNet** nodo para generación guiada:
   * Clic derecho → Añadir nodo → **ControlNet**
   * Conecta tu imagen de referencia
   * Selecciona el procesador: `Canny`, `Profundidad`, `Pose`, etc.
5. Haz clic en **Invocar** para ejecutar todo el flujo

### Ejemplo 3: Uso de LoRA

1. Descarga una LoRA desde CivitAI (mediante Gestor de modelos → importación por URL)
2. En el panel de generación, busca **LoRA** sección
3. Haz clic en **+** y selecciona tu LoRA
4. Establece el peso (0.5–1.0 es lo habitual)
5. Añade la palabra desencadenante al prompt (indicada en la página del modelo de CivitAI)

Prompt de ejemplo con desencadenante LoRA:

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

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

1. Activa **IP-Adapter** en el panel de generación
2. Sube una imagen de referencia de estilo
3. Establece el peso (0.5 = influencia sutil, 1.0 = influencia fuerte)
4. Genera con cualquier prompt — el resultado 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 los 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 sencillo: 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: []
    
  Funciones:
    esrgan: true          # escalado ESRGAN
    internet_available: true
    
  Memoria/Rendimiento:
    ram: 12.0             # RAM máxima para la caché del modelo (GB)
    vram: 0.25            # Fracción de VRAM para la caché del modelo
    lazy_offload: true    # Descarga los modelos a la CPU cuando no estén en uso
    
  Rutas:
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs
```

### Ajustes recomendados por GPU

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

```yaml
Memoria/Rendimiento:
  ram: 24.0
  vram: 0.5   # Mantén el 50 % para el modelo activo
  lazy_offload: false  # No descargues: hay suficiente VRAM
```

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

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

**GPU más pequeñas (6-8 GB de 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

Descarga mediante Gestor de modelos → HuggingFace:

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

### 2. Elige el programador adecuado

| Programador    | Calidad   | Velocidad | Ideal para         |
| -------------- | --------- | --------- | ------------------ |
| `euler_a`      | Bueno     | Rápido    | Uso general        |
| `dpmpp_2m`     | Excelente | Rápido    | Fotorealista       |
| `dpmpp_2m_sde` | Excelente | Medio     | Alto detalle       |
| `ddim`         | Bueno     | Rápido    | Inpainting         |
| `lms`          | Bueno     | Rápido    | Estilos artísticos |

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

InvokeAI lo habilita automáticamente cuando está disponible. Verifica en los registros:

```
xFormers está disponible
```

### 4. Usa la 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. Divide en mosaicos para resoluciones grandes

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

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

***

## Solución de problemas

### Problema: "CUDA sin memoria"

```
RuntimeError: CUDA sin memoria
```

**Soluciones:**

1. Reduce la resolución (1024→768 o 512)
2. Reduce el tamaño de lote a 1
3. Activa la descarga diferida en invokeai.yaml
4. Usa un modelo más pequeño (SD1.5 en lugar de SDXL)

### Problema: la interfaz web no es accesible

```bash
# Comprueba si el contenedor está ejecutándose
docker ps | grep invokeai

# Revisa los registros en busca de errores
docker logs invokeai 2>&1 | tail -50

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

Asegúrate de que el puerto 9090 figure en la configuración de puertos de tu pedido de CLORE.AI.

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

```bash
# Descarga manualmente mediante 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 el uso de la GPU: `docker exec -it invokeai nvidia-smi`
* Asegúrate de que xFormers esté habilitado en los registros
* Prueba `euler_a` programador (el más rápido)

### Problema: imágenes negras/dañadas

Suele ser un problema de VAE. Prueba:

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

### 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)
* [Marketplace de CLORE.AI](https://clore.ai/marketplace)

***

## Recomendaciones de GPU para Clore.ai

| Caso de uso        | GPU recomendada | Costo estimado en Clore.ai                |
| ------------------ | --------------- | ----------------------------------------- |
| Desarrollo/Pruebas | RTX 3090 (24GB) | $0.07–0.21/gpu/hr                         |
| Producción         | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| Gran escala        | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

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


---

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