LangChain + Gonka AI — Mga AI Applications sa Mababang Halaga

Pinakamaikling halimbawa — pagkonekta sa LangChain sa Gonka:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-iyong-susi",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

response = llm.invoke("Ipaliwanag kung ano ang RAG")
print(response.content)

Iyan lang. Tatlong linya — at ang iyong proyekto ng LangChain ay gumagana sa pamamagitan ng decentralized network ng Gonka nang murang halaga.

Pag-install ng mga dependency:

pip install langchain langchain-openai

Rekomendasyon: Malinaw na tukuyin ang max_tokens=2048 — ito ang maximum sa pamamagitan ng JoinGonka Gateway. Ang context window ng Qwen3-235B ay 128K token — isaalang-alang ito kapag ino-configure ang chunk_size sa RAG-pipelines.

RAG (Retrieval-Augmented Generation) — ang pinakapopular na pattern ng AI applications. Naglo-load ka ng mga dokumento, hinahati sa mga chunk, gumagawa ng mga embedding, naghahanap ng mga relevant na fragment at bumubuo ng sagot na may konteksto.

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 sa pamamagitan ng Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-iyong-key",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Pag-load at pag-index ng mga dokumento
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Vector storage (local, libre)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

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

# 5. Kahilingan
result = qa.invoke("Tungkol saan ang dokumentong ito?")
print(result["result"])

Gastos: isang RAG-pipeline query (retrieval + generation) ay gumagamit ng ~2-5K LLM tokens. Sa pamamagitan ng Gonka, ito ay $0.000002-0.000005. Sa pamamagitan ng OpenAI — $0.005-0.05. Ang pagkakaiba ay 10,000x.

Para sa mga sistema ng produksyon na nagpoproseso ng libu-libong kahilingan araw-araw, ang pagtitipid ay libu-libong dolyar bawat buwan.

Pinapayagan ng LangChain na lumikha ng mga agent na may mga tool. Sinusuportahan ng Qwen3-235B ang native tool calling — gumagana nang maaasahan ang mga agent, nang walang pag-parse ng mga text sagot.

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

@tool
def calculator(expression: str) -> str:
    """Kinakalkula ang matematikal na expression."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Naghahanap ng impormasyon sa internet."""
    return f"Mga resulta ng paghahanap para sa: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Ikaw ay isang kapaki-pakinabang na 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": "Magkano ang 2**10 * 3.14?"})
print(result["output"])

Tinatawag ng ahente ang calculator, nakakakuha ng resulta at bumubuo ng sagot. Ang buong cycle ay nagkakahalaga ng ~$0.00001 sa pamamagitan ng Gonka. Sa pamamagitan ng OpenAI — $0.01-0.05. Para sa mga system na may libu-libong user, ito ay isang pagkakaiba sa libu-libong dolyar.