> 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

Node-basierte Stable-Diffusion-Oberfläche mit ComfyUI auf Clore.ai

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 gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Serveranforderungen

| Parameter | Minimum      | Empfohlen |
| --------- | ------------ | --------- |
| RAM       | 16 GB        | 32 GB+    |
| VRAM      | 8 GB (SDXL)  | 12 GB+    |
| Netzwerk  | 500 Mbit/s   | 1 Gbit/s+ |
| 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 ist in dieser Zeit normal.
{% endhint %}

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

## Warum ComfyUI?

* **Knotenbasierter Workflow** - Visuelle Programmierung zur Bildgenerierung
* **Maximale Kontrolle** - Jeden Schritt der Pipeline feinabstimmen
* **Effizient** - Geringerer VRAM-Verbrauch als Alternativen
* **Erweiterbar** - Riesiges Ökosystem an benutzerdefinierten Knoten
* **Workflow-Freigabe** - Import/Export als JSON

## Schnellbereitstellung auf CLORE.AI

**Docker-Image:**

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

**Ports:**

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

**Umgebung:**

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

### Prüfen, ob es funktioniert

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

```bash
# Prüfen, ob die UI zugänglich ist (beim ersten Start kann es 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 16 GB+ RAM
2. Server hat 8 GB+ VRAM für SDXL, 16 GB+ für FLUX
3. Die Netzwerkgeschwindigkeit ist ausreichend, um Modelle herunterzuladen
   {% endhint %}

## Auf deinen Dienst zugreifen

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

* **Web-UI:** `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 folgenden Beispiele funktionieren bei einer SSH-Verbindung. Für externen Zugriff ersetzen Sie `https://your-http-pub.clorecloud.net/` die 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:cu130-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/cu128

# Abhängigkeiten 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/  # Hochskalierer
│   └── clip/            # CLIP-Modelle
├── input/               # Eingabebilder
├── output/              # Generierte Bilder
└── custom_nodes/        # Erweiterungen
```

## Modelle herunterladen

### Stable Diffusion-Checkpoints

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

# Von CivitAI oder HuggingFace herunterladen
# .safetensors-Dateien hier ablegen
```

## Grundlegender Workflow

### Text zu Bild

1. Knoten hinzufügen:
   * **Checkpoint laden** → Modell auswählen
   * **CLIP-Text-Kodierung** (x2) → positive und negative Prompts
   * **Leeres Latent-Bild** → Abmessungen festlegen
   * **KSampler** → alles verbinden
   * **VAE-Decodierung** → von 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 Latent-Bild** durch:

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

## ComfyUI Manager

ComfyUI Manager ist eine **unverzichtbare Erweiterung** die eine GUI zum Installieren, Aktualisieren und Verwalten von benutzerdefinierten 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 — in der Symbolleiste erscheint ein "Manager"-Button
```

### Verwendung von ComfyUI Manager

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

**Wichtige Funktionen:**

| Funktion                               | Zugriffsmöglichkeiten                                     |
| -------------------------------------- | --------------------------------------------------------- |
| Benutzerdefinierte Knoten installieren | Manager → Benutzerdefinierte Knoten installieren          |
| Alle Knoten aktualisieren              | Manager → Alle aktualisieren                              |
| Knoten deaktivieren/aktivieren         | Manager → Knoten-Manager für benutzerdefinierte Knoten    |
| Fehlende Knoten installieren           | Manager → Fehlende benutzerdefinierte Knoten installieren |
| Modellinformationen abrufen            | Manager → Modell-Manager                                  |
| Snapshot wiederherstellen              | Manager → Snapshot-Manager                                |

**Workflow: Installation eines neuen Knotenpakets**

1. Klicken Sie auf **Manager** Schaltfläche
2. Wähle **Benutzerdefinierte Knoten installieren**
3. Nach Namen suchen (z. B. "FLUX", "AnimateDiff")
4. Klicken Sie auf **Installieren** für das gewünschte Paket
5. Klicken Sie auf **Neustarten** wenn Sie dazu aufgefordert werden
6. Neue Knoten erscheinen im Hinzufügen-Menü per Rechtsklick

**Fehlende Knoten automatisch installieren:** Wenn Sie ein Workflow-JSON importieren, das Knoten verwendet, die Sie nicht haben, erkennt Manager sie und bietet an, sie automatisch zu installieren über **Fehlende benutzerdefinierte Knoten installieren**.

### Knoten aktuell halten

```bash
# Über die CLI (Alternative zur GUI):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Oder verwenden Sie im UI Manager → Update All
```

***

## FLUX-Workflow in ComfyUI

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

### Benötigte Dateien

Vor dem Ausführen des Workflows herunterladen:

```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 unter `flux_dev_workflow.json` und importieren über die **Laden** Schaltfläche 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": ["Eine atemberaubende fotorealistische Landschaft, Golden-Hour-Beleuchtung, 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"`
* Modelldatei: `flux1-schnell.safetensors`

Oder über die UI festlegen: KSampler → Schritte: **4**, cfg: **1.0**, sampler: **euler**, scheduler: **simple**

### Wichtige Knotenunterschiede: FLUX vs. SD

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

***

## Wichtige benutzerdefinierte Nodes

### Empfohlene Knotenpakete

| Knotenpaket              | GitHub                                  | Anwendungsfall                                 |
| ------------------------ | --------------------------------------- | ---------------------------------------------- |
| **ComfyUI-Manager**      | ltdrdata/ComfyUI-Manager                | Alle anderen Knoten installieren und verwalten |
| **ComfyUI-FLUX**         | XLabs-AI/x-flux-comfyui                 | FLUX-ControlNet-Knoten                         |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | 100+ Utility-Knoten                            |
| 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- und Maskenknoten                        |
| rgthree-comfy            | rgthree/rgthree-comfy                   | Workflow-Hilfen, bessere Benutzeroberfläche    |

### ComfyUI-FLUX (XLabs-AI)

Fügt ControlNet-Unterstützung für FLUX in 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: Bild-Batch, Textoperationen, Bildanalyse, Cache-Knoten, Bus-Knoten, Hochskalierung, Maskenoperationen

### Über den Manager installieren

1. Klicken Sie auf **Manager** Schaltfläche
2. **Benutzerdefinierte Knoten installieren**
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

# Tiefe
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-Kantenerkennung
2. ControlNet anwenden → KSampler
3. Generieren mit Pose-/Kantenführung

### Hochskalierung

```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 generieren (768x768)
2. Knoten „Bild hochskalieren (Modell)“
3. Optional: img2img-Durchlauf für Details

### SDXL + Refiner

1. Mit SDXL-Basis generieren (Schritte 1–20)
2. Latent an SDXL-Refiner übergeben (Schritte 21–30)
3. VAE dekodiert das Endergebnis

## Tastenkombinationen

| Taste                   | Aktion                        |
| ----------------------- | ----------------------------- |
| `Strg+Eingabe`          | Prompt in Warteschlange       |
| `Strg+Umschalt+Eingabe` | Prompt vorne in Warteschlange |
| `Strg+Z`                | Rückgängig                    |
| `Strg+Y`                | Wiederholen                   |
| `Strg+S`                | Workflow speichern            |
| `Strg+O`                | Workflow laden                |
| `Strg+A`                | Alles auswählen               |
| `Entf`                  | Ausgewählte löschen           |
| `Strg+M`                | Knoten stummschalten          |
| `Strg+B`                | Knoten umgehen                |

## API-Nutzung

### Prompt in Warteschlange

```python
import json
import urllib.request

# Für externen Zugriff verwende deine http_pub-URL:
SERVER = "your-http-pub.clorecloud.net"
# Oder per 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 den Fortschritt

```python
import websocket
import json

# Für externen Zugriff verwende wss:// mit deiner 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"Schritt {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("Fertig!")
        break
```

## Leistungstipps

1. **--lowvram aktivieren** für <8 GB VRAM
2. **fp16 verwenden** Modelle, wenn möglich
3. **Batchgröße 1** bei begrenztem VRAM
4. **Gekacheltes VAE** für hochauflösende Bilder
5. **Vorschau deaktivieren** für schnellere Generierung

## GPU-Anforderungen

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

## GPU-Voreinstellungen

### RTX 3060 12GB (Budget)

```bash
# Mit Optimierungen starten
python main.py --lowvram --force-fp16

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

**Am besten 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 für:** SDXL, ControlNet-Workflows, moderates FLUX

### RTX 4090 24GB (Leistung)

```bash
# Start mit voller Geschwindigkeit
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 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 für:** Produktions-Workloads, FLUX, hochauflösende Generierung

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

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

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

## Fehlerbehebung

### HTTP 502 über längere Zeit

1. **RAM prüfen:** Server muss über 16 GB+ RAM verfügen
2. **VRAM prüfen:** 8 GB+ für SDXL, 16 GB+ für FLUX
3. **Abhängigkeiten werden heruntergeladen:** Der erste Lauf dauert 5–10 Min.
4. **Modell wird heruntergeladen:** Große Modelle brauchen länger

### Speicher erschöpft

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

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

### Schwarze Bilder

* Prüfe, ob VAE geladen ist
* Versuche ein anderes VAE
* Bildgröße reduzieren

### Langsame Generierung

* CUDA aktivieren
* fp16-Modelle verwenden
* Schritte reduzieren (20–30 reichen oft aus)

## 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-Hochskalierung](/guides/guides_v2-de/bildverarbeitung/real-esrgan-upscaling.md)
* [Kohya-Training](/guides/guides_v2-de/training/kohya-training.md) - Benutzerdefinierte 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, and the optional `goal` query parameter:

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