LlamaIndex + Gonka AI — Applications RAG pour une bouchée de pain

Clé API JoinGonka : inscrivez-vous sur gate.joingonka.ai/register — nous vous offrons 10 millions de jetons gratuits au démarrage — et créez une clé jg-xxx dans le tableau de bord.

Installation :

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

Pour toute API compatible OpenAI arbitraire, LlamaIndex fournit la classe OpenAILike du package llama_index.llms.openai_like. Un exemple minimal de requête à Gonka :

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-votre-clé",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # Gonka est un point de terminaison de chat
    is_function_calling_model=True, # l'appel de fonctions natif est pris en charge
    context_window=131072,         # 128K pour Qwen3-235B
    max_tokens=8192,               # plafond de sortie via Gateway (Qwen)
)

response = llm.complete("Expliquez le RAG en trois phrases.")
print(response)

Important pour OpenAILike : assurez-vous de spécifier is_chat_model=True — sinon LlamaIndex ira vers le point de terminaison de complétion, que nous n'avons pas. is_function_calling_model=True active les appels d'outils natifs. Définissez context_window en fonction du modèle pour que LlamaIndex coupe correctement le contexte.

Un scénario classique de LlamaIndex est un index de vos documents et des requêtes via query_engine. Le LLM global est défini une seule fois via Settings.llm, puis tout le pipeline utilise Gonka automatiquement.

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 (une seule fois - globalement)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-votre-clé",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    max_tokens=8192,
)

# 2. Embeddings locaux (gratuits, sans OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Chargement et indexation des documents du dossier ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Requête à la base de connaissances
query_engine = index.as_query_engine()
response = query_engine.query("De quoi parle ce document ?")
print(response)

Nuance critique concernant les embeddings : par défaut, VectorStoreIndex utilise les embeddings OpenAI (text-embedding-ada-002) — ce sont des appels payants distincts à OpenAI, et non à Gonka. Pour vous affranchir complètement d'OpenAI, définissez un modèle d'embeddings local via Settings.embed_model (comme dans l'exemple ci-dessus — HuggingFaceEmbedding, package pip install llama-index-embeddings-huggingface). La génération passera alors par Gonka, et la vectorisation sera locale et gratuite.

Coût : une requête de pipeline RAG (recherche + génération) consomme environ 2 à 5 000 jetons LLM. Via Gonka, cela représente des fractions de cent ; via OpenAI/Anthropic — 3 à 4 ordres de grandeur plus cher. Pour un flux de milliers de requêtes par jour, la différence se traduit par des dizaines de milliers de dollars d'économies par mois.

Une application RAG n'est pas un chat ponctuel, mais un flux constant de requêtes : chaque question d'utilisateur entraîne 2 à 5K jetons LLM (la question elle-même plus les fragments de contexte trouvés). Calculons les volumes typiques et leur coût chez différents fournisseurs. Prix Gonka via JoinGonka Gateway : entrée ~0,0005 $/1M, sortie ×3.

Avec les 10 millions de jetons gratuits, vous pouvez déboguer l'ensemble du pipeline RAG, indexer un corpus de test et exécuter des milliers de requêtes, sans dépenser un centime. À des volumes de production, JoinGonka Gateway transforme le RAG d'un service coûteux en une dépense négligeable.

LlamaIndex sait non seulement répondre aux documents, mais aussi construire des agents avec des outils. Les trois modèles Gonka prennent en charge l'appel d'outils natif — les agents appellent des fonctions de manière structurée, sans analyse de texte. Exemple d'agent avec un outil :

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-votre-clé",
    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:
    """Multiplie deux nombres."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Vous êtes un assistant utile. Utilisez les outils pour les calculs.",
)

async def main():
    result = await agent.run("Combien font 1234 multiplié par 5678 ?")
    print(result)

asyncio.run(main())

Choix du modèle (champ model et limites correspondantes context_window / max_tokens) :

La limite max_tokens via Gateway est jusqu'à 8192 pour le modèle Qwen3 ; pour Kimi et MiniMax, spécifiez 3072 et 4096 respectivement. Si max_tokens n'est pas défini pour une requête non-stream, par défaut, jusqu'à 1500 jetons seront renvoyés — pour les réponses RAG et les étapes d'agent, définissez la valeur explicitement.

TypeScript : pour LlamaIndex.TS, il existe un chemin miroir — la classe OpenAI du package @llamaindex/openai accepte baseURL et apiKey (ou lit les variables OPENAI_BASE_URL / OPENAI_API_KEY), de sorte que la même passerelle se connecte également à la pile Node.js. Si vous construisez des applications AI avec des frameworks Python, consultez également le guide sur LangChain.