RAGFlow

Clore.ai GPUs पर RAGFlow डीप डॉक्यूमेंट अंडरस्टैंडिंग RAG इंजन तैनात करें

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

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

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

📄 गहन दस्तावेज़ समझ — OCR, तालिका निष्कर्षण, आकृति पहचान
🔍 कई खंडन रणनीतियाँ — अर्थगत, लेआउट-जागरूक, निश्चित-आकार, Q&A शैली
🤖 LLM एकीकरण — OpenAI, Ollama, Anthropic, स्थानीय मॉडलों के साथ काम करता है
🌐 सभी सुविधाओं वाला WebUI — ड्रैग-एंड-ड्रॉप दस्तावेज़ प्रबंधन
🔌 REST API — RAGFlow को किसी भी एप्लिकेशन में एकीकृत करें
📊 संदर्भ ट्रैकिंग — उत्तरों में स्रोत दस्तावेज़ संदर्भ शामिल होते हैं
🏗️ मल्टी-टेनेंट — अनुमति नियंत्रण के साथ टीम कार्यक्षेत्र

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

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

पैरामीटर

न्यूनतम

अनुशंसित

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

Docker

आवश्यक

Docker + Docker Compose

RAGFlow मुख्य एप्लिकेशन के साथ कई सेवाएँ (Elasticsearch, MinIO, MySQL, Redis, Nginx) चलाता है। सुनिश्चित करें कि आपके पास पर्याप्त RAM (कम से कम 16 GB, 32 GB अनुशंसित) और डिस्क स्थान हो।

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

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

पर जाएँ CLORE.AI मार्केटप्लेस और इनके अनुसार फ़िल्टर करें:

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 -c "docker-compose -f docker/docker-compose.yml up -d"

3. WebUI तक पहुँचें

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

डिफ़ॉल्ट क्रेडेंशियल: admin@ragflow.io / admin

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

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

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

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

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

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

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

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

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

# वातावरण फ़ाइल कॉपी और संपादित करें
cp docker/.env.example docker/.env
nano docker/.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: सही इमेज़ वेरिएंट चुनें

# उपलब्ध टैग देखें
# CUDA 12.8 के लिए (RTX 30xx, 40xx, 50xx)
docker pull infiniflow/ragflow:latest

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

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

cd /workspace/ragflow/docker

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

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

इसके लिए प्रतीक्षा करें:

ragflow-server | INFO: एप्लिकेशन स्टार्टअप पूर्ण।

चरण 7: व्यवस्थापक खाता बनाएँ

खोलें http://<server-ip>:80 और पहला व्यवस्थापक खाता पंजीकृत करें।

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

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

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

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

में लॉग इन करें http://<server-ip>:80
क्लिक करें "ज्ञान आधार" → "ज्ञान आधार बनाएँ"
इसे नाम दें: "Clore.ai दस्तावेज़ीकरण"
ड्रैग-एंड-ड्रॉप का उपयोग करके PDF/Word/TXT फ़ाइलें अपलोड करें
पार्सिंग पूरी होने की प्रतीक्षा करें (प्रगति UI में दिखाई जाती है)
पर जाएँ "चैट" → अपने ज्ञान आधार से जुड़ा एक नया सहायक बनाएँ
अपने दस्तावेज़ों के बारे में प्रश्न पूछें

उदाहरण 2: API — ज्ञान आधार बनाएँ और दस्तावेज़ अपलोड करें

import requests
import json
from pathlib import Path

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

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

# चरण 1: ज्ञान आधार बनाएँ
kb_payload = {
    "name": "Clore.ai तकनीकी दस्तावेज़",
    "description": "GPU क्लाउड मार्केटप्लेस के दस्तावेज़ और मार्गदर्शिकाएँ",
    "language": "अंग्रेज़ी",
    "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 के माध्यम से दस्तावेज़ क्वेरी करें

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📌 प्रश्न: {question}")
    answer, refs = ask_ragflow(question, CHAT_ID)
    print(f"💬 उत्तर: {answer}")
    if refs:
        print(f"📚 स्रोत ({len(refs)} खंड):")
        for ref in refs[:2]:
            print(f"   - {ref.get('docnm_kwd', 'अज्ञात')}: {ref.get('content_ltks', '')[:100]}...")

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

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"✓ अपलोड किया गया: {path.name} → {doc_id}")
            else:
                print(f"✗ विफल: {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"\n{len(doc_ids)} दस्तावेज़ों की पार्सिंग हो रही है...")

        # पूर्ण होने तक पोल करें
        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"  प्रसंस्करण: {len(pending)} | पूर्ण: {len(done)}/{len(doc_ids)}")

            if len(pending) == 0:
                break

    ✓ सभी दस्तावेज़ पार्स हो गए!
    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: स्थानीय Ollama LLM के साथ RAGFlow

# 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 में: सेटिंग्स → मॉडल प्रदाता → Ollama जोड़ें
# बेस URL: http://host.docker.internal:11434
# या यदि Ollama Docker में चल रहा है: http://ollama:11434

# 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}")

# WebUI में कॉन्फ़िगर किए गए स्थानीय LLM का उपयोग करके 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": "RAGFlow की संरचना समझाइए", "stream": False}
)
print(response.json()["data"]["answer"])",

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

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

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

खंडन रणनीतियाँ

विधि

किसके लिए सर्वोत्तम

विवरण

साधारण

सामान्य दस्तावेज़

ओवरलैप के साथ निश्चित-आकार के खंड

प्रश्न-उत्तर

FAQ/Q&A दस्तावेज़

प्रश्न-उत्तर युग्मों पर विभाजित करता है

तालिका

स्प्रेडशीट, तालिकाएँ

तालिका संरचना को बनाए रखता है

शोधपत्र

शैक्षणिक शोधपत्र

अनुभाग, सार, संदर्भ

पुस्तक

लंबी किताबें, मैनुअल

अध्याय-सचेत खंडन

कानून

कानूनी दस्तावेज़

अनुच्छेद-आधारित खंडन

मैनुअल

तकनीकी मैनुअल

अनुभाग पदानुक्रम संरक्षण

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

1. Elasticsearch मेमोरी बढ़ाएँ

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

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

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

सेटिंग्स → मॉडल प्रदाता में, Ollama के माध्यम से एक स्थानीय GPU मॉडल का उपयोग करें
या Clore.ai GPU पर चल रही एक समर्पित एम्बेडिंग सेवा की ओर इंगित करें

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

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

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

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

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

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

समस्या: सेवाएँ प्रारंभ होने में विफल (मेमोरी)

# memory usage जांचें
free -h
docker stats

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

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

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

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

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

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

# टास्क वर्कर लॉग जाँचें
docker compose logs ragflow-worker

# वर्कर पुनः प्रारंभ करें
docker compose restart ragflow-worker

समस्या: Elasticsearch heap में मेमोरी समाप्त

# .env में heap बढ़ाएँ
ES_JAVA_OPTS=-Xms2g -Xmx2g
docker compose restart es01

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

# 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
आधिकारिक दस्तावेज़: https://ragflow.io/docs
डॉकर हब: https://hub.docker.com/r/infiniflow/ragflow
API संदर्भ: https://ragflow.io/docs/dev/http_api_reference
Discord: https://discord.gg/4XxujFgUN7
CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण

अनुशंसित GPU

Clore.ai पर अनुमानित लागत

विकास/परीक्षण

RTX 3090 (24GB)

$0.07–0.21/gpu/hr

प्रोडक्शन RAG

RTX 3090 (24GB)

$0.07–0.21/gpu/hr

उच्च-थ्रूपुट एम्बेडिंग

RTX 4090 (24GB)

$0.14–0.42/gpu/hr

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.

पिछलाअवलोकन

अगलाLlamaIndex

अंतिम अपडेट 1 माह पहले

क्या यह उपयोगी था?