> 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-fr/generation-dimages/comfyui.md).

# ComfyUI

Interface Stable Diffusion basée sur des nœuds avec ComfyUI sur Clore.ai

Interface basée sur des nœuds pour Stable Diffusion avec une flexibilité ultime sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre          | Minimum        | Recommandé |
| ------------------ | -------------- | ---------- |
| RAM                | 16 Go          | 32 Go+     |
| VRAM               | 8 Go (SDXL)    | 12 Go+     |
| Réseau             | 500 Mbps       | 1 Gbps+    |
| Temps de démarrage | 5 à 10 minutes | -          |

{% hint style="warning" %}
**Temps de démarrage :** Au premier lancement, les dépendances et les modèles sont téléchargés (5 à 10 minutes selon la vitesse du réseau). Un code HTTP 502 pendant ce temps est normal.
{% endhint %}

{% hint style="danger" %}
**Important :** ComfyUI avec les modèles FLUX nécessite 16 Go+ de VRAM. Pour SDXL avec ControlNet, assurez-vous d'avoir au moins 10 Go de VRAM.
{% endhint %}

## Pourquoi ComfyUI ?

* **Flux de travail basé sur des nœuds** - Programmation visuelle pour la génération d'images
* **Contrôle maximal** - Ajustez finement chaque étape du pipeline
* **Efficace** - Utilisation de VRAM plus faible que les alternatives
* **Extensible** - Un vaste écosystème de nœuds personnalisés
* **Partage de workflows** - Import/export au format JSON

## Déploiement rapide sur CLORE.AI

**Image Docker :**

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

**Ports :**

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

**Environnement :**

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

### Vérifier que cela fonctionne

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

```bash
# Vérifiez si l'interface est accessible (peut prendre 5 à 10 min au premier lancement)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
Si vous obtenez un HTTP 502 pendant plus de 15 minutes, vérifiez :

1. Le serveur dispose de 16 Go+ de RAM
2. Le serveur dispose de 8 Go+ de VRAM pour SDXL, 16 Go+ pour FLUX
3. La vitesse du réseau est suffisante pour télécharger les modèles
   {% endhint %}

## Accéder à votre service

Lors du déploiement sur CLORE.AI, accédez à ComfyUI via la `http_pub` URL :

* **Interface Web :** `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" %}
Tous `localhost:8188` les exemples ci-dessous fonctionnent lorsque vous êtes connecté via SSH. Pour un accès externe, remplacez par votre `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Installation

### Utilisation de Docker (recommandé)

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

### Installation manuelle

```bash
# Cloner le dépôt
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Créer un environnement virtuel
python -m venv venv
source venv/bin/activate

# Installer PyTorch avec CUDA
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128

# Installer les dépendances
pip install -r requirements.txt

# Exécuter
python main.py --listen 0.0.0.0
```

## Structure du répertoire

```
ComfyUI/
├── models/
│   ├── checkpoints/     # modèles SD (.safetensors)
│   ├── loras/           # modèles LoRA
│   ├── vae/             # modèles VAE
│   ├── controlnet/      # modèles ControlNet
│   ├── upscale_models/  # upscalers
│   └── clip/            # modèles CLIP
├── input/               # images d'entrée
├── output/              # images générées
└── custom_nodes/        # extensions
```

## Télécharger les modèles

### Checkpoints Stable Diffusion

```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 (plus petit, plus rapide)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (photoréaliste)
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

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

# VAE SD 1.5 (meilleures couleurs)
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

# Télécharger depuis CivitAI ou HuggingFace
# Placez les fichiers .safetensors ici
```

## Workflow de base

### Texte vers image

1. Ajouter des nœuds :
   * **Charger un checkpoint** → sélectionner le modèle
   * **Encodage de texte CLIP** (x2) → prompts positif et négatif
   * **Image latente vide** → définir les dimensions
   * **KSampler** → tout connecter
   * **Décodage VAE** → latent vers image
   * **Enregistrer l'image** → sortie
2. Connectez :

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

### Image vers image

Remplacer **Image latente vide** par :

1. **Charger une image** → votre image source
2. **Encodage VAE** → convertir en latent
3. Ajuster **dénoiser** dans KSampler (0,5-0,8)

## ComfyUI Manager

ComfyUI Manager est une **extension essentielle** qui ajoute une interface graphique pour installer, mettre à jour et gérer les nœuds personnalisés. C'est la méthode standard pour étendre ComfyUI.

### Installation

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# Redémarrez ComfyUI — un bouton « Manager » apparaîtra dans la barre d'outils
```

### Utilisation de ComfyUI Manager

Après le redémarrage, un **Manager** bouton apparaît en haut à droite de l'interface ComfyUI.

**Fonctionnalités clés :**

| Fonctionnalité                       | Comment y accéder                                     |
| ------------------------------------ | ----------------------------------------------------- |
| Installer des nœuds personnalisés    | Manager → Installer des nœuds personnalisés           |
| Mettre à jour tous les nœuds         | Manager → Tout mettre à jour                          |
| Désactiver/activer des nœuds         | Manager → Gestionnaire de nœuds personnalisés         |
| Installer les nœuds manquants        | Manager → Installer les nœuds personnalisés manquants |
| Récupérer les informations du modèle | Manager → Gestionnaire de modèles                     |
| Restaurer un instantané              | Manager → Gestionnaire d'instantanés                  |

**Workflow : installation d'un nouveau pack de nœuds**

1. Cliquez sur **Manager** bouton
2. Sélectionnez **Installer des nœuds personnalisés**
3. Rechercher par nom (par ex. « FLUX », « AnimateDiff »)
4. Cliquez sur **Installer** sur le pack souhaité
5. Cliquez sur **Redémarrer** lorsque vous y êtes invité
6. Les nouveaux nœuds apparaissent dans le menu d'ajout au clic droit

**Installation automatique des nœuds manquants :** Lorsque vous importez un JSON de workflow qui utilise des nœuds que vous n'avez pas, Manager les détecte et propose de les installer automatiquement via **Installer les nœuds personnalisés manquants**.

### Maintenir les nœuds à jour

```bash
# Depuis le CLI (alternative à l'interface graphique) :
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Ou utilisez Manager → Tout mettre à jour dans l'interface
```

***

## Workflow FLUX dans ComfyUI

FLUX utilise une structure de nœuds différente de celle des modèles SD standard. Vous trouverez ci-dessous un workflow complet FLUX.1-dev.

### Fichiers requis

Avant d'exécuter le workflow, téléchargez :

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

# Encodeurs de texte
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
```

### JSON du workflow FLUX.1-dev

Enregistrer sous `flux_dev_workflow.json` et importer via **Charger** bouton dans 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": ["Un paysage photoréaliste époustouflant, éclairage de l'heure dorée, 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
}
```

### Workflow FLUX.1-schnell (4 étapes)

Pour schnell, modifiez les paramètres de KSampler dans le JSON ci-dessus :

* `num_inference_steps`: `4`
* `cfg`: `1.0`
* `ordonnanceur`: `"simple"`
* Fichier du modèle : `flux1-schnell.safetensors`

Ou définissez via l'interface : KSampler → étapes : **4**, cfg : **1.0**, échantillonneur : **euler**, ordonnanceur : **simple**

### Différences clés des nœuds : FLUX vs SD

| Nœud               | SD/SDXL               | FLUX                            |
| ------------------ | --------------------- | ------------------------------- |
| Chargeur de modèle | Charger un checkpoint | UNETLoader                      |
| Encodeur de texte  | CLIPTextEncode        | DualCLIPLoader + CLIPTextEncode |
| Latent             | Image latente vide    | EmptySD3LatentImage             |
| Supplémentaire     | —                     | ModelSamplingFlux               |
| Prompt négatif     | Requis                | Facultatif (laisser vide)       |

***

## Nœuds personnalisés essentiels

### Packs de nœuds recommandés

| Pack de nœuds            | GitHub                                  | Cas d’utilisation                           |
| ------------------------ | --------------------------------------- | ------------------------------------------- |
| **ComfyUI-Manager**      | ltdrdata/ComfyUI-Manager                | Installer et gérer tous les autres nœuds    |
| **ComfyUI-FLUX**         | XLabs-AI/x-flux-comfyui                 | Nœuds ControlNet FLUX                       |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | Plus de 100 nœuds utilitaires               |
| ComfyUI-Impact-Pack      | ltdrdata/ComfyUI-Impact-Pack            | Détection de visages, SAM, ADetailer        |
| ComfyUI-Inspire-Pack     | ltdrdata/ComfyUI-Inspire-Pack           | Échantillonneurs avancés, workflows         |
| ComfyUI-AnimateDiff      | Kosinkadink/ComfyUI-AnimateDiff-Evolved | Génération de vidéo / animation             |
| ComfyUI-VideoHelperSuite | Kosinkadink/ComfyUI-VideoHelperSuite    | Gestion des E/S vidéo                       |
| ComfyUI-GGUF             | city96/ComfyUI-GGUF                     | Exécuter des modèles GGUF quantifiés        |
| ComfyUI-KJNodes          | kijai/ComfyUI-KJNodes                   | Nœuds utilitaires et de masque              |
| rgthree-comfy            | rgthree/rgthree-comfy                   | Assistants de workflow, meilleure interface |

### ComfyUI-FLUX (XLabs-AI)

Ajoute la prise en charge de ControlNet pour FLUX dans ComfyUI :

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

Ajoute les nœuds : `Appliquer ControlNet (FLUX)`, `Charger le modèle ControlNet (FLUX)`, `Échantillonneur XFlux`

### was-node-suite

Plus de 100 nœuds utilitaires pour des workflows avancés :

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

Nœuds clés : lot d'images, opérations sur le texte, analyse d'image, nœud cache, nœud bus, mise à l'échelle, opérations sur les masques

### Installer via le gestionnaire

1. Cliquez sur **Manager** bouton
2. **Installer des nœuds personnalisés**
3. Rechercher et installer
4. Redémarrer ComfyUI

## Workflows avancés

### ControlNet

```bash
# Télécharger les modèles ControlNet
cd ComfyUI/models/controlnet

# Canny
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth

# Profondeur
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. Charger l'image → Détecteur de contours Canny
2. Appliquer ControlNet → KSampler
3. Générer avec guidage de pose/de contour

### Mise à l'échelle

```bash
# Télécharger l'upscaler
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth
```

Workflow :

1. Générer l'image à plus faible résolution (768x768)
2. Nœud Upscale Image (Model)
3. Optionnel : passage img2img pour plus de détails

### SDXL + Refiner

1. Générer avec la base SDXL (étapes 1-20)
2. Passer le latent au raffineur SDXL (étapes 21-30)
3. Décoder le résultat final avec le VAE

## Raccourcis clavier

| Touche            | Action                                      |
| ----------------- | ------------------------------------------- |
| `Ctrl+Entrée`     | Mettre l'invite en file d'attente           |
| `Ctrl+Maj+Entrée` | Mettre l'invite en file d'attente (en tête) |
| `Ctrl+Z`          | Annuler                                     |
| `Ctrl+Y`          | Rétablir                                    |
| `Ctrl+S`          | Enregistrer le workflow                     |
| `Ctrl+O`          | Charger le workflow                         |
| `Ctrl+A`          | Tout sélectionner                           |
| `Suppr`           | Supprimer la sélection                      |
| `Ctrl+M`          | Mettre le nœud en sourdine                  |
| `Ctrl+B`          | Contourner le nœud                          |

## Utilisation de l’API

### Mettre l'invite en file d'attente

```python
import json
import urllib.request

# Pour un accès externe, utilisez votre URL http_pub :
SERVER = "your-http-pub.clorecloud.net"
# Ou 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)

# Charger le JSON du workflow et mettre en file d'attente
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)
```

### WebSocket pour la progression

```python
import websocket
import json

# Pour un accès externe, utilisez wss:// avec votre URL http_pub
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

while True:
    msg = json.loads(ws.recv())
    if msg['type'] == 'progress':
        print(f"Étape {msg['data']['value']}/{msg['data']['max']}")
    elif msg['type'] == 'executed':
        print("Terminé !")
        break
```

## Conseils de performance

1. **Activer --lowvram** pour <8 Go de VRAM
2. **Utiliser fp16** modèles si possible
3. **Taille du lot 1** pour une VRAM limitée
4. **VAE en tuiles** pour les images haute résolution
5. **Désactiver l'aperçu** pour une génération plus rapide

## Exigences GPU

| Modèle            | VRAM minimale | VRAM recommandée | RAM minimale |
| ----------------- | ------------- | ---------------- | ------------ |
| SD 1.5            | 4 Go          | 8 Go             | 16 Go        |
| SDXL              | 8 Go          | 12 Go            | 16 Go        |
| SDXL + ControlNet | 10GB          | 16 Go            | 16 Go        |
| FLUX              | 16 Go         | 24GB             | 32 Go        |

## Préréglages GPU

### RTX 3060 12 Go (économique)

```bash
# Lancer avec optimisations
python main.py --lowvram --force-fp16

# Paramètres recommandés :
# - SDXL : 768x768, lot 1
# - SD 1.5 : 512x512, lot 4
# - Utiliser le tuilage VAE
# - 20-30 étapes
```

**Idéal pour :** SD 1.5, SDXL (avec limites)

### RTX 3090 24 Go (optimal)

```bash
# Lancement standard
python main.py --force-fp16

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 2
# - FLUX schnell : 1024x1024, lot 1-2
# - ControlNet + SDXL fonctionne bien
# - 30-50 étapes
```

**Idéal pour :** SDXL, workflows ControlNet, FLUX modéré

### RTX 4090 24 Go (performance)

```bash
# Lancement à pleine vitesse
python main.py

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 4
# - FLUX dev : 1024x1024, lot 1-2
# - Workflows complexes avec plusieurs ControlNets
# - 50+ étapes pour la qualité
```

**Idéal pour :** FLUX, workflows complexes, génération par lots

### A100 40 Go/80 Go (production)

```bash
# Performances maximales
python main.py --highvram

# Paramètres recommandés :
# - SDXL : 1024x1024, lot 8+
# - FLUX : 1024x1024, lot 2-4
# - Plusieurs modèles chargés simultanément
# - Sorties haute résolution (2048x2048)
```

**Idéal pour :** Charges de travail de production, FLUX, génération haute résolution

## Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

| GPU      | VRAM  | Prix/jour   | Vitesse SDXL |
| -------- | ----- | ----------- | ------------ |
| RTX 3060 | 12 Go | 0,15–0,30 $ | \~15 s/image |
| RTX 3090 | 24GB  | 0,30–1,00 $ | \~8 s/image  |
| RTX 4090 | 24GB  | 0,50–2,00 $ | \~4 s/image  |
| A100     | 40 Go | 1,50–3,00 $ | \~3 s/image  |

*Prix en USD/jour. Les tarifs varient selon le fournisseur — vérifier* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

## Dépannage

### HTTP 502 pendant longtemps

1. **Vérifier la RAM :** Le serveur doit avoir 16 Go+ de RAM
2. **Vérifier la VRAM :** 8 Go+ pour SDXL, 16 Go+ pour FLUX
3. **Téléchargement des dépendances :** La première exécution prend 5 à 10 min
4. **Téléchargement du modèle :** Les grands modèles prennent plus de temps

### Mémoire insuffisante

```bash
# Exécuter en mode faible VRAM
python main.py --lowvram

# Ou forcer fp16
python main.py --force-fp16
```

### Images noires

* Vérifier que le VAE est chargé
* Essayer un autre VAE
* Réduire la taille de l'image

### Génération lente

* Activer CUDA
* Utiliser des modèles fp16
* Réduire les étapes (20 à 30 suffisent souvent)

## Exemples de workflows

Importez ces workflows JSON dans ComfyUI :

* [txt2img de base](https://comfyworkflows.com)
* [SDXL + Refiner](https://comfyworkflows.com)
* [ControlNet Canny](https://comfyworkflows.com)
* [Vidéo AnimateDiff](https://comfyworkflows.com)

## Étapes suivantes

* [Guide ControlNet](/guides/guides_v2-fr/traitement-dimages/controlnet-advanced.md)
* [Mise à l’échelle Real-ESRGAN](/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling.md)
* [Entraînement Kohya](/guides/guides_v2-fr/entrainement/kohya-training.md) - Entraîner des LoRA personnalisés
* [Fooocus](/guides/guides_v2-fr/generation-dimages/fooocus-simple-sd.md) - Alternative plus simple


---

# 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-fr/generation-dimages/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.