LangChain + Gonka AI — Applications IA pour des centimes

Un exemple minimal — connecter LangChain à 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)

C'est tout. Trois lignes — et votre projet LangChain tourne via le réseau décentralisé Gonka pour une bouchée de pain.

Installation des dépendances :

pip install langchain langchain-openai

# for the RAG and agent examples below
pip install langchain-classic langchain-community langchain-text-splitters faiss-cpu sentence-transformers

Les imports des exemples sont donnés pour LangChain 1.x (testé sur la version 1.4) : les anciennes chaînes et AgentExecutor y vivent dans le paquet langchain-classic, et le découpage du texte dans langchain-text-splitters.

Recommandation : indiquez explicitement max_tokens=8192 — c'est le plafond de sortie via JoinGonka Gateway pour MiniMax M2.7 et GLM-5.3 Flash (pour DeepSeek V4 Flash, jusqu'à 32768). La fenêtre de contexte est de 200K tokens pour MiniMax M2.7 (380K pour DeepSeek V4 Flash, 390K pour GLM-5.3 Flash) — tenez-en compte lors du réglage du chunk_size dans les pipelines RAG.

RAG (Retrieval-Augmented Generation) est le pattern d'application IA le plus répandu. Vous chargez des documents, les découpez en chunks, créez des embeddings, recherchez les fragments pertinents et générez une réponse avec le contexte.

from langchain_openai import ChatOpenAI
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_classic.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"])

Coût : une requête d'un pipeline RAG (retrieval + generation) consomme environ 2-5K tokens LLM. Via Gonka, cela coûte 0,00001-0,000024 $. Via OpenAI — 0,005-0,05 $. La différence est de 1 300x.

Pour les systèmes de production qui traitent des milliers de requêtes par jour, l'économie se chiffre en dizaines de milliers de dollars par mois.

LangChain permet de créer des agents dotés d'outils (tools). Les modèles du réseau prennent en charge le tool calling natif — les agents fonctionnent de manière fiable, sans parsing des réponses textuelles.

from langchain_openai import ChatOpenAI
from langchain_classic.agents import create_openai_tools_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.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"])

L'agent appelle calculator, récupère le résultat et formule sa réponse. Tout le cycle coûte ~0,00005 $ via Gonka. Via OpenAI — 0,01-0,05 $. Pour les systèmes comptant des milliers d'utilisateurs, la différence se chiffre en dizaines de milliers de dollars.