# RAG Frameworks की तुलना

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

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

***

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

|                     | 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) घटकों की एक श्रृंखला है।

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

### — 6 गाइड्स:

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

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

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

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

```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="What is machine learning?", params={"Retriever": {"top_k": 10}})
```

### LlamaIndex

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

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

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

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

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

```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": "What are the main risks?"})
print(result["answer"])
print("Sources:", result["sources"])
```

***

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

### मजबूतियाँ

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

### कमज़ोरियाँ

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

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

* दस्तावेज़ Q\&A सिस्टम (PDFs, रिपोर्ट्स, विकी)
* जटिल बहु-दस्तावेज़ तर्क
* नॉलेज ग्राफ निर्माण
* डेटा-से-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("What was the revenue growth last year?")
```

***

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

### मजबूतियाँ

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

### कमज़ोरियाँ

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

# घटकों को कनेक्ट करें
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 पर तैनाती

```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
# वेब 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      |

{% 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
```

इन चारों फ़्रेमवर्क्स में से कोई भी उत्कृष्ट विकल्प है — सही विकल्प आपके विशिष्ट आवश्यकताओं, टीम कौशल, और तैनाती सीमाओं पर निर्भर करता है। संदेह होने पर, शुरू करें **— 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-hi/comparisons/rag-frameworks-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.