LlamaIndex + Gonka AI – RAG-Anwendungen für kleines Geld

JoinGonka-API-Schlüssel: Registriere dich auf gate.joingonka.ai/register — zum Start gibt es 3M kostenlose Token — und erstelle einen Schlüssel jg-xxx im Dashboard.

Installation:

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

Für beliebige OpenAI-kompatible APIs stellt LlamaIndex die Klasse OpenAILike aus dem Paket llama_index.llms.openai_like bereit. Ein minimales Anfragebeispiel an 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)

Wichtig zu OpenAILike: Setze unbedingt is_chat_model=True — sonst greift LlamaIndex auf den veralteten Completions-Endpunkt mit rohem Prompt statt Dialog zurück. is_function_calling_model=True aktiviert native Tool Calls. context_window solltest du passend zum Modell angeben, damit LlamaIndex den Kontext richtig aufteilt.

Das klassische LlamaIndex-Szenario — ein Index über Ihre Dokumente und Abfragen daran über query_engine. Die globale LLM wird einmalig über Settings.llm festgelegt, danach nutzt die gesamte Pipeline automatisch 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)

Ein entscheidender Punkt zu Embeddings: Standardmäßig verwendet VectorStoreIndex die Embeddings von OpenAI (text-embedding-ada-002) — das sind separate kostenpflichtige Aufrufe an OpenAI, nicht an Gonka. Um OpenAI vollständig zu umgehen, legen Sie ein lokales Embedding-Modell über Settings.embed_model fest (wie im obigen Beispiel — HuggingFaceEmbedding, Paket pip install llama-index-embeddings-huggingface). Dann läuft die Generierung über Gonka und die Vektorisierung lokal und kostenlos.

Kosten: Eine Abfrage einer RAG-Pipeline (Suche + Generierung) verbraucht ~2–5K LLM-Tokens. Über Gonka kostet das Bruchteile eines Cents; über OpenAI/Anthropic ist es um 3–4 Größenordnungen teurer. Bei einem Volumen von Tausenden Anfragen pro Tag summiert sich die Differenz zu Zehntausenden Dollar Ersparnis pro Monat.

Eine RAG-Anwendung ist kein einmaliger Chat, sondern ein stetiger Anfragenstrom: Jede Nutzerfrage zieht 2–5K LLM-Tokens nach sich (die Frage selbst plus die gefundenen Kontextfragmente). Rechnen wir die typischen Volumina durch und was sie bei verschiedenen Anbietern kosten. Gonka-Preise über das JoinGonka Gateway: Input ~$0.0062/1M, Output ×3.

Mit den kostenlosen 3M Tokens kannst du die ersten Anfragen der RAG-Pipeline durchlaufen lassen, ein Testkorpus indexieren und Tausende Anfragen absetzen – ohne einen Cent auszugeben. Bei Production-Volumina macht das JoinGonka Gateway RAG von einem teuren Service zu einem Kostenposten, den man gar nicht mehr bemerkt.

LlamaIndex kann nicht nur Dokumente beantworten, sondern auch Agenten mit Tools erstellen. Alle drei Gonka-Modelle unterstützen natives Tool Calling — Agenten rufen Funktionen strukturiert auf, ohne Text-Parsing. Beispiel eines Agenten mit einem 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())

Modellwahl (Feld model und die entsprechenden Limits context_window / max_tokens):

Das Limit für max_tokens über das Gateway liegt bei bis zu 8192 für MiniMax M2.7 und GLM-5.3 Flash, bei bis zu 32768 für DeepSeek V4 Flash. Wenn max_tokens für eine nicht-streamende Anfrage nicht gesetzt ist, werden standardmäßig bis zu 1500 Tokens zurückgegeben — für RAG-Antworten und Agenten-Schritte geben Sie den Wert explizit an.

TypeScript: Für LlamaIndex.TS gibt es einen spiegelsymmetrischen Weg — die Klasse OpenAI aus dem Paket @llamaindex/openai akzeptiert baseURL und apiKey (oder liest die Variablen OPENAI_BASE_URL / OPENAI_API_KEY), sodass dasselbe Gateway auch im Node.js-Stack angebunden wird. Wenn Sie KI-Anwendungen auch mit Python-Frameworks bauen, werfen Sie zudem einen Blick auf den Leitfaden zu LangChain.