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

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

Pag-install:

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

Para sa anumang OpenAI-compatible na API, nagbibigay ang LlamaIndex ng class na OpenAILike mula sa package na llama_index.llms.openai_like. Pinakamaliit 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka is a chat endpoint
    is_function_calling_model=True, # native tool calling is supported
    context_window=180000,         # MiniMax M2.7 context window
    max_tokens=8192,               # Gateway output cap
)

response = llm.complete("Explain what RAG is in three sentences.")
print(response)

Mahalaga tungkol sa OpenAILike: siguraduhing itakda ang is_chat_model=True — kung hindi, pupunta ang LlamaIndex sa lumang Completions endpoint na may raw na prompt sa halip na usapan. Ang is_function_calling_model=True ay nagpapagana ng native na tool calls. Itakda ang context_window ayon sa modelo para tama ang paghahati ng context ng LlamaIndex.

Ang klasikong senaryo ng LlamaIndex — index sa iyong mga dokumento at mga query dito gamit ang query_engine. Ang global na LLM ay itinatakda nang isang beses sa pamamagitan ng Settings.llm, 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 via Gonka (set once, globally)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=180000,
    max_tokens=8192,
)

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

# 3. Load and index documents from the ./data folder
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Query the knowledge base
query_engine = index.as_query_engine()
response = query_engine.query("What is this document about?")
print(response)

Kritikal na detalye tungkol sa embeddings: bilang default, gumagamit ang VectorStoreIndex ng embeddings ng OpenAI (text-embedding-ada-002) — ito ay hiwalay na bayad na mga tawag sa OpenAI, hindi sa Gonka. Para tuluyang umiwas sa OpenAI, itakda ang lokal na embedding model sa pamamagitan ng Settings.embed_model (tulad ng nasa halimbawa sa itaas — HuggingFaceEmbedding, package na pip install llama-index-embeddings-huggingface). Sa ganoon, ang generation ay dumadaan sa Gonka, habang ang vectorization ay lokal at libre.

Gastos: ang isang query ng RAG pipeline (paghahanap + generation) ay gumagamit ng ~2–5K token ng LLM. Sa Gonka, ito ay maliit na bahagi lamang ng isang sentimo; sa OpenAI/Anthropic — mas mahal nang 3–4 na order ng magnitude. Sa daloy na libu-libong query kada araw, ang pagkakaiba ay nagiging sampu-sampung libong dolyar na matitipid kada buwan.

Ang isang RAG application ay hindi isang minsanang chat, kundi isang tuloy-tuloy na daloy ng mga request: bawat tanong ng user ay may kasamang 2–5K token ng LLM (ang tanong mismo at ang mga nahanap na fragment ng context). Bilangin natin ang mga tipikal na volume at magkano ang gastos sa iba't ibang provider. Mga presyo ng Gonka sa pamamagitan ng JoinGonka Gateway: input ~$0.0062/1M, output ×3.

Sa libreng 3M token, maaari mong patakbuhin ang mga unang request ng RAG pipeline, i-index ang test corpus, at magpatakbo ng libu-libong request — nang walang ginastos kahit isang sentimo. Sa production volumes, ginagawang hindi kapansin-pansing gastusin ng JoinGonka Gateway ang RAG mula sa isang mamahaling serbisyo.

Ang LlamaIndex ay hindi lamang sumasagot base sa mga dokumento — nakakabuo rin ito ng mga agent na may mga tool. Lahat ng tatlong modelo ng Gonka ay sumusuporta sa native na tool calling — ang mga agent ay tumatawag ng mga function nang structured, walang pag-parse ng teksto. 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=180000,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """Multiplies two numbers."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="You are a helpful assistant. Use the tools for calculations.",
)

async def main():
    result = await agent.run("What is 1234 multiplied by 5678?")
    print(result)

asyncio.run(main())

Pagpili ng modelo (ang field na model at ang kaukulang mga limitasyon sa context_window / max_tokens):

Ang limitasyon ng max_tokens sa Gateway — 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 itinakda para sa non-streaming na kahilingan, bilang default ay hanggang 1500 token ang ibabalik — para sa mga RAG na sagot at hakbang ng agent, itakda ito nang malinaw.

TypeScript: para sa LlamaIndex.TS may katumbas na paraan — ang klase 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 makakonekta rin sa Node.js stack. Kung gagawa ka ng AI na aplikasyon gamit ang Python frameworks, tingnan din ang gabay sa LangChain.