FR ▾
Obtenir une clé API

API LLM en Python : chat, streaming et appels d'outils

Ce guide de l'API LLM en Python utilise le SDK OpenAI officiel pointé vers un endpoint compatible OpenAI. Vous obtenez une première requête, le streaming, un appel d'outil et la logique de retry dans un code que vous pouvez coller et exécuter.

Mis à jour

Bande de blocs de code s'écoulant d'un ordinateur portable vers des bulles de chat, illustrant un appel API LLM Python
01

Points clés

  • Installez openai, définissez l'URL de base et la clé, et utilisez l'ID de modèle uncensored.
  • Utilisez le streaming avec stream=True et fermez le flux tôt pour libérer le slot de concurrence.
  • Les appels d'outils retournent des arguments que vous devez analyser et valider avant d'exécuter quoi que ce soit.
  • Gérez le 429 avec Retry-After et limitez les requêtes simultanées à 8 avec une clé complète.

Installer le SDK et faire le premier appel

Si vous souhaitez une configuration API LLM en Python opérationnelle en cinq minutes, le SDK OpenAI suffit. L'API est compatible OpenAI, donc vous gardez le client officiel et modifiez deux valeurs : l'URL de base et la clé. L'ID de modèle est uncensored.

Commencez par obtenir une clé. Inscrivez-vous sur la page des clés API, réclamez le crédit d'essai en un clic, et copiez la clé. Ensuite, installez le client et gardez la clé hors de votre code source.

pip install openai
export LLM_API_KEY="your-key-here"

Voici maintenant le programme le plus utile :

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage)

C'est toute l'intégration. resp.usage donne les comptes de tokens de prompt et de complétion, que vous pouvez multiplier par les tarifs sur la page de tarification (0,15 $ par 1M de tokens d'entrée, 0,50 $ par 1M de tokens de sortie) pour voir le coût de chaque requête. Le même endpoint accepte également POST /v1/responses si votre code utilise déjà ce format, et GET /v1/models liste l'ID de modèle.

À quoi ressemble la requête et la réponse

Le client OpenAI masque les détails HTTP, mais il est utile de les connaître quand quelque chose se passe mal. Le SDK envoie un POST à /v1/chat/completions avec un jeton bearer. Vous pouvez reproduire l'appel avec curl et comparer.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Paramètres utiles qui sont transmis au modèle : temperature, top_p, stop, seed et les pénalités de fréquence et de présence. max_tokens est optionnel. Si vous le laissez de côté, la complétion peut utiliser tout ce qui reste de la fenêtre de 100 000 tokens (prompt et complétion ensemble).

Deux en-têtes de réponse méritent d'être enregistrés à chaque appel : X-Request-Id pour les questions de support, et X-Balance-USD pour votre crédit restant. Avec le SDK Python, vous y accédez via la réponse brute :

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Streaming des tokens à leur arrivée

Pour les interfaces de chat et tout ce à quoi une personne attend, activez le streaming de la réponse. Définissez stream=True et itérez sur les blocs. L'API les envoie via des événements envoyés par le serveur, et le dernier bloc contient les informations d'utilisation lorsque vous le demandez.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    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)

Deux détails posent souvent problème. Premièrement, certains blocs ont une liste choices vide (le bloc d'utilisation, par exemple), donc vérifiez avant d'accéder par index. Deuxièmement, une requête en streaming occupe son slot de concurrence jusqu'à la fin du flux. Si vous ouvrez un flux et l'abandonnez sans le fermer, ce slot reste occupé et les appels ultérieurs peuvent échouer avec une erreur concurrency. Utilisez le streaming dans un bloc with ou appelez stream.close() lorsque vous arrêtez la lecture prématurément.

Si un flux se coupe avec un message peu clair, l'article sur comment utiliser un modèle LLM sur ce site couvre les bases de la lecture des erreurs et des nouvelles tentatives.

Un appel d'outil contre le modèle

L'appel de fonctions permet au modèle de demander à votre code d'exécuter une fonction, puis de continuer avec le résultat. Le flux comporte trois étapes : envoyer les définitions d'outils, exécuter ce que le modèle demande, et renvoyer la sortie avec role: "tool".

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

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-1042?"}]
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)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Analysez toujours call.function.arguments comme du JSON dans un bloc try dans le code réel, car les modèles produisent parfois des arguments qui ne correspondent pas à votre schéma. Validez avant d'exécuter quoi que ce soit ayant des effets secondaires. Pour les boucles d'agents plus longues, consultez le guide sur l'utilisation de cette API pour les agents.

Les appels de fonctions stream également : les arguments arrivent par morceaux dans delta.tool_calls, et vous les concaténez par index jusqu'à la fin du stream.

Mode JSON pour les sorties structurées

Lorsque vous avez besoin d'une sortie lisible par machine plutôt que de texte, définissez response_format sur un objet JSON. Décrivez la forme souhaitée dans le prompt, car le mode JSON garantit une syntaxe JSON valide mais pas votre schéma particulier.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Utilisez temperature=0 pour l'extraction et la classification afin que les exécutions répétées donnent les mêmes étiquettes. Ajoutez seed si vous souhaitez verrouiller davantage l'échantillonnage, et validez toujours le résultat analysé par rapport à votre propre schéma.

Limites, tentatives et gestion des erreurs

Une clé complète permet 8 requêtes concurrentes et 300 requêtes par minute. Une clé d'essai permet 2 requêtes concurrentes et 60 par minute. En dépasser l'une ou l'autre renvoie un HTTP 429. Le code d'erreur indique quelle limite vous avez atteinte : rate_limited pour les requêtes par minute et concurrency pour trop de requêtes à la fois. En cas de surcharge temporaire, vous obtenez également un 429 avec un en-tête Retry-After: 5.

Le SDK OpenAI tente déjà de nouvelles tentatives pour certaines erreurs, mais vous devez définir la politique vous-même :

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Si vous répartissez le travail avec des threads ou asyncio, limitez le pool à 8 (ou 2 avec une clé d'essai) à l'aide d'un sémaphore. Cela vous maintient sous la limite de concurrence sans dépendre des nouvelles tentatives. Les requêtes échouées ou refusées ne sont pas facturées, donc les nouvelles tentatives ne coûtent pas plus cher pour les tentatives échouées.

Vérifiez votre solde depuis le code avec GET /v1/balance, ou lisez X-Balance-USD depuis n'importe quelle réponse. La liste complète des paramètres se trouve dans la documentation de l'API.

Combien coûtent ces exemples

Les exemples ci-dessus sont minuscules. Une requête avec 300 tokens de prompt et 200 tokens de complétion coûte 300 x 0,15 $ / 1M plus 200 x 0,50 $ / 1M, soit 0,000045 $ plus 0,0001 $, ou 0,000145 $. Environ 6 900 de ces requêtes tiennent dans un dollar. Le crédit d'essai de 0,50 $ couvre environ 3 400 d'entre eux, et il est valable 7 jours sans détails de paiement.

Après l'essai, rechargez 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 $. Le crédit n'expire jamais et il n'y a pas d'abonnement. Les prompts ne sont pas utilisés pour l'entraînement.

02

Questions et réponses

Puis-je utiliser la bibliothèque Python officielle OpenAI ?

Oui. Définissez base_url sur l'adresse de l'API et api_key sur votre clé, puis appelez chat.completions.create avec le modèle uncensored.

L'API prend-elle en charge le Python asynchrone ?

Oui, utilisez AsyncOpenAI avec la même URL de base et la même clé. Maintenez les tâches concurrentes à 8 au maximum avec une clé complète, ou 2 avec une clé d'essai.

Comment voir combien de tokens une requête a utilisés ?

Lisez resp.usage sur une requête normale, ou passez stream_options avec include_usage sur une requête en streaming. Multipliez par 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie.

Quelle est la longueur maximale de mon prompt ?

La fenêtre de contexte est de 100 000 tokens, prompts et complétions combinés. Le corps de la requête est limité à 8 Mo.

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