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

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

Installation :

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

Pour toute API compatible OpenAI, LlamaIndex fournit la classe OpenAILike du paquet llama_index.llms.openai_like. Exemple minimal de requête vers Gonka :

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-votre-clé",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka est un endpoint de chat
    is_function_calling_model=True, # tool calling natif supporté
    context_window=200000,         # 200K pour les modèles du réseau
    max_tokens=8192,               # plafond de sortie via Gateway
)

response = llm.complete("Explique ce qu'est le RAG en trois phrases.")
print(response)

Important concernant OpenAILike : assurez-vous d'indiquer is_chat_model=True — sinon LlamaIndex cherchera un endpoint de complétion, que nous n'avons pas. is_function_calling_model=True active les tool calls natifs. Configurez context_window selon le modèle pour que LlamaIndex découpe correctement le contexte.

Le scénario classique de LlamaIndex est la création d'un index sur vos documents et les requêtes via un query_engine. La LLM globale est configurée une 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-cle",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=200000,
    max_tokens=8192,
)

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

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

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

Nuance critique sur les embeddings : par défaut, VectorStoreIndex utilise les embeddings d'OpenAI (text-embedding-ada-002) — il s'agit d'appels payants distincts vers OpenAI, et non vers Gonka. Pour vous affranchir totalement d'OpenAI, configurez 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 se fait alors via Gonka, et la vectorisation localement et gratuitement.

Coût : une requête de pipeline RAG (recherche + génération) consomme ~2–5K tokens LLM. Via Gonka, cela ne représente qu'une fraction de centime ; via OpenAI/Anthropic — c'est 3 à 4 ordres de grandeur plus cher. Sur un flux de milliers de requêtes par jour, la différence représente des dizaines de milliers de dollars d'économie par mois.

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

Avec les 3M jetons gratuits, vous pouvez effectuer les premières requêtes de votre pipeline RAG, indexer un corpus de test et lancer des milliers de requêtes — sans dépenser un centime. Sur les volumes de production, JoinGonka Gateway transforme le RAG d'un service coûteux en une ligne de dépense que vous ne remarquerez même pas.

LlamaIndex sait non seulement répondre à partir de documents, mais aussi construire des agents avec des outils. Les trois modèles Gonka supportent le tool calling 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="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:
    """Multiplie deux nombres."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Tu es un assistant utile. Utilise des 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 MiniMax M2.7 et GLM-5.3 Flash, et jusqu'à 32768 pour DeepSeek V4 Flash. Si max_tokens n'est pas défini pour une requête non-streaming, 1500 jetons seront retournés par défaut — pour les réponses RAG et les étapes d'agent, spécifiez explicitement la valeur.

TypeScript : pour LlamaIndex.TS, il existe une méthode 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 le même Gateway peut être connecté dans la pile Node.js. Si vous construisez des applications AI avec des frameworks Python, consultez également le guide sur LangChain.