LlamaIndex + Gonka AI — aplikacje RAG za grosze

Klucz API JoinGonka: zarejestruj się na gate.joingonka.ai/register — na start dajemy 10M darmowych tokenów — i utwórz klucz jg-xxx w Dashboardzie.

Instalacja:

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

Dla dowolnego API kompatybilnego z OpenAI, LlamaIndex udostępnia klasę OpenAILike z pakietu llama_index.llms.openai_like. Minimalny przykład zapytania do Gonka:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-twój-klucz",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # Gonka to chat-endpoint
    is_function_calling_model=True, # natywne wywołania narzędzi są obsługiwane
    context_window=131072,         # 128K dla Qwen3-235B
    max_tokens=8192,               # limit wyjścia przez Gateway (Qwen)
)

response = llm.complete("Wyjaśnij, czym jest RAG, w trzech zdaniach.")
print(response)

Ważne o OpenAILike: koniecznie ustaw is_chat_model=True — w przeciwnym razie LlamaIndex przejdzie do endpointu uzupełniania, którego u nas nie ma. is_function_calling_model=True włącza natywne wywołania narzędzi. Ustaw context_window zgodnie z modelem, aby LlamaIndex poprawnie dzielił kontekst.

Klasyczny scenariusz LlamaIndex to indeksowanie dokumentów i wykonywanie zapytań za pomocą query_engine. Globalny LLM jest ustawiany raz poprzez Settings.llm, a następnie cały potok automatycznie używa 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 przez Gonka (raz — globalnie)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-twój-klucz",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    max_tokens=8192,
)

# 2. Lokalne osadzenia (darmowe, bez OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Ładowanie i indeksowanie dokumentów z folderu ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Zapytanie do bazy wiedzy
query_engine = index.as_query_engine()
response = query_engine.query("O czym jest ten dokument?")
print(response)

Krytyczny niuans dotyczący osadzeń: domyślnie VectorStoreIndex używa osadzeń OpenAI (text-embedding-ada-002) — są to oddzielne płatne wywołania do OpenAI, a nie do Gonka. Aby całkowicie odłączyć się od OpenAI, ustaw lokalny model osadzeń poprzez Settings.embed_model (jak w przykładzie powyżej — HuggingFaceEmbedding, pakiet pip install llama-index-embeddings-huggingface). Wtedy generowanie odbywa się przez Gonka, a wektoryzacja — lokalnie i za darmo.

Koszt: jedno zapytanie w potoku RAG (wyszukiwanie + generacja) zużywa ~2–5K tokenów LLM. Przez Gonka to ułamki centa; przez OpenAI/Anthropic — 3–4 rzędy wielkości drożej. W przypadku tysięcy zapytań dziennie różnica zamienia się w dziesiątki tysięcy dolarów oszczędności miesięcznie.

Aplikacja RAG to nie jednorazowy czat, ale stały strumień zapytań: każde pytanie użytkownika pociąga za sobą 2–5 tys. tokenów LLM (samo pytanie plus znalezione fragmenty kontekstu). Obliczmy typowe wolumeny i ich koszt u różnych dostawców. Ceny Gonka przez JoinGonka Gateway: wejście ~$0.0005/1M, wyjście ×3.

Na darmowych 10M tokenów można dostroić cały potok RAG, zaindeksować korpus testowy i wykonać tysiące zapytań — i nie wydać ani centa. Na wolumenach produkcyjnych JoinGonka Gateway zamienia RAG z drogiej usługi w pozycję kosztów, którą można w ogóle nie zauważać.

LlamaIndex potrafi nie tylko odpowiadać na podstawie dokumentów, ale także budować agenty z narzędziami. Wszystkie trzy modele Gonka obsługują natywne wywołania narzędzi — agenci wywołują funkcje w sposób ustrukturyzowany, bez parsowania tekstu. Przykład agenta z narzędziem:

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-twój-klucz",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=131072,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """Mnoży dwie liczby."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Jesteś pomocnym asystentem. Do obliczeń używaj narzędzi.",
)

async def main():
    result = await agent.run("Ile to 1234 razy 5678?")
    print(result)

asyncio.run(main())

Wybór modelu (pole model i odpowiednie limity context_window / max_tokens):

Limit max_tokens przez Gateway — do 8192 dla modelu Qwen3; dla Kimi i MiniMaxa odpowiednio 3072 i 4096. Jeśli max_tokens nie jest ustawiony dla żądania niestrumieniowego, domyślnie zostanie zwrócone do 1500 tokenów — dla odpowiedzi RAG i kroków agenta ustaw wartość jawnie.

TypeScript: dla LlamaIndex.TS istnieje lustrzana ścieżka — klasa OpenAI z pakietu @llamaindex/openai przyjmuje baseURL i apiKey (lub odczytuje zmienne OPENAI_BASE_URL / OPENAI_API_KEY), więc ten sam Gateway łączy się również w stosie Node.js. Jeśli budujesz aplikacje AI również na frameworkach Python, sprawdź również przewodnik po LangChain.