> 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/ai-platforms-and-agents/dify.md).

# Dify.ai Workflow Platform

## अवलोकन

[Dify.ai](https://github.com/langgenius/dify) एक ओपन-सोर्स LLM एप्लिकेशन विकास प्लेटफ़ॉर्म है जिसमें **114K+ GitHub स्टार**। यह एक विज़ुअल वर्कफ़्लो बिल्डर, रिट्रीवल-ऑगमेंटेड जेनरेशन (RAG) पाइपलाइन, एजेंट ऑर्केस्ट्रेशन, मॉडल प्रबंधन, और एक एक-क्लिक API डिप्लॉयमेंट लेयर को एक सिंगल self-hostable स्टैक में संयोजित करता है।

पर **Clore.ai** आप पूरे Dify स्टैक को चला सकते हैं — जिसमें इसका Postgres डेटाबेस, Redis कैश, Weaviate वेक्टर स्टोर, Nginx रिवर्स प्रॉक्सी, API वर्कर्स, और वेब फ्रंटएंड शामिल हैं — एक किराये पर ली गई GPU सर्वर पर सिर्फ **$0.20–$0.35/घं** (RTX 3090/4090)। GPU Dify के लिए वैकल्पिक है, लेकिन जब आप लोकल मॉडल इन्फरेंस को Ollama या vLLM बैकएंड के माध्यम से जोड़ते हैं तो यह आवश्यक बन जाता है।

**मुख्य क्षमताएँ:**

* 🔄 **विज़ुअल वर्कफ़्लो बिल्डर** — ब्रांचिंग, लूप और सशर्त लॉजिक के साथ ड्रैग-एंड-ड्रॉप LLM पाइपलाइन्स
* 📚 **RAG पाइपलाइन** — PDF, URL, Notion पृष्ठ अपलोड करें; चंकिंग + एम्बेडिंग + रिट्रीवल सभी UI में प्रबंधित
* 🤖 **एजेंट मोड** — टूल उपयोग के साथ ReAct और फ़ंक्शन-कॉलिंग एजेंट (वेब सर्च, कोड इंटरप्रेटर, कस्टम API)
* 🚀 **API-प्रथम** — हर ऐप तुरंत एक REST एंडपॉइंट और SDK स्नीपेट्स उत्पन्न करता है
* 🔌 **100+ मॉडल इंटीग्रेशन** — OpenAI, Anthropic, Mistral, Cohere, साथ ही Ollama/vLLM के माध्यम से लोकल मॉडल
* 🏢 **मल्टी-टेनेंट** — टीमें, वर्कस्पेस, RBAC, उपयोग कोटा

***

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

Dify मल्टी-कंटेनर Docker Compose स्टैक के रूप में चलता है। विकास के लिए न्यूनतम योग्य सर्वर CPU-ओनली इंस्टेंस है; लोकल मॉडल इन्फरेंस के साथ प्रोडक्शन के लिए आप एक GPU नोड चाहेंगे।

| कॉन्फ़िगरेशन                  | GPU                 | VRAM  | सिस्टम RAM | डिस्क  | Clore.ai मूल्य   |
| ----------------------------- | ------------------- | ----- | ---------- | ------ | ---------------- |
| **न्यूनतम** (सिर्फ़ API कीज़) | कोई नहीं / केवल CPU | —     | 8 GB       | 30 GB  | \~$0.05/घं (CPU) |
| **मानक**                      | RTX 3080            | 10 GB | 16 GB      | 50 GB  | \~$0.15/घंटा     |
| **अनुशंसित**                  | RTX 3090 / 4090     | 24 GB | 32 GB      | 80 GB  | $0.20–0.35/घंटा  |
| **प्रोडक्शन + लोकल LLM**      | A100 80 GB          | 80 GB | 64 GB      | 200 GB | \~$1.10/घंटा     |
| **हाई-थ्रूपुट**               | H100 SXM            | 80 GB | 128 GB     | 500 GB | \~$2.50/घं       |

> **संकेत:** यदि आप केवल क्लाउड API प्रदाताओं (OpenAI, Anthropic, आदि) का उपयोग करते हैं, तो किसी भी 2‑कोर CPU इंस्टेंस के साथ 8 GB RAM काम करता है। केवल तब GPU मायने रखता है जब आप Ollama या vLLM के माध्यम से लोकल मॉडल चला रहे हों — देखें [GPU त्वरक](#gpu-acceleration) नीचे।

### डिस्क नोट

Weaviate और Postgres डेटा दस्तावेज़ अपलोड के साथ तेजी से बढ़ते हैं। प्रावधान करें **कम से कम 50 GB** और Clore.ai के वॉल्यूम विकल्पों के माध्यम से स्थायी स्टोरेज माउंट करें।

***

## त्वरित प्रारम्भ

### 1. एक Clore.ai सर्वर किराए पर लें

ब्राउज़ करें [clore.ai](https://clore.ai), अपनी इच्छित GPU से फ़िल्टर करें, और निम्न के साथ एक सर्वर डिप्लॉय करें:

* **Docker** प्रि-इंस्टॉल (सभी Clore इमेज इसमें शामिल हैं)
* एक्सपोज़्ड पोर्ट **80** और **443** (यदि आवश्यक हो तो ऑफर सेटिंग्स में कस्टम पोर्ट जोड़ें)
* SSH एक्सेस सक्षम

### 2. सर्वर से कनेक्ट करें और तैयार करें

```bash
# अपने Clore सर्वर में SSH करें
ssh root@<clore-server-ip> -p <ssh-port>

# सिस्टम पैकेज अपडेट करें
apt-get update && apt-get upgrade -y

# सत्यापित करें कि Docker उपलब्ध है
docker --version
docker compose version   # v2.x होना चाहिए
```

### 3. Dify क्लोन करें और लॉन्च करें

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

# उदाहरण एनवायरनमेंट फ़ाइल कॉपी करें
cp .env.example .env

# (वैकल्पिक) लॉन्च से पहले सेटिंग्स संपादित करें
nano .env

# सभी इमेज खींचें और बैकग्राउंड में सभी सेवाएँ स्टार्ट करें
docker compose up -d

# स्टार्टअप के दौरान लॉग देखें (पहली बार 2-3 मिनट लगते हैं)
docker compose logs -f
```

### 4. सत्यापित करें कि सभी सेवाएँ स्वस्थ हैं

```bash
# कंटेनर स्थिति जांचें
docker compose ps

# अपेक्षित आउटपुट:
# NAME                    STATUS
# docker-api-1            Up (healthy)
# docker-web-1            Up (healthy)
# docker-worker-1         Up (healthy)
# docker-nginx-1          Up
# docker-db-1             Up (healthy)
# docker-redis-1          Up (healthy)
# docker-weaviate-1       Up (healthy)
# docker-sandbox-1        Up (healthy)
```

### 5. वेब UI तक पहुँचें

अपने ब्राउज़र को खोलें और नेविगेट करें:

```
http://<clore-server-ip>:80
```

पहली लॉन्च पर, Dify आपको व्यवस्थापक खाता बनाने के लिए सेटअप विज़ार्ड पर रीडायरेक्ट करेगा। विज़ार्ड पूरा करें, फिर लॉग इन करें।

***

## कॉन्फ़िगरेशन

सारी कॉन्फ़िगरेशन इन में रहती है `dify/docker/.env`। यहाँ सबसे महत्वपूर्ण सेटिंग्स हैं:

### आवश्यक पर्यावरण चर

```bash
# ── सीक्रेट कीज़ (इन्हें बदलें) ──────────────────────────────────────────────
SECRET_KEY=your-super-secret-key-change-this-immediately
# एक मजबूत की जेनरेट करें:
# python3 -c "import secrets; print(secrets.token_hex(32))"

# ── एप्लिकेशन URL ──────────────────────────────────────────────────────────
# अपने सर्वर के पब्लिक IP या डोमेन पर सेट करें
CONSOLE_WEB_URL=http://<clore-server-ip>
APP_WEB_URL=http://<clore-server-ip>

# ── डेटाबेस (Postgres) ─────────────────────────────────────────────────────
DB_USERNAME=postgres
DB_PASSWORD=difyai123456          # प्रोडक्शन में बदलें!
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

# ── Redis ───────────────────────────────────────────────────────────────────
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=difyai123456       # प्रोडक्शन में बदलें!

# ── स्टोरेज (डिफ़ॉल्ट रूप से लोकल डिस्क) ─────────────────────────────────────
STORAGE_TYPE=local
# या S3-कम्पैटिबल स्टोरेज का उपयोग करें:
# STORAGE_TYPE=s3
# S3_ENDPOINT=https://s3.amazonaws.com
# S3_BUCKET_NAME=your-dify-bucket
# S3_ACCESS_KEY=...
# S3_SECRET_KEY=...

# ── डिफ़ॉल्ट LLM प्रदाता ─────────────────────────────────────────────────────
# लॉगिन के बाद UI में सेट करें, या यहाँ प्री-कॉन्फ़िगर करें:
# OPENAI_API_KEY=sk-...
```

### एक्सपोज़्ड पोर्ट बदलना

डिफ़ॉल्ट रूप से Nginx पोर्ट पर सुनता है **80**। बदलने के लिए:

```bash
# docker-compose.yaml में nginx सर्विस संपादित करें:
# ports:
#   - "8080:80"   ← 8080 को अपनी पसंदीदा होस्ट पोर्ट में बदलें

# फिर पुनरारंभ करें:
docker compose down && docker compose up -d
```

### स्थायी डेटा वॉल्यूम

Dify की Compose फ़ाइल डिफ़ॉल्ट रूप से ये वॉल्यूम माउंट करती है:

```yaml
volumes:
  oradata:          # Postgres डेटा
  redis_data:       # Redis AOF
  weaviate_data:    # वेक्टर स्टोर
  app_storage:      # अपलोड किए गए दस्तावेज़ और जेनरेट किए गए फ़ाइलें
```

बैकअप लेने के लिए:

```bash
# पहले सेवाएँ रोकें, फिर Docker वॉल्यूम का tar बनाएं
docker compose stop
docker run --rm \
  -v docker_oradata:/data \
  -v $(pwd)/backups:/backup \
  alpine tar czf /backup/postgres-$(date +%Y%m%d).tar.gz /data
docker compose start
```

***

## GPU त्वरक

Dify का मूल प्लेटफ़ॉर्म CPU-आधारित है, लेकिन आप जोड़कर लोकल मॉडल इन्फरेंस अनलॉक करते हैं **Ollama** या **vLLM** के रूप में मॉडल प्रदाताओं — दोनों GPU से अत्यधिक लाभान्वित होते हैं।

### विकल्प A: Ollama साइडकार (सबसे आसान)

उसी Clore सर्वर पर Dify के साथ Ollama चलाएँ:

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# एक मॉडल पुल करें (उदा. Llama 3 8B)
ollama pull llama3:8b

# सत्यापित करें कि GPU उपयोग हो रहा है
ollama run llama3:8b "Hello!"
nvidia-smi   # Ollama प्रक्रिया VRAM का उपयोग दिखानी चाहिए
```

फिर Dify UI → **Settings → Model Providers → Ollama**:

* बेस URL: `http://localhost:11434`
* अपना मॉडल चुनें और सहेजें

> पूरा Ollama गाइड देखने के लिए देखें [language-models/ollama.md](/guides/guides_v2-hi/language-models/ollama.md).

### विकल्प B: vLLM साइडकार (हाई-थ्रूपुट)

```bash
# vLLM को GPU passthrough के साथ अलग कंटेनर के रूप में चलाएँ
docker run -d \
  --name vllm \
  --gpus all \
  --runtime nvidia \
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -e HUGGING_FACE_HUB_TOKEN=<your-hf-token> \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.2 \
  --dtype auto \
  --max-model-len 4096

# एंडपॉइंट सत्यापित करें
curl http://localhost:8000/v1/models
```

फिर Dify UI → **Settings → Model Providers → OpenAI-compatible**:

* बेस URL: `http://localhost:8000/v1`
* API कुंजी: `dummy`
* मॉडल नाम: `mistralai/Mistral-7B-Instruct-v0.2`

> पूरा vLLM सेटअप देखने के लिए देखें [language-models/vllm.md](/guides/guides_v2-hi/language-models/vllm.md).

### लोकल मॉडलों के लिए GPU मेमोरी सिफारिशें

| मॉडल               | आवश्यक VRAM | अनुशंसित Clore GPU |
| ------------------ | ----------- | ------------------ |
| Llama 3 8B (Q4)    | 6 GB        | RTX 3060           |
| Llama 3 8B (FP16)  | 16 GB       | RTX 3090 / 4090    |
| Mistral 7B (Q4)    | 5 GB        | RTX 3060           |
| Llama 3 70B (Q4)   | 40 GB       | A100 40GB          |
| Llama 3 70B (FP16) | 140 GB      | 2× H100            |

***

## टिप्स और सर्वोत्तम प्रथाएँ

### Clore.ai पर लागत अनुकूलन

```bash
# स्पॉट प्राइसिंग का उपयोग करें — Dify के डेटाबेस वॉल्यूम में स्टेट बनाए रखते हैं
# इसलिए आप इंस्टेंस को सस्ते में स्टॉप/रिस्टार्ट कर सकते हैं

# अपने Clore इंस्टेंस को रोकने से पहले DB dump करें:
docker exec docker-db-1 pg_dump -U postgres dify > dify_backup_$(date +%Y%m%d).sql

# स्थानांतरण के लिए स्टोरेज वॉल्यूम को कंप्रेस करें
tar czf dify_storage_$(date +%Y%m%d).tar.gz \
  $(docker volume inspect docker_app_storage --format '{{.Mountpoint}}')
```

### Caddy के साथ HTTPS सक्षम करें (प्रोडक्शन के लिए अनुशंसित)

```bash
# docker-compose.yaml में Caddy जोड़ें या स्टैंडअलोन चलाएँ
docker run -d \
  --name caddy \
  --network docker_default \
  -p 443:443 -p 80:80 \
  -v $PWD/Caddyfile:/etc/caddy/Caddyfile \
  -v caddy_data:/data \
  caddy:latest

# Caddyfile सामग्री:
# your-domain.com {
#     reverse_proxy nginx:80
# }
```

### भारी वर्कलोड के लिए वर्कर्स को स्केल करें

```bash
# 1 की बजाय 4 celery वर्कर्स चलाएँ
docker compose up -d --scale worker=4
```

### रिसोर्स उपयोग की निगरानी करें

```bash
# लाइव कंटेनर स्टैट्स
docker stats

# GPU उपयोग (यदि लोकल मॉडलों का उपयोग कर रहे हैं)
watch -n1 nvidia-smi

# Dify एप्लिकेशन लॉग्स
docker compose logs -f api worker
```

### RAG प्रदर्शन ट्यूनिंग

* सेट करें **चंक साइज** अधिकांश दस्तावेज़ प्रकारों के लिए 512–1024 टोकन तक
* सक्षम करें **पैरेंट-चाइल्ड रिट्रीवल** लंबे दस्तावेज़ों के लिए Dataset सेटिंग्स में
* उपयोग करें **हाइब्रिड सर्च** (कीवर्ड + वेक्टर) तकनीकी सामग्री पर बेहतर रिकॉल के लिए
* API रेट सीमाओं से बचने के लिए ऑफ-पीक घंटों में दस्तावेज़ों को इंडेक्स करें

***

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

### सेवाएँ बार-बार रिस्टार्ट हो रही हैं

```bash
# फेल होने वाली सेवा के लॉग्स जांचें
docker compose logs --tail=50 api
docker compose logs --tail=50 worker

# सामान्य कारण: गलत SECRET_KEY या DB कनेक्शन
# सुनिश्चित करें .env SECRET_KEY सेट और अनूठी है
grep SECRET_KEY .env
```

### "स्टार्टअप पर माइग्रेशन फेल हुआ"

```bash
# DB माइग्रेशन मैन्युअली चलाएँ
docker compose exec api flask db upgrade

# यदि वह फेल हो, तो पहले जांचें कि Postgres स्वस्थ है
docker compose exec db pg_isready -U postgres
```

### Dify से Ollama से कनेक्ट नहीं कर पा रहे

```bash
# डिफ़ॉल्ट रूप से Ollama 127.0.0.1 पर बाइंड करता है
# इसे सभी इंटरफेस पर सुनने के लिए बदलें:
OLLAMA_HOST=0.0.0.0 ollama serve

# या systemd सर्विस संपादित करें:
systemctl edit ollama
# [Service] के अंतर्गत जोड़ें:
# Environment="OLLAMA_HOST=0.0.0.0"
systemctl restart ollama

# Dify कंटेनर के अंदर से टेस्ट करें:
docker compose exec api curl http://host.docker.internal:11434/api/tags
```

### डिस्क स्पेस ख़त्म

```bash
# वॉल्यूम आकार जांचें
df -h
docker system df

# अनयूज़्ड इमेज हटाएँ
docker image prune -a

# Weaviate लॉग्स बहुत बड़े हो सकते हैं — इन्हें रोटेट करें
docker compose exec weaviate truncate -s 0 /tmp/weaviate.log
```

### Weaviate वेक्टर स्टोर त्रुटियाँ

```bash
# Weaviate रीसेट करें (सावधान: यह सभी एम्बेडिंग्स को हटा देता है, पुनः-इंडेक्स आवश्यक होगा)
docker compose stop weaviate
docker volume rm docker_weaviate_data
docker compose up -d weaviate

# फिर Dify UI → Datasets → [dataset] → Re-index में अपने डेटासेट्स को पुनः-इंडेक्स करें
```

### पोर्ट 80 पहले से उपयोग में है

```bash
# देखें कौन पोर्ट 80 का उपयोग कर रहा है
ss -tlnp | grep :80
# या
lsof -i :80

# संघर्ष कर रही सेवा को रोकें या docker-compose.yaml में Dify के nginx पोर्ट को बदलें
```

***

## अधिक पढ़ने के लिए

* [Dify आधिकारिक दस्तावेज़](https://docs.dify.ai)
* [Dify GitHub रिपोजिटरी](https://github.com/langgenius/dify)
* [Dify सेल्फ-होस्टिंग गाइड](https://docs.dify.ai/getting-started/install-self-hosted/docker-compose)
* [Clore.ai पर Ollama चलाना](/guides/guides_v2-hi/language-models/ollama.md)
* [Clore.ai पर vLLM चलाना](/guides/guides_v2-hi/language-models/vllm.md)
* [Clore.ai GPU तुलना](/guides/guides_v2-hi/getting-started/gpu-comparison.md)
* [Dify समुदाय Discord](https://discord.gg/FngNHpbcY7)


---

# 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/ai-platforms-and-agents/dify.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.
