> 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-hi/image-generation/comfyui.md).

# ComfyUI

Clore.ai पर ComfyUI के साथ नोड-आधारित Stable Diffusion इंटरफ़ेस

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 चाहिए। SDXL with ControlNet के लिए, कम से कम 10GB VRAM सुनिश्चित करें।
{% endhint %}

## ComfyUI क्यों?

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

## CLORE.AI पर त्वरित परिनियोजन

**Docker इमेज:**

```
yanwk/comfyui-boot:cu130-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+ VRAM है
3. मॉडल डाउनलोड करने के लिए नेटवर्क गति पर्याप्त है
   {% endhint %}

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

CLORE.AI पर डिप्लॉय करने पर, ComfyUI तक इस माध्यम से पहुँचें: `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" %}
सभी `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:cu130-slim
```

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

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

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

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

# आवश्यकताएँ इंस्टॉल करें
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 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 (छोटा, तेज़)
wget https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned.safetensors

# यथार्थवादी विज़न (फोटोरियलिस्टिक)
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. नोड जोड़ें:
   * **Load Checkpoint** → मॉडल चुनें
   * **CLIP Text Encode** (x2) → सकारात्मक और नकारात्मक प्रॉम्प्ट
   * **Empty Latent Image** → आयाम सेट करें
   * **KSampler** → सभी को कनेक्ट करें
   * **VAE Decode** → latent को image में बदलें
   * **Save Image** → आउटपुट
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]
```

### Image to Image

बदलें **Empty Latent Image** को इससे:

1. **Load Image** → आपकी स्रोत छवि
2. **VAE Encode** → latent में बदलें
3. समायोजित करें **डीनॉइज़** KSampler में (0.5-0.8)

## ComfyUI Manager

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

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

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

### ComfyUI Manager का उपयोग

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

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

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

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

1. क्लिक करें **Manager** बटन
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

# Text encoders
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": ["एक शानदार फोटोरियलिस्टिक परिदृश्य, गोल्डन आवर लाइटिंग, 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                            |
| ------------------- | ------------------ | ------------------------------- |
| मॉडल लोडर           | Load Checkpoint    | UNETLoader                      |
| टेक्स्ट एन्कोडर     | CLIPTextEncode     | DualCLIPLoader + CLIPTextEncode |
| Latent              | Empty Latent Image | 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
```

मुख्य नोड्स: Image Batch, Text Operations, Image Analyze, Cache Node, Bus Node, Upscale, Mask operations

### मैनेजर के माध्यम से इंस्टॉल करें

1. क्लिक करें **Manager** बटन
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 Edge Detector
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 + Refiner

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

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

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

## API उपयोग

### # बाहरी पहुँच के लिए, अपना http\_pub URL उपयोग करें:

```python
import json
import urllib.request

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

### import websocket

```python
# बाहरी पहुँच के लिए, अपने http_pub URL के साथ wss:// उपयोग करें
import json

ws = websocket.WebSocket()
ws.connect(f"wss://{SERVER}/ws")
msg = json.loads(ws.recv())

while True:
    if msg['type'] == 'progress':
    print(f"स्टेप {msg['data']['value']}/{msg['data']['max']}")
        elif msg['type'] == 'executed':
    print("पूरा हुआ!")
        print("पूरा हुआ!")
        break
```

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

1. **--lowvram सक्षम करें** 8GB से कम VRAM के लिए
2. **fp16 का उपयोग करें** जहाँ संभव हो मॉडल
3. **बैच साइज 1** सीमित VRAM के लिए
4. **Tiled 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, batch 1
# - SD 1.5: 512x512, batch 4
# - VAE टाइलिंग उपयोग करें
# - 20-30 steps
```

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

### RTX 3090 24GB (इष्टतम)

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

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

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

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

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

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

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

### A100 40GB/80GB (उत्पादन)

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

# अनुशंसित सेटिंग्स:
# - SDXL: 1024x1024, batch 8+
# - FLUX: 1024x1024, batch 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 अक्सर पर्याप्त होते हैं)

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

ComfyUI में ये JSON वर्कफ़्लो इम्पोर्ट करें:

* [बेसिक txt2img](https://comfyworkflows.com)
* [SDXL + Refiner](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) - कस्टम LoRAs प्रशिक्षित करें
* [Fooocus](/guides/guides_v2-hi/image-generation/fooocus-simple-sd.md) - सरल विकल्प


---

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