LangChain + Gonka AI — Aplicaciones de IA por centavos

Un ejemplo mínimo: conectar LangChain a Gonka:

from langchain_openai import ChatOpenAI

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

response = llm.invoke("Explain what RAG is")
print(response.content)

Eso es todo. Tres líneas, y su proyecto LangChain funciona a través de la red descentralizada Gonka por centavos.

Instalación de dependencias:

pip install langchain langchain-openai

Recomendación: especifique explícitamente max_tokens=2048, que es el máximo a través de JoinGonka Gateway. La ventana de contexto de Qwen3-235B es de 128K tokens; téngalo en cuenta al configurar chunk_size en las tuberías de RAG.

RAG (Retrieval-Augmented Generation) es el patrón más popular de aplicaciones de IA. Cargue documentos, divídalos en fragmentos, cree embeddings, busque fragmentos relevantes y genere una respuesta con 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 a través de Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-su-clave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    streaming=True,
)

# 2. Carga e indexación de documentos
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Almacenamiento vectorial (local, gratuito)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

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

# 5. Consulta
result = qa.invoke("What is this document about?")
print(result["result"])

Costo: una consulta del pipeline RAG (recuperación + generación) utiliza ~2-5K tokens de LLM. A través de Gonka, esto es $0.000002-0.000005. A través de OpenAI, $0.005-0.05. La diferencia es de 10,000 veces.

Para sistemas de producción que procesan miles de solicitudes al día, el ahorro asciende a decenas de miles de dólares al mes.

LangChain permite crear agentes con herramientas (tools). Qwen3-235B admite el tool calling nativo: los agentes funcionan de forma fiable, sin analizar las respuestas 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-su-clave",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@tool
def calculator(expression: str) -> str:
    """Calcula una expresión matemática."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Busca información en Internet."""
    return f"Resultados de búsqueda para: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente ú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": "¿Cuánto es 2**10 * 3.14?"})
print(result["output"])

El agente llama a calculator, obtiene el resultado y forma la respuesta. Todo el ciclo cuesta ~$0.00001 a través de Gonka. A través de OpenAI, $0.01-0.05. Para sistemas con miles de usuarios, esta es una diferencia de decenas de miles de dólares.