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

Clé API JoinGonka : inscrivez-vous sur gate.joingonka.ai/register — nous vous offrons 10M de tokens gratuits au départ — 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 via le package llama_index.llms.openai_like. 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-cle",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka est un chat-endpoint
    is_function_calling_model=True, # tool calling natif supporté
    context_window=200000,         # 200K pour les modèles du réseau
    max_tokens=8192,               # limite de sortie via Gateway
)

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

Important concernant OpenAILike : spécifiez impérativement is_chat_model=True — sinon LlamaIndex tentera d'utiliser un completion-endpoint que nous ne proposons pas. is_function_calling_model=True active le tool calling natif. Définissez context_window selon le modèle pour que LlamaIndex segmente 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 utilisateur consomme 2 à 5K tokens LLM (la question elle-même plus les fragments de contexte trouvés). Calculons les volumes typiques et leurs coûts sur différents fournisseurs. Tarifs Gonka via JoinGonka Gateway : entrée ~0,003 $ / 1M, sortie ×3.

Avec les 10M de tokens gratuits, vous pouvez déboguer l'ensemble du pipeline RAG, indexer un corpus de test et lancer des milliers de requêtes sans dépenser un centime. En volume de production, JoinGonka Gateway transforme le RAG d'un service coûteux en une ligne de dépense quasi négligeable.

LlamaIndex sait non seulement répondre à partir de documents, mais aussi construire des agents avec des outils. Les deux modèles Gonka supportent le tool calling natif — les agents appellent des fonctions de manière structurée, sans parsing 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-cle",
    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 context_window / max_tokens correspondantes) :

La limite max_tokens via Gateway est jusqu'à 8192 pour tous les modèles du réseau. Si max_tokens n'est pas spécifié pour une requête non-streaming, 1500 tokens seront renvoyés par défaut — pour les réponses RAG et les étapes d'agent, définissez explicitement la valeur.

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