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

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

इंस्टॉलेशन:

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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka is a chat endpoint
    is_function_calling_model=True, # native tool calling is supported
    context_window=180000,         # MiniMax M2.7 context window
    max_tokens=8192,               # Gateway output cap
)

response = llm.complete("Explain what RAG is in three sentences.")
print(response)

OpenAILike के बारे में ज़रूरी बात: is_chat_model=True अवश्य सेट करें — वरना LlamaIndex संवाद की जगह कच्चे प्रॉम्प्ट के साथ पुराने Completions 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. LLM via Gonka (set once, globally)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=180000,
    max_tokens=8192,
)

# 2. Local embeddings (free, no OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Load and index documents from the ./data folder
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Query the knowledge base
query_engine = index.as_query_engine()
response = query_engine.query("What is this document about?")
print(response)

एम्बेडिंग्स को लेकर एक ज़रूरी बारीकी: डिफ़ॉल्ट रूप से VectorStoreIndex OpenAI की एम्बेडिंग्स (text-embedding-ada-002) इस्तेमाल करता है — ये OpenAI को अलग से किए जाने वाले पेड कॉल हैं, Gonka को नहीं। 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.0062/1M, आउटपुट ×3।

मुफ्त 3M टोकन के साथ, आप 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=180000,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """Multiplies two numbers."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="You are a helpful assistant. Use the tools for calculations.",
)

async def main():
    result = await agent.run("What is 1234 multiplied by 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 की गाइड भी देख लें।