लामाइंडेक्स + गोंका AI - बहुत कम लागत पर RAG-अनुप्रयोग

जॉइनगोंका API कुंजी: gate.joingonka.ai/register पर पंजीकरण करें - हम शुरुआत में 10M मुफ्त टोकन देते हैं - और डैशबोर्ड में jg-xxx कुंजी बनाएं।

स्थापना:

pip install llama-index llama-index-llms-openai-like

मनमानी OpenAI-संगत API के लिए, लामाइंडेक्स llama_index.llms.openai_like पैकेज से OpenAILike क्लास प्रदान करता है। गोंका को अनुरोध का न्यूनतम उदाहरण:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-आपकी-कुंजी",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # गोंका एक चैट-एंडपॉइंट है
    is_function_calling_model=True, # मूल टूल कॉलिंग समर्थित है
    context_window=131072,         # Qwen3-235B में 128K
    max_tokens=8192,               # गेटवे के माध्यम से आउटपुट की सीमा (Qwen)
)

response = llm.complete("समझाएं कि RAG क्या है, तीन वाक्यों में।")
print(response)

OpenAILike के बारे में महत्वपूर्ण: is_chat_model=True अवश्य निर्दिष्ट करें - अन्यथा लामाइंडेक्स एक पूर्णता-एंडपॉइंट पर जाएगा, जो हमारे पास नहीं है। is_function_calling_model=True मूल टूल कॉल को सक्षम करता है। context_window को मॉडल के अनुसार सेट करें, ताकि लामाइंडेक्स संदर्भ को सही ढंग से काट सके।

लामाइंडेक्स का क्लासिक परिदृश्य आपके दस्तावेज़ों पर एक अनुक्रमणिका और query_engine के माध्यम से उस पर प्रश्न। वैश्विक LLM Settings.llm के माध्यम से एक बार सेट किया जाता है, फिर पूरी पाइपलाइन स्वचालित रूप से गोंका का उपयोग करती है।

from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    Settings,
)
from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# 1. गोंका के माध्यम से LLM (एक बार - विश्व स्तर पर)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-आपकी-कुंजी",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    max_tokens=8192,
)

# 2. स्थानीय एम्बेडिंग (मुफ्त, बिना OpenAI के)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. ./data फ़ोल्डर से दस्तावेज़ लोड करना और अनुक्रमित करना
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. ज्ञान आधार पर प्रश्न
query_engine = index.as_query_engine()
response = query_engine.query("यह दस्तावेज़ किसके बारे में है?")
print(response)

एम्बेडिंग के बारे में महत्वपूर्ण nuance: डिफ़ॉल्ट रूप से VectorStoreIndex OpenAI एम्बेडिंग (text-embedding-ada-002) का उपयोग करता है - ये OpenAI के लिए अलग, भुगतान किए गए कॉल हैं, गोंका के लिए नहीं। OpenAI से पूरी तरह से बचने के लिए, Settings.embed_Model के माध्यम से एक स्थानीय एम्बेडिंग मॉडल सेट करें (जैसा कि ऊपर दिए गए उदाहरण में - HuggingFaceEmbedding, पैकेज pip install llama-index-embeddings-huggingface)। फिर जनरेशन गोंका के माध्यम से होती है, और वेक्टरकरण स्थानीय और मुफ्त होता है।

लागत: एक RAG-पाइपलाइन अनुरोध (खोज + जनरेशन) ~2–5K LLM टोकन खर्च करता है। गोंका के माध्यम से यह कुछ सेंट है; OpenAI/एंथ्रोपिक के माध्यम से - 3–4 गुना अधिक महंगा है। प्रति दिन हजारों अनुरोधों के प्रवाह पर, अंतर प्रति माह दसियों हज़ार डॉलर की बचत में बदल जाता है।

RAG-एप्लिकेशन एक बार का चैट नहीं है, बल्कि अनुरोधों का एक निरंतर प्रवाह है: उपयोगकर्ता का प्रत्येक प्रश्न 2-5K LLM टोकन (प्रश्न स्वयं प्लस संदर्भ के पाए गए अंश) को खींचता है। आइए विशिष्ट मात्राओं की गणना करें और विभिन्न प्रदाताओं पर उनकी लागत क्या आती है। जॉइनगोंका गेटवे (JoinGonka Gateway) के माध्यम से गोंका की कीमतें: इनपुट ~$0.0005/1M, आउटपुट ×3।

10M मुफ्त टोकन पर, आप पूरी RAG-पाइपलाइन को डिबग कर सकते हैं, एक परीक्षण कॉर्पस को अनुक्रमित कर सकते हैं, और हजारों अनुरोध चला सकते हैं - और एक भी सेंट खर्च नहीं कर सकते। उत्पादन की मात्रा पर, जॉइनगोंका गेटवे RAG को एक महंगी सेवा से एक व्यय मद में बदल देता है, जिसे आप बिल्कुल भी नोटिस नहीं कर सकते।

लामाइंडेक्स न केवल दस्तावेज़ों पर जवाब दे सकता है, बल्कि उपकरणों के साथ एजेंटों का निर्माण भी कर सकता है। सभी तीन गोंका मॉडल मूल टूल कॉलिंग का समर्थन करते हैं - एजेंट संरचित रूप से, टेक्स्ट को पार्स किए बिना, फ़ंक्शन कॉल करते हैं। उपकरण के साथ एजेंट का एक उदाहरण:

import asyncio
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-आपकी-कुंजी",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=131072,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """दो संख्याओं को गुणा करता है।"""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="आप एक उपयोगी सहायक हैं। गणना के लिए उपकरणों का उपयोग करें।",
)

async def main():
    result = await agent.run("1234 को 5678 से गुणा करने पर कितना होगा?")
    print(result)

asyncio.run(main())

मॉडल का चयन (model फ़ील्ड और संबंधित context_window / max_tokens सीमाएं):

गेटवे के माध्यम से max_tokens की सीमा - Qwen3 मॉडल पर 8192 तक; Kimi और MiniMax के लिए क्रमशः 3072 और 4096 निर्दिष्ट करें। यदि गैर-स्ट्रीमिंग अनुरोध के लिए max_tokens निर्दिष्ट नहीं है, तो डिफ़ॉल्ट रूप से 1500 टोकन तक लौटाए जाएंगे - RAG-उत्तरों और एजेंट चरणों के लिए मान स्पष्ट रूप से सेट करें।

TypeScript: LlamaIndex.TS के लिए एक समान रास्ता है - @llamaindex/openai पैकेज से OpenAI क्लास baseURL और apiKey स्वीकार करता है (या OPENAI_BASE_URL / OPENAI_API_KEY चर पढ़ता है), ताकि वही गेटवे Node.js-स्टैक में भी जुड़ जाए। यदि आप पायथन-फ्रेमवर्क पर AI-एप्लिकेशन भी बना रहे हैं, तो लैंगचेन (LangChain) के लिए गाइड भी देखें।