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

Chave API JoinGonka: registre-se em gate.joingonka.ai/register — no início, damos 10M de tokens gratuitos — e crie uma chave jg-xxx no Dashboard.

Instalação:

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

Para uma API arbitrária compatível com OpenAI, o LlamaIndex fornece a classe OpenAILike do pacote llama_index.llms.openai_like. Exemplo mínimo de uma solicitação para Gonka:

from llama_index.llms.openai_like import OpenAILike

llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-sua-chave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,            # Gonka é um endpoint de chat
    is_function_calling_model=True, # tool calling nativo é suportado
    context_window=131072,         # 128K com Qwen3-235B
    max_tokens=8192,               # limite de saída via Gateway (Qwen)
)

response = llm.complete("Explique o que é RAG em três frases.")
print(response)

Importante sobre OpenAILike: certifique-se de definir is_chat_model=True — caso contrário, o LlamaIndex irá para o endpoint de conclusão, que não temos. is_function_calling_model=True habilita chamadas de ferramenta nativas. Defina context_window de acordo com o modelo para que o LlamaIndex corte o contexto corretamente.

O cenário clássico do LlamaIndex é um índice sobre seus documentos e consultas a ele através de um query_engine. A LLM global é definida uma vez via Settings.llm, e então todo o pipeline usa 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 (uma vez — globalmente)
Settings.llm = OpenAILike(
    api_base="https://gate.joingonka.ai/v1",
    api_key="jg-sua-chave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    is_chat_model=True,
    context_window=131072,
    max_tokens=8192,
)

# 2. Embeddings locais (grátis, sem OpenAI)
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-small-en-v1.5"
)

# 3. Carregar e indexar documentos da pasta ./data
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# 4. Consultar a base de conhecimento
query_engine = index.as_query_engine()
response = query_engine.query("Qual é o objetivo deste documento?")
print(response)

Nuance crítica sobre embeddings: por padrão, o VectorStoreIndex usa embeddings da OpenAI (text-embedding-ada-002) — estas são chamadas pagas separadas para a OpenAI, não para a Gonka. Para se afastar completamente da OpenAI, defina um modelo de embeddings local através de Settings.embed_model (como no exemplo acima — HuggingFaceEmbedding, pacote pip install llama-index-embeddings-huggingface). Assim, a geração ocorre via Gonka, e a vetorização é local e gratuita.

Custo: uma única solicitação de pipeline RAG (pesquisa + geração) consome ~2–5K tokens LLM. Via Gonka, são frações de centavos; via OpenAI/Anthropic — 3–4 ordens de magnitude mais caro. Em um fluxo de milhares de solicitações por dia, a diferença se traduz em dezenas de milhares de dólares em economia por mês.

Um aplicativo RAG não é um chat único, mas um fluxo constante de requisições: cada pergunta do usuário aciona 2-5K tokens LLM (a própria pergunta mais os fragmentos de contexto encontrados). Vamos calcular os volumes típicos e quanto eles custam em diferentes provedores. Preços Gonka via JoinGonka Gateway: entrada ~$0,0005/1M, saída ×3.

Com 10M de tokens gratuitos, você pode depurar todo o pipeline RAG, indexar um corpus de teste e executar milhares de consultas — sem gastar um centavo. Em volumes de produção, o JoinGonka Gateway transforma o RAG de um serviço caro em uma despesa que pode ser completamente ignorada.

LlamaIndex não só pode responder a documentos, mas também construir agentes com ferramentas. Todos os três modelos Gonka suportam tool calling nativo — os agentes chamam funções de forma estruturada, sem parsing de texto. Exemplo de agente com 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-sua-chave",
    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 dois números."""
    return a * b

agent = FunctionAgent(
    tools=[multiply],
    llm=llm,
    system_prompt="Você é um assistente útil. Use ferramentas para cálculos.",
)

async def main():
    result = await agent.run("Quanto é 1234 multiplicado por 5678?")
    print(result)

asyncio.run(main())

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

O limite de max_tokens via Gateway é de até 8192 no modelo Qwen3; para Kimi e MiniMax, especifique 3072 e 4096, respectivamente. Se max_tokens não for definido para uma solicitação não-streaming, por padrão, ele retornará até 1500 tokens — para respostas RAG e etapas de agente, defina o valor explicitamente.

TypeScript: para o LlamaIndex.TS, há um caminho espelho — a classe OpenAI do pacote @llamaindex/openai aceita baseURL e apiKey (ou lê as variáveis OPENAI_BASE_URL / OPENAI_API_KEY), de modo que o mesmo Gateway se conecta também à pilha Node.js. Se você está construindo aplicativos de IA em frameworks Python, consulte também o guia sobre LangChain.