Connectez LangChain en quatre lignes
Si vous souhaitez utiliser des modèles open source LangChain sans rien héberger, le chemin le plus court est une API compatible OpenAI. La classe de chat OpenAI de LangChain se moque de qui répond, tant que l'endpoint parle le même protocole. Vous modifiez l'URL de base et la clé, et le reste de vos chaînes, prompts et agents reste identique.
Ce service héberge un modèle à poids ouverts, exécuté par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour une utilisation légale par les adultes. Ce n'est pas l'API officielle d'un quelconque éditeur de modèle et ce n'est pas un routeur entre fournisseurs. Installez le package et créez l'objet modèle :
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Ceci est la connexion complète. Dans les projets réels, conservez la clé dans une variable d’environnement et lisez-la avec os.environ au lieu de l’écrire dans un fichier. Si vous n’avez pas encore de clé, la page clé explique comment vous inscrire et obtenir 0,50 $ de crédit d’essai, sans carte bancaire.
Node.js et LangChain.js
Le package JavaScript suit la même idée, avec l'URL de base passée via un objet de configuration.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
Si vous voyez une erreur 404 ou une page HTML, l'URL de base est généralement incorrecte. Elle doit se terminer par /v1. Les deux endpoints sous-jacents sont POST /v1/chat/completions et GET /v1/models, et rien d'autre n'est nécessaire pour le modèle de chat de LangChain.
Un modèle open source dans LangChain est-il mieux hébergé ou local ?
LangChain peut également exécuter des modèles open source sur votre propre machine, par exemple via Ollama ou un serveur local. Cette voie présente de réels avantages, et il est honnête de le dire. Les modèles locaux ne coûtent pas de frais par token, fonctionnent hors ligne et conservent chaque octet sur votre matériel. Le prix est le matériel : vous avez besoin de suffisamment de mémoire GPU pour le modèle que vous choisissez, vous maintenez le runtime, et le débit est limité par votre machine.
| Question | Serveur local | Cette API hébergée |
|---|---|---|
| Coût initial | Matériel ou GPU loué | Aucun ; crédit prépayé dès 20 $ |
| Coût par token | Aucun, mais usure du matériel et consommation électrique | 0,15 $ par 1M de tokens en entrée, 0,50 $ par 1M de tokens en sortie |
| Fenêtre de contexte | Dépend de la mémoire disponible | 100 000 tokens |
| Concurrence | Dépend de votre configuration | 8 sur une clé complète |
| Emplacement des données | Votre machine | Hébergé ; prompts non utilisés pour l'entraînement |
Une pratique courante consiste à prototyper sur l’endpoint hébergé, puis à décider, à partir du nombre réel de tokens, si un déploiement local est pertinent. Comme les deux côtés utilisent le protocole OpenAI, le changement se résume à une ligne dans base_url, et les chaînes que vous avez créées restent intactes. La page sur ce qu’est un modèle sans censure explique ce que le réglage change au niveau du comportement.
Outils et un agent simple
L’appel d’outils passe par le champ tools de style OpenAI, et bind_tools de LangChain le construit pour vous à partir d’une fonction Python décorée. Le modèle renvoie des demandes d’appel d’outils, et les résultats reviennent sous forme de messages role: "tool".
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
La boucle d'agent appelle le modèle, exécute l'outil quand on le lui demande, et renvoie la sortie jusqu'à ce que le modèle réponde en texte brut. Deux précautions s'appliquent. Donnez à chaque outil une docstring écrite pour le modèle, car c'est ce texte qu'il lit pour choisir un outil. Et définissez une limite de récursion sur les agents pour qu'une exécution confuse ne puisse pas continuer à dépenser du crédit ; LangGraph accepte un recursion_limit dans la configuration.
Pour un contrôle direct sans agent, utilisez llm.bind_tools([word_count]) et inspectez vous-même .tool_calls sur le message renvoyé.
Sortie structurée avec le mode JSON
Pour les tâches d'extraction, passez le paramètre du mode JSON via bind. Le prompt doit indiquer au modèle quelles clés vous souhaitez, car le mode JSON ne fait que le pousser à produire un objet JSON valide.
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
Validez le résultat avec Pydantic ou une simple vérification de clé avant de l'utiliser. Le mode n'impose pas de schéma, donc un champ manquant est possible, et un nouvel essai avec un prompt plus clair le corrige généralement.
Streaming et concurrence
Le streaming s'exécute via les événements envoyés par le serveur et fonctionne avec la méthode standard stream. L'utilisation est envoyée à la fin du flux.
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
Lorsque vous traitez de nombreux éléments, batch les exécute en parallèle, et c’est là que les limites comptent. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d’essai permet 2 et 60. Une requête en streaming occupe son emplacement jusqu’à la fin du flux. Définissez une limite pour que LangChain ne dépasse jamais ce que votre clé autorise :
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
Si vous voyez toujours une erreur HTTP 429, le code d'erreur vous indique quelle limite vous avez atteinte : rate_limited pour les requêtes par minute, concurrency pour trop de requêtes à la fois. Une erreur 429 avec un en-tête Retry-After: 5 marque une surcharge temporaire. ChatOpenAI a une option max_retries qui réessaie sur de telles erreurs avec un backoff ; définissez-la à 3 ou 4 pour les travaux par lots.
Une chaîne de récupération sans endpoint d'embeddings
Cette API couvre uniquement la génération, donc une chaîne de récupération nécessite deux fournisseurs : un pour les embeddings et un pour l'étape de chat. LangChain rend cela facile, car le vector store et le modèle de chat sont des objets séparés. Utilisez n'importe quel modèle d'embedding que vous aimez, depuis une bibliothèque locale ou un autre service, pour indexer vos documents. Ensuite, passez le texte récupéré au modèle de chat via le prompt.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
Ici top_chunks est ce que votre retriever a renvoyé. Limitez-le aux quelques passages qui comptent. Quatre chunks de 300 tokens ajoutent 1 200 tokens par appel, ce qui est correct, mais quarante chunks ajoutent 12 000 et rendent chaque appel dix fois plus lourd.
Liste de dépannage
- Erreurs d'authentification : confirmez que la clé est dans
api_key, et non dans un autre paramètre, et qu'aucune variable d'environnementOPENAI_API_KEYne remplace silencieusement ce que vous vouliez passer. - Modèle introuvable : l'ID du modèle est exactement
uncensored. AppelezGET /v1/modelspour voir ce que le serveur liste. - Arguments d’outils inattendus : lisez la chaîne d’arguments brute, affiniez la description de l’outil et réduisez la température à environ 0,2 pour les exécutions d’agent.
- Traçage et débogage : activez le mode verbeux ou débogage de LangChain localement pour voir chaque prompt qui part et chaque réponse qui revient.
- Tests reproductibles : passez
seedet une température faible lorsque vous comparez des versions de prompt, afin que les différences viennent de votre modification et non de la chance d'échantillonnage.
Coût d'une charge de travail LangChain
La facturation est par token depuis le crédit prépayé. Il n’y a pas d’abonnement, les requêtes échouées ou refusées ne sont pas facturées, et le crédit n’expire jamais. Les recharges sont un montant entier de 20 $ à 500 $, par crypto (USDT sur TRC20, USDC sur Base), avec un bonus de 5 % à partir de 50 $, 10 % à partir de 100 $ et 15 % à partir de 200 $. La page des tarifs contient les détails.
Prenons un exemple. Un bot de support répond à 2 000 questions en une journée. Chaque requête envoie environ 1 500 tokens (prompt système, extraits récupérés, question) et retourne environ 250 tokens.
- Entrée : 2 000 x 1 500 = 3 000 000 tokens, donc 3 x 0,15 $ = 0,45 $.
- Sortie : 2 000 x 250 = 500 000 tokens, donc 0,5 x 0,50 $ = 0,25 $.
- Total : 0,70 $ par jour pour 2 000 réponses, soit 0,00035 $ chacune.
Les chaînes de récupération sont là où les coûts peuvent dériver, car chaque segment supplémentaire récupéré ajoute des tokens d’entrée à chaque appel. Journalisez usage_metadata depuis les réponses, surveillez la taille moyenne du prompt et réduisez le nombre de segments avant de passer à l’échelle. La documentation de l’API liste tous les paramètres pris en charge si vous souhaitez aller plus loin.
