# RAGFlow

RAGFlow एक ओपन-सोर्स **रीट्राइवल-ऑगमेंटेड जेनरेशन (RAG) इंजन** गहरे दस्तावेज़ समझ क्षमताओं के साथ। **50,000 से अधिक GitHub स्टार**— यह उपलब्ध सबसे व्यापक RAG प्लेटफार्मों में से एक है — जो PDF, Word फाइलें, स्प्रेडशीट, छवियाँ और अधिक सहित जटिल दस्तावेज़ों से जानकारी निकालने, चंक करने और तर्क करने के लिए डिज़ाइन किया गया है।

साधारण RAG सिस्टम्स जो दस्तावेज़ों को सरलता से चंक में विभाजित करते हैं, के विपरीत RAGFlow लेआउट-आधारित पार्सिंग का उपयोग करता है ताकि दस्तावेज़ की संरचना, तालिकाएँ, चित्र और मल्टी-कॉलम लेआउट को समझा जा सके। इससे रिकवरी सटीकता और उत्तर की गुणवत्ता में नाटकीय रूप से सुधार होता है।

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

* 📄 **गहरा दस्तावेज़ समझ** — OCR, तालिका निष्कर्षण, आंकड़ा पहचान
* ACE-Step (ओपन-सोर्स Suno विकल्प) **कई चंकिंग रणनीतियाँ** — सैमॉन्टिक, लेआउट-अवेयर, निश्चित-आकार, Q\&A शैली
* हाइलाइट्स **LLM एकीकरण** — OpenAI, Ollama, Anthropic, लोकल मॉडल के साथ कार्य करता है
* 🌐 **पूर्ण-विशेषतायुक्त वेबUI** — ड्रैग-एंड-ड्रॉप दस्तावेज़ प्रबंधन
* 🔌 **REST API** — RAGFlow को किसी भी एप्लिकेशन में एकीकृत करें
* Aider, TabbyML (स्व-होस्टेड Copilot) **उद्धरण ट्रैकिंग** — उत्तरों में स्रोत दस्तावेज़ संदर्भ शामिल होते हैं
* 🏗️ **मल्टी-टेनेंट** — अनुमति नियंत्रण के साथ टीम वर्कस्पेसेज़

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

***

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

| पैरामीटर        | न्यूनतम                 | अनुशंसित                |
| --------------- | ----------------------- | ----------------------- |
| GPU             | NVIDIA RTX 3080 (10 GB) | NVIDIA RTX 4090 (24 GB) |
| VRAM            | 8 GB                    | 16–24 GB                |
| RAM             | 16 GB                   | 32–64 GB                |
| CPU             | 8 कोर                   | 16+ कोर                 |
| डिस्क           | 50 GB                   | 100–500 GB              |
| ऑपरेटिंग सिस्टम | Ubuntu 20.04+           | Ubuntu 22.04            |
| CUDA            | 11.8+                   | 12.1+                   |
| पोर्ट्स         | 22, 9380, 80            | 22, 9380, 80            |
| Docker          | आवश्यक                  | Docker + Docker Compose |

{% hint style="warning" %}
RAGFlow मुख्य एप्लिकेशन के साथ कई सेवाएँ (Elasticsearch, MinIO, MySQL, Redis, Nginx) चलाता है। सुनिश्चित करें कि आपके पास पर्याप्त RAM है (न्यूनतम 16 GB, 32 GB अनुशंसित) और डिस्क स्पेस।
{% endhint %}

***

## CLORE.AI पर त्वरित तैनाती

### 1. एक उपयुक्त सर्वर खोजें

जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और फ़िल्टर करें:

* **VRAM**: ≥ 8 GB
* **RAM**: ≥ 16 GB
* **डिस्क**: ≥ 50 GB
* **GPU**: RTX 3090, 4090, A100, H100

### 2. अपनी तैनाती कॉन्फ़िगर करें

**Docker इमेज:**

```
infiniflow/ragflow:latest
```

**पोर्ट मैपिंग्स:**

```
22   → SSH एक्सेस
80   → RAGFlow वेब UI (HTTP)
9380 → RAGFlow API
```

**स्टार्टअप कमांड:**

```bash
bash -c "docker-compose -f docker/docker-compose.yml up -d"
```

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

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

डिफ़ॉल्ट प्रमाण-पत्र: `admin@ragflow.io` / `admin`

***

## चरण-दर-चरण सेटअप

### चरण 1: अपने सर्वर में SSH करें

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### चरण 2: Docker Compose इंस्टॉल करें

```bash
apt-get update && apt-get install -y docker-compose-plugin

# सत्यापित करें
docker compose version
```

### चरण 3: RAGFlow रिपॉज़िटरी क्लोन करें

```bash
cd /workspace
git clone https://github.com/infiniflow/ragflow.git
cd ragflow
```

### चरण 4: पर्यावरण कॉन्फ़िगर करें

```bash
# पर्यावरण फ़ाइल कॉपी और संपादित करें
cp docker/.env.example docker/.env
nano docker/.env
```

कॉन्फ़िगर करने के लिए प्रमुख सेटिंग्स:

```env
# LLM कॉन्फ़िगरेशन
OPENAI_API_KEY=your-openai-api-key

# या लोकल Ollama इंस्टेंस का उपयोग करें
OLLAMA_BASE_URL=http://localhost:11434

# स्टोरेज सेटिंग्स
MINIO_USER=ragflow
MINIO_PASSWORD=infini_rag_flow

# MySQL सेटिंग्स
MYSQL_PASSWORD=infini_rag_flow

# एप्लिकेशन पोर्ट
HTTP_PORT=80
RAGFLOW_API_PORT=9380
```

### चरण 5: सही इमेज वेरिएंट चुनें

```bash
# उपलब्ध टैग जांचें
# CUDA 12.1 के लिए (अधिकांश RTX कार्ड्स)
docker pull infiniflow/ragflow:latest

# विशिष्ट CUDA संस्करण के लिए
docker pull infiniflow/ragflow:v0.7.0-cuda12.1
```

### चरण 6: सभी सेवाएँ प्रारंभ करें

```bash
cd /workspace/ragflow/docker

# GPU समर्थन के साथ प्रारंभ करें
docker compose -f docker-compose.yml up -d

# स्टार्टअप मॉनिटर करें (2–5 मिनट लगते हैं)
docker compose logs -f
```

प्रतीक्षा करें:

```
ragflow-server | INFO: Application startup complete.
```

### चरण 7: एडमिन खाता बनाएं

खुला `http://<server-ip>:80` और पहला एडमिन खाते के रूप में रजिस्टर करें।

### चरण 8: LLM मॉडल कॉन्फ़िगर करें

1. जाएँ **Settings → Model Providers**
2. अपना LLM जोड़ें (OpenAI, Ollama, आदि)
3. डिफ़ॉल्ट चैट मॉडल और एम्बेडिंग मॉडल सेट करें

***

## उपयोग के उदाहरण

### उदाहरण 1: WebUI के माध्यम से दस्तावेज़ अपलोड और क्वेरी

1. लॉग इन करें `http://<server-ip>:80`
2. पर क्लिक करें **"Knowledge Base"** → **"Create Knowledge Base"**
3. नाम दें: `"Clore.ai Documentation"`
4. ड्रैग-एंड-ड्रॉप का उपयोग करके PDF/Word/TXT फाइलें अपलोड करें
5. पार्सिंग के लिए प्रतीक्षा करें (प्रोग्रेस UI में दिखेगा)
6. जाएँ **"Chat"** → अपने नॉलेज बेस से जुड़ा नया असिस्टेंट बनाएं
7. अपने दस्तावेज़ों के बारे में प्रश्न पूछें

***

### उदाहरण 2: API — नॉलेज बेस बनाना और दस्तावेज़ अपलोड करना

```python
import requests
import json
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"  # Settings → API से प्राप्त करें

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# चरण 1: एक नॉलेज बेस बनाएं
kb_payload = {
    "name": "Clore.ai Technical Docs",
    "description": "GPU क्लाउड मार्केटप्लेस डॉक्यूमेंटेशन और गाइड्स",
    "language": "English",
    "embedding_model": "text-embedding-ada-002",
    "chunk_method": "naive",  # या 'qa', 'table', 'paper', 'book'
}

response = requests.post(
    f"{BASE_URL}/api/v1/knowledgebase",
    headers=headers,
    json=kb_payload
)
kb = response.json()
kb_id = kb["data"]["id"]
print(f"Created knowledge base: {kb_id}")

# चरण 2: एक दस्तावेज़ अपलोड करें
pdf_path = Path("technical_manual.pdf")

with open(pdf_path, "rb") as f:
    files = {"file": (pdf_path.name, f, "application/pdf")}
    upload_response = requests.post(
        f"{BASE_URL}/api/v1/document/upload?kb_id={kb_id}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files=files
    )

doc = upload_response.json()
doc_id = doc["data"]["id"]
print(f"Uploaded document: {doc_id}")

# चरण 3: पार्सिंग शुरू करें
parse_response = requests.post(
    f"{BASE_URL}/api/v1/document/run",
    headers=headers,
    json={"doc_ids": [doc_id]}
)
print(f"Parsing started: {parse_response.json()}")
```

***

### उदाहरण 3: API के माध्यम से दस्तावेज़ों से क्वेरी करना

```python
import requests
import json

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"
CHAT_ID = "your-chat-assistant-id"  # WebUI → Chat से

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

def ask_ragflow(question, chat_id, session_id=None):
    """RAGFlow को प्रश्न भेजें और उद्धरणों के साथ उत्तर प्राप्त करें."""
    payload = {
        "question": question,
        "stream": False
    }

    if session_id:
        payload["session_id"] = session_id

    response = requests.post(
        f"{BASE_URL}/api/v1/chat/{chat_id}/completion",
        headers=headers,
        json=payload
    )

    result = response.json()
    if result.get("code") == 0:
        data = result["data"]
        answer = data.get("answer", "")
        references = data.get("reference", {}).get("chunks", [])
        return answer, references
    else:
        return None, []

# उदाहरण प्रश्न
questions = [
    "Clore.ai पर उपलब्ध GPU विनिर्देश क्या हैं?",
    "मैं मार्केटप्लेस पर GPU सर्वर कैसे रेंट करूं?",
    "GPU इंस्टेंस के लिए मूल्य निर्धारण मॉडल क्या है?",
    "कौन से डीप लर्निंग फ्रेमवर्क समर्थित हैं?",
]

for question in questions:
    print(f"\n📌 Q: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 A: {answer}")
    if refs:
        print(f"📚 स्रोत ({len(refs)} चंक्स):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'Unknown')}: {ref.get('content_ltks', '')[:100]}...")
```

***

### उदाहरण 4: बैच दस्तावेज़ प्रसंस्करण पाइपलाइन

```python
import requests
import time
from pathlib import Path

BASE_URL = "http://<your-clore-server-ip>:9380"
API_KEY = "your-ragflow-api-key"

headers = {"Authorization": f"Bearer {API_KEY}"}

def upload_and_parse_documents(kb_id, document_paths):
    """कई दस्तावेज़ अपलोड करें और पार्सिंग पूरी होने तक प्रतीक्षा करें."""
    doc_ids = []

    # सभी दस्तावेज़ अपलोड करें
    for doc_path in document_paths:
        path = Path(doc_path)
        with open(path, "rb") as f:
            mime = "application/pdf" if path.suffix == ".pdf" else "text/plain"
            files = {"file": (path.name, f, mime)}
            resp = requests.post(
                f"{BASE_URL}/api/v1/document/upload?kb_id={kb_id}",
                headers=headers,
                files=files
            )
            if resp.status_code == 200:
                doc_id = resp.json()["data"]["id"]
                doc_ids.append(doc_id)
                print(f"✓ Uploaded: {path.name} → {doc_id}")
            else:
                print(f"✗ Failed: {path.name}")

    # बैच पार्सिंग शुरू करें
    if doc_ids:
        requests.post(
            f"{BASE_URL}/api/v1/document/run",
            headers={**headers, "Content-Type": "application/json"},
            json={"doc_ids": doc_ids}
        )
        print(f"\nParsing {len(doc_ids)} documents...")

        # पूर्ण होने तक पोल करें
        while True:
            time.sleep(5)
            status_resp = requests.get(
                f"{BASE_URL}/api/v1/document/list?kb_id={kb_id}",
                headers=headers
            )
            docs = status_resp.json().get("data", {}).get("docs", [])
            pending = [d for d in docs if d.get("status") == "1"]  # 1 = processing
            done = [d for d in docs if d.get("status") == "2"]     # 2 = done

            print(f"  Processing: {len(pending)} | Done: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    print("✓ सभी दस्तावेज़ पार्स हो गए!")
    return doc_ids

# उपयोग
docs = ["manual_v1.pdf", "faq.txt", "api_reference.pdf"]
doc_ids = upload_and_parse_documents(kb_id="your-kb-id", document_paths=docs)
```

***

### उदाहरण 5: RAGFlow स्थानीय Ollama LLM के साथ

```bash
# 1. उसी Clore.ai सर्वर पर Ollama इंस्टॉल करें
curl -fsSL https://ollama.ai/install.sh | sh

# 2. एक लोकल मॉडल पुल करें
ollama pull llama3:8b
ollama pull nomic-embed-text  # एम्बेडिंग के लिए

# 3. RAGFlow को Ollama उपयोग के लिए कॉन्फ़िगर करें
# WebUI में: Settings → Model Providers → Add Ollama
# बेस URL: http://host.docker.internal:11434
# या यदि Ollama Docker में चल रहा है: http://ollama:11434
```

```python
# Ollama एकीकरण का परीक्षण करें
import requests

# सत्यापित करें कि Ollama चल रहा है
resp = requests.get("http://localhost:11434/api/tags")
models = [m["name"] for m in resp.json()["models"]]
print(f"उपलब्ध Ollama मॉडल: {models}")

# स्थानीय LLM (WebUI में कॉन्फ़िगर) का उपयोग करके RAGFlow से क्वेरी करें
BASE_URL = "http://localhost:9380"
API_KEY = "your-api-key"
CHAT_ID = "your-chat-id"

response = requests.post(
    f"{BASE_URL}/api/v1/chat/{CHAT_ID}/completion",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={"question": "Explain the RAGFlow architecture", "stream": False}
)
print(response.json()["data"]["answer"])
```

***

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

### docker-compose.yml प्रमुख सेवाएँ

```yaml
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "9380:9380"
      - "80:80"
    environment:
      - HF_ENDPOINT=https://huggingface.co
      - MACOS=0
    depends_on:
      - mysql
      - minio
      - es01
      - redis

  es01:
    image: elasticsearch:8.11.3
    environment:
      - xpack.security.enabled=false
      - discovery.type=single-node
    volumes:
      - esdata01:/usr/share/elasticsearch/data

  mysql:
    image: mysql:8.0.39
    environment:
      - MYSQL_ROOT_PASSWORD=infini_rag_flow

  minio:
    image: quay.io/minio/minio:RELEASE.2023-12-20T01-00-02Z
    command: server /data --console-address ":9001"

  redis:
    image: redis:7.2.4
```

### चंकिंग रणनीतियाँ

| विधि     | माध्य/दिन              | विवरण                               |
| -------- | ---------------------- | ----------------------------------- |
| `naive`  | सामान्य दस्तावेज़      | ओवरलैप के साथ निश्चित-आकार के चंक्स |
| `qa`     | FAQ/Q\&A दस्तावेज़     | प्रश्न-उत्तर जोड़ों पर विभाजन       |
| `table`  | स्प्रेडशीट्स, तालिकाएँ | तालिका संरचना संरक्षित रखता है      |
| `paper`  | अकादमिक पेपर्स         | अनुभाग, सार, संदर्भ                 |
| `book`   | लंबी किताबें, मैनुअल   | अध्याय-समझ के अनुसार चंकिंग         |
| `laws`   | कानूनी दस्तावेज़       | अनुच्छेद-आधारित चंकिंग              |
| `manual` | तकनीकी मैनुअल          | अनुभागीय अनुक्रम संरक्षा            |

***

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

### 1. Elasticsearch मेमोरी स्केल करें

```yaml
# docker-compose.yml में
es01:
  environment:
    - ES_JAVA_OPTS=-Xms4g -Xmx4g  # बड़े दस्तावेज़ सेट्स के लिए बढ़ाएँ
```

### 2. GPU-त्वरित एम्बेडिंग

RAGFlow को GPU-आधारित एम्बेडिंग मॉडल उपयोग करने के लिए कॉन्फ़िगर करें:

* Settings → Model Providers में, Ollama के माध्यम से लोकल GPU मॉडल का उपयोग करें
* या Clore.ai GPU पर चल रही समर्पित एम्बेडिंग सेवा की ओर संकेत करें

### 3. समानांतर दस्तावेज़ प्रसंस्करण

RAGFlow डिफ़ॉल्ट रूप से दस्तावेज़ों को समानांतर में प्रोसेस करता है। वर्कर काउंट कॉन्फ़िगर करें:

```env
# docker/.env में
TASK_WORKER_COUNT=4  # CPU कोर के आधार पर समायोजित करें
```

### 4. बड़े दस्तावेज़ सेट्स के लिए MinIO

हज़ारों दस्तावेज़ वाले डिप्लॉयमेंट के लिए, अपने CLORE.AI ऑर्डर में बड़े डिस्क आवंटन के साथ समर्पित MinIO स्टोरेज कॉन्फ़िगर करें।

***

## समस्या निवारण

### समस्या: सेवाएँ शुरू नहीं हो रहीं (मेमोरी)

```bash
# मेमोरी उपयोग जांचें
free -h
docker stats

# Elasticsearch मेमोरी कम करें
# docker/.env संपादित करें: ES_JAVA_OPTS=-Xms1g -Xmx1g
```

### समस्या: पोर्ट 80 पर WebUI तक पहुँच नहीं है

```bash
# जांचें कि nginx चल रहा है
docker compose ps

# पोर्ट बाइंडिंग जाँचें
docker port ragflow-nginx-1

# CLORE.AI में सत्यापित करें: पोर्ट 80 को आपके सर्वर ऑर्डर में मैप किया जाना चाहिए
```

### समस्या: दस्तावेज़ पार्सिंग अटकी हुई है

```bash
# task worker लॉग्स जांचें
docker compose logs ragflow-worker

# वर्कर रीस्टार्ट करें
docker compose restart ragflow-worker
```

### समस्या: Elasticsearch हीप आउट ऑफ मेमोरी

```bash
# .env में हीप बढ़ाएँ
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01
```

### समस्या: एम्बेडिंग मॉडल नहीं मिला

```bash
# HuggingFace मॉडल डाउनलोड सत्यापित करें
docker exec ragflow-server ls /ragflow/models/

# पुनः डाउनलोड करें
docker exec ragflow-server python -c "
from huggingface_hub import snapshot_download
snapshot_download('BAAI/bge-large-en-v1.5')
"
```

***

## लिंक

* **GitHub**: <https://github.com/infiniflow/ragflow>
* **Official Docs**: <https://ragflow.io/docs>
* **Docker Hub**: <https://hub.docker.com/r/infiniflow/ragflow>
* **API संदर्भ**: <https://ragflow.io/docs/dev/http_api_reference>
* **/ <support@clore.ai>**: <https://discord.gg/4XxujFgUN7>
* **CLORE.AI मार्केटप्लेस**: <https://clore.ai/marketplace>

***

## Clore.ai GPU सिफारिशें

| उपयोग केस             | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| --------------------- | ----------------- | ------------------------- |
| डेवलपमेंट/टेस्टिंग    | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| Production RAG        | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| हाई-थ्रूपुट एम्बेडिंग | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।