LlamaIndex + Gonka AI — Aplicaciones RAG por centavos

Clave API de JoinGonka: regístrese en gate.joingonka.ai/register —al inicio le damos 3M de tokens gratuitos— y cree 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 proporciona la clase OpenAILike del paquete llama_index.llms.openai_like. Ejemplo mínimo de solicitud a Gonka:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-su-clave",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka es un endpoint de chat
    is_function_calling_model=True, # tool calling nativo soportado
    context_window=200000,         # 200K en los modelos de la red
    max_tokens=8192,               # límite de salida a través del Gateway
)

response = llm.complete("Explica qué es RAG en tres oraciones.")
print(response)

Importante sobre OpenAILike: asegúrese de especificar is_chat_model=True, de lo contrario, LlamaIndex irá al endpoint de finalización, que no tenemos. is_function_calling_model=True habilita los tool calls nativos. Establezca context_window según el modelo para que LlamaIndex procese el contexto correctamente.

Un escenario clásico de LlamaIndex es un índice sobre sus documentos y consultas a través de query_engine. La LLM global se establece una vez a través de 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 a través de Gonka (una vez - globalmente)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-tu-clave",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,
    context_window=200000,
    max_tokens=8192,
)

# 2. Embeddings locales (gratis, sin OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Carga e indexación de documentos desde la carpeta ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Consulta a la base de conocimiento
query_engine = index.as_query_engine()
response = query_engine.query("¿De qué trata este documento?")
print(response)

Matiz crítico sobre embeddings: por defecto, VectorStoreIndex utiliza embeddings de OpenAI (text-embedding-ada-002), lo cual implica llamadas de pago separadas a OpenAI, no a Gonka. Para dejar de depender de OpenAI, configure un modelo de embeddings local a través de Settings.embed_model (como en el ejemplo anterior: HuggingFaceEmbedding, paquete pip install llama-index-embeddings-huggingface). Entonces, la generación se realiza a través de Gonka y la vectorización localmente y gratis.

Costo: una solicitud de pipeline RAG (búsqueda + generación) consume ~2–5K tokens de LLM. A través de Gonka esto es una fracción de centavo; a través de OpenAI/Anthropic es 3–4 órdenes de magnitud más caro. Con miles de solicitudes al día, la diferencia se convierte en decenas de miles de dólares de ahorro al mes.

Una aplicación RAG no es un chat de una sola vez, sino un flujo constante de solicitudes: cada pregunta del usuario consume de 2 a 5K tokens de LLM (la pregunta en sí más los fragmentos de contexto encontrados). Calculemos los volúmenes típicos y cuánto cuestan en diferentes proveedores. Precios de Gonka a través de JoinGonka Gateway: entrada ~$0.0069/1M, salida ×3.

Con los 3M tokens gratuitos, puede ejecutar las primeras solicitudes del pipeline RAG, indexar un corpus de prueba y realizar miles de consultas sin gastar un centavo. En volúmenes de producción, JoinGonka Gateway convierte a RAG de un servicio costoso en un gasto que ni siquiera notará.

LlamaIndex no solo sabe responder a documentos, sino también crear agentes con herramientas. Los tres modelos Gonka soportan tool calling nativo: los agentes llaman a funciones de forma estructurada, sin analizar texto. Ejemplo de agente con 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-tu-clave",
    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:
    """Multiplica dos números."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Eres un asistente útil. Usa herramientas para cálculos.",
)

async def main():
    result = await agent.run("¿Cuánto es 1234 multiplicado por 5678?")
    print(result)

asyncio.run(main())

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

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

TypeScript: para LlamaIndex.TS hay una ruta espejo: la clase OpenAI del paquete @llamaindex/openai acepta baseURL y apiKey (o lee las variables OPENAI_BASE_URL / OPENAI_API_KEY), por lo que el mismo Gateway se conecta también en la pila Node.js. Si construye aplicaciones AI con frameworks de Python, consulte también la guía de LangChain.