LlamaIndex

Clore.ai GPUs पर LlamaIndex डेटा-से-LLM पाइपलाइन और RAG अनुप्रयोग बनाएँ

LlamaIndex (पहले GPT Index) एक LLM अनुप्रयोगों के लिए डेटा फ्रेमवर्क के साथ 37,000 GitHub स्टार्स. जबकि LangChain LLM कॉल्स को चेन करने पर केंद्रित है, LlamaIndex इसमें उत्कृष्ट है डेटा इनजेशन, इंडेक्सिंग, और संरचित क्वेरी करने में — जिससे यह तब पहली पसंद बन जाता है जब आपके अनुप्रयोग को बड़े, विषम दस्तावेज़ संग्रहों पर तर्क करना हो।

LlamaIndex जटिल डेटा संरचनाओं (डेटाबेस, API, PDF, Notion पेज, GitHub रिपो) और उन्नत पुनर्प्राप्ति रणनीतियों के लिए प्रथम-श्रेणी समर्थन प्रदान करता है। इसे स्थानीय LLM के साथ Clore.ai GPU सर्वरों पर चलाने से API लागत समाप्त हो जाती है और आपका डेटा निजी रहता है।

मुख्य ताकतें:

• 📊 डेटा कनेक्टर्स — 160+ इंटीग्रेशन (PDF, SQL, Notion, Slack, GitHub आदि)

• 🗂️ कई प्रकार के इंडेक्स — वेक्टर, ट्री, लिस्ट, कीवर्ड, नॉलेज ग्राफ

• 🔍 उन्नत पुनर्प्राप्ति — उप-प्रश्न विभाजन, पुनरावर्ती पुनर्प्राप्ति, हाइब्रिड सर्च

• 🤖 क्वेरी इंजन — किसी भी डेटा स्रोत पर SQL, संरचित, और प्राकृतिक भाषा

• 🧩 बहु-मोडल — पाठ के साथ-साथ छवियाँ, ऑडियो और वीडियो

• 💾 स्थायित्व — ChromaDB, Pinecone, Weaviate आदि के लिए अंतर्निहित समर्थन

• ⚡ असिंक्रोनस-प्रथम — प्रोडक्शन थ्रूपुट के लिए बनाया गया

• 🔗 LangChain-संगत — दोनों फ्रेमवर्क को साथ में उपयोग करें

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

---

सर्वर आवश्यकताएँ

पैरामीटर	न्यूनतम	अनुशंसित
GPU	NVIDIA RTX 3080 (10 GB)	NVIDIA RTX 4090 (24 GB)
VRAM	8 GB (7B मॉडल)	24 GB (13B–34B मॉडल)
RAM	16 GB	32–64 GB
CPU	4 कोर	16 कोर
डिस्क	30 GB	100+ GB (स्थानीय मॉडल + डेटा)
ओएस	Ubuntu 20.04+	Ubuntu 22.04
CUDA	11.8+	12.1+
Python	3.9+	3.11
पोर्ट्स	22, 8000	22, 8000, 11434 (Ollama)

LlamaIndex एक Python लाइब्रेरी है — GPU संसाधन अंतर्निहित LLM और एम्बेडिंग मॉडल द्वारा उपयोग किए जाते हैं। प्रोडक्शन परिनियोजन के लिए, LlamaIndex को Ollama (स्थानीय इन्फ़रेंस के लिए) और ChromaDB (वेक्टर स्टोरेज के लिए) के साथ जोड़ें, और दोनों को अपने Clore.ai GPU सर्वर पर चलाएँ।

---

CLORE.AI पर त्वरित परिनियोजन

1. एक उपयुक्त सर्वर खोजें

पर जाएँ CLORE.AI मार्केटप्लेस और अपने LLM के आकार के आधार पर चुनें:

उपयोग-प्रकरण	GPU	नोट्स
विकास / परीक्षण	RTX 3080 (10 GB)	7B मॉडल, छोटे दस्तावेज़ सेट
प्रोडक्शन (छोटा)	RTX 4090 (24 GB)	13B मॉडल, मध्यम डेटासेट
प्रोडक्शन (बड़ा)	A100 40G / 80G	34B–70B मॉडल, बड़े डेटासेट
एंटरप्राइज़	H100 (80 GB)	अधिकतम थ्रूपुट

2. अपना परिनियोजन कॉन्फ़िगर करें

Docker इमेज (बेस):

nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04

पोर्ट मैपिंग:

22    → SSH एक्सेस
8000  → LlamaIndex API / Gradio UI
11434 → Ollama इन्फ़रेंस इंजन

स्टार्टअप स्क्रिप्ट:

#!/bin/bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5
ollama pull llama3:8b
ollama pull nomic-embed-text

# LlamaIndex स्थापित करें
pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama
pip install chromadb fastapi uvicorn

python /workspace/app.py

3. API तक पहुँचें

http://<your-clore-server-ip>:8000

---

चरण-दर-चरण सेटअप

चरण 1: अपने सर्वर में SSH करें

ssh root@<your-clore-server-ip> -p <ssh-port>

चरण 2: Ollama स्थापित करें

curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5

# मॉडल डाउनलोड करें
ollama pull llama3:8b              # जनरेशन के लिए LLM
ollama pull nomic-embed-text       # एम्बेडिंग मॉडल

# सत्यापित करें
ollama list

चरण 3: Python वातावरण सेट अप करें

mkdir -p /workspace/llamaindex-app
cd /workspace/llamaindex-app

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

चरण 4: LlamaIndex पैकेज स्थापित करें

# कोर LlamaIndex
pip install llama-index

# LLM इंटीग्रेशन
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # वैकल्पिक: OpenAI

# एम्बेडिंग इंटीग्रेशन
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# वेक्टर स्टोर इंटीग्रेशन
pip install llama-index-vector-stores-chroma

# डेटा लोडर्स
pip install llama-index-readers-file
pip install llama-index-readers-web

# वैकल्पिक: अतिरिक्त रीडर
pip install pypdf docx2txt

चरण 5: वैश्विक सेटिंग्स कॉन्फ़िगर करें

# settings.py
from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# LLM कॉन्फ़िगर करें
Settings.llm = Ollama(
    model="llama3:8b",
    base_url="http://localhost:11434",
    request_timeout=300.0,
    temperature=0.1,
)

# एम्बेडिंग कॉन्फ़िगर करें
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434",
)

# चंक सेटिंग्स कॉन्फ़िगर करें
Settings.chunk_size = 1024
Settings.chunk_overlap = 200

चरण 6: अपना पहला इंडेक्स बनाएँ

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# किसी निर्देशिका से दस्तावेज़ लोड करें
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"लोड किए गए दस्तावेज़: {len(documents)}")

# वेक्टर इंडेक्स बनाएं (स्वतः एम्बेड और स्टोर करता है)
index = VectorStoreIndex.from_documents(documents)

# इंडेक्स को डिस्क पर सहेजें
index.storage_context.persist("/workspace/index_storage")
print("इंडेक्स बन गया और सेव हो गया!")

चरण 7: इंडेक्स से क्वेरी करें

from llama_index.core import load_index_from_storage, StorageContext

# मौजूदा इंडेक्स लोड करें
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# क्वेरी इंजन बनाएँ
query_engine = index.as_query_engine(similarity_top_k=5)

# प्रश्न पूछें
response = query_engine.query("Clore.ai पर कौन से GPU सर्वर उपलब्ध हैं?")
print(f"उत्तर: {response}")
print(f"\nस्रोत: {len(response.source_nodes)} नोड्स उपयोग किए गए")

---

उपयोग के उदाहरण

उदाहरण 1: मूल दस्तावेज़ प्रश्नोत्तर

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from pathlib import Path

# स्थानीय Ollama मॉडल के साथ LLamaIndex कॉन्फ़िगर करें
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# नमूना दस्तावेज़ निर्देशिका बनाएँ
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# एक नमूना दस्तावेज़ बनाएँ
(data_dir / "clore_faq.txt").write_text("""\nClore.ai अक्सर पूछे जाने वाले प्रश्न\nप्रश्न: Clore.ai क्या है?\nउत्तर: Clore.ai एक विकेंद्रीकृत GPU क्लाउड मार्केटप्लेस है जो GPU मालिकों को उन AI शोधकर्ताओं और डेवलपर्स से जोड़ता है जिन्हें कंप्यूटिंग शक्ति की आवश्यकता होती है.\nप्रश्न: कौन से GPU उपलब्ध हैं?\nउत्तर: Clore.ai NVIDIA GTX 1080 से लेकर नवीनतम H100 80GB तक के GPU प्रदान करता है. लोकप्रिय विकल्पों में RTX 4090, A100 40G/80G, और RTX 3090 शामिल हैं.\nप्रश्न: मूल्य निर्धारण कैसे काम करता है?\nउत्तर: कीमतें GPU प्रदाताओं द्वारा तय की जाती हैं और GPU मॉडल, VRAM, और उपलब्धता के अनुसार बदलती हैं. आमतौर पर AWS/GCP की तुलना में 30-70% सस्ती होती हैं.\nप्रश्न: मैं कौन सा सॉफ़्टवेयर चला सकता हूँ?\nउत्तर: कोई भी Docker कंटेनर. PyTorch, TensorFlow, ComfyUI, Stable Diffusion, और अधिक के लिए पूर्व-कॉन्फ़िगर की गई इमेजें उपलब्ध हैं.\n""")
Clore.ai अक्सर पूछे जाने वाले प्रश्न

प्रश्न: Clore.ai क्या है?
उत्तर: Clore.ai एक विकेंद्रीकृत GPU क्लाउड मार्केटप्लेस है जो GPU मालिकों को उन AI शोधकर्ताओं और डेवलपर्स से जोड़ता है जिन्हें कंप्यूटिंग शक्ति की आवश्यकता होती है.

प्रश्न: कौन से GPU उपलब्ध हैं?
उत्तर: Clore.ai NVIDIA GTX 1080 से लेकर नवीनतम H100 80GB तक के GPU प्रदान करता है. लोकप्रिय विकल्पों में RTX 4090, A100 40G/80G, और RTX 3090 शामिल हैं.

प्रश्न: मूल्य निर्धारण कैसे काम करता है?
उत्तर: कीमतें GPU प्रदाताओं द्वारा तय की जाती हैं और GPU मॉडल, VRAM, और उपलब्धता के अनुसार बदलती हैं. आमतौर पर AWS/GCP की तुलना में 30-70% सस्ती होती हैं.

प्रश्न: मैं कौन सा सॉफ़्टवेयर चला सकता हूँ?
उत्तर: कोई भी Docker कंटेनर. PyTorch, TensorFlow, ComfyUI, Stable Diffusion, और अधिक के लिए पूर्व-कॉन्फ़िगर की गई इमेजें उपलब्ध हैं.
""")

# इंडेक्स बनाएँ
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# क्वेरी करें
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "Clore.ai कौन से GPU प्रदान करता है?",
    "Clore.ai की कीमतें AWS की तुलना में कैसी हैं?",
    "क्या मैं कस्टम Docker कंटेनर चला सकता हूँ?",
]

for q in questions:
    print(f"\n❓ {q}")
    response = query_engine.query(q)
    print(f"\n💬 {response}")

---

उदाहरण 2: ChromaDB के साथ बहु-दस्तावेज़ RAG

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, Settings
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb

# LLM और एम्बेडिंग कॉन्फ़िगर करें
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# ChromaDB से कनेक्ट करें (जो उसी Clore.ai सर्वर पर चल रहा है)
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# LlamaIndex के लिए ChromaDB वेक्टर स्टोर बनाएँ
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# कई स्रोतों से दस्तावेज़ लोड करें
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # उपनिर्देशिकाएँ शामिल करें
    required_exts=[".pdf", ".txt", ".md"],  # केवल ये प्रारूप
    filename_as_id=True          # फ़ाइलनाम को डॉक आईडी के रूप में उपयोग करें
).load_data()

print(f"{docs_dir} से {len(documents)} दस्तावेज़ लोड किए गए")

# इंडेक्स बनाएँ (ChromaDB में संग्रहीत होता है)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("इंडेक्स बन गया और ChromaDB में स्थायी रूप से सहेज दिया गया!")

# मौजूदा इंडेक्स लोड करें (भविष्य के सत्रों के लिए)
# index = VectorStoreIndex.from_vector_store(vector_store)

# मेटाडेटा फ़िल्टरिंग के साथ उन्नत क्वेरी इंजन
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# मेटाडेटा फ़िल्टर के साथ क्वेरी करें
filtered_engine = index.as_query_engine(
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(key="file_type", value=".pdf"),
        ]
    )
)

response = filtered_engine.query("दस्तावेज़ों में प्रमुख तकनीकी अवधारणाओं का सारांश दें।")
print(f"\nफ़िल्टर किया गया उत्तर: {response}")

---

उदाहरण 3: उप-प्रश्न विघटन

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# विभिन्न ज्ञान डोमेन के लिए अलग-अलग इंडेक्स बनाएँ
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# अलग-अलग ज्ञान आधार
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# टूल्स के रूप में तैयार करें
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Clore.ai के लिए मूल्य निर्धारण जानकारी, लागत तुलना, और बिलिंग विवरण शामिल हैं."
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="GPU स्पेसिफिकेशन, Docker परिनियोजन, और APIs के बारे में तकनीकी दस्तावेज़ शामिल हैं."
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="अक्सर पूछे जाने वाले प्रश्न और उनके उत्तर शामिल हैं."
        )
    ),
]

# उप-प्रश्न इंजन जटिल प्रश्नों को विभाजित करता है
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# जटिल बहु-भाग प्रश्न
"""
Clore.ai पर 7B पैरामीटर वाले LLM को 100 घंटे तक चलाने की लागत की AWS से तुलना करें,
और प्रत्येक विकल्प के लिए आवश्यक तकनीकी सेटअप समझाएँ.
"""

print(f"प्रश्न: {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nव्यापक उत्तर:\n{response}")

---

उदाहरण 4: ज्ञान ग्राफ इंडेक्स

from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:13b", base_url="http://localhost:11434")  # बेहतर निष्कर्षण के लिए बड़ा मॉडल
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# दस्तावेज़ लोड करें
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# ज्ञान ग्राफ बनाएँ (इकाइयाँ और संबंध निकालता है)
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # प्रति चंक अधिकतम 10 ट्रिपलेट निकालें
    include_embeddings=True,
    show_progress=True
)

# ग्राफ सहेजें
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"ज्ञान ग्राफ बन गया!")
print(f"नोड्स: {len(kg_index.index_struct.table)}")

# ज्ञान ग्राफ से क्वेरी करें
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # स्रोत पाठ शामिल करें
    retriever_mode="keyword",     # कीवर्ड-आधारित पुनर्प्राप्ति का उपयोग करें
    response_mode="tree_summarize"
)

questions = [
    "GPU मॉडल और उपयोग के मामलों के बीच क्या संबंध हैं?",
    "मूल्य निर्धारण और GPU स्पेसिफिकेशन कैसे संबंधित हैं?",
    "कौन-सी परिनियोजन विधियाँ किन सेवाओं से जुड़ती हैं?",
]

for q in questions:
    print(f"\n🔍 {q}")
    response = kg_query_engine.query(q)
    print(f"📊 {response}")

---

उदाहरण 5: डेटाबेस पर SQL क्वेरी इंजन

from llama_index.core import SQLDatabase, Settings
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.ollama import Ollama
from sqlalchemy import create_engine, text
import pandas as pd

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")

# GPU मार्केटप्लेस डेटा के साथ नमूना डेटाबेस बनाएँ
engine = create_engine("sqlite:////workspace/clore_data.db")

# टेबल बनाएँ और उनमें डेटा भरें
with engine.connect() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS gpu_servers (
            id INTEGER PRIMARY KEY,
            gpu_model TEXT,
            vram_gb INTEGER,
            price_per_hour REAL,
            location TEXT,
            available INTEGER
        )
    """))

    conn.execute(text("""
        INSERT OR REPLACE INTO gpu_servers VALUES
        (1, 'RTX 4090', 24, 0.65, 'US-East', 1),
        (2, 'RTX 4090', 24, 0.70, 'EU-West', 1),
        (3, 'A100 80G', 80, 2.50, 'US-West', 1),
        (4, 'H100 80G', 80, 4.20, 'US-East', 0),
        (5, 'RTX 3090', 24, 0.35, 'Asia-Pacific', 1),
        (6, 'RTX 3080', 10, 0.20, 'EU-East', 1),
        (7, 'A100 40G', 40, 1.50, 'US-East', 1)
    """))
    conn.commit()

# LlamaIndex SQL डेटाबेस रैपर बनाएँ
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])

# प्राकृतिक भाषा से SQL क्वेरी इंजन
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# डेटाबेस से प्राकृतिक भाषा में क्वेरी करें
nl_queries = [
    "उपलब्ध सबसे सस्ता GPU सर्वर कौन सा है?",
    "40GB से अधिक VRAM वाले सभी GPU सर्वर दिखाएँ",
    "RTX 4090 सर्वरों के लिए प्रति घंटे औसत कीमत क्या है?",
    "किन स्थानों पर GPU सर्वर उपलब्ध हैं?",
    "कीमत के अनुसार क्रमबद्ध सभी उपलब्ध A100 सर्वरों की सूची दें",
]

for query in nl_queries:
    print(f"\n💬 प्राकृतिक भाषा: {query}")
    response = query_engine.query(query)
    print(f"📊 उत्तर: {response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL: {response.metadata['sql_query']}")

---

कॉन्फ़िगरेशन

डॉकर कम्पोज़ (पूर्ण LlamaIndex स्टैक)

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    runtime: nvidia
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped

  llamaindex-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: llamaindex-api
    ports:
      - "8000:8000"
    volumes:
      - ./data:/workspace/data
      - ./indices:/workspace/indices
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - CHROMA_HOST=chromadb
      - CHROMA_PORT=8000
      - LLM_MODEL=llama3:8b
      - EMBED_MODEL=nomic-embed-text
    depends_on:
      - ollama
      - chromadb
    restart: unless-stopped

volumes:
  ollama_models:
  chroma_data:

मुख्य कॉन्फ़िगरेशन चर

सेटिंग	डिफ़ॉल्ट	विवरण
Settings.llm	OpenAI GPT-3.5	जनरेशन के लिए LLM
Settings.embed_model	OpenAI Ada	एम्बेडिंग मॉडल
Settings.chunk_size	1024	टोकन में पाठ खंड का आकार
Settings.chunk_overlap	200	खंडों के बीच ओवरलैप
Settings.num_output	256	LLM प्रतिक्रिया में अधिकतम टोकन
Settings.context_window	4096	LLM संदर्भ विंडो का आकार

---

प्रदर्शन सुझाव

1. थ्रूपुट के लिए असिंक्रोनस क्वेरीज़

import asyncio
from llama_index.core import VectorStoreIndex

query_engine = index.as_query_engine(use_async=True)

async def batch_query(questions):
    tasks = [query_engine.aquery(q) for q in questions]
    return await asyncio.gather(*tasks)

questions = ["Q1?", "Q2?", "Q3?", "Q4?", "Q5?"]
answers = asyncio.run(batch_query(questions))

2. हाइब्रिड खोज (कीवर्ड + सिमेंटिक)

from llama_index.core import VectorStoreIndex
from llama_index.core.retrievers import VectorIndexRetriever, KeywordTableSimpleRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import QueryFusionRetriever

# वेक्टर और कीवर्ड पुनर्प्राप्ति को संयोजित करें
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # वेक्टर पुनर्प्राप्ति
        index.as_retriever(retriever_mode="keyword"),  # कीवर्ड पुनर्प्राप्ति
    ],
    similarity_top_k=5,
    num_queries=3,  # कई क्वेरी विविधताएँ उत्पन्न करें
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)

3. गुणवत्ता के लिए पुनः-क्रमांकन

from llama_index.core.postprocessor import SentenceTransformerRerank

# पुनर्प्राप्ति के बाद पुनः-क्रमांकन चरण जोड़ें
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # अधिक उम्मीदवार प्राप्त करें
    node_postprocessors=[reranker]  # शीर्ष 3 तक पुनः-क्रमांकित करें
)

4. प्रतिक्रियाशील UI के लिए स्ट्रीमिंग

# टोकन जैसे-जैसे उत्पन्न हों, उन्हें स्ट्रीम करें
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Clore.ai कैसे काम करता है, समझाएँ")

for token in response.response_gen:
    print(token, end="", flush=True)

---

समस्या निवारण

समस्या: एम्बेडिंग मॉडल Ollama से कनेक्ट नहीं हो रहा

# Ollama embeddings को सीधे परीक्षण करें
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "प्रयोग पाठ"
}'

समस्या: इंडेक्स बनाना धीमा है

# एम्बेडिंग के दौरान GPU उपयोग की निगरानी करें
watch -n1 nvidia-smi

# छोटे बैच आकारों का उपयोग करें
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    docs,
    show_progress=True,
    # छोटे बैचों में डालें
)

समस्या: इंटीग्रेशनों के लिए ModuleNotFoundError

# LlamaIndex v0.10+ में प्लगइन आर्किटेक्चर का उपयोग करता है
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# स्थापित पैकेजों की जाँच करें
pip list | grep llama

समस्या: संदर्भ विंडो सीमा पार हो गई

# chunk size घटाएँ
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# या बड़े संदर्भ वाला मॉडल उपयोग करें
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # संदर्भ विंडो का विस्तार करें
)

समस्या: क्वेरीज़ अप्रासंगिक परिणाम लौटाती हैं

# similarity top-k बढ़ाएँ
query_engine = index.as_query_engine(similarity_top_k=10)

# या बेहतर एम्बेडिंग मॉडल का उपयोग करें
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)

---

लिंक्स

• GitHub: https://github.com/run-llama/llama_index

• आधिकारिक दस्तावेज़: https://docs.llamaindex.ai

• PyPI: https://pypi.org/project/llama-index

• इंटीग्रेशन्स: https://llamahub.ai

• Discord: https://discord.gg/dGcwcsnxhU

• ब्लॉग: https://www.llamaindex.ai/blog

• CLORE.AI मार्केटप्लेस: https://clore.ai/marketplace

---

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

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन RAG	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
उच्च-थ्रूपुट एम्बेडिंग	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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