# ComfyUI

CLORE.AI GPUs पर अंतिम लचीलापन के साथ Stable Diffusion के लिए नोड-आधारित इंटरफ़ेस।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## सर्वर आवश्यकताएँ

| पैरामीटर      | न्यूनतम    | अनुशंसित |
| ------------- | ---------- | -------- |
| RAM           | 16GB       | 32GB+    |
| VRAM          | 8GB (SDXL) | 12GB+    |
| नेटवर्क       | 500Mbps    | 1Gbps+   |
| स्टार्टअप समय | 5-10 मिनट  | -        |

{% hint style="warning" %}
**स्टार्टअप समय:** पहला लॉन्च निर्भरताएँ और मॉडल डाउनलोड करता है (नेटवर्क गति के अनुसार 5-10 मिनट)। इस दौरान HTTP 502 सामान्य है।
{% endhint %}

{% hint style="danger" %}
**महत्वपूर्ण:** FLUX मॉडल के साथ ComfyUI के लिए 16GB+ VRAM चाहिए। ControlNet के साथ SDXL के लिए कम से कम 10GB VRAM सुनिश्चित करें।
{% endhint %}

## क्यों ComfyUI?

* **नोड-आधारित कार्यप्रवाह** - छवि जनरेशन के लिए दृश्य प्रोग्रामिंग
* **अधिकतम नियंत्रण** - पाइपलाइन के हर चरण को बारीक रूप से समायोजित करें
* **कुशल** - विकल्पों की तुलना में कम VRAM उपयोग
* **विस्तार योग्य** - कस्टम नोड्स का विशाल इकोसिस्टम
* **वर्कफ़्लो साझाकरण** - JSON के रूप में आयात/निर्यात

## CLORE.AI पर त्वरित डिप्लॉय

**Docker इमेज:**

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

**पोर्ट:**

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

**पर्यावरण:**

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

### जांचें कि यह काम कर रहा है

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर**:

```bash
# जाँचें कि UI सुलभ है या नहीं (पहली बार चलाने पर 5-10 मिनट लग सकते हैं)
curl https://your-http-pub.clorecloud.net/
```

{% hint style="info" %}
यदि आपको 15 मिनट से अधिक समय तक HTTP 502 मिलता है, तो जाँच करें:

1. सर्वर के पास 16GB+ RAM है
2. सर्वर में SDXL के लिए 8GB+ VRAM, FLUX के लिए 16GB+ है
3. मॉडल डाउनलोड करने के लिए नेटवर्क गति उपयुक्त है
   {% endhint %}

## अपनी सेवा तक पहुँचना

जब CLORE.AI पर परिनियोजित हो, तो ComfyUI तक पहुँचें `http_pub` URL:

* **वेब 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" %}
सभी `localhost:8188` नीचे दिए गए उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी पहुंच के लिए, इसे अपने साथ बदलें `https://your-http-pub.clorecloud.net/` URL।
{% endhint %}

## इंस्टॉलेशन

### Docker का उपयोग (अनुशंसित)

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

### मैनुअल इंस्टॉलेशन

```bash
# रिपॉज़िटरी क्लोन करें
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# वर्चुअल वातावरण बनाएं
python -m venv venv
source venv/bin/activate

# CUDA के साथ PyTorch इंस्टॉल करें
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

# Install requirements
pip install -r requirements.txt

# चलाएँ
python main.py --listen 0.0.0.0
```

## निर्देशिका संरचना

```
ComfyUI/
├── models/
│   ├── checkpoints/     # SD मॉडल (.safetensors)
│   ├── loras/           # LoRA मॉडल
│   ├── vae/             # VAE मॉडल
│   ├── controlnet/      # ControlNet मॉडल
│   ├── upscale_models/  # अप्स्केलर्स
│   └── clip/            # CLIP मॉडल
├── input/               # इनपुट इमेजेस
├── output/              # जनरेट की गई इमेजेस
└── custom_nodes/        # एक्सटेंशन
```

## मॉडल डाउनलोड करें

### Stable Diffusion चेकपॉइंट्स

```bash
cd ComfyUI/models/checkpoints

# SDXL बेस
wget https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors

# SDXL रिफाइनर
wget https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/resolve/main/sd_xl_refiner_1.0.safetensors

# SD 1.5 (छोटा, तेज़)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# Realistic Vision (फोटोरियलिस्टिक)
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 (बेहतर रंग)
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

# CivitAI या HuggingFace से डाउनलोड करें
# .safetensors फ़ाइलें यहाँ रखें
```

## बुनियादी वर्कफ़्लो

### टेक्स्ट से इमेज

1. नोड जोड़ें:
   * **चेकपॉइंट लोड करें** → मॉडल चुनें
   * **CLIP टेक्स्ट एन्कोड** (x2) → सकारात्मक और नकारात्मक प्रॉम्प्ट
   * **खाली लैटेंट इमेज** → आयाम सेट करें
   * **KSampler** → सभी कनेक्ट करें
   * **VAE डीकोड** → लैटेंट को इमेज में
   * **इमेज सेव करें** → आउटपुट
2. कनेक्ट करें:

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

### इमेज से इमेज

बदलेँ **खाली लैटेंट इमेज** के साथ:

1. **इमेज लोड करें** → आपका स्रोत इमेज
2. **VAE एन्कोड** → लैटेंट में रूपांतरित करें
3. समायोजित करें **डिनोइज़** KSampler में (0.5-0.8)

## ComfyUI मैनेजर

ComfyUI मैनेजर एक **आवश्यक एक्सटेंशन है** जो कस्टम नोड्स स्थापित, अपडेट और प्रबंधित करने के लिए GUI जोड़ता है। यह ComfyUI का विस्तार करने का मानक तरीका है।

### इंस्टॉलेशन

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
# ComfyUI को पुनरारंभ करें — टूलबार में "Manager" बटन दिखाई देगा
```

### ComfyUI मैनेजर का उपयोग करना

पुनरारंभ के बाद, एक **मैनेजर** बटन ComfyUI इंटरफ़ेस के ऊपरी-दाएँ कोने में दिखाई देता है।

**मुख्य विशेषताएँ:**

| फ़ीचर                      | कैसे पहुँचें                           |
| -------------------------- | -------------------------------------- |
| कस्टम नोड्स स्थापित करें   | Manager → Install Custom Nodes         |
| सभी नोड्स अपडेट करें       | Manager → Update All                   |
| नोड्स अक्षम/सक्षम करें     | Manager → Custom Nodes Manager         |
| गायब नोड्स इंस्टॉल करें    | Manager → Install Missing Custom Nodes |
| मॉडल जानकारी लाएँ          | Manager → Model Manager                |
| स्नैपशॉट पुनर्स्थापित करें | Manager → Snapshot Manager             |

**वर्कफ़्लो: नया नोड पैक इंस्टॉल करना**

1. क्लिक करें **मैनेजर** बटन
2. चुनें **Install Custom Nodes**
3. नाम से खोजें (उदा., "FLUX", "AnimateDiff")
4. क्लिक करें **इंस्टॉल करें** मनचाहे पैक पर
5. क्लिक करें **जब कहा जाए तो** पुनरारंभ करें
6. नए नोड्स राइट-क्लिक ऐड मेनू में प्रकट होते हैं

**गायब नोड्स ऑटो-इंस्टॉल करें:** जब आप ऐसा वर्कफ़्लो JSON आयात करते हैं जो आपके पास नहीं होने वाले नोड्स का उपयोग करता है, Manager उन्हें पहचानता है और स्वचालित रूप से इंस्टॉल करने का प्रस्ताव देता है **Install Missing Custom Nodes**.

### नोड्स को अपडेट रखना

```bash
# CLI से (GUI का विकल्प):
cd ComfyUI/custom_nodes/ComfyUI-Manager
git pull

# या UI में Manager → Update All उपयोग करें
```

***

## ComfyUI में FLUX वर्कफ़्लो

FLUX मानक SD मॉडलों से अलग नोड संरचना उपयोग करता है। नीचे पूरा FLUX.1-dev वर्कफ़्लो है।

### आवश्यक फ़ाइलें

वर्कफ़्लो चलाने से पहले, डाउनलोड करें:

```bash
# FLUX मॉडल (dev या schnell)
cd ComfyUI/models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/resolve/main/flux1-dev.safetensors

# टेक्स्ट एन्कोडर्स
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 वर्कफ़्लो JSON

इसे के रूप में सहेजें `flux_dev_workflow.json` और द्वारा आयात करें **लोड** ComfyUI में बटन:

```json
{
  "last_node_id": 12,
  "last_link_id": 20,
  "nodes": [
    {
      "id": 1,
      "type": "UNETLoader",
      "pos": [100, 100],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [1]}],
      "properties": {},
      "widgets_values": ["flux1-dev.safetensors", "default"]
    },
    {
      "id": 2,
      "type": "DualCLIPLoader",
      "pos": [100, 200],
      "size": [350, 80],
      "inputs": [],
      "outputs": [{"name": "CLIP", "type": "CLIP", "links": [2, 3]}],
      "properties": {},
      "widgets_values": ["clip_l.safetensors", "t5xxl_fp16.safetensors", "flux"]
    },
    {
      "id": 3,
      "type": "CLIPTextEncode",
      "pos": [500, 150],
      "size": [425, 180],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 2}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [4]}],
      "properties": {},
      "widgets_values": ["A stunning photorealistic landscape, golden hour lighting, 8K"]
    },
    {
      "id": 4,
      "type": "EmptySD3LatentImage",
      "pos": [100, 350],
      "size": [300, 100],
      "inputs": [],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [5]}],
      "properties": {},
      "widgets_values": [1024, 1024, 1]
    },
    {
      "id": 5,
      "type": "ModelSamplingFlux",
      "pos": [500, 350],
      "size": [300, 80],
      "inputs": [{"name": "model", "type": "MODEL", "link": 1}],
      "outputs": [{"name": "MODEL", "type": "MODEL", "links": [6]}],
      "properties": {},
      "widgets_values": [1.15, 0.5, 1024, 1024]
    },
    {
      "id": 6,
      "type": "KSampler",
      "pos": [850, 250],
      "size": [350, 240],
      "inputs": [
        {"name": "model", "type": "MODEL", "link": 6},
        {"name": "positive", "type": "CONDITIONING", "link": 4},
        {"name": "negative", "type": "CONDITIONING", "link": 7},
        {"name": "latent_image", "type": "LATENT", "link": 5}
      ],
      "outputs": [{"name": "LATENT", "type": "LATENT", "links": [8]}],
      "properties": {},
      "widgets_values": [42, "fixed", 20, 3.5, "euler", "simple", 1.0]
    },
    {
      "id": 7,
      "type": "CLIPTextEncode",
      "pos": [500, 500],
      "size": [300, 60],
      "inputs": [{"name": "clip", "type": "CLIP", "link": 3}],
      "outputs": [{"name": "CONDITIONING", "type": "CONDITIONING", "links": [7]}],
      "properties": {},
      "widgets_values": [""]
    },
    {
      "id": 8,
      "type": "VAELoader",
      "pos": [100, 500],
      "size": [300, 60],
      "inputs": [],
      "outputs": [{"name": "VAE", "type": "VAE", "links": [9]}],
      "properties": {},
      "widgets_values": ["ae.safetensors"]
    },
    {
      "id": 9,
      "type": "VAEDecode",
      "pos": [1250, 300],
      "size": [210, 46],
      "inputs": [
        {"name": "samples", "type": "LATENT", "link": 8},
        {"name": "vae", "type": "VAE", "link": 9}
      ],
      "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}],
      "properties": {}
    },
    {
      "id": 10,
      "type": "SaveImage",
      "pos": [1500, 300],
      "size": [300, 270],
      "inputs": [{"name": "images", "type": "IMAGE", "link": 10}],
      "outputs": [],
      "properties": {},
      "widgets_values": ["flux_output"]
    }
  ],
  "links": [
    [1, 1, 0, 5, 0, "MODEL"],
    [2, 2, 0, 3, 0, "CLIP"],
    [3, 2, 0, 7, 0, "CLIP"],
    [4, 3, 0, 6, 1, "CONDITIONING"],
    [5, 4, 0, 6, 3, "LATENT"],
    [6, 5, 0, 6, 0, "MODEL"],
    [7, 7, 0, 6, 2, "CONDITIONING"],
    [8, 6, 0, 9, 0, "LATENT"],
    [9, 8, 0, 9, 1, "VAE"],
    [10, 9, 0, 10, 0, "IMAGE"]
  ],
  "groups": [],
  "config": {},
  "extra": {"ds": {"scale": 0.8, "offset": [0, 0]}},
  "version": 0.4
}
```

### FLUX.1-schnell वर्कफ़्लो (4 चरण)

schnell के लिए, ऊपर दिए JSON में KSampler सेटिंग्स बदलें:

* `num_inference_steps`: `4`
* `cfg`: `1.0`
* `scheduler`: `"simple"`
* मॉडल फ़ाइल: `flux1-schnell.safetensors`

या UI के माध्यम से सेट करें: KSampler → steps: **4**, cfg: **1.0**, sampler: **euler**, scheduler: **simple**

### मुख्य नोड अंतर: FLUX बनाम SD

| नोड                 | SD/SDXL           | FLUX                            |
| ------------------- | ----------------- | ------------------------------- |
| मॉडल लोडर           | चेकपॉइंट लोड करें | UNETLoader                      |
| टेक्स्ट एन्कोडर     | CLIPTextEncode    | DualCLIPLoader + CLIPTextEncode |
| लैटेंट              | खाली लैटेंट इमेज  | EmptySD3LatentImage             |
| अतिरिक्त            | —                 | ModelSamplingFlux               |
| नकारात्मक प्रॉम्प्ट | आवश्यक            | वैकल्पिक (खाली छोड़ें)          |

***

## आवश्यक कस्टम नोड्स

### अनुशंसित नोड पैक्स

| नोड पैक                  | GitHub                                  | उपयोग का मामला                          |
| ------------------------ | --------------------------------------- | --------------------------------------- |
| **ComfyUI-Manager**      | ltdrdata/ComfyUI-Manager                | सभी अन्य नोड्स इंस्टॉल और प्रबंधित करें |
| **ComfyUI-FLUX**         | XLabs-AI/x-flux-comfyui                 | FLUX ControlNet नोड्स                   |
| **was-node-suite**       | WASasquatch/was-node-suite-comfyui      | 100+ उपयोगिता नोड्स                     |
| ComfyUI-Impact-Pack      | ltdrdata/ComfyUI-Impact-Pack            | चेहरे का पता लगाना, SAM, ADetailer      |
| ComfyUI-Inspire-Pack     | ltdrdata/ComfyUI-Inspire-Pack           | उन्नत सैम्पलर्स, वर्कफ़्लोज़            |
| ComfyUI-AnimateDiff      | Kosinkadink/ComfyUI-AnimateDiff-Evolved | वीडियो / ऐनिमेशन जनरेशन                 |
| ComfyUI-VideoHelperSuite | Kosinkadink/ComfyUI-VideoHelperSuite    | वीडियो I/O हैंडलिंग                     |
| ComfyUI-GGUF             | city96/ComfyUI-GGUF                     | क्वांटाइज़्ड GGUF मॉडल चलाएँ            |
| ComfyUI-KJNodes          | kijai/ComfyUI-KJNodes                   | यूटिलिटी और मास्क नोड्स                 |
| rgthree-comfy            | rgthree/rgthree-comfy                   | वर्कफ़्लो सहायता, बेहतर UI              |

### ComfyUI-FLUX (XLabs-AI)

ComfyUI के अंदर FLUX के लिए ControlNet समर्थन जोड़ता है:

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

नोड्स जोड़ता है: `ControlNet लागू करें (FLUX)`, `ControlNet मॉडल लोड करें (FLUX)`, `XFlux सैम्पलर`

### was-node-suite

उन्नत वर्कफ़्लो के लिए 100+ उपयोगिता नोड्स:

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

मुख्य नोड्स: इमेज बैच, टेक्स्ट ऑपरेशन्स, इमेज एनालाइज़, कैश नोड, बस नोड, अपस्केल, मास्क ऑपरेशन्स

### Manager द्वारा इंस्टॉल करें

1. क्लिक करें **मैनेजर** बटन
2. **Install Custom Nodes**
3. खोजें और इंस्टॉल करें
4. ComfyUI पुनरारंभ करें

## उन्नत वर्कफ़्लोज़

### ControlNet

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

वर्कफ़्लो:

1. इमेज लोड करें → Canny एज डिटेक्टर
2. ControlNet लागू करें → KSampler
3. पोज/एज गाइडेंस के साथ जनरेट करें

### अपस्केलिंग

```bash
# अपस्केलर डाउनलोड करें
cd ComfyUI/models/upscale_models
wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth
```

वर्कफ़्लो:

1. कम रेस में इमेज जनरेट करें (768x768)
2. Upscale Image (Model) नोड
3. वैकल्पिक: विवरण के लिए img2img पास

### SDXL + रिफाइनर

1. SDXL बेस के साथ जनरेट करें (स्टेप्स 1-20)
2. लैटेंट को SDXL रिफाइनर को पास करें (स्टेप्स 21-30)
3. अंतिम परिणाम VAE डीकोड करें

## कीबोर्ड शॉर्टकट्स

| की                 | एक्शन                             |
| ------------------ | --------------------------------- |
| `Ctrl+Enter`       | प्रॉम्प्ट कतार में जोड़ें         |
| `Ctrl+Shift+Enter` | प्रॉम्प्ट कतार (आगामी) में जोड़ें |
| `Ctrl+Z`           | पूर्ववत करें                      |
| `Ctrl+Y`           | दोहराएँ                           |
| `Ctrl+S`           | वर्कफ़्लो सहेजें                  |
| `Ctrl+O`           | वर्कफ़्लो लोड करें                |
| `Ctrl+A`           | सभी चुनें                         |
| `Delete`           | चयनित हटाएँ                       |
| `Ctrl+M`           | नोड म्यूट करें                    |
| `Ctrl+B`           | नोड बाईपास करें                   |

## API उपयोग

### प्रॉम्प्ट कतार

```python
import json
import urllib.request

# बाहरी पहुँच के लिए अपने http_pub URL का उपयोग करें:
SERVER = "your-http-pub.clorecloud.net"
# या 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)

# वर्कफ़्लो JSON लोड करें और कतार में डालें
with open("workflow.json") as f:
    workflow = json.load(f)
queue_prompt(workflow)
```

### प्रगति के लिए WebSocket

```python
import websocket
import json

# बाहरी पहुँच के लिए, अपने http_pub URL के साथ wss:// उपयोग करें
ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")

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

## प्रदर्शन सुझाव

1. **--lowvram सक्षम करें** <8GB VRAM के लिए
2. **जब संभव हो fp16 का उपयोग करें** मॉडल्स
3. **सीमित VRAM के लिए बैच साइज 1** के लिए
4. **टाइल्ड VAE** उच्च-रेस इमेजेस के लिए
5. **पूर्वावलोकन अक्षम करें** तेज़ जनरेशन के लिए

## GPU आवश्यकताएँ

| मॉडल              | न्यूनतम VRAM | अनुशंसित VRAM | न्यूनतम RAM |
| ----------------- | ------------ | ------------- | ----------- |
| SD 1.5            | 4GB          | 8GB           | 16GB        |
| SDXL              | 8GB          | 12GB          | 16GB        |
| SDXL + ControlNet | 10GB         | 16GB          | 16GB        |
| FLUX              | 16GB         | 24GB          | 32GB        |

## GPU प्रीसेट्स

### RTX 3060 12GB (बजट)

```bash
# अनुकूलनों के साथ लॉन्च
python main.py --lowvram --force-fp16

# अनुशंसित सेटिंग्स:
# - SDXL: 768x768, बैच 1
# - SD 1.5: 512x512, बैच 4
# - VAE टाइलिंग का उपयोग करें
# - 20-30 चरण
```

**इसके लिए सर्वश्रेष्ठ:** SD 1.5, SDXL (सीमाओं के साथ)

### RTX 3090 24GB (उत्तम)

```bash
# मानक लॉन्च
python main.py --force-fp16

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, बैच 2
# - FLUX schnell: 1024x1024, बैच 1
# - ControlNet + SDXL अच्छी तरह काम करता है
# - 30-50 चरण
```

**इसके लिए सर्वश्रेष्ठ:** SDXL, ControlNet वर्कफ़्लो, मध्यम FLUX

### RTX 4090 24GB (प्रदर्शन)

```bash
# पूर्ण गति लॉन्च
python main.py

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, बैच 4
# - FLUX dev: 1024x1024, बैच 1-2
# - कई ControlNets के साथ जटिल वर्कफ़्लो
# - गुणवत्ता के लिए 50+ चरण
```

**इसके लिए सर्वश्रेष्ठ:** FLUX, जटिल वर्कफ़्लो, बैच जनरेशन

### A100 40GB/80GB (प्रोडक्शन)

```bash
# अधिकतम प्रदर्शन
python main.py --highvram

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, बैच 8+
# - FLUX: 1024x1024, बैच 2-4
# - एक साथ कई मॉडल लोड किए गए
# - उच्च-रिज़ॉल्यूशन आउटपुट (2048x2048)
```

**इसके लिए सर्वश्रेष्ठ:** प्रोडक्शन वर्कलोड, FLUX, उच्च-रिज़ॉल्यूशन जनरेशन

## लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें:

| GPU      | VRAM | प्राइस/दिन | SDXL गति       |
| -------- | ---- | ---------- | -------------- |
| RTX 3060 | 12GB | $0.15–0.30 | \~15 सेकंड/छवि |
| RTX 3090 | 24GB | $0.30–1.00 | \~8 सेकंड/छवि  |
| RTX 4090 | 24GB | $0.50–2.00 | \~4 सेकंड/छवि  |
| A100     | 40GB | $1.50–3.00 | \~3 सेकंड/छवि  |

*मूल्य USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — जांचें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

## समस्याओं का निवारण

### लंबे समय के लिए HTTP 502

1. **RAM जाँच करें:** सर्वर में 16GB+ RAM होना चाहिए
2. **VRAM जाँच करें:** SDXL के लिए 8GB+, FLUX के लिए 16GB+
3. **निर्भरता डाउनलोड हो रही हैं:** पहली बार चलाने पर 5-10 मिनट लगेगा
4. **मॉडल डाउनलोडिंग:** बड़े मॉडल में अधिक समय लगता है

### आउट ऑफ़ मेमोरी

```bash
# लो VRAM मोड में चलाएँ
python main.py --lowvram

# या fp16 को मजबूर करें
python main.py --force-fp16
```

### काली छवियाँ

* जांचें कि VAE लोड हुआ है
* विभिन्न VAE आज़माएँ
* इमेज साइज घटाएँ

### धीमा जनरेशन

* CUDA सक्षम करें
* fp16 मॉडल का उपयोग करें
* चरणों को कम करें (अक्सर 20-30 पर्याप्त होते हैं)

## वर्कफ़्लो उदाहरण

इन JSON वर्कफ़्लो को ComfyUI में आयात करें:

* [बुनियादी txt2img](https://comfyworkflows.com)
* [SDXL + रिफाइनर](https://comfyworkflows.com)
* [ControlNet Canny](https://comfyworkflows.com)
* [AnimateDiff वीडियो](https://comfyworkflows.com)

## अगले कदम

* [ControlNet गाइड](/guides/guides_v2-hi/image-processing/controlnet-advanced.md)
* [Real-ESRGAN अपस्केलिंग](/guides/guides_v2-hi/image-processing/real-esrgan-upscaling.md)
* [Kohya प्रशिक्षण](/guides/guides_v2-hi/training/kohya-training.md) - कस्टम LoRA प्रशिक्षण
* [Fooocus](/guides/guides_v2-hi/image-generation/fooocus-simple-sd.md) - सरल विकल्प


---

# Agent Instructions: 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-hi/image-generation/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.