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-clé",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

response = llm.invoke("Expliquez 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 pour des centimes.

Installation des dépendances :

pip install langchain langchain-openai

Recommandation : spécifiez explicitement max_tokens=2048 — c'est le maximum via JoinGonka Gateway. La fenêtre de contexte de Qwen3-235B est de 128K jetons — tenez-en compte lors de la configuration de chunk_size dans les pipelines RAG.

RAG (Retrieval-Augmented Generation) — le modèle le plus populaire d'applications IA. Vous chargez des documents, les divisez en morceaux, créez des embeddings, recherchez des fragments pertinents et générez une réponse avec le 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-votre-clé",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    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 (récupération + génération) utilise environ 2 à 5 000 jetons LLM. Via Gonka, cela coûte 0,000002 à 0,000005 $. Via OpenAI, 0,005 à 0,05 $. La différence est de 10 000x.

Pour les systèmes de production traitant des milliers de requêtes par jour, l'économie représente des dizaines de milliers de dollars par mois.

LangChain permet de créer des agents avec des outils (tools). Qwen3-235B prend en charge l'appel d'outil natif — les agents fonctionnent de manière fiable, sans analyser les 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-votre-clé",
    model="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
)

@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 la recherche pour : {query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "Vous êtes 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, obtient le résultat et formule la réponse. Le cycle entier coûte environ 0,00001 $ via Gonka. Via OpenAI, 0,01 à 0,05 $. Pour les systèmes avec des milliers d'utilisateurs, c'est une différence de dizaines de milliers de dollars.