LangChain + Gonka AI — Aplicaciones de IA por centavos

Ejemplo mínimo: conectar LangChain a Gonka:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-tu-clave",
    model="MiniMaxAI/MiniMax-M2.7",
)

response = llm.invoke("Explica qué es RAG")
print(response.content)

Eso es todo. Tres líneas y tu proyecto LangChain funciona a través de la red descentralizada Gonka por una fracción del costo.

Instalación de dependencias:

pip install langchain langchain-openai

Recomendación: especifique explícitamente max_tokens=8192: este es el límite de salida a través del JoinGonka Gateway para todos los modelos de la red. La ventana de contexto de los modelos de la red es de 200K tokens: téngalo en cuenta al configurar chunk_size en los pipelines de RAG.

RAG (Retrieval-Augmented Generation) es el patrón más popular de aplicaciones de IA. Subes documentos, los divides en trozos, creas embeddings, buscas fragmentos relevantes y generas 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 vía Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-tu-clave",
    model="MiniMaxAI/MiniMax-M2.7",
    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("¿De qué trata este documento?")
print(result["result"])

Coste: una consulta de pipeline RAG (recuperación + generación) utiliza ~2-5K tokens de LLM. A través de Gonka esto son $0.00001-0.000024. A través de OpenAI — $0.005-0.05. La diferencia es de 1,300x.

Para sistemas en 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). Kimi K2.6 admite tool calling nativo, por lo que los agentes funcionan de forma fiable sin necesidad de analizar 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-tu-clave",
    model="MiniMaxAI/MiniMax-M2.7",
)

@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 invoca a calculator, obtiene el resultado y genera la respuesta. El ciclo completo cuesta ~$0.00005 a través de Gonka. Con OpenAI, $0.01-$0.05. Para sistemas con miles de usuarios, esto supone una diferencia de decenas de miles de dólares.