LlamaIndex + Gonka AI — Aplicações RAG por alguns centavos

Chave de API da JoinGonka: cadastre-se em gate.joingonka.ai/register — na largada você ganha 3M tokens grátis — e crie uma chave jg-xxx no Dashboard.

Instalação:

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

Para qualquer API compatível com OpenAI, o LlamaIndex oferece a classe OpenAILike do pacote llama_index.llms.openai_like. Exemplo mínimo de requisição à 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: indique obrigatoriamente is_chat_model=True — caso contrário, o LlamaIndex vai para o endpoint obsoleto Completions com o prompt bruto em vez de um diálogo. is_function_calling_model=True ativa chamadas de ferramentas nativas. Defina context_window de acordo com o modelo para que o LlamaIndex divida o contexto corretamente.

O cenário clássico do LlamaIndex: um índice dos seus documentos e consultas a ele via query_engine. A LLM global é definida uma única vez por meio de Settings.llm e, a partir daí, todo o pipeline usa a Gonka automaticamente.

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)

Um detalhe crítico sobre os embeddings: por padrão, o VectorStoreIndex usa os embeddings da OpenAI (text-embedding-ada-002), que são chamadas pagas à OpenAI, e não à Gonka. Para se livrar totalmente da OpenAI, defina um modelo de embeddings local via Settings.embed_model (como no exemplo acima: HuggingFaceEmbedding, pacote pip install llama-index-embeddings-huggingface). Assim, a geração passa pela Gonka e a vetorização acontece localmente e de graça.

Custo: uma consulta de um pipeline RAG (busca + geração) consome ~2–5K tokens de LLM. Pela Gonka, custa frações de centavo; pela OpenAI/Anthropic, é 3–4 ordens de magnitude mais caro. Em um fluxo de milhares de consultas por dia, a diferença se transforma em dezenas de milhares de dólares de economia por mês.

Uma aplicação RAG não é um chat pontual, mas um fluxo constante de requisições: cada pergunta do usuário carrega consigo de 2 a 5K tokens de LLM (a própria pergunta mais os trechos de contexto recuperados). Vamos calcular os volumes típicos e quanto custam em diferentes provedores. Preços da Gonka via JoinGonka Gateway: entrada ~$0.0062/1M, saída ×3.

Com os 3M tokens gratuitos, você pode rodar as primeiras requisições do pipeline RAG, indexar um corpus de teste e disparar milhares de requisições sem gastar um centavo. Em volumes de produção, o JoinGonka Gateway transforma o RAG de um serviço caro em uma linha de despesa que você pode simplesmente ignorar.

O LlamaIndex não só responde com base em documentos: também permite construir agentes com ferramentas. Os três modelos da Gonka suportam tool calling nativo — os agentes chamam funções de forma estruturada, sem fazer parsing de texto. Exemplo de um agente com uma ferramenta:

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

Escolha do modelo (campo model e os limites correspondentes de context_window / max_tokens):

O limite de max_tokens pelo Gateway é de até 8192 para MiniMax M2.7 e GLM-5.3 Flash, e de até 32768 para DeepSeek V4 Flash. Se max_tokens não for definido em uma requisição não-streaming, por padrão retornam até 1500 tokens — para respostas RAG e etapas de agentes, defina o valor explicitamente.

TypeScript: para o LlamaIndex.TS existe um caminho espelhado — a classe OpenAI do pacote @llamaindex/openai aceita baseURL e apiKey (ou lê as variáveis OPENAI_BASE_URL / OPENAI_API_KEY), então o mesmo Gateway também se conecta em um stack Node.js. Se você constrói aplicações de IA também com frameworks Python, dê uma olhada no guia de LangChain.