> 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/rag/llamaindex.md). # 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-संगत** — दोनों फ्रेमवर्क को साथ में उपयोग करें {% hint style="success" %} सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace). {% endhint %} *** ## सर्वर आवश्यकताएँ | पैरामीटर | न्यूनतम | अनुशंसित | | -------- | ----------------------- | ----------------------------- | | 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) | {% hint style="info" %} LlamaIndex एक Python लाइब्रेरी है — GPU संसाधन अंतर्निहित LLM और एम्बेडिंग मॉडल द्वारा उपयोग किए जाते हैं। प्रोडक्शन परिनियोजन के लिए, LlamaIndex को Ollama (स्थानीय इन्फ़रेंस के लिए) और ChromaDB (वेक्टर स्टोरेज के लिए) के साथ जोड़ें, और दोनों को अपने Clore.ai GPU सर्वर पर चलाएँ। {% endhint %} *** ## CLORE.AI पर त्वरित परिनियोजन ### 1. एक उपयुक्त सर्वर खोजें पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace) और अपने 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 इन्फ़रेंस इंजन ``` **स्टार्टअप स्क्रिप्ट:** ```bash #!/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://:8000 ``` *** ## चरण-दर-चरण सेटअप ### चरण 1: अपने सर्वर में SSH करें ```bash ssh root@ -p ``` ### चरण 2: Ollama स्थापित करें ```bash 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 वातावरण सेट अप करें ```bash mkdir -p /workspace/llamaindex-app cd /workspace/llamaindex-app python3 -m venv venv source venv/bin/activate pip install --upgrade pip ``` ### चरण 4: LlamaIndex पैकेज स्थापित करें ```bash # कोर 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: वैश्विक सेटिंग्स कॉन्फ़िगर करें ```python # 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: अपना पहला इंडेक्स बनाएँ ```python 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: इंडेक्स से क्वेरी करें ```python 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: मूल दस्तावेज़ प्रश्नोत्तर ```python 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 ```python 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: उप-प्रश्न विघटन ```python 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: ज्ञान ग्राफ इंडेक्स ```python 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 क्वेरी इंजन ```python 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 स्टैक) ```yaml 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. थ्रूपुट के लिए असिंक्रोनस क्वेरीज़ ```python 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. हाइब्रिड खोज (कीवर्ड + सिमेंटिक) ```python 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. गुणवत्ता के लिए पुनः-क्रमांकन ```python 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 के लिए स्ट्रीमिंग ```python # टोकन जैसे-जैसे उत्पन्न हों, उन्हें स्ट्रीम करें 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 से कनेक्ट नहीं हो रहा ```bash # Ollama embeddings को सीधे परीक्षण करें curl http://localhost:11434/api/embeddings -d '{ "model": "nomic-embed-text", "prompt": "प्रयोग पाठ" }' ``` ### समस्या: इंडेक्स बनाना धीमा है ```bash # एम्बेडिंग के दौरान GPU उपयोग की निगरानी करें watch -n1 nvidia-smi # छोटे बैच आकारों का उपयोग करें from llama_index.core import VectorStoreIndex index = VectorStoreIndex.from_documents( docs, show_progress=True, # छोटे बैचों में डालें ) ``` ### समस्या: इंटीग्रेशनों के लिए ModuleNotFoundError ```bash # 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 ``` ### समस्या: संदर्भ विंडो सीमा पार हो गई ```python # chunk size घटाएँ Settings.chunk_size = 512 Settings.chunk_overlap = 50 # या बड़े संदर्भ वाला मॉडल उपयोग करें Settings.llm = Ollama( model="llama3:8b", context_window=8192 # संदर्भ विंडो का विस्तार करें ) ``` ### समस्या: क्वेरीज़ अप्रासंगिक परिणाम लौटाती हैं ```python # 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**: * **आधिकारिक दस्तावेज़**: * **PyPI**: * **इंटीग्रेशन्स**: * **Discord**: * **ब्लॉग**: * **CLORE.AI मार्केटप्लेस**: *** ## 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](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/rag/llamaindex.md?ask=&goal= ``` `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.