FR ▾
Obtenir la clé API

LangChain Custom LLM API : Pointez vers n'importe quelle URL de base URL de base

Pour utiliser une API LangChain Custom LLM, vous n'avez pas besoin d'écrire une classe personnalisée : le wrapper de chat compatible OpenAI accepte une URL de base, une clé et un nom de modèle. Voici la configuration exacte, ainsi que le streaming, les outils, la sortie JSON et la gestion des limites.

Mis à jour le

Points clés

  • ChatOpenAI prend base_url, api_key et model, donc aucune sous-classation n'est nécessaire.
  • Utilisez le modèle uncensored et l'URL de base https://api.llmapistatus.com/v1.
  • L'appel d'outils, le streaming et le mode JSON passent tous par l'endpoint.
  • Limitez les chaînes parallèles à 8 pour rester sous la limite de concurrence ; les embeddings ne sont pas proposés.
Chaîne de nœuds liés se connectant à un serveur de modèle distant via un seul endpoint

La réponse courte : ChatOpenAI avec une URL de base différente

LangChain communique avec des serveurs de style OpenAI via le package langchain-openai. Sa classe ChatOpenAI vous permet de remplacer l'endroit où les requêtes sont envoyées, ce qui est exactement ce dont a besoin un endpoint personnalisé. Installez le package, puis passez trois valeurs : l'URL de base https://api.llmapistatus.com/v1, votre clé et l'ID du modèle uncensored.

Installez avec pip install -U langchain-openai langchain-core.

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.llmapistatus.com/v1",
    api_key=os.environ["LLM_API_KEY"],
    temperature=0.7,
)

print(llm.invoke("Reply with the single word: ready").content)

Si cela affiche une réponse, le câblage est correct. Vous obtenez une clé depuis la page clé API ; le guide de démarrage rapide montre le même commutateur pour les utilisateurs de SDK standards. L'endpoint sert POST /v1/chat/completions et GET /v1/models, et ces deux méthodes sont tout ce dont le wrapper OpenAI a besoin pour le chat.

Un mot sur le terme « LLM personnalisé ». LangChain documente également une façon d'écrire votre propre modèle de chat en sous-classant une classe de base, ce qui a du sens pour les APIs qui ne parlent pas le format OpenAI. Cet endpoint le parle, donc la sous-classation n'ajouterait que du code à maintenir. Utilisez-le seulement si vous avez besoin d'un comportement que le wrapper ne peut pas exprimer.

Construire une chaîne avec des prompts et une analyse de sortie

Avec l'objet modèle en place, tout le reste dans LangChain fonctionne comme avec n'importe quel modèle de chat. Voici une petite chaîne écrite dans le style du langage d'expression : un modèle de prompt, le modèle et un analyseur de chaîne.

# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a blunt technical editor. Answer in at most {limit} words."),
    ("human", "Rewrite this for clarity:\n\n{text}"),
])

chain = prompt | llm | StrOutputParser()

print(chain.invoke({
    "limit": 60,
    "text": "The thing that we did was basically to make the cache be invalidated on write.",
}))

Rien dans cette chaîne ne sait ou ne se soucie que le modèle se trouve derrière un domaine différent. C'est l'avantage de l'API compatible : les prompts, les classes de mémoire, les retrievers et les agents écrits pour l'interface de chat standard continuent de fonctionner. Ce que vous devez vérifier de votre côté, c'est le prompt lui-même. Un modèle entraîné à répondre sans refus de contenu suit les instructions littéralement, donc des prompts système vagues produisent un comportement vague. Définissez le rôle, le format et la longueur.

Une limite vaut la peine d'être connue avant de concevoir un pipeline de récupération. Ce service est textuel uniquement. Il n'y a pas d'embeddings, donc OpenAIEmbeddings pointé vers cette URL de base échouera. Utilisez un modèle d'embedding local ou un autre fournisseur pour le magasin vectoriel, et utilisez cet endpoint uniquement pour la génération.

Streaming des tokens à leur arrivée

L'endpoint prend en charge les événements envoyés par le serveur lorsque vous envoyez stream: true, et LangChain transforme cela en un itérateur. Vous ne définissez pas le flag vous-même ; appeler .stream() le fait.

# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
for chunk in llm.stream("Write a four-line poem about a failing cron job."):
    print(chunk.content, end="", flush=True)
print()

Pour les serveurs asynchrones, utilisez astream. Le même appel existe dans la bibliothèque JavaScript :

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.LLM_API_KEY,
  configuration: { baseURL: "https://api.llmapistatus.com/v1" },
});

const stream = await llm.stream("Write a four-line poem about a failing cron job.");
for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

N'oubliez pas qu'une requête en streaming conserve son slot de concurrence jusqu'à ce que le dernier événement arrive. Si un utilisateur ferme l'onglet du navigateur et que votre serveur continue de lire le flux, ce slot reste occupé. Annulez la requête amont lorsque le client se déconnecte. Les chiffres d'utilisation arrivent à la fin du flux, c'est là que vous lisez les compteurs de tokens finaux pour les journaux de facturation.

Appel de fonctions et agents

L'appel d'outils est disponible : l'endpoint accepte tools et tool_choice, diffuse tool_calls en retour, et prend vos résultats en tant que messages avec role: "tool". Dans LangChain, vous attachez des outils avec bind_tools et laissez le framework construire les messages.

# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.tools import tool

@tool
def get_order_status(order_id: str) -> str:
    'Look up the status of an order by its id.'
    return f"Order {order_id} shipped yesterday."

llm_tools = llm.bind_tools([get_order_status])
ai = llm_tools.invoke("Where is order A-1042?")
print(ai.tool_calls)

Exécuter l'appel et retourner le résultat est la deuxième moitié de la boucle :

# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
# llm_tools comes from the previous snippet
from langchain_core.messages import HumanMessage, ToolMessage

messages = [HumanMessage("Where is order A-1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)

for call in ai.tool_calls:
    result = get_order_status.invoke(call["args"])
    messages.append(ToolMessage(content=result, tool_call_id=call["id"]))

print(llm_tools.invoke(messages).content)

Les modèles à poids ouverts varient dans leur capacité à choisir des outils et à remplir des arguments. Gardez les descriptions d'outils courtes et concrètes, utilisez peu d'outils par appel, et validez les arguments dans votre fonction plutôt que de leur faire confiance. Si un agent boucle, réduisez la température et définissez un nombre maximum d'étapes dans votre exécuteur d'agent.

Sortie structurée et JSON

Le mode JSON est pris en charge via response_format: {"type": "json_object"}. Dans LangChain, la méthode la plus simple est with_structured_output en utilisant la méthode en mode JSON, qui valide également le résultat par rapport à un schéma.

# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from pydantic import BaseModel

class Ticket(BaseModel):
    title: str
    priority: str
    tags: list[str]

structured = llm.with_structured_output(Ticket, method="json_mode")

result = structured.invoke(
    "Return JSON with keys title, priority and tags for this report: "
    "login page times out on mobile, affects many users."
)
print(result)

Le mode JSON garantit que la sortie est un objet JSON, pas qu'il possède les champs que vous souhaitiez. Deux habitudes aident. Premièrement, nommez les clés dans le prompt, comme ci-dessus ; l'instruction de produire du JSON doit être explicite. Deuxièmement, enveloppez l'appel dans une nouvelle tentative qui réanalyse la sortie en cas d'échec. La vérification pydantic attrape les champs manquants et les types erronés, et une seule tentative avec le message d'erreur ajouté le corrige généralement.

Vous pouvez également définir response_format directement lorsque vous construisez le modèle avec model_kwargs={"response_format": {"type": "json_object"}}, ce qui est pratique pour les chaînes brutes qui se terminent par un analyseur JSON.

Limites de débit, tentatives et chaînes parallèles

Les lots et les agents effectuent de nombreux appels à la fois, et c'est là qu'un endpoint personnalisé diffère d'un modèle local. Une clé complète permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai permet 2 requêtes simultanées et 60 par minute. Au-delà d'une limite, l'API répond avec HTTP 429 et le code d'erreur rate_limited ou concurrency ; en cas de surcharge temporaire, elle répond 429 avec Retry-After: 5.

Deux paramètres LangChain gèrent la plupart des cas. Le modèle prend max_retries, qui réessaie les échecs transitoires avec un backoff, et les runnables acceptent une valeur max_concurrency dans leur configuration pour le travail par lots :

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.llmapistatus.com/v1",
    api_key=os.environ["LLM_API_KEY"],
    max_retries=4,
    timeout=120,
)

questions = [f"Summarise item {i} in one sentence." for i in range(40)]
answers = llm.batch(questions, config={"max_concurrency": 6})

Définir le plafond à 6 sur une clé complète laisse de la place pour deux autres requêtes, comme un appel visible par l'utilisateur depuis la même application. Sur une clé d'essai, utilisez 1 ou 2. Ne comptez pas uniquement sur les tentatives pour un problème de concurrence : si le plafond est supérieur à la limite, les tentatives recréent simplement la même collision. Lire X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency dans les en-têtes de réponse vous indique ce que votre clé est autorisée à faire.

Les longues entrées sont acceptées jusqu'à la fenêtre de 100 000 tokens, partagée entre le prompt et la complétion, et le corps de la requête est limité à 8 Mo. Les diviseurs de texte LangChain définis sur quelques milliers de tokens par morceau vous tiennent loin de ces deux limites.

Dépannage d'un endpoint personnalisé

La plupart des problèmes avec une URL de base personnalisée se classent dans une courte liste, et chacun a un test rapide.

  • Erreurs d'authentification. LangChain lit également la variable d'environnement OPENAI_API_KEY. Si vous passez api_key explicitement, cette valeur l'emporte, mais une variable périmée peut encore confondre un deuxième objet modèle que vous avez oublié de configurer. Passez la clé chaque fois, et donnez à la variable un autre nom tel que LLM_API_KEY.
  • Erreurs de type 'non trouvé'. L'URL de base doit se terminer par /v1. LangChain ajoute /chat/completions lui-même, donc l'ajouter à l'URL de base produit un chemin doublé.
  • Modèle inconnu. Appelez GET /v1/models avec la même clé et copiez l'ID qu'il affiche. Il devrait être uncensored.
  • Blocages silencieux dans les longues chaînes. Définissez timeout sur le modèle et journalisez l'en-tête de réponse X-Request-Id. Si vous contactez le support, cet ID leur permet de trouver la requête exacte.
  • Sortie surprenante. Imprimez le prompt final avant qu'il ne soit envoyé. La plupart des réponses étranges dans LangChain proviennent d'un template qui a rempli une variable avec quelque chose d'inattendu, pas du modèle.

En cas de doute, reproduisez l'appel défaillant avec curl brut contre la même URL. Si curl fonctionne et LangChain non, la faute est dans votre chaîne ; si les deux échouent, vérifiez la clé et le solde.

Vérifier les coûts pendant le développement

Les chaînes masquent les comptes de tokens, mesurez dès le début. Chaque réponse inclut l'usage, et les en-têtes incluent X-Balance-USD. Le prix est de 0,15 $ par 1M tokens d'entrée et 0,50 $ par 1M tokens de sortie, prélevé sur le crédit prépayé.

Un exemple détaillé : une chaîne de récupération qui envoie 6 000 tokens de contexte et de question et reçoit 400 tokens en retour coûte 6 000 x 0,15 $ / 1M = 0,0009 $ pour l'entrée plus 400 x 0,50 $ / 1M = 0,0002 $ pour la sortie, soit 0,0011 $ par appel. Exécuter 5 000 de ces appels dans un test coûte 5,50 $. C'est utile à savoir avant de laisser une boucle d'agent tourner toute la nuit.

Les requêtes échouées ou refusées ne sont pas facturées. La page de tarification liste les recharges de 20 $ à 500 $ avec des bonus, et les nouveaux comptes peuvent réclamer un crédit d'essai gratuit de 0,50 $ en un clic, suffisant pour quelques centaines d'petits appels de test pendant que vous configurez.

Questions et réponses

Dois-je sous-classer la classe de base du modèle de chat de LangChain ?

Non. L'endpoint est compatible OpenAI, donc ChatOpenAI avec une base_url personnalisée, une clé API et un modèle fonctionne. La sous-classification n'est nécessaire que pour les API qui utilisent un format différent.

Puis-je utiliser OpenAIEmbeddings avec cet endpoint ?

Non. Le service est uniquement textuel et ne dispose pas d'embeddings. Utilisez un modèle d'embedding local ou un autre fournisseur pour les vecteurs, et utilisez cet endpoint pour la génération.

Quel nom de modèle dois-je passer ?

Passez uncensored comme modèle. GET /v1/models retourne le même ID.

Pourquoi obtiens-je des erreurs 429 dans un travail par lots ?

Vous avez dépassé soit les requêtes par minute, soit les requêtes concurrentes. Diminuez max_concurrency en dessous de 8 sur une clé complète, ou 2 sur une clé d'essai, et gardez les tentatives activées.

Le streaming de LangChain fonctionne-t-il ici ?

Oui. L'appel de stream ou astream utilise les événements envoyés par le serveur, et l'utilisation est envoyée à la fin du flux.

Votre clé est à un formulaire de distance

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

Obtenir une clé API