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 tokens gratuits pour démarrer — puis 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 met à disposition 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka is a chat endpoint
    is_function_calling_model=True, # native tool calling is supported
    context_window=180000,         # MiniMax M2.7 context window
    max_tokens=8192,               # Gateway output cap
)

response = llm.complete("Explain what RAG is in three sentences.")
print(response)

Important concernant OpenAILike : indiquez impérativement is_chat_model=True — sinon LlamaIndex se tournera vers l'endpoint Completions obsolète avec un prompt brut au lieu d'un dialogue. is_function_calling_model=True active les appels d'outils natifs. Réglez context_window selon le modèle pour que LlamaIndex découpe correctement le contexte.

Le scénario classique de LlamaIndex : un index de vos documents et des requêtes via query_engine. Le LLM global se définit 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 (set once, globally)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=180000,
    max_tokens=8192,
)

# 2. Local embeddings (free, no OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Load and index documents from the ./data folder
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Query the knowledge base
query_engine = index.as_query_engine()
response = query_engine.query("What is this document about?")
print(response)

Un détail crucial concernant les embeddings : par défaut, VectorStoreIndex utilise les embeddings OpenAI (text-embedding-ada-002) — ce sont des appels payants distincts vers OpenAI, et non vers Gonka. Pour vous affranchir totalement d'OpenAI, définissez un modèle d'embeddings local via Settings.embed_model (comme dans l'exemple ci-dessus — HuggingFaceEmbedding, paquet pip install llama-index-embeddings-huggingface). La génération passe alors par Gonka, tandis que la vectorisation se fait en local et gratuitement.

Coût : une requête d'un pipeline RAG (recherche + génération) consomme environ 2 à 5 K tokens LLM. Via Gonka, cela représente des fractions 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 se traduit par des dizaines de milliers de dollars d'économies par mois.

Une application RAG, ce n'est pas un chat ponctuel, mais un flux constant de requêtes : chaque question d'un utilisateur entraîne 2 à 5K tokens de 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.0062/1M, sortie ×3.

Avec les 3M tokens offerts, vous pouvez lancer les premières requêtes de votre pipeline RAG, indexer un corpus de test et faire tourner des milliers de requêtes — sans dépenser un centime. À l'échelle de la production, JoinGonka Gateway transforme le RAG d'un service coûteux en une ligne de dépenses que vous pouvez ignorer complètement.

LlamaIndex ne se contente pas de répondre à partir de documents : il permet aussi de construire des agents dotés d'outils. Les trois modèles Gonka prennent en charge le tool calling natif — les agents appellent les 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=180000,
    max_tokens=8192,
)

def multiply(a: float, b: float) -> float:
    """Multiplies two numbers."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="You are a helpful assistant. Use the tools for calculations.",
)

async def main():
    result = await agent.run("What is 1234 multiplied by 5678?")
    print(result)

asyncio.run(main())

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

La limite max_tokens via le Gateway va jusqu'à 8192 pour MiniMax M2.7 et GLM-5.3 Flash, jusqu'à 32768 pour DeepSeek V4 Flash. Si max_tokens n'est pas défini pour une requête non-streaming, jusqu'à 1500 tokens sont renvoyés par défaut — pour les réponses RAG et les étapes d'agents, indiquez la valeur explicitement.

TypeScript : pour LlamaIndex.TS, il existe un chemin miroir — la classe OpenAI du paquet @llamaindex/openai accepte baseURL et apiKey (ou lit les variables OPENAI_BASE_URL / OPENAI_API_KEY), si bien que le même Gateway s'intègre aussi à une stack Node.js. Si vous développez des applications d'IA également avec des frameworks Python, consultez aussi le guide LangChain.