Points clés
- ChatOpenAI prend base_url, api_key et model, donc n'importe quel endpoint compatible OpenAI fonctionne.
- Utilisez l'URL de base https://api.uncensoredllmhub.com/v1 et le modèle uncensored.
- L'appel de fonctions est pris en charge ; pour la sortie structurée, le mode JSON est la méthode la plus sûre.
- Respectez les limites : 8 requêtes simultanées pour une clé complète, donc plafonnez le parallélisme de vos lots.
Installation et connexion
L'intégration OpenAI de LangChain est un package séparé de la bibliothèque principale. Installez-le avec pip install langchain-openai. Obtenez une clé sur la page des clés API ; les nouveaux utilisateurs peuvent y réclamer 0,50 $ de crédit d'essai en un clic, sans carte bancaire.
Ensuite, créez l'objet modèle. Trois arguments comptent : model, base_url et api_key.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredllmhub.com/v1",
api_key="YOUR_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a lighthouse cat.").content)Voici toute l'intégration. Tout ce qui suit, comme les prompts, les analyseurs, les agents et les retrieveurs, traite llm comme n'importe quel autre modèle de chat. Si vous préférez les variables d'environnement, le SDK OpenAI lit OPENAI_API_KEY et OPENAI_BASE_URL, ce qui facilite le changement d'environnement sans modifier le code.
Ce que l'endpoint prend en charge
Le service expose POST /v1/chat/completions, POST /v1/responses et GET /v1/models. ChatOpenAI utilise les chat completions par défaut, ce qui est le choix sûr. Le modèle est un modèle à poids ouverts ajusté pour répondre activement sans refus de contenu pour un usage adulte légal, avec une fenêtre de contexte de 100 000 tokens partagée par le prompt et la complétion.
Fonctionnalités de requête prises en charge sur lesquelles LangChain s'appuie : streaming via SSE avec l'utilisation à la fin, appel de fonctions, mode JSON, et les paramètres d'échantillonnage temperature, top_p, stop, seed et les pénalités. Non disponible : embeddings, génération d'images ou audio, fine-tuning. Si une chaîne de retrieval a besoin d'embeddings, utilisez un autre modèle d'embedding pour cette étape et gardez cet endpoint pour la génération. Les notes complètes sur les paramètres sont dans la documentation.
Un prompt, un modèle et un analyseur
Le schéma LCEL de base pipe un prompt dans le modèle puis dans un analyseur de sortie. Le streaming est gratuit avec .stream().
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You are a concise editor. Reply in {tone} tone."),
("human", "Improve this sentence: {text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))
for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
print(piece, end="", flush=True)Le message système définit le comportement pour chaque appel. Comme la fenêtre de contexte est grande, vous pouvez également fournir un texte de référence long via le prompt template sans splitter dans de nombreux cas. Le coût d'entrée est de $0,15 par 1 M de tokens, donc un document de 20 000 tokens dans le prompt coûte 20 000 / 1 000 000 x $0,15 = $0,003 par appel.
Appel de fonctions
L'appel de fonctions suit le format OpenAI : vous passez des définitions de fonctions, le modèle répond avec tool_calls, vous exécutez la fonction et retournez le résultat comme un message avec le rôle tool. LangChain enveloppe cela dans bind_tools.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([add])
msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
print(call["name"], call["args"]) # run the function yourself, then send a ToolMessage backLe modèle demande l'appel ; votre code l'exécute. Dans un framework d'agent comme LangGraph, une boucle fait cela pour vous jusqu'à ce que le modèle réponde en texte brut. Gardez les descriptions d'outils courtes et les noms d'arguments simples. Si le modèle ignore un outil, serrez la docstring et définissez tool_choice pour forcer l'appel pendant le débogage.
Sortie structurée avec le mode JSON
L'endpoint prend en charge le mode JSON, response_format: {"type":"json_object"}. Dans LangChain, demandez-le via with_structured_output et choisissez la méthode mode JSON, puis validez avec un modèle Pydantic.
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
class Ticket(BaseModel):
title: str
priority: str
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")
print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))Deux habitudes rendent le JSON fiable. Premièrement, dites "JSON" et nommez les clés dans le prompt, car le mode JSON garantit une syntaxe valide mais pas votre schéma. Deuxièmement, enveloppez l'appel dans une tentative de nouvelle requête qui attrape les erreurs de validation et envoie le texte d'erreur au modèle une fois. Ne dépendez pas du décodage contraint par le schéma à moins que vous ne l'ayez testé avec cet endpoint.
Parallélisme, tentatives et contrôle des coûts
LangChain facilite les appels parallèles avec .batch(), et c'est là que les limites entrent en jeu. Une clé complète permet 8 requêtes simultanées et 300 par minute. Une clé d'essai permet 2 et 60. Passez config={"max_concurrency": 6} à batch pour rester sous le plafond.
Lorsque la limite est dépassée, l'API renvoie HTTP 429 avec le code rate_limited ou concurrency, et un en-tête Retry-After: 5 en cas de surcharge temporaire. ChatOpenAI a un argument max_retries qui gère cela avec backoff ; réglez-le de 3 à 5. Les streams occupent un slot jusqu'à leur fin, donc ne laissez pas de streams à moitié lus ouverts.
Exemple de coût calculé : un lot de 2 000 éléments, chacun avec 800 tokens d'entrée et 150 tokens de sortie. Entrée : 2 000 x 800 = 1 600 000 tokens = 1,6 x 0,15 $ = 0,24 $. Sortie : 2 000 x 150 = 300 000 tokens = 0,3 x 0,50 $ = 0,15 $. Le lot coûte 0,39 $. Les requêtes échouées ou refusées ne sont pas facturées, et l'en-tête X-Balance-USD vous permet de surveiller votre solde. Voir tarifs pour les recharges, qui vont de 20 $ à 500 $ et peuvent être payées par crypto.
Agents et mémoire de conversation
Deux schémas apparaissent juste après que la première chaîne fonctionne. Le premier est la mémoire de conversation. Les helpers d'historique de messages de LangChain stockent les tours passés et les préfixent à chaque appel. Comme la fenêtre fait 100 000 tokens, vous pouvez conserver de longs historiques, mais rappelez-vous que chaque tour les renvoie. Un historique de 30 000 tokens sur 50 tours signifie 1 500 000 tokens d'entrée, soit 1,5 x $0,15 = $0,225 pour la session. Résumer les anciens tours une fois que l'historique dépasse une limite de taille maintient le coût constant.
Le second est la boucle d'agent. Dans LangGraph, un agent préconstruit prend le même objet llm plus une liste d'outils et boucle jusqu'à ce que le modèle arrête de demander des outils. Définissez un nombre maximum d'étapes pour qu'une boucle confuse ne puisse pas augmenter les tokens d'entrée. Journalisez l'en-tête de réponse X-Request-Id pour tout appel qui se comporte étrangement, car c'est l'identifiant à citer si vous contactez support.
Dépannage
- 404 à chaque appel. L'URL de base doit se terminer par
/v1et ne doit pas inclure/chat/completions. - Modèle introuvable. Utilisez
uncensoredexactement. LangChain ne valide pas les noms de modèles pour les endpoints personnalisés. - Avertissements de comptage de tokens. Certaines fonctionnalités de LangChain estiment les tokens avec les tokenizers OpenAI. Les décomptes peuvent différer légèrement du modèle réel, alors fiez-vous à l'utilisation retournée par l'API.
- Les longues boucles d'agents coûtent cher. Chaque boucle renvoie tout l'historique. Réduisez l'ancienne sortie d'outil avant qu'elle n'atteigne l'appel suivant.
Si votre chaîne semble correcte et échoue toujours, appelez l'endpoint avec curl brut pour séparer un problème LangChain d'un problème de compte.

