Comment utiliser un modèle LLM via une API, étape par étape
L'utilisation d'un modèle de langage hébergé se résume à un appel HTTP avec une clé, un nom de modèle et une liste de messages. Ce guide vous conduit du dossier vide au streaming, à la sortie JSON et aux appels d'outils.

Points clés
- L'API est compatible OpenAI : changez l'URL de base et la clé, gardez votre SDK.
- Utilisez l'ID de modèle uncensored avec POST /v1/chat/completions.
- Le streaming, le mode JSON et l'appel d'outils fonctionnent tous avec les paramètres standards.
- Un 429 signifie qu'une limite a été atteinte, et le code d'erreur vous indique laquelle.
Ce dont vous avez besoin avant la première requête
Si vous souhaitez savoir comment utiliser les endpoints de modèles LLM dans votre propre code, trois éléments suffisent : une clé, une URL de base et un nom de modèle. Aucun client spécial n'est à installer. Tout SDK ou client OpenAI fonctionne une fois que vous le pointez vers une autre adresse.
- URL de base :
https://api.llmmodelsapi.com/v1 - ID de modèle :
uncensored - Authentification : un en-tête
Authorization: Bearer YOUR_KEY, que les SDK ajoutent pour vous
Pour obtenir une clé, inscrivez-vous avec Google ou avec un e-mail et un mot de passe, puis ouvrez la page des clés API. Les nouveaux comptes peuvent y réclamer $0,50 de crédit d'essai en un clic, sans carte, valable 7 jours. C'est largement suffisant pour tout ce qui est dans cet article. L'endpoint prend en charge deux méthodes : POST /v1/chat/completions pour la génération et GET /v1/models pour lister ce qui est disponible.
Il est utile de savoir ce qu'est le modèle, afin d'avoir les attentes appropriées. Il s'agit d'un modèle à poids ouverts géré par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour une utilisation légale des adultes. Ce n'est pas l'API officielle d'aucun grand fournisseur, et il ne gère que le texte. Pas de génération d'images ou d'audio, pas d'embeddings et pas de fine-tuning.
Étape 1 : vérifier la clé avec curl
Avant d'écrire du code d'application, confirmez que la clé et le chemin réseau fonctionnent. Lister les modèles est le test le moins cher, car il ne génère rien.
export LLM_KEY="paste-your-key-here"
# the list should include the model id: uncensored
curl https://api.llmmodelsapi.com/v1/models -H "Authorization: Bearer $LLM_KEY"
Vous devriez obtenir une liste JSON qui inclut uncensored. Si vous voyez un 401, la clé est incorrecte ou le mot Bearer est manquant. Envoyez maintenant une vraie requête de chat.
curl https://api.llmmodelsapi.com/v1/chat/completions -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" -d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain what a context window is in two sentences."}
],
"max_tokens": 150
}'
La réponse contient un tableau choices, et le texte se trouve à choices[0].message.content. Les en-têtes de réponse contiennent X-Request-Id et X-Balance-USD, afin que vous puissiez voir votre crédit restant à chaque appel. Le champ usage affiche les jetons comptabilisés pour la facturation.
Étape 2 : l'appeler depuis Python ou Node
En pratique, vous utiliserez un SDK. Installez le package officiel OpenAI, puis définissez l'URL de base lorsque vous créez le client. Rien d'autre dans votre code ne change.
Python
from openai import OpenAI
client = OpenAI(
base_url="https://api.llmmodelsapi.com/v1",
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You answer in plain language."},
{"role": "user", "content": "Give me three names for a fantasy tavern."},
],
temperature=0.9,
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llmmodelsapi.com/v1",
apiKey: process.env.LLM_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});
console.log(resp.choices[0].message.content);
Conservez la clé dans une variable d'environnement plutôt que dans le fichier source. Si une clé fuit, remplacez-la sur la page des clés et l'ancienne cessera de fonctionner.
Étape 3 : façonner la sortie avec des paramètres
Le modèle est un prédicteur de texte, donc la façon dont vous formulez la requête est aussi importante que les paramètres. Quelques habitudes portent immédiatement leurs fruits.
- Utilisez le message système pour les règles permanentes. Placez-y le ton, le format et le rôle, et gardez le message utilisateur pour la tâche réelle.
- Soyez précis sur la longueur. Demandez « trois points à puces » ou « moins de 120 mots ». C'est plus fiable que de simplement abaisser
max_tokens, qui coupe le texte en plein milieu d'une phrase. - Ajustez la température en fonction de la tâche. Une valeur autour de 0,2 convient à l'extraction et à la classification. Une valeur entre 0,8 et 1,0 convient à la fiction et au jeu de rôle.
- Transmettez ce dont vous avez besoin.
top_p,stop,seedet les pénalités de fréquence et de présence sont transmises au modèle.
La fenêtre de contexte est de 100 000 tokens, en comptant le prompt et la complétion ensemble. Vous n'avez pas besoin de définir max_tokens, car la réponse peut utiliser tout l'espace restant. Le définir de toute façon est un bon moyen de fixer un plafond au coût.
Une façon pratique d'apprendre ces paramètres est d'exécuter le même prompt trois fois à différentes températures et de comparer. Changez une valeur par exécution et gardez le reste fixe, en utilisant le même seed si possible. Après dix minutes de cela, vous saurez beaucoup mieux comment le modèle se comporte pour votre tâche que n'importe quelle description ne pourrait vous le dire, et le coût de l'expérience est une fraction de centime.
La tarification est de 0,15 $ par million de tokens d'entrée et de 0,50 $ par million de tokens de sortie. Une requête avec 1 500 tokens d'entrée et 400 tokens de sortie coûte 1 500 x 0,15 / 1 000 000 = 0,000225 $ plus 400 x 0,50 / 1 000 000 = 0,0002 $, soit 0,000425 $ au total. La page de tarification propose les options de rechargement.
Étape 4 : streamer la réponse
Attendre une réponse complète semble lent dans une application interactive. Avec stream: true, le serveur envoie des tokens en tant qu'événements server-sent, et votre interface utilisateur peut les afficher à leur arrivée. L'utilisation est signalée à la fin du flux.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse."}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Une chose à retenir concernant la concurrence : une requête en streaming occupe son emplacement jusqu'à la fin du flux. Une clé complète permet 8 requêtes simultanées, une clé d'essai en permet 2. Si vous ouvrez un flux dans le navigateur et ne le fermez jamais, cet emplacement reste occupé.
Étape 5 : mode JSON et appel d'outils
Lorsqu'un autre programme doit lire la réponse, le texte libre devient un problème. Le mode JSON demande au modèle de retourner un objet JSON valide.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Décrivez également la forme souhaitée dans le prompt, car le mode JSON garantit une syntaxe valide et non vos noms de champs exacts. Enveloppez l'analyse dans un bloc try et réessayez une fois en cas d'échec.
L'appel d'outils permet au modèle de demander à votre code d'exécuter une fonction. Vous décrivez les outils, le modèle répond avec une entrée tool_calls, vous l'exécutez et renvoyez le résultat en tant que message avec role: "tool".
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_time",
"description": "Return the current time for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]
messages.append(first.choices[0].message)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps({"time": "14:05"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
En production, vérifiez que tool_calls est présent avant d'y accéder, car le modèle peut répondre directement au lieu d'appeler la fonction. Le paramètre tool_choice vous permet de forcer ou d'interdire un appel lorsque vous en avez besoin.
Maintenir une conversation
L'API n'a pas de mémoire entre les appels. Si vous voulez que le modèle se souvienne de ce qui a été dit il y a deux tours, vous renvoyez ces tours. Une application de chat est donc une liste qui grandit : vous ajoutez le message utilisateur, appelez l'API, ajoutez la réponse de l'assistant, et répétez.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]
def say(text):
history.append({"role": "user", "content": text})
resp = client.chat.completions.create(model="uncensored", messages=history, max_tokens=300)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))
Parce que chaque appel contient toute la liste, le coût et la latence augmentent avec la conversation. Une fois que l'historique devient long, supprimez les tours les plus anciens ou remplacez-les par un résumé d'un paragraphe. Vous avez beaucoup de marge, car 100 000 tokens représentent à peu près la longueur d'un court roman, mais il n'y a aucune raison de payer pour des tokens qui n'aident plus la réponse.
Pour la même raison, gardez le message système court et stable. Il est envoyé à chaque appel, donc un prompt système de 1 000 jetons sur 500 requêtes représente 500 000 jetons d'entrée, ce qui coûte 500 000 x 0,15 / 1 000 000 = $0,075 à lui seul.
Les erreurs des débutants
- Oublier d'ajouter la réponse de l'assistant. Le modèle ne voit alors que vos questions et perd le fil.
- Mettre des secrets dans le front-end. Une clé dans le code du navigateur est visible par tout le monde. Appelez l'API depuis votre serveur et exposez votre propre endpoint à la place.
- S'attendre à des faits d'un prédicteur de texte. Le modèle peut affirmer des détails erronés avec assurance. Donnez-lui le texte source dans le prompt lorsque la précision est importante, et vérifiez les sorties importantes.
- Analyser du texte libre. Si le code doit lire la réponse, utilisez le mode JSON ou un appel d'outil au lieu des expressions régulières.
Erreurs, limites et prochaines étapes
La plupart des problèmes entrent dans une courte liste.
| Symptôme | Cause probable | Correction |
|---|---|---|
| Réponse 401 | Clé manquante ou incorrecte | Vérifiez l'en-tête Bearer et la clé sur la page des clés |
429, code rate_limited | Plus de 300 requêtes par minute (60 sur une clé d'essai) | Ralentissez ou mettez en file d'attente les requêtes |
429, code concurrency | Plus de 8 requêtes à la fois (2 sur une clé d'essai) | Limitez les workers parallèles, fermez les flux ouverts |
429 avec Retry-After: 5 | Surcharge temporaire | Attendez 5 secondes et réessayez |
| Requête trop volumineuse | Corps de plus de 8 Mo | Envoyez moins de texte par appel |
Une simple réessai avec un court délai gère les cas 429. Les requêtes échouées ne sont pas facturées, donc réessayer ne coûte rien de plus. Les prompts ne sont pas utilisés pour l'entraînement.
Depuis ici, la documentation de l'API liste tous les paramètres, et la vue d'ensemble sur le paiement au token couvre pour qui le service est destiné. Une règle s'applique partout : le contenu sexuel impliquant des mineurs n'est jamais autorisé.
Plus de guides
Questions et réponses
Quel ID de modèle dois-je envoyer dans la requête ?
Utilisez uncensored comme valeur de modèle dans chaque requête. Vous pouvez le confirmer en appelant GET /v1/models.
Ai-je besoin d'un SDK spécial ?
Non. Tout SDK ou client OpenAI fonctionne une fois que vous avez modifié l'URL de base vers https://api.llmmodelsapi.com/v1 et utilisé votre propre clé.
Puis-je l'utiliser sans carte bancaire ?
Oui, pour les tests. Les nouveaux utilisateurs peuvent réclamer $0,50 de crédit d'essai en un clic après l'inscription, sans carte, valable 7 jours.
Quelle est la taille maximale de mon prompt ?
La fenêtre de contexte est de 100 000 tokens pour le prompt et la complétion ensemble, et le corps de la requête peut faire jusqu'à 8 Mo.
Votre clé est à un formulaire près
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.