FR ▾
Obtenir une clé API

LLM Inference APIGuide

LLM Inference API : streaming, outils et mode JSON

Une API d'inférence LLM vous permet d'envoyer un prompt via HTTPS et de recevoir du texte généré, sans GPU de votre côté. Cette page présente une configuration fonctionnelle vers un endpoint compatible OpenAI, de la première requête au streaming, aux outils, au mode JSON et aux limites de débit.

Mis à jour :

Illustration isométrique de paquets de données circulant d'un terminal vers une passerelle cloud, représentant un appel d'API d'inférence

Points clés

  1. Configurez n'importe quel SDK OpenAI vers https://api.llminferenceapi.com/v1, utilisez l'ID de modèle uncensored et envoyez votre clé en tant que jeton Bearer.
  2. Deux endpoints sont disponibles : POST /v1/chat/completions et GET /v1/models.
  3. Le streaming, l'appel de fonctions et le mode JSON fonctionnent via les champs de requête standards.
  4. Une clé complète permet 8 requêtes simultanées et 300 par minute ; une réponse 429 indique quelle limite vous avez atteinte.

Ce dont vous avez besoin avant le premier appel

Vous avez besoin de trois éléments : une URL de base, une clé et un nom de modèle. L'URL de base est https://api.llminferenceapi.com/v1, l'ID de modèle est uncensored, et la clé provient de la page de la clé API après vous être connecté avec Google ou avec un e-mail et un mot de passe. Les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai en un clic. Aucune carte n'est nécessaire, cela dure 7 jours et est limité à un par personne.

Le service est uniquement textuel. Il expose POST /v1/chat/completions et GET /v1/models. Il n'y a pas de route pour les embeddings, ni de génération d'images ou d'audio, ni de fine-tuning. Il fait tourner un seul modèle à poids ouverts, opéré par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour un usage adulte légal. Ce n'est pas l'API officielle d'aucun fournisseur de modèle. Une règle stricte s'applique : le contenu sexualisant les mineurs n'est pas autorisé.

Conservez la clé dans une variable d'environnement plutôt que dans le code source. Les exemples ci-dessous la lisent depuis API_KEY là où le langage le permet.

Votre première requête

Commencez par curl, car il montre exactement ce qui passe sur le réseau.

curl https://api.llminferenceapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "List three uses of a message queue."}
    ],
    "temperature": 0.7
  }'

La réponse est l'objet de complétion de chat habituel : choices[0].message.content contient le texte et usage contient les comptages de tokens. Vous pouvez également lister les modèles avec GET /v1/models, ce qui est un moyen rapide de confirmer que la clé et l'URL sont corrects avant de déboguer autre chose.

En Python avec le SDK OpenAI officiel, seul le constructeur change :

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llminferenceapi.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)

Et en Node :

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.llminferenceapi.com/v1",
  apiKey: process.env.API_KEY,
});

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);

La complétion peut utiliser tout ce qui reste de la fenêtre de contexte de 100 000 tokens après votre prompt, donc max_tokens est optionnel. Définissez-le de toute façon lorsque vous voulez un plafond strict sur le coût ou la longueur. Les contrôles d'échantillonnage tels que temperature, top_p, stop, seed et les pénalités de fréquence et de présence sont transmis.

Deux paramètres méritent d'être connus dès le départ. seed rend l'échantillonnage reproductible pour les tests, ce qui aide lorsque vous comparez deux versions d'un prompt et voulez que la différence vienne du prompt plutôt que du hasard. stop prend une ou plusieurs chaînes qui arrêtent la génération dès que le modèle les écrit, un moyen peu coûteux de couper une réponse à un délimiteur et d'éviter de payer pour des tokens que vous jetteriez.

Réponses en streaming

Avec stream: true, le serveur répond via des événements envoyés par le serveur et envoie le texte en petits deltas. Les utilisateurs voient les premiers mots rapidement, ce qui est important dans les interfaces de chat. Les données d'utilisation arrivent à la fin du flux.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem 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("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Deux points sont faciles à manquer. Premièrement, le dernier fragment peut contenir des données d'utilisation et une liste choices vide, donc vérifiez que choices n'est pas vide avant de l'indexer. Deuxièmement, une requête en streaming occupe son slot de requêtes simultanées jusqu'à la fin du flux. Si un client ouvre un flux et ne le lit pas jusqu'au bout, ce slot reste occupé et vos requêtes ultérieures peuvent rencontrer une erreur concurrency. Fermez ou consommez toujours entièrement les flux.

Appel de fonctions

L'appel de fonctions permet au modèle de demander à votre code d'exécuter une fonction et d'utiliser le résultat. Vous décrivez les fonctions dans tools, orientez éventuellement le choix avec tool_choice, exécutez ce que le modèle demande et renvoyez la sortie en tant que message avec role: "tool".

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1043?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"order_id": args["order_id"], "status": "shipped"}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

Analysez toujours function.arguments de manière défensive. C'est une chaîne JSON produite par un modèle de langage et, dans de rares cas, elle peut être mal formée ou contenir un champ que vous n'avez pas défini. Validez-la avant d'agir dessus, en particulier lorsque la fonction modifie des données. Les appels de fonctions fonctionnent également avec le streaming, auquel cas les tool_calls arrivent sous forme de fragments que vous devez joindre par index avant l'analyse.

Gestion de l'historique de conversation

L'API est sans état. Elle ne se souvient pas des requêtes précédentes, donc une conversation multi-tours ne fonctionne que parce que votre code renvoie les tours précédents à chaque fois. Conservez une liste de messages, ajoutez le nouveau message de l'utilisateur, appelez l'endpoint, puis ajoutez la réponse de l'assistant avant le tour suivant.

history = [{"role": "system", "content": "You are a patient writing coach."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    resp = client.chat.completions.create(model="uncensored", messages=history)
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))

Comme chaque tour renvoie l'historique, les tokens d'entrée augmentent avec la longueur de la conversation. La fenêtre de contexte contient 100 000 tokens, ce qui est suffisant pour la plupart des conversations, mais le coût augmente bien avant d'atteindre la limite. Un modèle courant consiste à conserver le message système et les derniers tours, et à remplacer les tours plus anciens par un résumé court que le modèle lui-même écrit. Lisez usage.prompt_tokens après chaque appel pour voir la taille de l'historique.

Mode JSON

Lorsque vous avez besoin d'une sortie lisible par machine, définissez response_format sur {"type": "json_object"} et indiquez dans le prompt que vous voulez du JSON. Décrire les clés que vous attendez rend le résultat beaucoup plus stable.

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
        {"role": "user", "content": "Describe a short story about a lost robot."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Le mode JSON fait que la sortie peut être analysée en JSON, mais il n'impose pas votre schéma. Vérifiez les clés dans le code et gardez une solution de repli au cas où une valeur manquerait. Si la réponse est coupée parce qu'elle a atteint une limite de tokens, le JSON sera incomplet, donc ne définissez pas max_tokens trop bas pour la sortie structurée.

Une courte liste de vérification en cas d'échec

La plupart des problèmes du premier jour proviennent d'un petit nombre de causes, et vous pouvez les éliminer dans l'ordre.

  1. URL de base. Elle doit se terminer par /v1. Le SDK ajoute /chat/completions lui-même, donc une URL avec le chemin déjà inclus ne fonctionnera pas.
  2. En-tête de clé. La clé va dans Authorization: Bearer suivi de la clé. Un espace ou une nouvelle ligne copiés avec la clé est une cause fréquente d'erreurs d'authentification.
  3. ID de modèle. Utilisez uncensored exactement. Les noms des modèles d'autres fournisseurs ne sont pas valides ici.
  4. Taille de la requête. La limite du corps est de 8 Mo, et le prompt plus la complétion doivent tenir dans 100 000 tokens.
  5. Solde. Consultez l'en-tête X-Balance-USD sur n'importe quelle réponse pour voir si le crédit est le problème.
  6. Citez l’ID de requête. Si vous contactez le support, incluez la valeur X-Request-Id de la réponse défaillante pour que la requête soit retrouvée.

Gardez à l'esprit qu'un refus n'est pas la même chose qu'une erreur. Parce que le modèle est ajusté pour éviter les refus de contenu pour un usage adulte légal, vous en verrez moins que sur les services filtrés, mais le modèle peut toujours décliner ou donner une réponse faible à un prompt vague. Un message système plus clair résout généralement mieux cela qu'une température plus élevée.

Limites, en-têtes et nouvelles tentatives

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. Le corps de la requête peut atteindre 8 Mo. Chaque réponse contient X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests et X-RateLimit-Limit-Concurrency, qui sont pratiques pour la journalisation et pour afficher un solde sur un écran d'administration.

Lorsque vous dépassez une limite, l'API renvoie HTTP 429. Le code d'erreur rate_limited signifie trop de requêtes par minute, et concurrency signifie trop en même temps. En cas de surcharge temporaire, vous obtenez également 429, avec un en-tête Retry-After: 5. Un simple wrapper de nouvelle tentative couvre les trois cas :

import time
from openai import RateLimitError

def ask(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = 5 if attempt == 0 else 5 * (attempt + 1)
            retry_after = getattr(e.response, "headers", {}).get("retry-after")
            time.sleep(int(retry_after) if retry_after else wait)
    raise RuntimeError("still rate limited after retries")

Pour un pool de travailleurs, limitez la taille du pool à votre limite de concurrence au lieu de compter sur les nouvelles tentatives. Huit travailleurs sur une clé complète verront rarement une erreur concurrency. Si vous rencontrez des erreurs inattendues, l'article de dépannage passe en revue les causes courantes.

Paiement

La facturation est au paiement à l'usage à partir de crédit prépayé : 0,15 $ par 1 M de tokens d'entrée et 0,50 $ par 1 M de tokens de sortie, sans abonnement. Les requêtes échouées ou refusées ne sont pas facturées, et le crédit n'expire jamais. Une requête avec 1 500 tokens d'entrée et 400 tokens de sortie coûte 1 500 / 1 000 000 x 0,15 $ + 400 / 1 000 000 x 0,50 $ = 0,000225 $ + 0,0002 $ = 0,000425 $.

Les recharges sont n'importe quel montant entier de 20 $ à 500 $, avec un bonus de 5 % à partir de 50 $, 10 % à partir de 100 $ et 15 % à partir de 200 $. Vous pouvez payer avec de la crypto uniquement (USDT sur TRC20, USDC sur Base). Les prompts ne sont pas utilisés pour l'entraînement. La page de tarification liste les détails et le guide de démarrage rapide répète les étapes de configuration sous forme courte.

Questions et réponses

Puis-je utiliser la bibliothèque officielle OpenAI avec cette API ?

Oui. Installez le SDK OpenAI pour Python ou Node, définissez l'URL de base sur https://api.llminferenceapi.com/v1, passez votre clé et utilisez l'ID de modèle uncensored.

L’API prend-elle en charge l’appel de fonctions ?

Oui. Transmettez les outils et optionnellement tool_choice, puis renvoyez chaque résultat en tant que message avec le rôle tool. Les tool_calls en streaming sont également pris en charge.

Que signifie une erreur 429 ici ?

Vous avez atteint une limite. Le code rate_limited signifie trop de requêtes par minute, concurrency signifie trop de requêtes au même moment, et un en-tête Retry-After: 5 signale une surcharge temporaire. Attendez et réessayez.

Puis-je l’utiliser pour les embeddings ou les images ?

Non. L'API est uniquement textuelle et propose des complétions de chat et une liste de modèles.

Votre clé est à un pas de vous

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

Obtenir une clé API