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

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

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-आपका-कुंजी",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

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

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

निर्भरता स्थापित करना:

pip install langchain langchain-openai

सिफारिश: स्पष्ट रूप से max_tokens=2048 इंगित करें — यह JoinGonka Gateway के माध्यम से अधिकतम है। Qwen3-235B की संदर्भ विंडो — 128K टोकन — RAG पाइपलाइनों में chunk_size को कॉन्फ़िगर करते समय इसे ध्यान में रखें।

RAG (रिट्रीवल-ऑगमेंटेड जनरेशन) 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. Gonka के माध्यम से LLM
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-आपका-कुंजी",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    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-पाइपलाइन का एक अनुरोध (पुनर्प्राप्ति + जनरेशन) LLM के ~2-5K टोकन का उपयोग करता है। Gonka के माध्यम से यह $0.000002-0.000005 है। OpenAI के माध्यम से – $0.005-0.05 है। अंतर – 10,000x।

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

LangChain औजारों (tools) के साथ एजेंट बनाने की अनुमति देता है। Qwen3-235B नेटिव टूल कॉलिंग का समर्थन करता है – एजेंट बिना टेक्स्ट प्रतिक्रियाओं को पार्स किए विश्वसनीय रूप से काम करते हैं।

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="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@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.00001 है। OpenAI के माध्यम से – $0.01-0.05। हजारों उपयोगकर्ताओं वाली प्रणालियों के लिए यह दसियों हज़ार डॉलर का अंतर है।