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

## Exigences du serveur

| Paramètre          | Minimum      | Recommandé |
| ------------------ | ------------ | ---------- |
| RAM                | 16Go         | 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 :** Le premier lancement télécharge les dépendances et les modèles (5-10 minutes selon la vitesse du réseau). Un HTTP 502 pendant cette période 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'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 chaque étape du pipeline
* **Efficace** - Utilisation de VRAM plus faible que les alternatives
* **Extensible** - Énorme écosystème de nœuds personnalisés
* **Partage de workflows** - Importer/exporter au format JSON

## Déploiement rapide sur CLORE.AI

**Image Docker :**

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

**Ports :**

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

**Environnement :**

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

### Vérifiez 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 lors du premier lancement)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
Si vous obtenez 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

Lorsqu'il est déployé sur CLORE.AI, accédez à ComfyUI via le `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 lorsqu'ils sont connectés 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:cu126-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/cu124

# 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 des modèles

### Checkpoints Stable Diffusion

```bash
cd ComfyUI/models/checkpoints

# SDXL de 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échargez depuis CivitAI ou HuggingFace
# Placez les fichiers .safetensors ici
```

## Flux de travail de base

### Texte vers Image

1. Ajouter des nœuds :
   * **Charger Checkpoint** → sélectionner le modèle
   * **CLIP Text Encode** (x2) → prompts positifs et négatifs
   * **Image latente vide** → définir les dimensions
   * **KSampler** → connecter tout
   * **VAE Decode** → latent vers image
   * **Sauvegarder l'image** → sortie
2. Connecter :

```
[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 l'image** → votre image source
2. **VAE Encode** → 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 manière standard d'é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 :**

| Fonction                          | Comment y accéder                                     |
| --------------------------------- | ----------------------------------------------------- |
| Installer des nœuds personnalisés | Manager → Installer des nœuds personnalisés           |
| Mettre à jour tous les nœuds      | Manager → Mettre tout à 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 infos du modèle     | Manager → Gestionnaire de modèles                     |
| Restaurer un snapshot             | Manager → Gestionnaire de snapshots                   |

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

1. Cliquez **Manager** bouton
2. Sélectionner **Installer des nœuds personnalisés**
3. Rechercher par nom (par ex., "FLUX", "AnimateDiff")
4. Cliquez **Installer** sur le pack souhaité
5. Cliquez **Redémarrer** lorsqu'on vous le demande
6. Les nouveaux nœuds apparaissent dans le menu d'ajout (clic droit)

**Installation automatique des nœuds manquants :** Lorsque vous importez un workflow JSON 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'UI) :
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# Ou utilisez Manager → Mettre tout à jour dans l'UI
```

***

## Flux FLUX dans ComfyUI

FLUX utilise une structure de nœuds différente des modèles SD standard. Ci-dessous se trouve un workflow FLUX.1-dev complet.

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

### Workflow JSON 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": ["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
}
```

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

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

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

Ou définissez via l'UI : KSampler → steps : **4**, cfg : **1.0**, sampler : **euler**, scheduler : **simple**

### Principales différences de nœuds : FLUX vs SD

| Nœud               | SD/SDXL            | FLUX                            |
| ------------------ | ------------------ | ------------------------------- |
| Chargeur de modèle | Charger Checkpoint | UNETLoader                      |
| Encodeur de texte  | CLIPTextEncode     | DualCLIPLoader + CLIPTextEncode |
| Latent             | Image latente vide | EmptySD3LatentImage             |
| Extra              | —                  | ModelSamplingFlux               |
| Prompt négatif     | Requis             | Optionnel (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 pour FLUX               |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | 100+ nœuds utilitaires                   |
| ComfyUI-Impact-Pack      | ltdrdata/ComfyUI-Impact-Pack            | Détection de visage, SAM, ADetailer      |
| ComfyUI-Inspire-Pack     | ltdrdata/ComfyUI-Inspire-Pack           | Samplers avancés, workflows              |
| ComfyUI-AnimateDiff      | Kosinkadink/ComfyUI-AnimateDiff-Evolved | Génération de vidéo / animation          |
| ComfyUI-VideoHelperSuite | Kosinkadink/ComfyUI-VideoHelperSuite    | Gestion I/O vidéo                        |
| ComfyUI-GGUF             | city96/ComfyUI-GGUF                     | Exécuter des modèles GGUF quantifiés     |
| ComfyUI-KJNodes          | kijai/ComfyUI-KJNodes                   | Nœuds utilitaires & de masque            |
| rgthree-comfy            | rgthree/rgthree-comfy                   | Aides au workflow, meilleure interface   |

### ComfyUI-FLUX (XLabs-AI)

Ajoute le support 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 des nœuds : `Appliquer ControlNet (FLUX)`, `Charger le modèle ControlNet (FLUX)`, `XFlux Sampler`

### was-node-suite

Plus de 100 nœuds utilitaires pour 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 : Image Batch, Opérations sur texte, Analyse d'image, Nœud Cache, Nœud Bus, Upscale, Opérations de masque

### Installer via Manager

1. Cliquez **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

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

### Suréchantillonnage

```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 basse résolution (768x768)
2. Nœud Upscale Image (Model)
3. Optionnel : passage img2img pour le détail

### SDXL + Refiner

1. Générer avec la base SDXL (étapes 1-20)
2. Transmettre le latent au refiner SDXL (étapes 21-30)
3. VAE Decode du résultat final

## Raccourcis clavier

| Touche             | Action                             |
| ------------------ | ---------------------------------- |
| `Ctrl+Enter`       | Mettre en file la prompt           |
| `Ctrl+Shift+Enter` | Mettre en file la prompt (en tête) |
| `Ctrl+Z`           | Annuler                            |
| `Ctrl+Y`           | Rétablir                           |
| `Ctrl+S`           | Sauvegarder le workflow            |
| `Ctrl+O`           | Charger le workflow                |
| `Ctrl+A`           | Tout sélectionner                  |
| `Delete`           | Supprimer la sélection             |
| `Ctrl+M`           | Couper le son du nœud              |
| `Ctrl+B`           | Bypass du nœud                     |

## Utilisation de l'API

### Mettre en file la prompt

```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
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 <8Go de VRAM
2. **Utiliser fp16** les modèles lorsque possible
3. **Taille de batch 1** pour VRAM limitée
4. **VAE en tuiles** pour 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 min |
| ----------------- | ------------- | ---------------- | ------- |
| SD 1.5            | 4 Go          | 8 Go             | 16Go    |
| SDXL              | 8 Go          | 12Go             | 16Go    |
| SDXL + ControlNet | 10Go          | 16Go             | 16Go    |
| FLUX              | 16Go          | 24 Go            | 32Go    |

## Préréglages GPU

### RTX 3060 12GB (Budget)

```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 tiling VAE
# - 20-30 étapes
```

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

### RTX 3090 24GB (Optimal)

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

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

**Idéal pour :** Flux de travail SDXL, ControlNet, FLUX modéré

### RTX 4090 24GB (Performance)

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

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

**Idéal pour :** FLUX, flux de travail complexes, génération par lots

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

```bash
# Performance maximale
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 production, FLUX, génération haute résolution

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

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

*Prix en USD/jour. Les tarifs varient selon le fournisseur — vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour 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 :** 8Go+ pour SDXL, 16Go+ 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 gros 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 flux de travail

Importer ces workflows JSON dans ComfyUI :

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

## Prochaines étapes

* [Guide ControlNet](/guides/guides_v2-fr/traitement-dimages/controlnet-advanced.md)
* [Upscaling 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/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.