Local ou hébergé : choisissez selon la contrainte qui pèse
Les personnes recherchant LangChain avec un modèle local veulent généralement l'une des trois choses suivantes : confidentialité, pas de facture par token ou indépendance vis-à-vis d'un fournisseur. Un modèle sur votre propre machine, servi par un outil comme Ollama ou llama.cpp, offre ces trois avantages si vous disposez d'un matériel capable de le faire tourner à une vitesse utilisable. Le compromis est le temps d'installation, les limites de mémoire et la vitesse de votre GPU ou CPU.
Un endpoint hébergé échange ces avantages contre un petit coût d'utilisation. Vous envoyez des prompts sur le réseau et le modèle s'exécute sur le matériel de quelqu'un d'autre. Ici, cela signifie un modèle à poids ouverts, ajusté pour répondre sans refus de contenu pour une utilisation adulte légale, servi via une API compatible OpenAI. Les prompts ne sont pas utilisés pour l'entraînement, mais ils quittent votre machine, donc un service hébergé est la mauvaise réponse si votre règle est que les données ne doivent jamais le quitter.
La partie utile pour un développeur LangChain est que le code diffère peu. Les serveurs locaux comme Ollama et llama.cpp exposent des endpoints de style OpenAI, et un endpoint hébergé utilise le même protocole. Si vous écrivez votre application contre ChatOpenAI avec une URL de base configurable, vous pouvez développer en local et passer à un modèle hébergé avec une variable d'environnement. Cela vous donne un hybride pratique : itérez sur un petit modèle local et utilisez l'hébergé lorsque vous voulez le comportement d'un modèle plus grand sans posséder le GPU.
Connectez ChatOpenAI à l'endpoint
Installez le package d'intégration, puis créez l'objet modèle avec les trois paramètres importants.
pip install langchain-openai langchain-core
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Si cela fonctionne, tout le reste fonctionne de la même manière. Obtenez votre clé sur la page clé API ; les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai en un clic après s'être inscrits, sans carte bancaire. Indiquez explicitement l'URL de base dans votre code plutôt que de vous fier à une variable d'environnement, car les différentes versions des bibliothèques lisent des noms de variables différents et une récupération silencieuse vers l'hôte OpenAI par défaut enverrait votre clé au mauvais endroit.
Le nom du modèle est l'endroit où les gens se trompent. Le seul ID ici est uncensored. Un nom comme llama3 ou gpt-4o ne sera pas reconnu.
Une chaîne avec un modèle de prompt
Le pipeline standard de prompt, modèle et analyseur de sortie s'exécute sans changement. Cet exemple résume du texte dans un ton choisi.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a writing assistant. Answer in a {tone} tone."),
("human", "Summarize in two sentences:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "dry", "text": "Long article text goes here..."}))
Pour de nombreuses entrées, utilisez batch et limitez le parallélisme. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute, donc maintenez le paramètre à 8 ou moins :
results = chain.batch(
[{"tone": "dry", "text": t} for t in documents],
config={"max_concurrency": 6},
)
Une clé d'essai permet seulement 2 requêtes simultanées et 60 par minute, donc utilisez max_concurrency de 2 pendant les tests.
Streaming
L'API diffuse via Server-Sent Events, et LangChain expose cela via stream. Utilisez-le pour les interfaces de chat où une personne regarde la réponse se former.
for chunk in llm.stream("Write a short scene set in a lighthouse."):
print(chunk.content, end="", flush=True)
Un détail pratique : une requête en streaming conserve son slot de concurrence jusqu'à la fin du flux. Si votre interface utilisateur abandonne un flux en cours de route, assurez-vous que le générateur est fermé, sinon votre marge de concurrence diminue. Le code asynchrone utilise astream de la même manière.
Outils et agents
L'appel d'outils est pris en charge : l'API accepte tools et tool_choice, diffuse tool_calls et prend les résultats en tant que messages role: "tool". LangChain enveloppe cela dans bind_tools.
from langchain_core.tools import tool
@tool
def dice(sides: int) -> int:
"Roll a die with the given number of sides."
import random
return random.randint(1, sides)
llm_tools = llm.bind_tools([dice])
msg = llm_tools.invoke("Roll a twenty-sided die for the goblin attack.")
print(msg.tool_calls)
Le résultat liste les appels que le modèle souhaite, avec des noms et des arguments. Exécutez-les, ajoutez les résultats en tant que messages d'outil et appelez à nouveau le modèle, ou laissez un framework d'agent comme LangGraph exécuter cette boucle. Les agents effectuent de nombreux appels par demande utilisateur, donc ils atteignent la limite par minute plus rapidement que les chaînes simples. Comptez les appels par exécution avant de choisir un niveau de concurrence.
La fenêtre de contexte est de 100 000 tokens pour le prompt plus la complétion, ce qui est généreux pour la mémoire de conversation. Même ainsi, supprimez les anciens tours : vous payez pour tout l'historique à chaque appel à $0,15 par 1M de tokens d'entrée.
Sortie JSON
Le mode JSON est disponible via response_format. Dans LangChain, vous pouvez le passer avec model_kwargs ou utiliser l'assistant de sortie structurée en mode JSON, et décrivez les champs dans votre prompt.
from pydantic import BaseModel
class Character(BaseModel):
name: str
role: str
secret: str
structured = llm.with_structured_output(Character, method="json_mode")
out = structured.invoke(
"Invent a character for a mystery story. Reply in JSON with keys name, role, secret."
)
print(out)
Avec method="json_mode", le prompt doit indiquer au modèle quelles clés produire ; la classe Pydantic valide ensuite le résultat analysé. Prévoyez une logique de nouvelle tentative pour les rares réponses malformées.
Ce qui n'est pas disponible
Deux éléments essentiels de LangChain nécessitent une source différente. L'API n'a pas d'endpoint d'embeddings, donc OpenAIEmbeddings pointé ici échouera. Pour la récupération sur vos documents, utilisez un modèle d'embedding local ou un autre fournisseur d'embedding, et utilisez cet endpoint uniquement pour l'étape de chat. Il n'a également pas d'entrée ou de génération d'image, pas d'audio et pas de fine-tuning, donc les chaînes de vision et les chargeurs multimodaux sont exclus.
La gestion des erreurs concerne principalement les réponses 429. Le code rate_limited signifie que vous avez dépassé le plafond par minute, concurrency signifie trop d'appels parallèles, et un 429 avec Retry-After: 5 marque une surcharge temporaire. Définissez max_retries sur ChatOpenAI pour que le client attende et réessaie. Les demandes échouées et refusées ne sont pas facturées.
Les en-têtes de réponse aident à la surveillance : X-Balance-USD affiche votre crédit restant et X-Request-Id identifie un appel pour le support.
Passer du local à l'hébergé avec une seule variable
Si vous voulez la configuration hybride, mettez les trois paramètres dans des variables d'environnement et construisez le modèle en une fonction. Vos chaînes importent cette fonction et ne mentionnent jamais un fournisseur.
import os
from langchain_openai import ChatOpenAI
def make_llm():
if os.environ.get("LLM_MODE") == "local":
return ChatOpenAI(
model=os.environ["LOCAL_MODEL"],
base_url="http://localhost:11434/v1",
api_key="not-needed",
)
return ChatOpenAI(
model="uncensored",
base_url="https://api.llmproxyapi.com/v1",
api_key=os.environ["LLMPROXY_API_KEY"],
)
La branche locale suppose un serveur Ollama sur son port par défaut, qui expose une route de style OpenAI sous /v1 ; consultez la documentation de votre propre serveur pour la bonne adresse et le nom du modèle. Le comportement différera entre les modèles, donc relancez vos prompts après un changement. Un prompt ajusté pour les habitudes d'un modèle peut se comporter différemment sur un autre, et la qualité de l'appel d'outils varie avec le modèle, donc testez d'abord ces chemins.
Un flux de travail raisonnable est de développer des prompts contre le modèle hébergé pendant que vous n'avez pas de GPU libre, puis de décider quelles parties de l'application doivent rester sur votre propre machine. Les documents sensibles peuvent utiliser la branche locale, et les fonctionnalités créatives accessibles au public peuvent utiliser celle hébergée.
Coût et prochaines étapes
La tarification est de $0,15 par 1M de tokens d'entrée et $0,50 par 1M de tokens de sortie, à partir de crédit prépayé sans abonnement. Un appel de chaîne avec 2 000 tokens d'entrée et 500 tokens de sortie coûte 2 000 x $0,15 / 1M + 500 x $0,50 / 1M = $0,0003 + $0,00025 = $0,00055. Un millier de ces appels coûtent $0,55. Les recharges vont 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. Les détails sont sur la page de tarification.
Pour une vue HTTP simple de la même API, lisez le guide de démarrage rapide. Le site a également un bref aperçu du service paiement à l'usage.
