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

JoinGonka API-Key: Registrieren Sie sich unter gate.joingonka.ai/register — wir geben zum Start 3M kostenlose Token — und erstellen Sie einen Key jg-xxx im Dashboard.

Installation:

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

Für eine beliebige OpenAI-kompatible API stellt LlamaIndex die Klasse OpenAILike aus dem Paket llama_index.llms.openai_like bereit. Minimales Beispiel für eine Anfrage an Gonka:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-ihr-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka ist ein Chat-Endpoint
    is_function_calling_model=True, # natives Tool Calling wird unterstützt
    context_window=200000,         # 200K bei Netzmodellen
    max_tokens=8192,               # Ausgabe-Limit über Gateway
)

response = llm.complete("Erkläre kurz, was RAG ist, in drei Sätzen.")
print(response)

Wichtig für OpenAILike: Geben Sie unbedingt is_chat_model=True an — sonst greift LlamaIndex auf den Completion-Endpoint zu, den wir nicht haben. is_function_calling_model=True aktiviert natives Tool Calling. Setzen Sie context_window entsprechend dem Modell, damit LlamaIndex den Kontext korrekt schneidet.

Ein klassisches LlamaIndex-Szenario ist ein Index über Ihre Dokumente und Anfragen dazu über den query_engine. Die globale LLM wird einmal über Settings.llm festgelegt, danach nutzt die gesamte Pipeline Gonka automatisch.

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 über Gonka (global einmalig)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-ihr-schluessel",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=200000,
    max_tokens=8192,
)

# 2. Lokale Embeddings (kostenlos, ohne OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Laden und Indizieren von Dokumenten aus dem Ordner ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Anfrage an die Wissensdatenbank
query_engine = index.as_query_engine()
response = query_engine.query("Worum geht es in diesem Dokument?")
print(response)

Kritischer Hinweis zu Embeddings: Standardmäßig verwendet VectorStoreIndex OpenAI-Embeddings (text-embedding-ada-002) — dies sind separate kostenpflichtige Aufrufe an OpenAI und nicht an Gonka. Um OpenAI vollständig zu umgehen, setzen Sie ein lokales Embedding-Modell über Settings.embed_model (wie im Beispiel oben — HuggingFaceEmbedding, Paket pip install llama-index-embeddings-huggingface). Dann erfolgt die Generierung über Gonka und die Vektorisierung lokal und kostenlos.

Kosten: Eine RAG-Pipeline-Anfrage (Suche + Generierung) verbraucht ~2–5K LLM-Token. Über Gonka sind das Bruchteile eines Cents; über OpenAI/Anthropic ist es um 3–4 Größenordnungen teurer. Bei tausenden Anfragen täglich summiert sich der Unterschied auf zehntausende Dollar Ersparnis pro Monat.

Eine RAG-Anwendung ist kein einmaliger Chat, sondern ein ständiger Datenstrom von Anfragen: Jede Nutzerfrage zieht 2–5K LLM-Token nach sich (die Frage selbst plus die gefundenen Kontextfragmente). Wir berechnen die typischen Mengen und was diese bei verschiedenen Anbietern kosten. Gonka-Preise über JoinGonka Gateway: Input ~$0.0069/1M, Output ×3.

Mit den kostenlosen 3M Token können Sie die ersten RAG-Pipeline-Anfragen durchführen, den Testkorpus indizieren und Tausende von Abfragen ausführen — ohne einen Cent auszugeben. Bei Produktionsmengen verwandelt das JoinGonka Gateway RAG von einem teuren Dienst in eine Kostenstelle, die kaum ins Gewicht fällt.

LlamaIndex kann nicht nur auf Basis von Dokumenten antworten, sondern auch Agenten mit Werkzeugen erstellen. Alle drei Gonka-Modelle unterstützen natives Tool Calling — Agenten rufen Funktionen strukturiert auf, ohne Text-Parsing. Beispiel für einen Agenten mit Werkzeug:

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-ihr-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:
    """Multipliziert zwei Zahlen."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Du bist ein hilfreicher Assistent. Verwende für Berechnungen Werkzeuge.",
)

async def main():
    result = await agent.run("Was ist 1234 multipliziert mit 5678?")
    print(result)

asyncio.run(main())

Modellwahl (Feld model und entsprechende Limits für context_window / max_tokens):

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

TypeScript: Für LlamaIndex.TS gibt es einen analogen 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 angeschlossen werden kann. Wenn Sie AI-Anwendungen auch in Python-Frameworks bauen, werfen Sie auch einen Blick in den Leitfaden zu LangChain.