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

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

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

---

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

	LangChain	— 6 गाइड्स:	Haystack	LlamaIndex
उत्तम हेतु	सामान्य 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 ऑर्केस्ट्रेशन फ़्रेमवर्क है। यह chains, agents, memory, और RAG पाइपलाइनों के लिए एक एकीकृत इंटरफ़ेस प्रदान करता है।

दर्शन: सब कुछ घटनीय (composable) घटकों की एक श्रृंखला है।

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("What is the capital of France?")

— 6 गाइड्स:

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

दर्शन: पहले इंडेक्स, फिर बुद्धिमानी से प्रश्न पूछें।

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

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

# Query
query_engine = index.as_query_engine()
response = query_engine.query("Summarize the main findings")
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="What is machine learning?", params={"Retriever": {"top_k": 10}})

LlamaIndex

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

दर्शन: बॉक्स से बाहर रैग सिस्टम, किसी कोडिंग की आवश्यकता नहीं।

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

---

फ़ीचर तुलना

मुख्य RAG सुविधाएँ

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

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

इंटीग्रेशन प्रकार	LangChain	— 6 गाइड्स:	Haystack	LlamaIndex
LLM प्रदाता	50+	30+	20+	10+
वेक्टर DBs	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	— 6 गाइड्स:	Haystack	LlamaIndex
क्वेरी विखंडन (decomposition)	✅	✅	✅	✅
HyDE (Hypothetical Document Embeddings)	✅	✅	❌	❌
मल्टी-हॉप पुनर्प्राप्ति	✅	✅	आंशिक	✅
संदर्भगत संपीड़न (contextual compression)	✅	✅	✅	✅
Self-RAG	✅	✅	❌	❌
GraphRAG	✅	✅ (PropertyGraph)	❌	✅
उद्धरण ट्रैकिंग	आंशिक	✅	आंशिक	✅

---

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

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

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

फ़्रेमवर्क	HotpotQA (F1)	Natural Questions (EM)	TriviaQA (सटीकता)
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 सेकंड
— 6 गाइड्स:	~110 सेकंड	~15 सेकंड
Haystack	~130 सेकंड	~20 सेकंड
LlamaIndex	~150 सेकंड	~25 सेकंड

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

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

फ़्रेमवर्क	P50	P99	नोट्स
LangChain	450ms	1.2s	कोई री-रैंकिंग नहीं
— 6 गाइड्स:	400ms	1.0s	कोई री-रैंकिंग नहीं
Haystack	500ms	1.5s	पाइपलाइन ओवरहेड के साथ
LlamaIndex	600ms	2.0s	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": "What are the main risks?"})
print(result["answer"])
print("Sources:", result["sources"])

---

LlamaIndex: गहराई से अवलोकन

मजबूतियाँ

✅ दस्तावेज़-प्रथम डिज़ाइन — जटिल दस्तावेज़ इंडेक्सिंग के लिए सर्वोत्तम ✅ इंडेक्स प्रकार — वेक्टर, नॉलेज ग्राफ, SQL, कीवर्ड ✅ सब-प्रश्न इंजन — जटिल प्रश्नों को स्वचालित रूप से विखंडित करता है ✅ संरचित आउटपुट — Pydantic इंटीग्रेशन ✅ राउटर क्वेरी इंजन — सही इंडेक्स की बुद्धिमानी से मार्गदर्शित करता है

कमज़ोरियाँ

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

सर्वोत्तम उपयोग के मामले

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

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

• नॉलेज ग्राफ निर्माण

• डेटा-से-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("What was the revenue growth last year?")

---

Haystack: गहराई से अवलोकन

मजबूतियाँ

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

कमज़ोरियाँ

❌ सीखने की वक्रता अधिक तीखी प्रतिद्वंद्वियों की तुलना में ❌ छोटा समुदाय 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"))

# घटकों को कनेक्ट करें
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": "deep learning"}, 
                       "embedding_retriever": {"query": "deep learning"}})

---

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
# वेब UI तक पहुँचें http://<server-ip>:80 पर

---

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

यदि LangChain चुनें जब:

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

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

• जटिल मल्टी-स्टेप पाइपलाइन्स बना रहे हों

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

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

यदि LlamaIndex चुनें जब:

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

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

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

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

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

यदि Haystack चुनें जब:

• एंटरप्राइज़ वातावरण जिसमें अनुपालन आवश्यकताएँ हों

• विज़ुअल पाइपलाइन बिल्डिंग टूल्स चाहिए

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

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

• टीम को NLP पाइपलाइन अवलोकनीयता चाहिए

यदि RAGFlow चुनें जब:

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

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

• कस्टमाइज़ेशन पर तेजी से तैनाती प्राथमिकता है

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

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

---

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

फ़्रेमवर्क	न्यूनतम RAM	न्यूनतम VRAM	सिफारिश की गई GPU
LangChain	8GB	8GB (स्थानीय LLM)	RTX 3080
— 6 गाइड्स:	8GB	8GB (स्थानीय LLM)	RTX 3080
Haystack	16GB	8GB (स्थानीय LLM)	RTX 3090
LlamaIndex	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

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

---

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

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
प्रोडक्शन	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े पैमाने पर	A100 80GB	~$1.20/gpu/hr

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