LlamaIndex + Gonka AI — Aplicaciones RAG por centavos

Clave API de JoinGonka: regístrese en gate.joingonka.ai/register — al inicio le damos 10M 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. Un ejemplo mínimo de consulta 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="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # Gonka es un chat-endpoint
    is_function_calling_model=True, # se admite el tool calling nativo
    context_window=131072,         # 128K para Qwen3-235B
    max_tokens=8192,               # límite de salida a través de Gateway (Qwen)
)

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

Importante sobre OpenAILike: asegúrese de especificar is_chat_model=True, de lo contrario LlamaIndex irá a un endpoint de finalización que no tenemos. is_function_calling_model=True habilita las llamadas a herramientas nativas. Establezca context_window según el modelo para que LlamaIndex corte el contexto correctamente.

Un escenario clásico de LlamaIndex es un índice sobre sus documentos y consultas a él a través de query_engine. La LLM global se establece una vez a través de Settings.llm, después todo el pipeline utiliza 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="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    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 de la carpeta ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

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

Matiz crítico sobre los embeddings: por defecto, VectorStoreIndex utiliza embeddings de OpenAI (text-embedding-ada-002), lo que implica llamadas pagadas separadas a OpenAI, no a Gonka. Para prescindir por completo de OpenAI, especifique 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 realizará a través de Gonka y la vectorización localmente y de forma gratuita.

Coste: una única consulta a un pipeline RAG (búsqueda + generación) consume ~2–5K tokens de LLM. A través de Gonka, esto son fracciones de céntimo; a través de 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 de una sola vez, sino un flujo constante de solicitudes: cada pregunta del usuario consume 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 con diferentes proveedores. Precios de Gonka a través de JoinGonka Gateway: entrada ~$0.0005/1M, salida ×3.

Con 10M de tokens gratuitos, puedes depurar todo el pipeline RAG, indexar un corpus de prueba y ejecutar miles de consultas, sin gastar un céntimo. En volúmenes de producción, JoinGonka Gateway transforma RAG de un servicio costoso en una partida de gastos que ni siquiera se nota.

LlamaIndex no solo puede responder a partir de documentos, sino también construir agentes con herramientas. Los tres modelos de Gonka admiten llamadas a herramientas nativas: los agentes invocan funciones de forma estructurada, sin analizar 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-tu-clave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    is_function_calling_model=True,
    context_window=131072,
    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. Utiliza las 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 del modelo (campo model y los límites correspondientes context_window / max_tokens):

El límite de max_tokens a través de Gateway es de hasta 8192 en el modelo Qwen3; para Kimi y MiniMax, especifique 3072 y 4096 respectivamente. Si max_tokens no se especifica para una solicitud no-streaming, por defecto se devolverá hasta 1500 tokens; para respuestas RAG y pasos de agente, especifíquelo explícitamente.

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