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

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

इंस्टॉलेशन:

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

किसी भी OpenAI-compatible 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.003/1M, आउटपुट ×3।

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

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

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 की सीमा नेटवर्क के सभी मॉडलों के लिए 8192 है। यदि नॉन-स्ट्रीमिंग अनुरोध के लिए max_tokens सेट नहीं है, तो डिफ़ॉल्ट रूप से 1500 तक टोकन वापस आएंगे — RAG उत्तरों और एजेंट चरणों के लिए मान स्पष्ट रूप से सेट करें।

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