LlamaIndex + Gonka AI — Mga Aplikasyon ng RAG sa Maliit na Halaga

JoinGonka API key: mag-register sa gate.joingonka.ai/register — nagbibigay kami ng 10M tokens nang libre sa simula — at gumawa ng key na jg-xxx sa Dashboard.

Installation:

pip install llama-index llama-index-llms-openai-like

Para sa kahit anong OpenAI-compatible API, nagbibigay ang LlamaIndex ng OpenAILike class mula sa llama_index.llms.openai_like package. Narito ang isang minimal na halimbawa ng request sa Gonka:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-iyong-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Ang Gonka ay isang chat-endpoint
    is_function_calling_model=True, # native tool calling is supported
    context_window=200000,         # 200K para sa network models
    max_tokens=8192,               # output limit sa pamamagitan ng Gateway
)

response = llm.complete("Ipaliwanag kung ano ang RAG sa tatlong pangungusap.")
print(response)

Mahalagang paalala tungkol sa OpenAILike: siguraduhing ilagay ang is_chat_model=True — kundi pupunta ang LlamaIndex sa completion-endpoint, na wala kami. Ang is_function_calling_model=True ay nag-e-enable ng native tool calls. Itakda ang context_window base sa model para tama ang pag-cut ng context ng LlamaIndex.

Ang classic na scenario ng LlamaIndex ay index para sa iyong mga dokumento at pag-query dito sa pamamagitan ng query_engine. Ang global LLM ay itinakda nang isang beses sa Settings.llm, at pagkatapos ay awtomatikong gagamitin ng buong pipeline ang Gonka.

from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    Settings,
)
from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# 1. LLM sa pamamagitan ng Gonka (isang beses - global)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-iyong-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=200000,
    max_tokens=8192,
)

# 2. Local embeddings (libre, walang OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Pag-load at pag-index ng mga dokumento mula sa ./data folder
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Query sa knowledge base
query_engine = index.as_query_engine()
response = query_engine.query("Tungkol saan ang dokumentong ito?")
print(response)

Kritikal na nuance tungkol sa embeddings: sa default, ang VectorStoreIndex ay gumagamit ng OpenAI embeddings (text-embedding-ada-002) — ang mga ito ay hiwalay na bayad na tawag sa OpenAI, hindi sa Gonka. Upang ganap na lumayo sa OpenAI, magtakda ng local embedding model sa pamamagitan ng Settings.embed_model (gaya ng sa halimbawa sa itaas — HuggingFaceEmbedding, gamit ang pip install llama-index-embeddings-huggingface). Sa ganitong paraan, ang generation ay sa pamamagitan ng Gonka, at ang vectorization ay local at libre.

Gastos: ang isang RAG-pipeline request (search + generation) ay gumagamit ng ~2–5K LLM tokens. Sa pamamagitan ng Gonka, ito ay bahagi lamang ng isang sentimo; sa OpenAI/Anthropic, ito ay 3–4 na beses na mas mahal. Sa dami ng libo-libong request kada araw, ang pagkakaiba nito ay aabot sa sampu-sampung libong dolyar na matitipid kada buwan.

Ang RAG-application ay hindi isang one-time chat, kundi isang tuluy-tuloy na agos ng mga request: ang bawat tanong ng user ay humahatak ng 2–5K LLM tokens (ang tanong mismo kasama ang mga nahanap na fragment ng konteksto). Kalkulahin natin ang mga tipikal na volume at kung magkano ang gastos nito sa iba't ibang providers. Presyo ng Gonka sa pamamagitan ng JoinGonka Gateway: input ~$0.003/1M, output ×3.

Sa libreng 10M tokens, maaari mong i-debug ang buong RAG-pipeline, i-index ang test corpus, at magpatakbo ng libu-libong request — nang hindi gumagastos kahit isang sentimo. Sa production scale, ginagawang item ng gastos ang RAG ng JoinGonka Gateway na hindi mo man lang mapapansin.

Ang LlamaIndex ay hindi lamang marunong sumagot gamit ang mga dokumento, kundi kaya rin nitong bumuo ng mga agent na may tools. Ang parehong modelo ng Gonka ay sumusuporta sa native tool calling — ang mga agent ay nag-a-invoke ng mga function nang structured, nang walang parsing ng text. Halimbawa ng agent na may tool:

import asyncio
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-iyong-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=200000,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """I-multiply ang dalawang numero."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Ikaw ay isang helpful assistant. Gumamit ng tools para sa mga kalkulasyon.",
)

async def main():
    result = await agent.run("Magkano ang 1234 i-multiply sa 5678?")
    print(result)

asyncio.run(main())

Pagpili ng modelo (model field at kaukulang context_window / max_tokens limits):

Ang max_tokens limit sa pamamagitan ng Gateway ay hanggang 8192 para sa lahat ng modelos sa network. Kung ang max_tokens ay hindi naka-set para sa non-streaming request, ang default na ibabalik ay hanggang 1500 tokens — para sa mga RAG response at agent steps, itakda nang malinaw ang halaga.

TypeScript: para sa LlamaIndex.TS, mayroong mirror path — ang OpenAI class mula sa @llamaindex/openai package ay tumatanggap ng baseURL at apiKey (o nagbabasa ng OPENAI_BASE_URL / OPENAI_API_KEY variable), kaya ang parehong Gateway ay konektado rin sa Node.js stack. Kung bumubuo ka ng AI apps sa mga Python framework, tingnan din ang gabay para sa LangChain.