# InvokeAI

InvokeAI ist ein professionelles Stable Diffusion-Toolkit mit einem erweiterten, node-basierten Canvas-Editor, voller SDXL/SD1.5/SD2.x-Unterstützung, ControlNet, IP-Adapter, LoRA-Verwaltung und einer ausgereiften Web-Oberfläche. Es ist für Künstler und kreative Profis konzipiert, die präzise Kontrolle über ihren Bildgenerierungs-Workflow benötigen. CLORE.AIs GPUs mit viel VRAM ermöglichen es Ihnen, SDXL in voller Auflösung mit mehreren ControlNets gleichzeitig auszuführen.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

| Parameter  | Minimum              | Empfohlen                |
| ---------- | -------------------- | ------------------------ |
| RAM        | 12 GB                | 32 GB+                   |
| VRAM       | 6 GB                 | 12 GB+                   |
| Festplatte | 40 GB                | 200 GB+                  |
| GPU        | NVIDIA GTX 1060 6GB+ | RTX 3090, RTX 4090, A100 |

{% hint style="info" %}
Für SDXL (1024×1024) ohne Kompromisse werden 12 GB VRAM empfohlen. Für SD1.5 (512×512 oder 768×768) sind 6 GB VRAM ausreichend. Mehr VRAM = höhere Auflösung, schnellere Generierung und mehr ControlNets gleichzeitig.
{% endhint %}

## Schnelle Bereitstellung auf CLORE.AI

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

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

**Umgebungsvariablen:**

| Variable        | Beispiel    | Beschreibung                              |
| --------------- | ----------- | ----------------------------------------- |
| `INVOKEAI_ROOT` | `/invokeai` | Stammverzeichnis für Modelle und Ausgaben |

## Schritt-für-Schritt-Einrichtung

### 1. Mieten Sie einen GPU-Server auf CLORE.AI

Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace) und suchen Sie nach:

* **Budget-für-kreative-Arbeiten**: RTX 3080/3090 (10–24 GB VRAM)
* **Professionelles SDXL**: RTX 4090 (24 GB VRAM)
* **Maximale Qualität**: A100 80GB — mehrere Modelle gleichzeitig ausführen

### 2. SSH auf Ihren Server

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

### 3. Erstellen Sie die InvokeAI-Verzeichnisstruktur

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

### 4. Ziehen Sie das InvokeAI-Docker-Image

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

### 5. Starten Sie InvokeAI

**Basisstart:**

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

**Mit benutzerdefiniertem Root und erhöhten Ressourcen:**

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

**Mit spezifischer GPU (Multi-GPU-Server):**

```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. Warten Sie auf die Initialisierung

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

Achten Sie auf: `Uvicorn running on http://0.0.0.0:9090`

### 7. Zugriff über CLORE.AI HTTP-Proxy

Öffnen Sie Ihr CLORE.AI-Dashboard und finden Sie die `http_pub` URL für Port 9090:

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

Dies öffnet die vollständige InvokeAI-Weboberfläche in Ihrem Browser.

### 8. Laden Sie Ihr erstes Modell herunter

In der InvokeAI-Oberfläche:

1. Klicken Sie **Model Manager** (Würfel-Symbol in der linken Seitenleiste)
2. Klicken Sie **Modell hinzufügen → HuggingFace**
3. Geben Sie die Modell-ID ein (z. B., `stabilityai/stable-diffusion-xl-base-1.0`)
4. Klicken Sie **Modell hinzufügen**

Oder laden Sie direkt von CivitAI herunter:

1. Gehen Sie zu **Model Manager → Add Model → URL**
2. Fügen Sie die CivitAI-Download-URL ein
3. Stellen Sie den Modelltyp ein (Checkpoint, LoRA, usw.)

***

## Beispielanwendungen

### Beispiel 1: Basis-Bilderzeugung über die Web-Oberfläche

1. Öffnen Sie InvokeAI unter Ihrer CLORE.AI http\_pub-URL
2. Klicken Sie **Text zu Bild** im Workflow-Selector
3. Geben Sie ein Prompt ein: `"a majestic dragon perched on a crystal mountain, digital art, 4k"`
4. Setzen Sie den negativen Prompt: `"blurry, low quality, watermark"`
5. Stellen Sie die Auflösung ein auf `1024x1024` (SDXL) oder `512x512` (SD1.5)
6. Klicken Sie **Ausführen**

### Beispiel 2: Verwendung des node-basierten Canvas

Der Workflow-Editor ist InvokeAIs charakteristisches Feature:

1. Klicken Sie **Workflows** in der oberen Navigation
2. Klicken Sie **Neuer Workflow**
3. Knoten hinzufügen: **Text → Bild**, verbinden mit **Bild speichern**
4. Fügen Sie einen **ControlNet** Knoten für geführte Generierung hinzu:
   * Rechtsklick → Knoten hinzufügen → **ControlNet**
   * Verbinden Sie Ihr Referenzbild
   * Prozessor auswählen: `Canny`, `Depth`, `Pose`, usw.
5. Klicken Sie **Ausführen** um die gesamte Pipeline auszuführen

### Beispiel 3: LoRA-Verwendung

1. Laden Sie eine LoRA von CivitAI herunter (über Model Manager → URL-Import)
2. Im Generierungs-Panel finden Sie **LoRA** Abschnitt
3. Klicken Sie **+** und wählen Ihre LoRA aus
4. Gewicht einstellen (typisch 0.5–1.0)
5. Fügen Sie das Trigger-Wort zum Prompt hinzu (auf der CivitAI-Modellseite aufgeführt)

Beispiel-Prompt mit LoRA-Trigger:

```
portrait of a woman, <lora:detail-tweaker:0.8>, hyperrealistic, studio lighting
```

### Beispiel 4: Verwendung des IP-Adapters für Stilübertragung

1. Aktivieren Sie **IP-Adapter** im Generierungs-Panel
2. Laden Sie ein Referenzstilbild hoch
3. Gewicht einstellen (0.5 = subtile Einflussnahme, 1.0 = starker Einfluss)
4. Generieren Sie mit beliebigem Prompt — die Ausgabe passt sich dem Referenzstil an

### Beispiel 5: API-Verwendung (Headless)

InvokeAI stellt eine REST-API für die programmgesteuerte Nutzung bereit:

```python
import requests
import time
import base64

BASE_URL = "http://localhost:9090"  # oder Ihre CLORE.AI http_pub-URL

# Verfügbare Modelle auflisten
models = requests.get(f"{BASE_URL}/api/v1/models").json()
print("Available models:", [m["name"] for m in models.get("items", [])])

# Eine Generierung in die Warteschlange stellen
payload = {
    "batch": {
        "graph": {
            "nodes": {
                "text_encoder": {
                    "type": "compel",
                    "id": "text_encoder",
                    "prompt": "a futuristic city at sunset, photorealistic",
                },
                "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": [],
        }
    }
}

# Einfacher: Verwenden Sie die Queue-API
response = requests.post(f"{BASE_URL}/api/v1/queue/default/enqueue_batch", json=payload)
print(response.status_code)
```

***

## Konfiguration

### invokeai.yaml Konfigurationsdatei

Zu finden unter `/root/invokeai/invokeai.yaml`:

```yaml
InvokeAI:
  Web-Server:
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  Funktionen:
    esrgan: true          # ESRGAN Upscaling
    internet_available: true
    
  Speicher/Leistung:
    ram: 12.0             # Max. RAM für Modell-Cache (GB)
    vram: 0.25            # Anteil des VRAM für Modell-Cache
    lazy_offload: true    # Modelle auf CPU auslagern, wenn sie nicht verwendet werden
    
  Pfad:
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs
```

### Empfohlene Einstellungen nach GPU

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

```yaml
Speicher/Leistung:
  ram: 24.0
  vram: 0.5   # 50% für aktives Modell reservieren
  lazy_offload: false  # Nicht auslagern — genügend VRAM
```

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

```yaml
Speicher/Leistung:
  ram: 16.0
  vram: 0.25
  lazy_offload: true
```

**Kleinere GPUs (6-8 GB VRAM):**

```yaml
Speicher/Leistung:
  ram: 8.0
  vram: 0.1
  lazy_offload: true
```

***

## Leistungs-Tipps

### 1. Verwenden Sie SDXL-Turbo oder SDXL-Lightning für schnelle Generierung

Statt SDXL base (25–50 Schritte) verwenden Sie:

* **SDXL-Turbo**: 1–4 Schritte, Echtzeit-Generierung
* **SDXL-Lightning**: 4–8 Schritte, nahezu SDXL-Qualität

Herunterladen über Model Manager → HuggingFace:

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

### 2. Wählen Sie den richtigen Scheduler

| Scheduler      | Qualität      | Geschwindigkeit | Am besten für               |
| -------------- | ------------- | --------------- | --------------------------- |
| `euler_a`      | Gut           | Schnell         | Allgemeiner Gebrauch        |
| `dpmpp_2m`     | Ausgezeichnet | Schnell         | Fotorealistische Ergebnisse |
| `dpmpp_2m_sde` | Ausgezeichnet | Mittel          | Hohe Details                |
| `ddim`         | Gut           | Schnell         | Inpainting                  |
| `lms`          | Gut           | Schnell         | Künstlerische Stile         |

### 3. Aktivieren Sie xFormers Memory Optimization

InvokeAI aktiviert dies automatisch, wenn verfügbar. Überprüfen Sie die Logs:

```
xFormers is available
```

### 4. Verwenden Sie Modell-Caching

Halten Sie Ihre am häufigsten verwendeten Modelle im Cache. In invokeai.yaml:

```yaml
ram: 32.0  # Größer = mehr Modelle im Cache
```

### 5. Kacheln für hohe Auflösungen

Für Bilder, die größer sind als Ihr VRAM zulässt (z. B. 2048×2048 auf einer 12-GB-GPU):

* Verwenden Sie **Tiled VAE** im Workflow-Editor
* Oder erzeugen Sie bei 1024×1024 und skalieren dann mit **ESRGAN**

***

## Fehlerbehebung

### Problem: "CUDA out of memory"

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

**Lösungen:**

1. Niedrigere Auflösung (1024→768 oder 512)
2. Batch-Größe auf 1 reduzieren
3. Lazy-Offloading in invokeai.yaml aktivieren
4. Ein kleineres Modell verwenden (SD1.5 statt SDXL)

### Problem: Web-Oberfläche nicht erreichbar

```bash
# Prüfen, ob der Container läuft
docker ps | grep invokeai

# Prüfen Sie die Logs auf Fehler
docker logs invokeai 2>&1 | tail -50

# Überprüfen Sie die Port-Zuordnung
docker port invokeai
```

Stellen Sie sicher, dass Port 9090 in der Port-Konfiguration Ihrer CLORE.AI-Bestellung aufgeführt ist.

### Problem: Modell-Download schlägt im Container fehl

```bash
# Manuell per exec herunterladen
docker exec -it invokeai bash
cd /invokeai/models/main
wget "https://civitai.com/api/download/models/XXX" -O mymodel.safetensors
```

### Problem: Langsame Generierung (< 1 it/s)

* Prüfen Sie die GPU-Auslastung: `docker exec -it invokeai nvidia-smi`
* Stellen Sie sicher, dass xFormers in den Logs aktiviert ist
* Versuchen Sie `euler_a` scheduler (schnellster)

### Problem: Schwarze/defekte Bilder

Meist ein VAE-Problem. Versuchen Sie:

1. Model Manager → Modell bearbeiten → VAE ändern zu `sdxl-vae-fp16-fix`
2. Oder fügen Sie hinzu `--fp32-vae` Flag

### Problem: Container startet nicht

```bash
docker logs invokeai
# Häufig: Port 9090 bereits in Gebrauch
# Behebung:
docker stop $(docker ps -q --filter "publish=9090")
docker start invokeai
```

***

## Links

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

***

## Clore.ai GPU-Empfehlungen

| Anwendungsfall    | Empfohlene GPU  | Geschätzte Kosten auf Clore.ai |
| ----------------- | --------------- | ------------------------------ |
| Entwicklung/Tests | RTX 3090 (24GB) | \~$0.12/gpu/hr                 |
| Produktion        | RTX 4090 (24GB) | \~$0.70/gpu/hr                 |
| Großmaßstab       | A100 80GB       | \~$1.20/gpu/hr                 |

> 💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf [Clore.ai](https://clore.ai/marketplace) GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.


---

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