LangChain + Gonka AI — aplicativos AI por uma fração do custo

Exemplo mínimo — conexão do LangChain à Gonka:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-sua-chave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

response = llm.invoke("Explique o que é RAG")
print(response.content)

É tudo. Três linhas — e seu projeto LangChain funciona através da rede descentralizada Gonka por centavos.

Instalação das dependências:

pip install langchain langchain-openai

Recomendação: especifique explicitamente max_tokens=2048 — este é o máximo via JoinGonka Gateway. A janela de contexto do Qwen3-235B é de 128K tokens — leve isso em consideração ao configurar chunk_size nos pipelines RAG.

RAG (Retrieval-Augmented Generation) é o padrão mais popular de aplicativos AI. Você carrega documentos, os divide em chunks, cria embeddings, busca fragmentos relevantes e gera uma resposta com contexto.

from langchain_openai import ChatOpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.document_loaders import TextLoader

# 1. LLM via Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-sua-chave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Carregamento e indexação de documentos
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Armazenamento vetorial (local, gratuito)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. Cadeia RAG
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Consulta
result = qa.invoke("Sobre o que é este documento?")
print(result["result"])

Custo: uma consulta de pipeline RAG (recuperação + geração) usa ~2-5K tokens LLM. Via Gonka, isso é $0.000002-0.000005. Via OpenAI — $0.005-0.05. Diferença — 10.000x.

Para sistemas de produção, que processam milhares de requisições por dia, a economia é de dezenas de milhares de dólares por mês.

LangChain permite criar agentes com ferramentas (tools). Qwen3-235B suporta tool calling nativo — os agentes funcionam de forma confiável, sem analisar respostas de texto.

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain.prompts import ChatPromptTemplate

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-sua-chave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@tool
def calculator(expression: str) -> str:
    """Calcula uma expressão matemática."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Pesquisa informações na internet."""
    return f"Resultados da pesquisa para: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Você é um assistente útil."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_openai_tools_agent(llm, [calculator, search_web], prompt)
executor = AgentExecutor(agent=agent, tools=[calculator, search_web])

result = executor.invoke({"input": "Quanto é 2**10 * 3.14?"})
print(result["output"])

O agente invoca o calculator, obtém o resultado e formula a resposta. Todo o ciclo custa ~$0.00001 via Gonka. Via OpenAI — $0.01-0.05. Para sistemas com milhares de usuários, essa é uma diferença de dezenas de milhares de dólares.