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

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

Installation:

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

Für eine beliebige OpenAI-kompatible API bietet LlamaIndex die OpenAILike-Klasse aus dem Paket llama_index.llms.openai_like. 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-schluessel",
    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 Netzwerkmodellen
    max_tokens=8192,               # Ausgabelimit über Gateway
)

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

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

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 Strom von Anfragen: Jede Benutzerfrage zieht 2–5K LLM-Token nach sich (die Frage selbst plus die gefundenen Kontextfragmente). Berechnen wir die typischen Volumina und die Kosten bei verschiedenen Anbietern. Gonka-Preise über das JoinGonka Gateway: Eingabe ~$0,003/1M, Ausgabe ×3.

Mit 10M kostenlosen Token können Sie die gesamte RAG-Pipeline debuggen, den Testkorpus indizieren und Tausende von Anfragen ausführen — ohne einen Cent auszugeben. Bei Produktionsmengen verwandelt das JoinGonka Gateway RAG von einem teuren Dienst in einen Kostenpunkt, den Sie kaum bemerken werden.

LlamaIndex kann nicht nur Dokumente beantworten, sondern auch Agenten mit Tools aufbauen. Beide 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-ihr-schluessel",
    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. Nutze Tools für Berechnungen.",
)

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

asyncio.run(main())

Modellauswahl (Feld model und entsprechende Limits context_window / max_tokens):

Das max_tokens-Limit über das Gateway beträgt bis zu 8192 für alle Modelle im Netzwerk. Wenn max_tokens für eine Nicht-Streaming-Anfrage nicht festgelegt ist, werden standardmäßig bis zu 1500 Token zurückgegeben — für RAG-Antworten und Agenten-Schritte setzen Sie den Wert bitte explizit.

TypeScript: Für LlamaIndex.TS gibt es den analogen Weg — die OpenAI Klasse 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-Applikationen auch auf Python-Frameworks aufbauen, schauen Sie sich auch den Leitfaden zu LangChain an.