LangChain + Gonka AI – नाममात्र की लागत पर AI-अनुप्रयोग

सबसे छोटा उदाहरण — LangChain को Gonka से जोड़ना:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
)

response = llm.invoke("Explain what RAG is")
print(response.content)

बस इतना ही। तीन लाइनें — और आपका LangChain प्रोजेक्ट विकेंद्रीकृत Gonka नेटवर्क से बेहद कम खर्च में चलने लगता है।

डिपेंडेंसी इंस्टॉल करें:

pip install langchain langchain-openai

सलाह: max_tokens=8192 साफ़-साफ़ दें — MiniMax M2.7 और GLM-5.3 Flash के लिए JoinGonka Gateway से आउटपुट की यही ऊपरी सीमा है (DeepSeek V4 Flash में — 32768 तक)। कॉन्टेक्स्ट विंडो — MiniMax M2.7 में 200K टोकन (DeepSeek V4 Flash में 380K, GLM-5.3 Flash में 390K) — RAG पाइपलाइन में chunk_size सेट करते समय इसे ध्यान में रखें।

RAG (Retrieval-Augmented Generation) AI ऐप्स का सबसे लोकप्रिय पैटर्न है। आप दस्तावेज़ अपलोड करते हैं, उन्हें चंक्स में बाँटते हैं, एम्बेडिंग बनाते हैं, प्रासंगिक फ़्रैगमेंट ढूँढते हैं और कॉन्टेक्स्ट के साथ जवाब जनरेट करते हैं।

from langchain_openai import ChatOpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.document_loaders import TextLoader

# 1. LLM via Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Load and index documents
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Vector store (local, free)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. RAG chain
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Query
result = qa.invoke("What is this document about?")
print(result["result"])

लागत: एक RAG पाइपलाइन क्वेरी (retrieval + generation) में ~2-5K LLM टोकन लगते हैं। Gonka के ज़रिए यह $0.00001-0.000024 है। OpenAI के ज़रिए — $0.005-0.05। फ़र्क़ — 1,300x।

रोज़ हज़ारों क्वेरी प्रोसेस करने वाले production सिस्टम के लिए यह बचत हर महीने दसियों हज़ार डॉलर की होती है।

LangChain आपको tools के साथ एजेंट बनाने देता है। नेटवर्क के मॉडल नेटिव tool calling सपोर्ट करते हैं — एजेंट भरोसेमंद तरीके से काम करते हैं, टेक्स्ट जवाबों की पार्सिंग की ज़रूरत नहीं।

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
)

@tool
def calculator(expression: str) -> str:
    """Evaluates a math expression."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Searches the web for information."""
    return f"Search results for: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_openai_tools_agent(llm, [calculator, search_web], prompt)
executor = AgentExecutor(agent=agent, tools=[calculator, search_web])

result = executor.invoke({"input": "What is 2**10 * 3.14?"})
print(result["output"])

एजेंट calculator को कॉल करता है, नतीजा पाता है और जवाब तैयार करता है। पूरे साइकल की कीमत Gonka के ज़रिए ~$0.00005 है। OpenAI के ज़रिए — $0.01-0.05। हज़ारों यूज़र्स वाले सिस्टम के लिए यह दसियों हज़ार डॉलर का फ़र्क़ है।