LangChain + Gonka AI — Mga AI Applications sa Mababang Halaga

Minimal na halimbawa — pagkonekta ng LangChain sa 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)

Iyon lang. Tatlong linya — at gumagana na ang iyong LangChain project sa decentralized network ng Gonka nang napakamura.

Pag-install ng dependencies:

pip install langchain langchain-openai

# for the RAG and agent examples below
pip install langchain-classic langchain-community langchain-text-splitters faiss-cpu sentence-transformers

Ang mga import sa mga halimbawa ay para sa LangChain 1.x (nasubok sa version 1.4): ang mga dating chain at AgentExecutor ay nasa package na langchain-classic, at ang text splitting ay nasa langchain-text-splitters.

Rekomendasyon: tahasan mong itakda ang max_tokens=8192 — ito ang output ceiling sa JoinGonka Gateway para sa MiniMax M2.7 at GLM-5.3 Flash (sa DeepSeek V4 Flash — hanggang 32768). Ang context window ay 200K tokens sa MiniMax M2.7 (380K sa DeepSeek V4 Flash, 390K sa GLM-5.3 Flash) — isaalang-alang ito kapag nag-configure ng chunk_size sa RAG pipelines.

Ang RAG (Retrieval-Augmented Generation) ang pinakasikat na pattern ng AI applications. Naglo-load ka ng mga dokumento, hinahati sa chunks, gumagawa ng embeddings, naghahanap ng relevant na fragments, at bubuo ng sagot na may context.

from langchain_openai import ChatOpenAI
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_classic.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"])

Gastos: ang isang RAG pipeline request (retrieval + generation) ay gumagamit ng ~2-5K LLM tokens. Sa Gonka, ito ay $0.00001-0.000024. Sa OpenAI — $0.005-0.05. Ang pagkakaiba — 1,300x.

Para sa production systems na nagpoproseso ng libu-libong request bawat araw, ang matitipid ay umaabot ng sampu-sampung libong dolyar kada buwan.

Binibigyang-daan ng LangChain ang paggawa ng mga agent na may mga tool. Sinusuportahan ng mga modelo sa network ang native na tool calling — maaasahan ang paggana ng mga agent, walang pangangailangang i-parse ang mga text response.

from langchain_openai import ChatOpenAI
from langchain_classic.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.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"])

Tatawagin ng agent ang calculator, kukunin ang resulta, at bubuo ng sagot. Ang buong cycle ay nagkakahalaga ng ~$0.00005 sa Gonka. Sa OpenAI — $0.01-0.05. Para sa mga sistemang may libu-libong user, ito ay pagkakaiba ng sampu-sampung libong dolyar.