# 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](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/controlnet-advanced)
* [Upscaling Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling)
* [Entraînement Kohya](https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training) - Entraîner des LoRA personnalisés
* [Fooocus](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/fooocus-simple-sd) - Alternative plus simple