LlamaIndex + Gonka AI — Aplicaciones RAG por centavos

Clave API de JoinGonka: regístrate en gate.joingonka.ai/register — al empezar te damos 3M tokens gratis — y crea una clave jg-xxx en el Dashboard.

Instalación:

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

Para cualquier API compatible con OpenAI, LlamaIndex ofrece la clase OpenAILike del paquete llama_index.llms.openai_like. Ejemplo mínimo de petición a 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)

Importante sobre OpenAILike: asegúrate de indicar is_chat_model=True — de lo contrario, LlamaIndex irá al endpoint obsoleto Completions con el prompt en bruto en lugar de un diálogo. is_function_calling_model=True habilita las llamadas a herramientas nativas. Configura context_window según el modelo para que LlamaIndex divida el contexto correctamente.

El escenario clásico de LlamaIndex: un índice sobre tus documentos y consultas a través de query_engine. La LLM global se define una sola vez mediante Settings.llm, y a partir de ahí todo el pipeline usa Gonka automáticamente.

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 detalle crítico sobre los embeddings: por defecto, VectorStoreIndex usa los embeddings de OpenAI (text-embedding-ada-002), que son llamadas de pago a OpenAI, no a Gonka. Para eliminar por completo la dependencia de OpenAI, define un modelo de embeddings local mediante Settings.embed_model (como en el ejemplo anterior: HuggingFaceEmbedding, paquete pip install llama-index-embeddings-huggingface). Así la generación pasa por Gonka y la vectorización se hace localmente y gratis.

Costo: una consulta de un pipeline RAG (búsqueda + generación) consume ~2–5K tokens de LLM. Con Gonka cuesta fracciones de centavo; con OpenAI/Anthropic es 3–4 órdenes de magnitud más caro. Con un flujo de miles de consultas al día, la diferencia se traduce en decenas de miles de dólares de ahorro al mes.

Una aplicación RAG no es un chat puntual, sino un flujo constante de solicitudes: cada pregunta del usuario arrastra consigo entre 2 y 5K tokens de LLM (la pregunta en sí más los fragmentos de contexto recuperados). Calculemos los volúmenes típicos y lo que cuestan en distintos proveedores. Precios de Gonka a través de JoinGonka Gateway: entrada ~$0.0062/1M, salida ×3.

Con los 3M tokens gratuitos puedes ejecutar las primeras solicitudes del pipeline RAG, indexar un corpus de prueba y lanzar miles de peticiones sin gastar ni un céntimo. En volúmenes de producción, JoinGonka Gateway convierte RAG de un servicio caro en una partida de gastos que puedes pasar por alto por completo.

LlamaIndex no solo responde sobre documentos: también permite construir agentes con herramientas. Los tres modelos de Gonka soportan tool calling nativo: los agentes llaman funciones de forma estructurada, sin parsear texto. Ejemplo de un agente con una herramienta:

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())

Elección del modelo (campo model y los límites correspondientes de context_window / max_tokens):

El límite de max_tokens a través del Gateway es de hasta 8192 para MiniMax M2.7 y GLM-5.3 Flash, y de hasta 32768 para DeepSeek V4 Flash. Si no se especifica max_tokens en una solicitud no streaming, por defecto se devuelven hasta 1500 tokens; para respuestas RAG y pasos de agentes, define el valor explícitamente.

TypeScript: para LlamaIndex.TS existe un camino equivalente: la clase OpenAI del paquete @llamaindex/openai acepta baseURL y apiKey (o lee las variables OPENAI_BASE_URL / OPENAI_API_KEY), así que el mismo Gateway también se conecta en un stack de Node.js. Si construyes aplicaciones de IA también con frameworks de Python, echa un vistazo a la guía de LangChain.