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

JoinGonka API-key: gate.joingonka.ai/register पर रजिस्टर करें — हम शुरुआत में 3M फ्री टोकन देते हैं — और Dashboard में एक jg-xxx की (key) बनाएं।

इंस्टालेशन:

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

किसी भी OpenAI-संगत API के लिए, LlamaIndex, llama_index.llms.openai_like पैकेज से OpenAILike क्लास प्रदान करता है। Gonka के लिए एक न्यूनतम रिक्वेस्ट उदाहरण:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-आपकी-की",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka एक chat-endpoint है
    is_function_calling_model=True, # नेटिव tool calling सपोर्टेड है
    context_window=200000,         # नेटवर्क के मॉडलों में 200K है
    max_tokens=8192,               # Gateway के माध्यम से आउटपुट लिमिट
)

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

OpenAILike के बारे में महत्वपूर्ण: सुनिश्चित करें कि आप is_chat_model=True सेट करें — अन्यथा LlamaIndex एक ऐसे completion-endpoint पर जाएगा जो हमारे पास नहीं है। is_function_calling_model=True नेटिव tool calls को इनेबल करता है। context_window को मॉडल के अनुसार सेट करें ताकि LlamaIndex कॉन्टेक्स्ट को सही तरीके से कट कर सके।

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

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

# 1. Gonka के माध्यम से LLM (एक बार — ग्लोबल)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-आपकी-की",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=200000,
    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. ज्ञान आधार (knowledge base) से क्वेरी करें
query_engine = index.as_query_engine()
response = query_engine.query("यह दस्तावेज़ किस बारे में है?")
print(response)

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

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

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

मुफ्त 3M टोकन के साथ, आप RAG-पाइपलाइन के पहले अनुरोधों को चला सकते हैं, टेस्ट कॉर्पस को इंडेक्स कर सकते हैं और हजारों अनुरोधों को चला सकते हैं — और एक सेंट भी खर्च नहीं करेंगे। प्रोडक्शन-स्केल पर, JoinGonka Gateway RAG को एक महंगी सेवा से बदलकर एक ऐसा खर्च बना देता है जिसे आप नोटिस भी नहीं करेंगे।

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

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="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=200000,
    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 सीमाएं):

Gateway के माध्यम से max_tokens सीमा — MiniMax M2.7 और GLM-5.3 Flash के लिए 8192 तक, DeepSeek V4 Flash के लिए 32768 तक। यदि नॉन-स्ट्रीमिंग रिक्वेस्ट के लिए max_tokens सेट नहीं है, तो डिफ़ॉल्ट रूप से 1500 टोकन वापस आएंगे — RAG जवाबों और एजेंट स्टेप्स के लिए मान स्पष्ट रूप से सेट करें।

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