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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
)

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

Eso es todo. Tres líneas — y tu proyecto de LangChain funciona a través de la red descentralizada Gonka por muy pocos céntimos.

Instalación de dependencias:

pip install langchain langchain-openai

Recomendación: especifica max_tokens=8192 explícitamente — es el tope de salida a través de JoinGonka Gateway para MiniMax M2.7 y GLM-5.3 Flash (en DeepSeek V4 Flash es de hasta 32768). La ventana de contexto es de 200K tokens en MiniMax M2.7 (380K en DeepSeek V4 Flash, 390K en GLM-5.3 Flash) — tenlo en cuenta al configurar chunk_size en tus pipelines RAG.

RAG (Retrieval-Augmented Generation) es el patrón más popular en aplicaciones de IA. Cargas documentos, los divides en fragmentos, creas embeddings, buscas los 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 via Gonka
llm = ChatOpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key="jg-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Load and index documents
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Vector store (local, free)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

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

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

Coste: una sola consulta al pipeline RAG (retrieval + generation) consume ~2-5K tokens del LLM. Con Gonka son $0.00001-0.000024. Con OpenAI, $0.005-0.05. La diferencia: 1.300x.

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

LangChain te permite crear agentes con herramientas (tools). Los modelos de la red admiten tool calling nativo, así que los agentes funcionan de forma fiable, sin parsear 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-your-key",
    model="MiniMaxAI/MiniMax-M2.7",
)

@tool
def calculator(expression: str) -> str:
    """Evaluates a math expression."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Searches the web for information."""
    return f"Search results for: {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("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": "What is 2**10 * 3.14?"})
print(result["output"])

El agente llama a calculator, obtiene el resultado y formula la respuesta. Todo el ciclo cuesta ~$0.00005 con Gonka. Con OpenAI, $0.01-0.05. Para sistemas con miles de usuarios, esa diferencia son decenas de miles de dólares.