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

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 ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।