LangChain + Gonka AI — Applications IA pour des centimes

Exemple minimal — connexion de LangChain à Gonka :

from langchain_openai import ChatOpenAI

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

response = llm.invoke("Explique ce qu'est le RAG")
print(response.content)

C'est tout. Trois lignes — et votre projet LangChain fonctionne via le réseau décentralisé Gonka à moindre coût.

Installation des dépendances :

pip install langchain langchain-openai

Recommandation : spécifiez explicitement max_tokens=8192 — c'est le plafond de sortie via JoinGonka Gateway pour tous les modèles du réseau. La fenêtre de contexte des modèles du réseau est de 200K tokens — gardez cela à l'esprit lors de la configuration de chunk_size dans les pipelines RAG.

RAG (Retrieval-Augmented Generation) est le modèle d'application AI le plus populaire. Vous chargez des documents, les divisez en morceaux, créez des embeddings, recherchez des fragments pertinents et générez une réponse avec contexte.

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-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
    streaming=True,
)

# 2. Chargement et indexation des documents
loader = TextLoader("docs/my_document.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)

# 3. Stockage vectoriel (local, gratuit)
embeddings = HuggingFaceEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 4. Chaîne RAG
qa = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
)

# 5. Requête
result = qa.invoke("De quoi parle ce document ?")
print(result["result"])

Coût : une requête de pipeline RAG (retrieval + generation) utilise ~2-5K jetons LLM. Via Gonka, cela coûte 0,00001-0,000024 $. Via OpenAI — 0,005-0,05 $. La différence est de 2 000x.

Pour les systèmes en production traitant des milliers de requêtes par jour, les économies s'élèvent à des dizaines de milliers de dollars par mois.

LangChain permet de créer des agents avec des outils (tools). Kimi K2.6 prend en charge le tool calling natif — les agents fonctionnent de manière fiable, sans parsing de réponses textuelles.

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-ваш-ключ",
    model="MiniMaxAI/MiniMax-M2.7",
)

@tool
def calculator(expression: str) -> str:
    """Calcule une expression mathématique."""
    return str(eval(expression))

@tool
def search_web(query: str) -> str:
    """Recherche des informations sur Internet."""
    return f"Résultats de recherche pour : {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile."),
    ("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": "Combien font 2**10 * 3.14 ?"})
print(result["output"])

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