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

JoinGonka API-Schlüssel: Registrieren Sie sich unter gate.joingonka.ai/register – wir geben Ihnen 10 Mio. kostenlose Token zum Start – und erstellen Sie einen Schlüssel 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. Ein 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-Schlüssel",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # Gonka ist ein Chat-Endpunkt
    is_function_calling_model=True, # native Tool-Aufrufe werden unterstützt
    context_window=131072,         # 128K bei Qwen3-235B
    max_tokens=8192,               # Ausgabeschwellenwert über Gateway (Qwen)
)

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

Wichtig zu OpenAILike: Geben Sie unbedingt is_chat_model=True an – andernfalls geht LlamaIndex zum Completion-Endpunkt, den wir nicht haben. is_function_calling_model=True aktiviert native Tool-Aufrufe. Stellen Sie context_window entsprechend dem Modell ein, damit LlamaIndex den Kontext korrekt aufteilt.

Ein klassisches LlamaIndex-Szenario ist ein Index für Ihre Dokumente und Abfragen, die über query_engine an diesen Index gesendet werden. Die globale LLM wird einmal über Settings.llm festgelegt, danach verwendet 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 über Gonka (einmal – global)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-Ihr-Schlüssel",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    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. Abfrage der 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 vermeiden, legen Sie ein lokales Embeddings-Modell über Settings.embed_model fest (wie im obigen Beispiel – HuggingFaceEmbedding, Paket pip install llama-index-embeddings-huggingface). Dann erfolgt die Generierung über Gonka und die Vektorisierung lokal und kostenlos.

Kosten: Eine Anfrage an die RAG-Pipeline (Suche + Generierung) verbraucht ~2–5K LLM-Token. Über Gonka sind das Bruchteile von Cents; über OpenAI/Anthropic – 3–4 Größenordnungen teurer. Bei täglich Tausenden von Anfragen wird der Unterschied zu Zehntausenden von Dollar Einsparungen pro Monat.

Eine RAG-Anwendung ist kein einmaliger Chat, sondern ein ständiger Strom von Anfragen: Jede Benutzerfrage zieht 2–5K LLM-Token nach sich (die Frage selbst plus gefundene Kontextfragmente). Berechnen wir typische Volumina und deren Kosten bei verschiedenen Anbietern. Gonka-Preise über JoinGonka Gateway: Eingabe ~0,0005 $/1 Mio., Ausgabe ×3.

Mit den 10 Mio. kostenlosen Token können Sie die gesamte RAG-Pipeline debuggen, einen Testkorpus indizieren und Tausende von Anfragen ausführen – ohne einen Cent auszugeben. Bei Produktionsvolumen verwandelt JoinGonka Gateway RAG von einem teuren Dienstposten in einen Ausgabenposten, der überhaupt nicht auffällt.

LlamaIndex kann nicht nur Dokumente beantworten, sondern auch Agenten mit Tools erstellen. Alle drei Gonka-Modelle unterstützen native Tool-Aufrufe – Agenten rufen Funktionen strukturiert auf, ohne Text zu parsen. 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-Ihr-Schlüssel",
    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:
    """Multipliziert zwei Zahlen."""
    return a * b

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

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

asyncio.run(main())

Modellwahl (Feld model und entsprechende Grenzwerte context_window / max_tokens):

Das Limit von max_tokens über das Gateway beträgt bis zu 8192 für das Qwen3-Modell; für Kimi und MiniMax geben Sie 3072 bzw. 4096 an. Wenn max_tokens für eine Nicht-Streaming-Anfrage nicht angegeben ist, werden standardmäßig bis zu 1500 Token zurückgegeben – legen Sie den Wert für RAG-Antworten und Agentenschritte explizit fest.

TypeScript: Für LlamaIndex.TS gibt es einen spiegelbildlichen Pfad – 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 KI-Anwendungen auch auf Python-Frameworks erstellen, sehen Sie sich auch den Leitfaden zu LangChain an.