Points clés
- En Python, utilisez ChatOpenAI(base_url=..., api_key=..., model="uncensored"). En JavaScript, utilisez configuration.baseURL.
- Les prompts, les chaînes, le streaming, la liaison d'outils et le mode JSON continuent de fonctionner via les interfaces standard.
- Les embeddings ne sont pas proposés, donc OpenAIEmbeddings doit pointer vers un autre service.
- Utilisez max_concurrency 8 sur une clé complète et laissez les nouvelles tentatives gérer les réponses 429.
Le changement en deux lignes
Lorsque vous recherchez l'URL de base OpenAI langchain, la réponse est courte. La classe de chat OpenAI de LangChain enveloppe le SDK OpenAI, et ce SDK accepte une URL de base personnalisée. Pointez-le vers ce service et rien d'autre dans votre chaîne ne doit changer. Installez d'abord les packages avec pip install langchain-openai langchain-core.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key="YOUR_KEY",
temperature=0.8,
)
print(llm.invoke("Describe a rainy harbor town in two sentences.").content)C'est toute l'intégration. Le service est compatible OpenAI, mais c'est un produit distinct : un modèle à poids ouverts, exécuté par un fournisseur indépendant, sans refus de contenu pour un usage adulte légal. Ce n'est pas l'API officielle d'OpenAI ou d'un autre fournisseur. Pour obtenir une clé, utilisez la page clé API ; les nouveaux comptes peuvent réclamer un crédit d'essai de 0,50 $ en un clic, sans carte.
Pourquoi cela fonctionne : ChatOpenAI construit des requêtes de complétion de chat standard et les envoie à l'adresse qui lui est donnée. Le service répond avec la forme de réponse standard, donc les objets de message, les rappels et les analyseurs de LangChain se comportent comme ils le font contre tout autre fournisseur. Vous conservez les mêmes abstractions, et seule la destination change. Parce que la destination est un modèle différent, vous devriez retester vos prompts. Un prompt conçu pour inciter un modèle restrictif à coopérer peut être inutile ici, et des instructions plus courtes fonctionnent souvent mieux.
Variables d'environnement ou arguments explicites
Vous pouvez configurer la même chose via l'environnement, ce qui est pratique pour les déploiements. Le SDK OpenAI lit OPENAI_BASE_URL et OPENAI_API_KEY. L'ancienne documentation LangChain utilisait OPENAI_API_BASE pour le même objectif. Comme les noms ont changé entre les versions, la pratique la plus sûre est de passer base_url et api_key explicitement et de lire votre propre variable.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
max_retries=3,
timeout=120,
)Un véritable avantage des arguments explicites : si votre projet utilise également un autre fournisseur pour d'autres tâches, une variable globale errante ne peut pas rediriger ce trafic vers le mauvais endroit. Deux objets ChatOpenAI avec des URL de base différentes cohabitent heureusement dans le même processus.
Le même paramètre dans LangChain.js
Dans le package JavaScript, l'URL de base va dans un objet configuration qui est remis au SDK sous-jacent.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: {
baseURL: "https://api.openaiapiproxy.com/v1",
},
});
const res = await llm.invoke("Give me three names for a haunted ship.");
console.log(res.content);La casse est le piège habituel : Python utilise base_url, le SDK JavaScript utilise baseURL.
Un prompt, un modèle et un analyseur
Une fois le modèle de chat construit, le langage d'expression LangChain fonctionne comme d'habitude. Cette chaîne transforme un sujet en une courte scène et retourne une chaîne de caractères simple.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You write short scenes for an adult fiction platform."),
("human", "Write a scene about: {topic}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"topic": "two smugglers meeting at a closed customs office"}))
for piece in chain.stream({"topic": "a stormy night at a mountain inn"}):
print(piece, end="", flush=True)Le streaming repose sur les événements envoyés par le serveur du service, qui arrivent au fur et à mesure que le modèle les génère. Un appel en streaming occupe un slot de concurrence jusqu'à sa fin.
L'opérateur | compose des exécutables, de sorte que la même chaîne peut ensuite ajouter un récupérateur, un second appel de modèle ou un parseur de sortie sans modifier les étapes précédentes. Si vous déplacez un modèle de prompt entre des fournisseurs, conservez le modèle de prompt dans un fichier afin de pouvoir le versionner séparément des paramètres de l'endpoint.
Appel de fonctions et sortie JSON
LangChain transforme les fonctions Python en schémas d'outils avec le décorateur @tool et les envoie via le paramètre standard tools. Le service prend en charge tools, tool_choice et les tool_calls en streaming, donc bind_tools fonctionne.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def lookup_character(name: str) -> str:
"""Return the notes for a character in the story bible."""
notes = {"Mara": "A ferry pilot with a fear of deep water."}
return notes.get(name, "No notes.")
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([lookup_character])
reply = llm_tools.invoke("What do we know about Mara?")
for call in reply.tool_calls:
print(call["name"], call["args"])
print(lookup_character.invoke(call["args"]))Pour le mode JSON, liez le format de réponse et mentionnez JSON dans vos instructions :
import json
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke("Return a JSON object with keys title and summary for a pirate novel.")
print(json.loads(msg.content))Même avec le mode JSON, enveloppez l'analyse dans la gestion des erreurs. Quel que soit le fournisseur, une sortie malformée se produit occasionnellement, et une nouvelle tentative unique avec l'erreur d'analyse jointe corrige généralement cela.
Historique de chat et longs documents
Les modèles de chat LangChain prennent une liste de messages, et l'historique est de votre responsabilité. Les classes de messages rendent les rôles explicites, ce qui est plus clair que les tuples une fois qu'un prompt a plusieurs parties.
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
messages = [
SystemMessage(content="You are the narrator of a slow-burn mystery."),
HumanMessage(content="Open with the detective arriving in town."),
]
first = llm.invoke(messages)
messages.append(AIMessage(content=first.content))
messages.append(HumanMessage(content="Now introduce the suspicious innkeeper."))
second = llm.invoke(messages)
print(second.content)
print(second.usage_metadata)La fenêtre de contexte est de 100 000 tokens, prompt et complétion confondus. Cela laisse de la place pour de longs historiques de chat, une fiche de personnage et plusieurs pages de texte de référence en un seul appel. Cela ne signifie pas que vous devez toujours le remplir. Les tokens d'entrée sont facturés à $0,15 par 1M, donc un prompt de 60 000 tokens coûte 60 000 / 1 000 000 x $0,15 = $0,009 par appel avant que le modèle n'écrive un mot. Une étape de récupération qui n'envoie que les trois pages pertinentes est moins chère et donne souvent de meilleures réponses.
Lorsqu'un prompt est construit à partir de beaucoup de texte récupéré, n'oubliez pas la limite de 8 MB sur le corps de la requête. Elle est bien au-dessus de ce que la fenêtre de tokens permet pour du texte normal, donc vous atteindrez généralement la limite de tokens en premier, mais les données collées avec de longues chaînes ininterrompues peuvent se comporter différemment.
Limites de débit, lots et agents
LangChain facilite le travail en parallèle, ce qui est exactement comment vous atteignez les limites par accident. Une clé complète permet 8 requêtes concurrentes et 300 par minute. Une clé d'essai permet 2 et 60. Utilisez l'argument config pour limiter le parallélisme dans les lots.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
titles = llm.batch(
[f"Suggest a title for episode {i} of a space western." for i in range(1, 25)],
config={"max_concurrency": 8},
)
for t in titles:
print(t.content)Si vous voyez une erreur HTTP 429, le code d'erreur dit pourquoi : rate_limited pour les requêtes par minute, concurrency pour trop en même temps. En cas de surcharge temporaire, la réponse inclut Retry-After: 5. La logique de nouvelle tentative dans le SDK sous-jacent gère la plupart de cela, mais les agents qui s'étendent en de nombreux appels d'outils parallèles peuvent encore saturer une clé d'essai, donc réduisez max_concurrency à 2 là-bas.
Boucle d'agent : chaque étape renvoie la conversation croissante en entrée, ce qui fait que les tokens d'entrée s'accumulent plus vite que les tokens de sortie. À $0,15 par 1M d'entrée et $0,50 par 1M de sortie, une exécution d'agent qui envoie 60 000 tokens d'entrée au total et produit 6 000 tokens de sortie coûte 60 000 / 1 000 000 x $0,15 + 6 000 / 1 000 000 x $0,50 = $0,009 + $0,003 = $0,012. La page tarifs indique les montants de rechargement.
Ce qui ne se transfère pas
- Embeddings. Il n'y a pas d'endpoint d'embeddings. Si votre chaîne de récupération s'appuie sur
OpenAIEmbeddings, utilisez une autre source d'embeddings pour cette partie et gardez uniquement le modèle de chat ici. - Images et audio. Le service est uniquement textuel.
- Changement de modèle. Il n'y a qu'un seul modèle,
uncensored. Une liste déroulante de noms de modèles de fournisseurs ne correspondra pas. - Comptage de tokens par nom. Les bibliothèques qui devinent les comptes de tokens à partir du nom du modèle peuvent tomber en défaut sur une approximation. Pour des nombres réels, lisez
usage_metadatasur le message de réponse.
La fenêtre de contexte est de 100 000 tokens pour le prompt et la complétion confondus, ce qui est généreux pour de longs historiques de chat et le bourrage de documents. Consultez la documentation pour la liste complète des paramètres, et n'oubliez pas que le modèle ne refuse pas le contenu adulte légal, donc ajoutez vos propres filtres à toute chaîne publique. La règle absolue est l'absence de contenu sexuel impliquant des mineurs.
Débogage d'une chaîne qui se comporte mal
Lorsqu'une chaîne produit une sortie étrange, identifiez ce qui a été réellement transmis avant de modifier le prompt. Trois outils aident, par ordre d'effort.
- Imprimez les métadonnées de réponse. Le message retourné par
invokecontientresponse_metadataetusage_metadata. Vous pouvez vérifier la raison de fin et les comptes de tokens sans configuration supplémentaire. - Activez la journalisation de débogage.
set_debug(True)depuislangchain_core.globalsaffiche chaque prompt et réponse dans une chaîne. Utilisez-le uniquement en développement, car il affiche les prompts complets. - Rejouez l'appel avec curl. Copiez les messages rendus depuis la sortie de débogage dans une requête vers
https://api.openaiapiproxy.com/v1/chat/completions. Si curl se comporte de la même manière, le problème est dans votre prompt. S'il diffère, le problème est dans la chaîne.
Symptômes typiques et où chercher : une erreur not-found signifie généralement que l'URL de base contient un /v1 en double ou le manque. Un message concernant un modèle inconnu signifie que le nom n'est pas uncensored. Des listes d'appels d'outils vides signifient souvent que le prompt n'a pas précisé clairement que l'outil doit être utilisé, ce qu'une description d'outil plus claire corrige. Et un agent qui se met en attente peut simplement être en file d'attente derrière ses propres appels parallèles sur une clé d'essai, donc réduisez la concurrence.
Conservez une note de l'en-tête ID de requête (X-Request-Id) des échecs. Si un problème est côté service, la page support explique comment le signaler, et cet ID accélère les choses.
