Comment implémenter un LLM en Python avec une API hébergée
Pour la plupart des projets, la mise en œuvre d'un LLM en Python se résume à appeler un modèle hébergé via HTTP, plutôt qu'à l'entraîner ou à le servir vous-même. Avec une API compatible OpenAI, cela prend environ dix lignes, et le même code évolue vers le streaming, la sortie JSON et l'appel de fonctions.
Mis à jour

Points clés
- Installez le package openai, définissez une URL de base et une clé, puis utilisez l'ID de modèle uncensored.
- Le streaming, le mode JSON et l'appel de fonctions sont tous pris en charge et utilisent les arguments standard du SDK.
- Conservez l'historique de chat dans une liste et surveillez la fenêtre de 100 000 tokens.
- Gérez l'erreur HTTP 429 avec un court retry ; les requêtes échouées ou refusées ne sont pas facturées.
Commencez avec le crédit d'essai
E-mail et mot de passe, la clé s'affiche tout de suite à l'écran.
Obtenir une clé APIAPI hébergée ou votre propre modèle
Il existe deux façons d'intégrer un modèle de langage dans un programme Python. Vous pouvez exécuter les poids vous-même, ce qui implique un GPU, une pile de service, des choix de quantification et beaucoup d'attente pour les téléchargements. Ou vous pouvez envoyer des requêtes à un modèle déjà géré par quelqu'un d'autre. La première voie est pertinente pour la recherche, une isolation stricte des données ou un volume élevé et stable. La seconde convient à presque tout le reste : un script, un bot, une fonctionnalité produit, un prototype que vous souhaitez voir fonctionner avant le déjeuner.
Ce guide suit la deuxième voie. Le service ici est une API textuelle hébergée compatible OpenAI avec un seul modèle à poids ouverts, géré par un fournisseur indépendant et optimisé pour répondre sans refus de contenu pour un usage adulte légal. Ce n'est pas une API officielle d'un fournisseur de modèle. Comme il suit le format de requête OpenAI, le package standard openai fonctionne, tout comme requests si vous préférez sans dépendances.
Étape 1 : installer et faire la première requête
Installez le SDK et stockez votre clé dans une variable d'environnement, afin qu'elle n'apparaisse jamais dans votre code source.
pip install openai
export API_KEY="your-key-here"
Créez ensuite un client avec l'URL de base du service. Les seuls éléments à modifier par rapport à toute autre configuration de style OpenAI sont l'URL, la clé et le nom du modèle.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxapikey.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain list comprehensions in two sentences."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
C'est un programme complet et fonctionnel. L'endpoint derrière est POST /v1/chat/completions, authentifié avec Authorization: Bearer <key>, et GET /v1/models liste l'ID de modèle. Vous pouvez obtenir une clé et un petit crédit d'essai sur la page de clé.
Étape 2 : diffuser la réponse
Attendre plusieurs secondes pour une réponse complète semble lent dans un terminal ou une page web. Définissez stream=True et affichez les tokens à mesure qu'ils arrivent via les événements envoyés par le serveur.
# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
Les données d'utilisation arrivent à la fin du flux, donc le dernier chunk peut ne pas avoir de choices. C'est pourquoi la boucle vérifie d'abord chunk.choices. À retenir : une requête en streaming conserve son slot de concurrence jusqu'à la fin du flux, donc lisez toujours jusqu'au bout ou fermez-le.
Étape 3 : maintenir une conversation
Le modèle n'a pas de mémoire entre les appels. Un chat n'est qu'une liste de messages croissante que vous renvoyez à chaque fois. Une petite classe suffit :
# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
def __init__(self, system):
self.messages = [{"role": "system", "content": system}]
def say(self, text):
self.messages.append({"role": "user", "content": text})
r = client.chat.completions.create(model="uncensored", messages=self.messages)
answer = r.choices[0].message.content
self.messages.append({"role": "assistant", "content": answer})
return answer
bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))
La fenêtre de contexte est de 100 000 tokens, partagée par le prompt et la complétion. C'est confortable, mais un long chat grandit à chaque tour, et vous payez pour tout l'historique à chaque requête. Quand il devient volumineux, supprimez les tours les plus anciens ou remplacez-les par un court résumé que vous demandez au modèle de rédiger.
Étape 4 : obtenir une sortie structurée
Les programmes veulent des données, pas des paragraphes. Le mode JSON rend la réponse JSON valide. Indiquez dans le prompt les clés que vous attendez.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
{"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])
Un JSON valide ne garantit pas vos clés. Vérifiez-les dans le code et réessayez une fois si l'une manque.
Étape 5 : permettre au modèle d'appeler vos fonctions
L'appel de fonctions permet au modèle de demander à votre programme d'exécuter une fonction, puis de continuer avec le résultat. Vous décrivez l'outil, vérifiez si la réponse contient un appel, l'exécutez et renvoyez la sortie avec le rôle tool.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
tools = [{
"type": "function",
"function": {
"name": "get_word_count",
"description": "Count the words in a text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = len(args["text"].split())
messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
Validez toujours les arguments avant d'agir dessus, car le modèle peut produire un appel que vous n'avez pas prévu. Les appels d'outils sont également en streaming, sous forme de deltas tool_calls, si vous en avez besoin. La documentation liste tous les champs.
Étape 6 : gérer les limites et les erreurs
Une clé complète permet 8 requêtes simultanées et 300 par minute ; une clé d'essai en permet 2 et 60. Si vous dépassez, l'API répond HTTP 429. Le code d'erreur est rate_limited pour trop de requêtes par minute et concurrency pour trop en même temps. En cas de surcharge temporaire, vous obtenez également un 429, avec un en-tête Retry-After: 5. Un petit wrapper de retry couvre les trois cas :
# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError
def ask(messages, tries=4):
for i in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still limited after retries")
Si vous exécutez du travail dans des threads, limitez-les à 8 avec un ThreadPoolExecutor(max_workers=8) pour atteindre rarement la limite de concurrence. Chaque réponse contient X-Request-Id, ce qu'il faut citer si vous contactez le support, et X-Balance-USD indique votre crédit restant. La taille maximale du corps est de 8 Mo.
Paramètres qui modifient la sortie
La plupart du réglage au quotidien se fait avec une poignée de paramètres, tous transmis au modèle.
temperaturecontrôle l'aléatoire. Utilisez 0,2 ou moins pour l'extraction et la classification, environ 0,7 pour le chat, et 1,0 ou plus pour le brainstorming et la fiction.top_préduit la queue peu probable des choix de mots. Modifiez soit cela, soit la température, pas les deux à la fois, afin de savoir lequel a fait le travail.seedrend les exécutions répétées plus comparables. Il est utile dans les tests où vous voulez voir l'effet d'un changement de prompt et non le bruit.stoparrête la génération à une chaîne que vous choisissez, ce qui est pratique pour couper un modèle qui continue d'ajouter des commentaires.max_tokensest optionnel. Sans lui, la complétion peut utiliser tout ce qui reste de la fenêtre de 100 000 tokens. Définissez-le lorsque vous voulez un plafond strict sur la longueur et le coût.- Les pénalités de fréquence et de présence découragent la répétition, ce qui aide pour les sorties créatives longues qui commencent à boucler.
Notez les paramètres que vous avez utilisés à côté de toute sortie qui vous intéresse. Des mois plus tard, « pourquoi a-t-il répondu différemment » est presque toujours un paramètre changé ou un message système changé.
Exécuter de nombreuses requêtes simultanément
Une boucle qui envoie une requête à la fois gaspille la plupart de votre quota. Avec une clé complète, vous pouvez avoir 8 requêtes en cours, donc un pool de threads réduit un lot long à environ un huitième du temps réel.
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")
def summarise(text):
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise in one line: " + text}],
max_tokens=60,
)
return r.choices[0].message.content
texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
for line in pool.map(summarise, texts):
print(line)
Maintenez le nombre de workers à 8 ou moins, ou à 2 sur une clé d'essai. Si vous voyez toujours des réponses 429 avec le code concurrency, réduisez le nombre d'une ou deux unités. La limite de 300 par minute est importante pour les requêtes rapides et courtes, donc un lot d'appels minuscules peut l'atteindre avant le plafond de concurrence.
Problèmes courants et solutions
La plupart des erreurs du premier jour proviennent d'une courte liste de causes.
- 401 ou erreur d'authentification. La clé est manquante, mal tapée ou envoyée au mauvais hôte. Affichez l'URL de base que votre client utilise réellement et assurez-vous qu'elle se termine par
/v1. - Modèle non trouvé. L'ID du modèle doit être
uncensored. AppelezGET /v1/modelssi vous voulez confirmer ce que le serveur liste. - Réponse vide ou coupée. Un
max_tokensfaible arrête la réponse en plein milieu d'une phrase. Augmentez-le ou supprimez-le. Vérifiezfinish_reasonsur le choix :lengthsignifie que le plafond a été atteint. - JSON qui ne s'analyse pas. Soit la réponse a été tronquée, soit le prompt n'a jamais décrit la forme. Corrigez d'abord le prompt et enveloppez l'analyse dans un bloc try.
- Premier token lent. Un prompt très long prend plus de temps à traiter. Réduisez l'historique ou envoyez moins de contexte.
- Requête trop volumineuse. La limite du corps est de 8 Mo, et la fenêtre de tokens est de 100 000. Divisez les grands documents en morceaux et résumez chacun.
Quand quelque chose semble encore incorrect, enregistrez l'en-tête X-Request-Id avec l'entrée défaillante. Cela permet au support de trouver la requête exacte.
Ce que cela coûte
Vous payez 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie depuis le crédit prépayé. Une requête typique avec 2 000 tokens en entrée et 500 en sortie coûte 0,002 x 0,15 $ = 0,0003 $ pour l'entrée plus 0,0005 x 0,50 $ = 0,00025 $ pour la sortie, soit 0,00055 $ au total. Dix mille de ces requêtes coûtent 5,50 $. Les requêtes échouées ou refusées ne sont pas facturées et le crédit n'expire jamais. Les recharges vont de 20 $ à 500 $ ; voir tarifs pour les paliers de bonus. Les prompts ne sont pas utilisés pour l'entraînement.
Les tokens de sortie coûtent plus cher que les tokens d'entrée, donc la meilleure habitude est de demander des réponses courtes : dites deux phrases, ou JSON uniquement, et définissez max_tokens à un plafond raisonnable. Lisez resp.usage pendant le développement pour voir les vrais nombres de tokens pour vos prompts, et multipliez par les tarifs ci-dessus avant de mettre à l'échelle une tâche. L'en-tête X-Balance-USD affiche ce qu'il reste après chaque appel.
Plus de guides
Questions et réponses
Ai-je besoin d'un GPU pour implémenter un LLM en Python ?
Pas avec une API hébergée. Votre code Python envoie uniquement des requêtes HTTP, donc n'importe quel ordinateur portable suffit.
Puis-je utiliser le package officiel openai ?
Oui. Définissez base_url sur l'URL du service et api_key sur votre clé, et utilisez l'ID de modèle uncensored.
Prend-il en charge le code asynchrone ?
Le client AsyncOpenAI du SDK fonctionne avec la même URL de base et la même clé. Maintenez la concurrence à 8 requêtes ou moins.
Comment l'essayer sans payer ?
Inscrivez-vous et réclamez le crédit d'essai de 0,50 $ sur la page de la clé. Il est valable 7 jours et ne nécessite pas de carte.
Votre clé est à un seul formulaire
Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.