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

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

Installation:

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

Para sa anumang OpenAI-compatible API, ang LlamaIndex ay nagbibigay ng class na OpenAILike mula sa package na llama_index.llms.openai_like. 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,            # Gonka ay isang chat-endpoint
    is_function_calling_model=True, # suportado ang native tool calling
    context_window=200000,         # 200K sa mga model ng network
    max_tokens=8192,               # output ceiling sa pamamagitan ng Gateway
)

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

Mahalaga tungkol sa OpenAILike: siguraduhing ilagay ang is_chat_model=True — kundi pupunta ang LlamaIndex sa completion-endpoint na wala tayo. Ang is_function_calling_model=True ay nag-e-enable ng native tool calls. I-set 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 beses na chat, kundi isang tuluy-tuloy na daloy ng requests: ang bawat tanong ng user ay humihila ng 2–5K tokens ng LLM (ang mismong tanong plus ang mga nahanap na fragments ng context). Bilangin natin ang mga tipikal na volume at kung magkano ang gastos nito sa iba't ibang provider. Mga presyo ng Gonka sa pamamagitan ng JoinGonka Gateway: input ~$0.0069/1M, output ×3.

Sa libreng 3M tokens, maaari mong patakbuhin ang unang mga request ng RAG pipeline, i-index ang test corpus, at magpatakbo ng libu-libong requests — nang hindi gumagastos ng kahit sentimo. Sa mga production volume, ginagawang mura ng JoinGonka Gateway ang RAG mula sa pagiging mahal na serbisyo tungo sa isang gastusin na halos hindi mo mapapansin.

Ang LlamaIndex ay hindi lang marunong sumagot base sa mga dokumento, kundi marunong din bumuo ng mga agent na may mga tool. Lahat ng tatlong modelo ng Gonka ay sumusuporta sa native tool calling — ang mga agent ay nag-iinvoke 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="Isa kang kapaki-pakinabang na assistant. Gumamit ng mga tool para sa mga kalkulasyon.",
)

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

asyncio.run(main())

Pagpili ng modelo (field na model at kaukulang mga limit na context_window / max_tokens):

Ang limit na max_tokens sa pamamagitan ng Gateway ay hanggang 8192 para sa MiniMax M2.7 at GLM-5.3 Flash, hanggang 32768 para sa DeepSeek V4 Flash. Kung ang max_tokens ay hindi naka-set para sa non-streaming request, default na babalik ito ng hanggang 1500 tokens — para sa mga RAG response at agent steps, i-set nang malinaw ang value.

TypeScript: para sa LlamaIndex.TS, may mirror path — ang class na OpenAI mula sa package na @llamaindex/openai ay tumatanggap ng baseURL at apiKey (o nagbabasa ng mga variable na OPENAI_BASE_URL / OPENAI_API_KEY), kaya ang parehong Gateway ay maaari ring ikonekta sa Node.js stack. Kung gumagawa ka ng AI application at nasa Python framework, tingnan din ang guide sa LangChain.