FR ▾

Uncensored Model HubModèles open source LangChain via une API sans censure

Modèles open source LangChain via une API sans censure

LangChain fonctionne avec des modèles open source via n'importe quel serveur compatible OpenAI, et une API hébergée vous évite de gérer vous-même les GPU. Voici la configuration en Python et Node, avec des outils, un agent, une sortie JSON, le streaming et un plan de concurrence.

Mis à jour le

Chaînes de verre reliant des blocs modulaires à un cube de serveur, illustrant LangChain avec une API de modèle à poids ouverts

Points clés

  1. Utilisez ChatOpenAI avec base_url défini sur https://api.uncensoredmodelhub.com/v1 et le modèle uncensored.
  2. L'appel d'outils, le mode JSON et le streaming fonctionnent tous via les interfaces standard de LangChain.
  3. Limitez max_concurrency à 8 sur une clé complète, 2 sur une clé d'essai, pour éviter les erreurs 429.
  4. La tarification est de 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie, sans abonnement.

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.

QuestionServeur localCette API hébergée
Coût initialMatériel ou GPU louéAucun ; crédit prépayé dès 20 $
Coût par tokenAucun, mais usure du matériel et consommation électrique0,15 $ par 1M de tokens en entrée, 0,50 $ par 1M de tokens en sortie
Fenêtre de contexteDépend de la mémoire disponible100 000 tokens
ConcurrenceDépend de votre configuration8 sur une clé complète
Emplacement des donnéesVotre machineHé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'environnement OPENAI_API_KEY ne remplace silencieusement ce que vous vouliez passer.
  • Modèle introuvable : l'ID du modèle est exactement uncensored. Appelez GET /v1/models pour 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 seed et 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.

Questions et réponses

Quelle classe LangChain dois-je utiliser pour cette API ?

Utilisez ChatOpenAI de langchain-openai en Python ou @langchain/openai en JavaScript. Définissez le modèle sur uncensored et pointez base_url vers https://api.uncensoredmodelhub.com/v1.

Prend-il en charge les agents et l’appel d’outils ?

Oui. L’appel d’outils utilise le format d’outils de style OpenAI, donc bind_tools et les agents LangGraph fonctionnent. Validez vous-même les arguments des outils, car le modèle les renvoie sous forme de texte.

Quelle est la fenêtre de contexte pour les chaînes LangChain ?

100 000 tokens, partagés entre prompt et complétion. Les mémoires tampons longues et de nombreux segments récupérés les consomment, donc réduisez l’historique dans votre chaîne.

Les embeddings sont-ils disponibles pour mon vector store ?

Non. L’API est uniquement du chat textuel, sans embeddings, images, audio ni fine-tuning. Utilisez un fournisseur d’embeddings séparé pour la récupération et cette API pour l’étape de génération.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé API