LlamaIndex + Gonka AI — Aplicaciones RAG por centavos

API-ключ JoinGonka: regístrese en gate.joingonka.ai/register — le damos 10M de tokens gratis al inicio — 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. Un 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-tu-clave",
    model="MiniMaxAI/MiniMax-M2.7",
    is_chat_model=True,            # Gonka es un endpoint de chat
    is_function_calling_model=True, # soporte nativo para tool calling
    context_window=200000,         # 200K en los modelos de la red
    max_tokens=8192,               # límite de salida a través de 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 accederá al endpoint de completion que no tenemos. is_function_calling_model=True habilita los tool calls nativos. Configure context_window según el modelo para que LlamaIndex segmente 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 puntual, sino un flujo constante de solicitudes: cada pregunta del usuario arrastra 2–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 varios proveedores. Precios de Gonka a través de JoinGonka Gateway: entrada ~$0.003/1M, salida ×3.

Con 10M de tokens gratuitos puede depurar todo el 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 el RAG de un servicio costoso a un gasto que ni siquiera notará.

LlamaIndex no solo puede responder basándose en documentos, sino también construir agentes con herramientas. Ambos modelos de Gonka soportan tool calling nativo: los agentes invocan funciones de manera estructurada, sin parsear texto. Ejemplo de 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-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 los 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 sus límites correspondientes de context_window / max_tokens):

El límite de max_tokens a través del Gateway es de hasta 8192 para todos los modelos de la red. Si max_tokens no se especifica para una solicitud no streaming, se devolverán por defecto hasta 1500 tokens; para respuestas RAG y pasos de agente, especifique el valor explícitamente.

TypeScript: para LlamaIndex.TS existe un camino paralelo: 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 puede conectar en el stack de Node.js. Si está construyendo aplicaciones de IA con frameworks de Python, consulte también la guía de LangChain.