> 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/comparisons/rag-frameworks-comparison.md).

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

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

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

***

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

|                          | 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 पाइपलाइन के लिए एक एकीकृत इंटरफ़ेस प्रदान करता है।

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

```python
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 को विविध डेटा स्रोतों से जोड़ने में उत्कृष्ट है।

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

```python
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 पाइपलाइनों पर केंद्रित है। इसमें दृश्य पाइपलाइन बिल्डर के साथ घटक-आधारित आर्किटेक्चर है।

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

```python
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 सिस्टम, किसी कोडिंग की आवश्यकता नहीं।

```yaml
# 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)

{% hint style="info" %}
बेंचमार्क डेटासेट और कॉन्फ़िगरेशन के अनुसार काफी भिन्न होते हैं। ये समुदाय बेंचमार्क से प्राप्त अनुमानित आंकड़े हैं।
{% endhint %}

| फ्रेमवर्क          | 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

```python
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)

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

```python
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 आवश्यकताओं वाले उत्पादन डिप्लॉयमेंट

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

```python
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 पर परिनियोजन

```yaml
# 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:
```

```bash
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 |

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

***

## उपयोगी लिंक

* [LangChain दस्तावेज़](https://python.langchain.com)
* [LlamaIndex दस्तावेज़](https://docs.llamaindex.ai)
* [Haystack दस्तावेज़](https://docs.haystack.deepset.ai)
* [RAGFlow GitHub](https://github.com/infiniflow/ragflow)
* [RAG सर्वे पेपर (arxiv)](https://arxiv.org/abs/2312.10997)

***

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

```
सरल दस्तावेज़ 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](https://clore.ai/bare-metal) |

> 💡 इस गाइड के सभी उदाहरण [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/comparisons/rag-frameworks-comparison.md?ask=<question>&goal=<endgoal>
```

`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.