RAG फ़्रेमवर्क तुलना

अपने Clore.ai GPU सर्वरों पर अपने प्रोजेक्ट के लिए सही Retrieval-Augmented Generation (RAG) फ्रेमवर्क चुनें।

RAG (Retrieval-Augmented Generation) यह LLMs को आपके अपने दस्तावेज़ों का उपयोग करके प्रश्नों के उत्तर देने देता है। यह गाइड चार प्रमुख फ्रेमवर्क की तुलना करती है: LangChain, LlamaIndex, Haystack, और RAGFlow — फीचर्स, प्रदर्शन, और प्रत्येक का उपयोग कब करना है, इन सबको कवर करते हुए।

---

त्वरित निर्णय मैट्रिक्स

	LangChain	LlamaIndex	Haystack	RAGFlow
इसके लिए सर्वश्रेष्ठ	सामान्य LLM ऐप्स	दस्तावेज़ Q&A	एंटरप्राइज़ खोज	स्व-होस्टेड RAG
सीखने की कठिनाई	मध्यम	निम्न-मध्यम	मध्यम-उच्च	कम
लचीलापन	बहुत उच्च	उच्च	उच्च	मध्यम
अंतर्निर्मित UI	नहीं	नहीं	नहीं	हाँ
GitHub स्टार्स	90K+	35K+	15K+	12K+
भाषा	Python	Python	Python	Python
लाइसेंस	MIT	MIT	Apache 2.0	Apache 2.0

---

अवलोकन

LangChain

LangChain सबसे लोकप्रिय LLM ऑर्केस्ट्रेशन फ्रेमवर्क है। यह चेन, एजेंट्स, मेमोरी, और RAG पाइपलाइन के लिए एक एकीकृत इंटरफ़ेस प्रदान करता है।

दर्शन: सब कुछ संयोजनीय घटकों की एक चेन है।

from langchain.chains import RetrievalQA
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI

# 5 पंक्तियों में RAG पाइपलाइन बनाएं
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(docs, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
chain = RetrievalQA.from_chain_type(llm=OpenAI(), retriever=retriever)
result = chain.run("फ्रांस की राजधानी क्या है?")

LlamaIndex

LlamaIndex (पहले GPT Index) दस्तावेज़ इंडेक्सिंग और पुनर्प्राप्ति के लिए विशेष रूप से बनाया गया है। यह LLMs को विविध डेटा स्रोतों से जोड़ने में उत्कृष्ट है।

दर्शन: पहले इंडेक्स करें, फिर समझदारी से क्वेरी करें।

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# दस्तावेज़ों को लोड और इंडेक्स करें
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# क्वेरी करें
query_engine = index.as_query_engine()
response = query_engine.query("मुख्य निष्कर्षों का सारांश दें")
print(response)

Haystack

Haystack (deepset द्वारा) एक एंटरप्राइज़-ग्रेड NLP फ्रेमवर्क है, जो खोज और Q&A पाइपलाइनों पर केंद्रित है। इसमें दृश्य पाइपलाइन बिल्डर के साथ घटक-आधारित आर्किटेक्चर है।

दर्शन: मॉड्यूलर पाइपलाइनें, एंटरप्राइज़-स्तरीय विश्वसनीयता के साथ।

from haystack.nodes import DensePassageRetriever, FARMReader
from haystack.pipelines import ExtractiveQAPipeline

retriever = DensePassageRetriever(document_store=document_store)
reader = FARMReader(model_name_or_path="deepset/roberta-base-squad2")
pipeline = ExtractiveQAPipeline(reader, retriever)
result = pipeline.run(query="मशीन लर्निंग क्या है?", params={"Retriever": {"top_k": 10}})

RAGFlow

RAGFlow एक ओपन-सोर्स RAG इंजन है, जिसमें अंतर्निर्मित वेब UI, दस्तावेज़ पार्सिंग, और ज्ञान आधार प्रबंधन शामिल है। इसे एक संपूर्ण समाधान के रूप में डिप्लॉय करने के लिए डिज़ाइन किया गया है।

दर्शन: तैयार-उपयोग RAG सिस्टम, किसी कोडिंग की आवश्यकता नहीं।

# RAGFlow को Docker Compose के जरिए डिप्लॉय किया जाता है
# localhost:80 पर वेब UI के माध्यम से कॉन्फ़िगरेशन
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:latest
    ports:
      - "80:80"
    volumes:
      - ./ragflow-data:/ragflow/data

---

फ़ीचर तुलना

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

विशेषता	LangChain	LlamaIndex	Haystack	RAGFlow
वेक्टर स्टोर समर्थन	50+	30+	20+	अंतर्निर्मित
दस्तावेज़ लोडर	100+	50+	30+	अंतर्निर्मित
हाइब्रिड खोज	✅	✅	✅	✅
पुनः-रैंकिंग	✅	✅	✅	✅
बहु-मोडल	✅	✅	आंशिक	✅
स्ट्रीमिंग	✅	✅	✅	✅
असिंक्रोनस समर्थन	✅	✅	✅	✅
एजेंट्स	✅	✅	✅	❌

इंटीग्रेशन इकोसिस्टम

इंटीग्रेशन प्रकार	LangChain	LlamaIndex	Haystack	RAGFlow
LLM प्रदाता	50+	30+	20+	10+
वेक्टर DB	Chroma, Pinecone, Weaviate, Qdrant, और 40+ अन्य	Chroma, Pinecone, Weaviate, और 25+ अन्य	Weaviate, Elasticsearch, और 15+ अन्य	अंतर्निर्मित InfiniFlow
दस्तावेज़ प्रकार	PDF, वेब, CSV, JSON, 80+	PDF, वेब, CSV, DB, 40+	PDF, TXT, HTML, 20+	PDF, Word, Excel, PPT, वेब
क्लाउड स्टोरेज	S3, GCS, Azure	S3, GCS, Azure	S3, GCS	S3

उन्नत RAG विशेषताएँ

विशेषता	LangChain	LlamaIndex	Haystack	RAGFlow
क्वेरी विघटन	✅	✅	✅	✅
HyDE (काल्पनिक दस्तावेज़ एम्बेडिंग्स)	✅	✅	❌	❌
मल्टी-हॉप पुनर्प्राप्ति	✅	✅	आंशिक	✅
संदर्भगत संपीड़न	✅	✅	✅	✅
Self-RAG	✅	✅	❌	❌
GraphRAG	✅	✅ (PropertyGraph)	❌	✅
संदर्भ ट्रैकिंग	आंशिक	✅	आंशिक	✅

---

प्रदर्शन बेंचमार्क

पुनर्प्राप्ति सटीकता (RAG-Bench, 2024)

बेंचमार्क डेटासेट और कॉन्फ़िगरेशन के अनुसार काफी भिन्न होते हैं। ये समुदाय बेंचमार्क से प्राप्त अनुमानित आंकड़े हैं।

फ्रेमवर्क	HotpotQA (F1)	Natural Questions (EM)	TriviaQA (Acc)
LangChain (RAG)	~68%	~42%	~72%
LlamaIndex (RAG)	~71%	~45%	~74%
Haystack (RAG)	~69%	~43%	~71%
RAGFlow (डिफ़ॉल्ट)	~65%	~40%	~68%

परिणाम चुने गए LLM, एम्बेडिंग मॉडल, और चंक आकार पर बहुत निर्भर करते हैं

इंडेक्सिंग गति (10K दस्तावेज़, प्रत्येक लगभग 1KB)

फ्रेमवर्क	केवल CPU	GPU एम्बेडिंग्स
LangChain	~120 सेकंड	~18 सेकंड
LlamaIndex	~110 सेकंड	~15 सेकंड
Haystack	~130 सेकंड	~20 सेकंड
RAGFlow	~150 सेकंड	~25 सेकंड

text-embedding-ada-002 के समकक्ष (1536 आयामों) के साथ

क्वेरी विलंबता (P50/P99, पूर्व-निर्मित इंडेक्स के साथ)

फ्रेमवर्क	P50	P99	नोट्स
LangChain	450ms	1.2s	पुनः-रैंकिंग नहीं
LlamaIndex	400ms	1.0s	पुनः-रैंकिंग नहीं
Haystack	500ms	1.5s	पाइपलाइन ओवरहेड के साथ
RAGFlow	600ms	2.0से.	UI/API ओवरहेड शामिल है

---

LangChain: गहन विश्लेषण

ताकतें

✅ सबसे बड़ा इकोसिस्टम — 50+ इंटीग्रेशन, विशाल समुदाय ✅ एजेंट्स और टूल्स — स्वायत्त AI एजेंट्स बनाएं ✅ LangSmith — उत्कृष्ट ऑब्ज़र्वेबिलिटी और डीबगिंग ✅ LCEL — चेन संयोजित करने के लिए LangChain Expression Language ✅ मेमोरी सिस्टम — बातचीत का इतिहास, इकाई मेमोरी

कमज़ोरियाँ

❌ जटिलता — सरल कार्यों के लिए जरूरत से ज़्यादा जटिल हो सकता है ❌ बार-बार तोड़ने वाले बदलाव — v0.1 से v0.2 से v0.3 माइग्रेशन ❌ भारी निर्भरता — बड़ा इंस्टॉल आकार ❌ एब्स्ट्रैक्शन लीकेज — कभी-कभी डीबग करना कठिन होता है

सर्वोत्तम उपयोग परिदृश्य

• जटिल लॉजिक वाली बहु-चरणीय LLM पाइपलाइनें

• वे टूल्स उपयोग करने वाले AI एजेंट्स (वेब खोज, कोड निष्पादन, APIs)

• संवाद मेमोरी की आवश्यकता वाली एप्लिकेशन

• अधिकतम लचीलेपन की आवश्यकता वाले प्रोजेक्ट

उदाहरण: स्रोतों के साथ उन्नत RAG

from langchain.chains import RetrievalQAWithSourcesChain
from langchain_community.vectorstores import Chroma
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter

# सेटअप
llm = ChatOpenAI(model="gpt-4", temperature=0)
embeddings = OpenAIEmbeddings()

# मेटाडेटा के साथ दस्तावेज़ों को इंडेक्स करें
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

vectorstore = Chroma.from_documents(
    chunks, 
    embeddings,
    persist_directory="./chroma_db"
)

# स्रोत-आरोपण के साथ चेन बनाएं
chain = RetrievalQAWithSourcesChain.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    return_source_documents=True
)

result = chain({"question": "मुख्य जोखिम क्या हैं?"})
print(result["answer"])
print("स्रोत:", result["sources"])

---

LlamaIndex: गहन विश्लेषण

ताकतें

✅ दस्तावेज़-प्रथम डिज़ाइन — जटिल दस्तावेज़ इंडेक्सिंग के लिए सर्वोत्तम ✅ इंडेक्स प्रकार — वेक्टर, ज्ञान ग्राफ, SQL, कीवर्ड ✅ उप-प्रश्न इंजन — जटिल क्वेरियों को स्वतः विघटित करता है ✅ संरचित आउटपुट — Pydantic इंटीग्रेशन ✅ राउटर क्वेरी इंजन — समझदारी से सही इंडेक्स पर मार्गित करता है

कमज़ोरियाँ

❌ एजेंट-केंद्रित कम LangChain की तुलना में ❌ छोटा इकोसिस्टम LangChain की तुलना में ❌ दस्तावेज़ीकरण असंगत हो सकता है

सर्वोत्तम उपयोग परिदृश्य

• दस्तावेज़ Q&A सिस्टम (PDF, रिपोर्ट, विकी)

• जटिल बहु-दस्तावेज़ तर्क

• ज्ञान ग्राफ निर्माण

• डेटा-से-LLM पुल (डेटाबेस, APIs)

उदाहरण: बहु-दस्तावेज़ क्वेरी इंजन

from llama_index.core import (
    VectorStoreIndex, 
    SimpleDirectoryReader,
    StorageContext,
    Settings
)
from llama_index.core.query_engine import RouterQueryEngine
from llama_index.core.tools import QueryEngineTool
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# वैश्विक रूप से कॉन्फ़िगर करें
Settings.llm = OpenAI(model="gpt-4")
Settings.embed_model = OpenAIEmbedding()

# अलग-अलग दस्तावेज़ सेट के लिए अलग इंडेक्स बनाएं
annual_reports = SimpleDirectoryReader("./annual_reports").load_data()
tech_docs = SimpleDirectoryReader("./tech_docs").load_data()

index_reports = VectorStoreIndex.from_documents(annual_reports)
index_tech = VectorStoreIndex.from_documents(tech_docs)

# सही इंडेक्स चुनने वाला राउटर बनाएं
tools = [
    QueryEngineTool.from_defaults(
        query_engine=index_reports.as_query_engine(),
        description="वार्षिक वित्तीय रिपोर्ट और व्यवसायिक मेट्रिक्स"
    ),
    QueryEngineTool.from_defaults(
        query_engine=index_tech.as_query_engine(),
        description="तकनीकी दस्तावेज़ और API संदर्भ"
    )
]

router = RouterQueryEngine.from_defaults(query_engine_tools=tools)
response = router.query("पिछले वर्ष की राजस्व वृद्धि क्या थी?")

---

Haystack: गहन विश्लेषण

ताकतें

✅ एंटरप्राइज़-ग्रेड — उत्पादन-स्तरीय विश्वसनीयता ✅ दृश्य पाइपलाइन बिल्डर — Haystack Studio ✅ एनोटेशन टूल — अंतर्निर्मित लेबलिंग UI ✅ मजबूत NLP — एक्स्ट्रैक्टिव QA, सार-संक्षेपण ✅ deepset Cloud — प्रबंधित डिप्लॉयमेंट विकल्प

कमज़ोरियाँ

❌ सीखने की अधिक कठिन प्रक्रिया प्रतिस्पर्धियों की तुलना में ❌ छोटा समुदाय LangChain/LlamaIndex की तुलना में ❌ कम लचीला नई आर्किटेक्चर के लिए

सर्वोत्तम उपयोग परिदृश्य

• एंटरप्राइज़ दस्तावेज़ खोज और Q&A

• ऑडिट ट्रेल और ऑब्ज़र्वेबिलिटी की आवश्यकता वाले प्रोजेक्ट

• दृश्य पाइपलाइन डिज़ाइन चाहने वाली टीमें

• SLA आवश्यकताओं वाले उत्पादन डिप्लॉयमेंट

उदाहरण: हाइब्रिड खोज पाइपलाइन

from haystack import Pipeline
from haystack.components.retrievers import InMemoryBM25Retriever, InMemoryEmbeddingRetriever
from haystack.components.joiners import DocumentJoiner
from haystack.components.rankers import MetaFieldRanker
from haystack.components.generators import OpenAIGenerator
from haystack.components.builders import RAGPromptBuilder

# हाइब्रिड खोज पाइपलाइन बनाएं
pipeline = Pipeline()
pipeline.add_component("bm25_retriever", InMemoryBM25Retriever(document_store=store, top_k=10))
pipeline.add_component("embedding_retriever", InMemoryEmbeddingRetriever(document_store=store, top_k=10))
pipeline.add_component("joiner", DocumentJoiner(join_mode="reciprocal_rank_fusion"))
pipeline.add_component("ranker", MetaFieldRanker(meta_field="score"))
pipeline.add_component("prompt_builder", RAGPromptBuilder())
pipeline.add_component("llm", OpenAIGenerator(model="gpt-4"))

# components को जोड़ें
pipeline.connect("bm25_retriever", "joiner.documents")
pipeline.connect("embedding_retriever", "joiner.documents")
pipeline.connect("joiner", "ranker")
pipeline.connect("ranker", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

result = pipeline.run({"bm25_retriever": {"query": "डीप लर्निंग"}, 
                       "embedding_retriever": {"query": "डीप लर्निंग"}})

---

RAGFlow: गहन विश्लेषण

ताकतें

✅ जीरो-कोड डिप्लॉयमेंट — पूरी UI शामिल है ✅ उन्नत दस्तावेज़ पार्सिंग — तालिकाएँ, चित्र, चार्ट ✅ ज्ञान आधार प्रबंधन — दृश्य इंटरफ़ेस ✅ API शामिल है — तैयार-उपयोग REST API ✅ एजेंटिक RAG — अंतर्निर्मित एजेंट्स

कमज़ोरियाँ

❌ कम अनुकूलन योग्य कोड-प्रथम फ्रेमवर्क्स की तुलना में ❌ उच्च संसाधन आवश्यकता (Elasticsearch + Infinity DB) ❌ सीमित LLM समर्थन LangChain की तुलना में ❌ नया प्रोजेक्ट — छोटा समुदाय

सर्वोत्तम उपयोग परिदृश्य

• बिना कोडिंग के RAG चाहने वाले गैर-विकासकर्ता

• पूर्ण ज्ञान आधार उत्पाद चाहने वाली टीमें

• आंतरिक एंटरप्राइज़ विकी और दस्तावेज़ खोज

• RAG एप्लिकेशन का त्वरित प्रोटोटाइप निर्माण

Clore.ai पर परिनियोजन

# RAGFlow के लिए docker-compose.yml
version: "3"
services:
  ragflow:
    image: infiniflow/ragflow:v0.12.0
    container_name: ragflow
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./ragflow-logs:/ragflow/logs
      - ./ragflow-data:/ragflow/data
    depends_on:
      - elasticsearch
      - infinity

  elasticsearch:
    image: elasticsearch:8.11.3
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.enabled=false
    volumes:
      - es_data:/usr/share/elasticsearch/data

  infinity:
    image: infiniflow/infinity:v0.3.0
    volumes:
      - infinity_data:/var/infinity

volumes:
  es_data:
  infinity_data:

docker compose up -d
# http://<server-ip>:80 पर वेब UI एक्सेस करें

---

किसका उपयोग कब करें

यदि LangChain चुनें:

• टूल्स के साथ AI एजेंट्स बनाना (वेब खोज, कोड निष्पादन, APIs)

• अधिकतम इकोसिस्टम लचीलापन चाहिए

• जटिल बहु-चरणीय पाइपलाइनें बनाना

• कई अलग-अलग LLMs और डेटा स्रोतों के साथ एकीकरण

• टीम Python के साथ सहज है

यदि LlamaIndex चुनें:

• प्राथमिक उपयोग मामला दस्तावेज़ Q&A है

• जटिल दस्तावेज़ संरचनाओं (तालिकाएँ, नेस्टेड सामग्री) के साथ काम करना

• ज्ञान ग्राफ या मल्टी-इंडेक्स रूटिंग की आवश्यकता हो

• सर्वोत्तम-श्रेणी की दस्तावेज़ इनजेशन चाहिए

• संरचित डेटा (डेटाबेस, API) के ऊपर निर्माण

Haystack चुनें यदि:

• अनुपालन आवश्यकताओं वाला एंटरप्राइज़ वातावरण

• दृश्य पाइपलाइन निर्माण टूल्स की आवश्यकता है

• Elasticsearch के ऊपर निर्माण

• एक्सट्रैक्टिव (सिर्फ जनरेटिव नहीं) QA चाहते हैं

• टीम को NLP पाइपलाइन ऑब्ज़र्वेबिलिटी चाहिए

RAGFlow चुनें यदि:

• गैर-तकनीकी टीम को सेल्फ-सर्विस RAG की आवश्यकता है

• एक पूर्ण उत्पाद चाहिए, फ्रेमवर्क नहीं

• कस्टमाइज़ेशन से अधिक प्राथमिकता तेज़ डिप्लॉयमेंट को है

• आंतरिक नॉलेज बेस बना रहे हैं

• Python कोड नहीं लिखना चाहते

---

Clore.ai पर चलाने के लिए: संसाधन आवश्यकताएँ

फ्रेमवर्क	न्यूनतम RAM	न्यूनतम VRAM	अनुशंसित GPU
LangChain	8GB	8GB (स्थानीय LLM)	RTX 3080
LlamaIndex	8GB	8GB (स्थानीय LLM)	RTX 3080
Haystack	16GB	8GB (स्थानीय LLM)	RTX 3090
RAGFlow	32GB (RAM!)	16GB	A6000 / A100

RAGFlow को अधिक RAM की आवश्यकता है: यह Elasticsearch + InfinityDB + स्वयं ऐप चलाता है। कम से कम 32GB सिस्टम RAM की योजना बनाएं। Elasticsearch के साथ Haystack को भी 16GB+ RAM का लाभ मिलता है।

---

उपयोगी लिंक

• LangChain दस्तावेज़

• LlamaIndex दस्तावेज़

• Haystack दस्तावेज़

• RAGFlow GitHub

• RAG सर्वे पेपर (arxiv)

---

सारांश अनुशंसा

सरल दस्तावेज़ Q&A          → LlamaIndex
जटिल AI एजेंट            → LangChain
एंटरप्राइज़ खोज            → Haystack
नो-कोड RAG उत्पाद          → RAGFlow
अधिकतम लचीलापन          → LangChain
सर्वोत्तम दस्तावेज़ समझ  → LlamaIndex

चारों फ्रेमवर्क उत्कृष्ट विकल्प हैं — सही विकल्प आपकी विशिष्ट आवश्यकताओं, टीम कौशल और परिनियोजन बाधाओं पर निर्भर करता है। यदि संदेह हो, तो शुरू करें LlamaIndex दस्तावेज़-प्रधान उपयोग मामलों के लिए या LangChain यदि आपको सबसे व्यापक संभव इकोसिस्टम की आवश्यकता है।

---

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

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
बड़े पैमाने पर	A100 80GB	bare metal

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