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

न्यूनतम उदाहरण — LangChain को Gonka से जोड़ना:

from langchain_openai import ChatOpenAI

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

response = llm.invoke("RAG क्या है समझाएं")
print(response.content)

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

डिपेंडेंसी इंस्टॉलेशन:

pip install langchain langchain-openai

सुझाव: स्पष्ट रूप से max_tokens=8192 निर्दिष्ट करें — यह नेटवर्क के सभी मॉडलों के लिए JoinGonka Gateway के माध्यम से आउटपुट की सीमा है। नेटवर्क मॉडल की कॉन्टेक्स्ट विंडो 200K टोकन है — RAG पाइपलाइनों में chunk_size सेट करते समय इसका ध्यान रखें।

RAG (Retrieval-Augmented Generation) एआई एप्लिकेशन का सबसे लोकप्रिय पैटर्न है। आप दस्तावेज़ लोड करते हैं, उन्हें चंक्स में विभाजित करते हैं, एम्बेडिंग बनाते हैं, प्रासंगिक टुकड़े खोजते हैं और संदर्भ के साथ उत्तर उत्पन्न करते हैं।

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. Gonka के माध्यम से LLM
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. दस्तावेज़ लोड करना और इंडेक्स करना
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. वेक्टर स्टोरेज (लोकल, मुफ्त)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. RAG-चेन
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. अनुरोध
result = qa.invoke("यह दस्तावेज़ किसके बारे में है?")
print(result["result"])

लागत: एक RAG-पाइपलाइन अनुरोध (retrieval + generation) लगभग 2-5K LLM टोकन का उपयोग करता है। Gonka के जरिए यह $0.00001-0.000024 है। OpenAI के जरिए — $0.005-0.05। अंतर — 2,000 गुना है।

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

LangChain आपको टूल्स (tools) के साथ एजेंट बनाने की अनुमति देता है। Kimi K2.6 नेटिव '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-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
)

@tool
def calculator(expression: str) -> str:
    """गणितीय अभिव्यक्ति की गणना करता है।"""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """इंटरनेट पर जानकारी खोजता है।"""
    return f"खोज परिणाम: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "आप एक उपयोगी सहायक हैं।"),
    ("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": "2**10 * 3.14 कितना होगा?"})
print(result["output"])

एजेंट calculator को कॉल करता है, परिणाम प्राप्त करता है और उत्तर बनाता है। पूरा चक्र Gonka के माध्यम से ~$0.00005 का है। OpenAI के माध्यम से — $0.01-0.05। हजारों उपयोगकर्ताओं वाले सिस्टम के लिए यह हज़ारों डॉलर का अंतर है।