> 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/rag/ragflow.md). # 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 को किसी भी एप्लिकेशन में एकीकृत करें * 📊 **संदर्भ ट्रैकिंग** — उत्तरों में स्रोत दस्तावेज़ संदर्भ शामिल होते हैं * 🏗️ **मल्टी-टेनेंट** — अनुमति नियंत्रण के साथ टीम कार्यक्षेत्र {% 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. WebUI तक पहुँचें ``` http://:80 ``` डिफ़ॉल्ट क्रेडेंशियल: `admin@ragflow.io` / `admin` *** ## चरण-दर-चरण सेटअप ### चरण 1: अपने सर्वर में SSH करें ```bash ssh root@ -p ``` ### चरण 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.8 के लिए (RTX 30xx, 40xx, 50xx) 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: एप्लिकेशन स्टार्टअप पूर्ण। ``` ### चरण 7: व्यवस्थापक खाता बनाएँ खोलें `http://:80` और पहला व्यवस्थापक खाता पंजीकृत करें। ### चरण 8: LLM मॉडल कॉन्फ़िगर करें 1. पर जाएँ **सेटिंग्स → मॉडल प्रदाता** 2. अपना LLM (OpenAI, Ollama, आदि) जोड़ें 3. डिफ़ॉल्ट चैट मॉडल और एम्बेडिंग मॉडल सेट करें *** ## उपयोग के उदाहरण ### उदाहरण 1: WebUI के माध्यम से दस्तावेज़ अपलोड और क्वेरी करें 1. में लॉग इन करें `http://:80` 2. क्लिक करें **"ज्ञान आधार"** → **"ज्ञान आधार बनाएँ"** 3. इसे नाम दें: `"Clore.ai दस्तावेज़ीकरण"` 4. ड्रैग-एंड-ड्रॉप का उपयोग करके PDF/Word/TXT फ़ाइलें अपलोड करें 5. पार्सिंग पूरी होने की प्रतीक्षा करें (प्रगति UI में दिखाई जाती है) 6. पर जाएँ **"चैट"** → अपने ज्ञान आधार से जुड़ा एक नया सहायक बनाएँ 7. अपने दस्तावेज़ों के बारे में प्रश्न पूछें *** ### उदाहरण 2: API — ज्ञान आधार बनाएँ और दस्तावेज़ अपलोड करें ```python import requests import json from pathlib import Path BASE_URL = "http://: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 के माध्यम से दस्तावेज़ क्वेरी करें ```python import requests import json BASE_URL = "http://: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: बैच दस्तावेज़ प्रसंस्करण पाइपलाइन ```python import requests import time from pathlib import Path BASE_URL = "http://: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 ```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 में: सेटिंग्स → मॉडल प्रदाता → 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}") # 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 की प्रमुख सेवाएँ ```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 ``` ### खंडन रणनीतियाँ | विधि | किसके लिए सर्वोत्तम | विवरण | | -------------- | -------------------- | --------------------------------------- | | `साधारण` | सामान्य दस्तावेज़ | ओवरलैप के साथ निश्चित-आकार के खंड | | `प्रश्न-उत्तर` | FAQ/Q\&A दस्तावेज़ | प्रश्न-उत्तर युग्मों पर विभाजित करता है | | `तालिका` | स्प्रेडशीट, तालिकाएँ | तालिका संरचना को बनाए रखता है | | `शोधपत्र` | शैक्षणिक शोधपत्र | अनुभाग, सार, संदर्भ | | `पुस्तक` | लंबी किताबें, मैनुअल | अध्याय-सचेत खंडन | | `कानून` | कानूनी दस्तावेज़ | अनुच्छेद-आधारित खंडन | | `मैनुअल` | तकनीकी मैनुअल | अनुभाग पदानुक्रम संरक्षण | *** ## प्रदर्शन सुझाव ### 1. Elasticsearch मेमोरी बढ़ाएँ ```yaml # docker-compose.yml में es01: environment: - ES_JAVA_OPTS=-Xms4g -Xmx4g # बड़े दस्तावेज़ सेटों के लिए बढ़ाएँ ``` ### 2. GPU-त्वरित एम्बेडिंग RAGFlow को GPU-आधारित एम्बेडिंग मॉडल का उपयोग करने के लिए कॉन्फ़िगर करें: * सेटिंग्स → मॉडल प्रदाता में, Ollama के माध्यम से एक स्थानीय GPU मॉडल का उपयोग करें * या Clore.ai GPU पर चल रही एक समर्पित एम्बेडिंग सेवा की ओर इंगित करें ### 3. समानांतर दस्तावेज़ प्रसंस्करण RAGFlow डिफ़ॉल्ट रूप से दस्तावेज़ों को समानांतर में संसाधित करता है। वर्कर संख्या कॉन्फ़िगर करें: ```env # docker/.env में TASK_WORKER_COUNT=4 # CPU कोर के आधार पर समायोजित करें ``` ### 4. बड़े दस्तावेज़ सेटों के लिए MinIO हज़ारों दस्तावेज़ों वाले परिनियोजन के लिए, अपने CLORE.AI ऑर्डर में बड़े डिस्क आवंटन के साथ समर्पित MinIO स्टोरेज कॉन्फ़िगर करें। *** ## समस्या निवारण ### समस्या: सेवाएँ प्रारंभ होने में विफल (मेमोरी) ```bash # memory usage जांचें 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 # टास्क वर्कर लॉग जाँचें docker compose logs ragflow-worker # वर्कर पुनः प्रारंभ करें docker compose restart ragflow-worker ``` ### समस्या: Elasticsearch heap में मेमोरी समाप्त ```bash # .env में heap बढ़ाएँ 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**: * **आधिकारिक दस्तावेज़**: * **डॉकर हब**: * **API संदर्भ**: * **Discord**: * **CLORE.AI मार्केटप्लेस**: *** ## 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](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access. --- # 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/rag/ragflow.md?ask=&goal= ``` `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.