> 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-de/bildgenerierung/comfyui.md).

# ComfyUI

Knotenbasierte Oberfläche für Stable Diffusion mit maximaler Flexibilität auf CLORE.AI-GPUs.

{% 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       | 16GB         | 32GB+     |
| VRAM      | 8 GB (SDXL)  | 12GB+     |
| Netzwerk  | 500Mbps      | 1Gbps+    |
| Startzeit | 5–10 Minuten | -         |

{% hint style="warning" %}
**Startzeit:** Beim ersten Start werden Abhängigkeiten und Modelle heruntergeladen (5–10 Minuten je nach Netzwerkgeschwindigkeit). HTTP 502 in dieser Zeit ist normal.
{% endhint %}

{% hint style="danger" %}
**Wichtig:** ComfyUI mit FLUX-Modellen benötigt 16 GB+ VRAM. Für SDXL mit ControlNet sollten mindestens 10 GB VRAM vorhanden sein.
{% endhint %}

## Warum ComfyUI?

* **Knotenbasierter Workflow** - Visuelle Programmierung zur Bildgenerierung
* **Maximale Kontrolle** - Feinabstimmung jedes Schrittes der Pipeline
* **Effizient** - Niedrigerer VRAM-Verbrauch als Alternativen
* **Erweiterbar** - Großes Ökosystem an benutzerdefinierten Knoten
* **Workflow-Sharing** - Import/Export als JSON

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
yanwk/comfyui-boot:cu126-slim
```

**Ports:**

```
22/tcp
8188/http
```

**Umgebung:**

```
CLI_ARGS=--listen 0.0.0.0
```

### Überprüfen, ob es funktioniert

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

```bash
# Prüfen, ob die UI erreichbar ist (kann beim ersten Start 5–10 Min dauern)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
Wenn Sie länger als 15 Minuten HTTP 502 erhalten, prüfen Sie:

1. Server hat 16GB+ RAM
2. Server hat 8 GB+ VRAM für SDXL, 16 GB+ für FLUX
3. Netzwerkgeschwindigkeit ist ausreichend zum Herunterladen von Modellen
   {% endhint %}

## Zugriff auf Ihren Dienst

Wenn auf CLORE.AI bereitgestellt, greifen Sie auf ComfyUI über die `http_pub` URL:

* **Weboberfläche:** `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" %}
Alle `localhost:8188` Die untenstehenden Beispiele funktionieren, wenn über SSH verbunden. Für externen Zugriff ersetzen Sie durch Ihre `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Installation

### Verwendung von Docker (empfohlen)

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

### Manuelle Installation

```bash
# Repository klonen
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate

# PyTorch mit CUDA installieren
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

# Anforderungen installieren
pip install -r requirements.txt

# Ausführen
python main.py --listen 0.0.0.0
```

## Verzeichnisstruktur

```
ComfyUI/
├── models/
│   ├── checkpoints/     # SD-Modelle (.safetensors)
│   ├── loras/           # LoRA-Modelle
│   ├── vae/             # VAE-Modelle
│   ├── controlnet/      # ControlNet-Modelle
│   ├── upscale_models/  # Upscaler
│   └── clip/            # CLIP-Modelle
├── input/               # Eingabebilder
├── output/              # Generierte Bilder
└── custom_nodes/        # Erweiterungen
```

## Modelle herunterladen

### Stable Diffusion Checkpoints

```bash
cd ComfyUI/models/checkpoints

# SDXL Basis
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 (kleiner, schneller)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (fotorealistisch)
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

# SDXL VAE
wget https://huggingface.co/stabilityai/sdxl-vae/resolve/main/sdxl_vae.safetensors

# SD 1.5 VAE (bessere Farben)
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

# Herunterladen von CivitAI oder HuggingFace
# Legen Sie .safetensors-Dateien hier ab
```

## Grundlegender Workflow

### Text zu Bild

1. Knoten hinzufügen:
   * **Checkpoint laden** → Modell auswählen
   * **CLIP Text Encode** (x2) → positive & negative Prompts
   * **Leeres latentes Bild** → Abmessungen einstellen
   * **KSampler** → alles verbinden
   * **VAE-Decodierung** → latent zu Bild
   * **Bild speichern** → Ausgabe
2. Verbinden:

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

### Bild zu Bild

Ersetzen **Leeres latentes Bild** mit:

1. **Bild laden** → Ihr Quellbild
2. **VAE-Enkodierung** → in Latent umwandeln
3. Anpassen **entrauschen** im KSampler (0.5–0.8)

## ComfyUI Manager

ComfyUI Manager ist eine **essentielle Erweiterung** die eine GUI zum Installieren, Aktualisieren und Verwalten benutzerdefinierter Knoten hinzufügt. Es ist der Standardweg, ComfyUI zu erweitern.

### Installation

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# ComfyUI neu starten — ein "Manager"-Button erscheint in der Werkzeugleiste
```

### Verwendung von ComfyUI Manager

Nach dem Neustart erscheint ein **Manager** Button oben rechts in der ComfyUI-Oberfläche.

**Hauptfunktionen:**

| Funktion                               | Wie zuzugreifen ist                    |
| -------------------------------------- | -------------------------------------- |
| Benutzerdefinierte Knoten installieren | Manager → Install Custom Nodes         |
| Alle Knoten aktualisieren              | Manager → Update All                   |
| Knoten deaktivieren/aktivieren         | Manager → Custom Nodes Manager         |
| Fehlende Knoten installieren           | Manager → Install Missing Custom Nodes |
| Modellinformationen abrufen            | Manager → Model Manager                |
| Snapshot wiederherstellen              | Manager → Snapshot Manager             |

**Workflow: Installation eines neuen Node-Pakets**

1. Klicken **Manager** Schaltfläche
2. Auswählen **Install Custom Nodes**
3. Nach Name suchen (z. B. "FLUX", "AnimateDiff")
4. Klicken **Installieren** auf dem gewünschten Paket
5. Klicken **Neustarten** wenn dazu aufgefordert
6. Neue Knoten erscheinen im Rechtsklick-Hinzufügen-Menü

**Fehlende Knoten automatisch installieren:** Wenn Sie ein Workflow-JSON importieren, das Knoten verwendet, die Sie nicht haben, erkennt Manager diese und bietet an, sie automatisch zu installieren via **Install Missing Custom Nodes**.

### Knoten aktuell halten

```bash
# Von der CLI (Alternative zur GUI):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Oder verwenden Sie Manager → Update All in der UI
```

***

## FLUX-Workflow in ComfyUI

FLUX verwendet eine andere Knotenstruktur als Standard-SD-Modelle. Unten ist ein vollständiger FLUX.1-dev-Workflow.

### Erforderliche Dateien

Laden Sie vor dem Ausführen des Workflows herunter:

```bash
# FLUX-Modell (dev oder schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# Text-Encoder
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

Speichern als `flux_dev_workflow.json` und importieren via **Laden** Button in 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 Schritte)

Für schnell ändern Sie die KSampler-Einstellungen im obigen JSON:

* `num_inference_steps`: `4`
* `cfg`: `1.0`
* `scheduler`: `"simple"`
* Modell-Datei: `flux1-schnell.safetensors`

Oder per UI einstellen: KSampler → steps: **4**, cfg: **1.0**, sampler: **euler**, scheduler: **simple**

### Wesentliche Knotenunterschiede: FLUX vs SD

| Knoten           | SD/SDXL              | FLUX                            |
| ---------------- | -------------------- | ------------------------------- |
| Modell-Loader    | Checkpoint laden     | UNETLoader                      |
| Text-Encoder     | CLIPTextEncode       | DualCLIPLoader + CLIPTextEncode |
| Latent           | Leeres latentes Bild | EmptySD3LatentImage             |
| Extra            | —                    | ModelSamplingFlux               |
| Negativer Prompt | Erforderlich         | Optional (leer lassen)          |

***

## Wesentliche benutzerdefinierte Knoten

### Empfohlene Node-Pakete

| Node-Paket               | GitHub                                  | Einsatzgebiet                                |
| ------------------------ | --------------------------------------- | -------------------------------------------- |
| **ComfyUI-Manager**      | ltdrdata/ComfyUI-Manager                | Alle anderen Knoten installieren & verwalten |
| **ComfyUI-FLUX**         | XLabs-AI/x-flux-comfyui                 | FLUX ControlNet-Knoten                       |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | 100+ Hilfsknoten                             |
| ComfyUI-Impact-Pack      | ltdrdata/ComfyUI-Impact-Pack            | Gesichtserkennung, SAM, ADetailer            |
| ComfyUI-Inspire-Pack     | ltdrdata/ComfyUI-Inspire-Pack           | Erweiterte Sampler, Workflows                |
| ComfyUI-AnimateDiff      | Kosinkadink/ComfyUI-AnimateDiff-Evolved | Video-/Animationsgenerierung                 |
| ComfyUI-VideoHelperSuite | Kosinkadink/ComfyUI-VideoHelperSuite    | Video I/O-Verarbeitung                       |
| ComfyUI-GGUF             | city96/ComfyUI-GGUF                     | Quantisierte GGUF-Modelle ausführen          |
| ComfyUI-KJNodes          | kijai/ComfyUI-KJNodes                   | Hilfs- & Maskenknoten                        |
| rgthree-comfy            | rgthree/rgthree-comfy                   | Workflow-Hilfen, bessere UI                  |

### ComfyUI-FLUX (XLabs-AI)

Fügt ControlNet-Unterstützung für FLUX innerhalb von ComfyUI hinzu:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/XLabs-AI/x-flux-comfyui
cd x-flux-comfyui
pip install -r requirements.txt
```

Fügt Knoten hinzu: `Apply ControlNet (FLUX)`, `Load ControlNet Model (FLUX)`, `XFlux Sampler`

### was-node-suite

Über 100 Hilfsknoten für fortgeschrittene Workflows:

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

Wichtige Knoten: Image Batch, Text Operations, Image Analyze, Cache Node, Bus Node, Upscale, Mask-Operationen

### Über Manager installieren

1. Klicken **Manager** Schaltfläche
2. **Install Custom Nodes**
3. Suchen und installieren
4. ComfyUI neu starten

## Erweiterte Workflows

### ControlNet

```bash
# ControlNet-Modelle herunterladen
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
```

Workflow:

1. Bild laden → Canny-Kantendetektor
2. Apply ControlNet → KSampler
3. Mit Pose-/Kantenführung generieren

### Upscaling

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

Workflow:

1. Bild in niedrigerer Auflösung erzeugen (768x768)
2. Upscale Image (Model)-Knoten
3. Optional: img2img-Pass für Details

### SDXL + Refiner

1. Mit SDXL-Basis erzeugen (Schritte 1–20)
2. Latent an SDXL-Refiner weitergeben (Schritte 21–30)
3. Finales Ergebnis mit VAE decodieren

## Tastaturkürzel

| Taste              | Aktion                                |
| ------------------ | ------------------------------------- |
| `Strg+Enter`       | Prompt in die Warteschlange           |
| `Strg+Shift+Enter` | Prompt vorrangig in die Warteschlange |
| `Strg+Z`           | Rückgängig                            |
| `Strg+Y`           | Wiederholen                           |
| `Strg+S`           | Workflow speichern                    |
| `Strg+O`           | Workflow laden                        |
| `Strg+A`           | Alles auswählen                       |
| `Entfernen`        | Auswahl löschen                       |
| `Strg+M`           | Knoten stummschalten                  |
| `Strg+B`           | Knoten umgehen                        |

## API-Nutzung

### Prompt in die Warteschlange

```python
import json
import urllib.request

# Für externen Zugriff verwenden Sie Ihre http_pub-URL:
SERVER = "your-http-pub.clorecloud.net"
# Oder via 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)

# Workflow-JSON laden und in die Warteschlange stellen
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)
```

### WebSocket für Fortschritt

```python
import websocket
import json

# Für externen Zugriff verwenden Sie wss:// mit Ihrer http_pub-URL
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("Fertig!")
        break
```

## Performance-Tipps

1. **--lowvram aktivieren** für <8 GB VRAM
2. **Verwenden Sie fp16** Modelle wenn möglich
3. **Batch-Größe 1** für begrenzten VRAM
4. **Gekacheltes VAE** für hochauflösende Bilder
5. **Vorschau deaktivieren** für schnellere Generierung

## GPU-Anforderungen

| Modell            | Minimaler VRAM | Empfohlener VRAM | Min. RAM |
| ----------------- | -------------- | ---------------- | -------- |
| SD 1.5            | 4GB            | 8GB              | 16GB     |
| SDXL              | 8GB            | 12GB             | 16GB     |
| SDXL + ControlNet | 10GB           | 16GB             | 16GB     |
| FLUX              | 16GB           | 24GB             | 32GB     |

## GPU-Voreinstellungen

### RTX 3060 12GB (Budget)

```bash
# Start mit Optimierungen
python main.py --lowvram --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 768x768, Batch 1
# - SD 1.5: 512x512, Batch 4
# - VAE-Tiling verwenden
# - 20–30 Schritte
```

**Am besten geeignet für:** SD 1.5, SDXL (mit Einschränkungen)

### RTX 3090 24GB (Optimal)

```bash
# Standardstart
python main.py --force-fp16

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 2
# - FLUX schnell: 1024x1024, Batch 1
# - ControlNet + SDXL funktioniert gut
# - 30–50 Schritte
```

**Am besten geeignet für:** SDXL, ControlNet-Workflows, moderates FLUX

### RTX 4090 24GB (Performance)

```bash
# Volle Geschwindigkeit starten
python main.py

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 4
# - FLUX dev: 1024x1024, Batch 1-2
# - Komplexe Workflows mit mehreren ControlNets
# - 50+ Schritte für Qualität
```

**Am besten geeignet für:** FLUX, komplexe Workflows, Batch-Generierung

### A100 40GB/80GB (Produktion)

```bash
# Maximale Leistung
python main.py --highvram

# Empfohlene Einstellungen:
# - SDXL: 1024x1024, Batch 8+
# - FLUX: 1024x1024, Batch 2-4
# - Mehrere Modelle gleichzeitig geladen
# - Hochauflösende Ausgaben (2048x2048)
```

**Am besten geeignet für:** Produktions-Workloads, FLUX, hochauflösende Generierung

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU      | VRAM | Preis/Tag  | SDXL Geschwindigkeit |
| -------- | ---- | ---------- | -------------------- |
| RTX 3060 | 12GB | $0.15–0.30 | \~15 Sek./Bild       |
| RTX 3090 | 24GB | $0.30–1.00 | \~8 Sek./Bild        |
| RTX 4090 | 24GB | $0.50–2.00 | \~4 Sek./Bild        |
| A100     | 40GB | $1.50–3.00 | \~3 Sek./Bild        |

*Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

## Fehlerbehebung

### HTTP 502 über lange Zeit

1. **Prüfe RAM:** Server muss 16GB+ RAM haben
2. **Prüfe VRAM:** 8GB+ für SDXL, 16GB+ für FLUX
3. **Abhängigkeiten herunterladen:** Erster Lauf dauert 5–10 Min.
4. **Modell-Download:** Große Modelle dauern länger

### Kein Speicher mehr

```bash
# Mit Low-VRAM-Modus ausführen
python main.py --lowvram

# Oder fp16 erzwingen
python main.py --force-fp16
```

### Schwarze Bilder

* Überprüfe, dass VAE geladen ist
* Probiere verschiedene VAE aus
* Bildgröße reduzieren

### Langsame Generierung

* CUDA aktivieren
* fp16-Modelle verwenden
* Schritte reduzieren (20–30 sind oft ausreichend)

## Workflow-Beispiele

Importiere diese JSON-Workflows in ComfyUI:

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

## Nächste Schritte

* [ControlNet Anleitung](/guides/guides_v2-de/bildverarbeitung/controlnet-advanced.md)
* [Real-ESRGAN-Upscaling](/guides/guides_v2-de/bildverarbeitung/real-esrgan-upscaling.md)
* [Kohya Training](/guides/guides_v2-de/training/kohya-training.md) - Eigene LoRAs trainieren
* [Fooocus](/guides/guides_v2-de/bildgenerierung/fooocus-simple-sd.md) - Einfachere Alternative


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/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.