API Deep Learning pour texte : créez rapidement un chatbot
Une API de deep learning pour texte vous permet de créer un chatbot fonctionnel en environ quinze minutes, car le modèle gère le travail linguistique et vous gérez uniquement les messages. Voici un chatbot Python complet avec historique, streaming et budget de tokens, utilisant un endpoint compatible OpenAI.

Résumé
- Un chatbot est une boucle qui ajoute des messages et renvoie l'historique à chaque tour.
- Le coût d'entrée augmente à chaque tour, donc réduisez ou résumez les anciens messages.
- Le streaming fournit l'utilisation à la fin, que vous pouvez utiliser pour suivre les dépenses.
- Supprimer les anciens tours réduit d'environ 62 % le nombre de tokens d'entrée d'une conversation de 50 tours.
Ce dont vous avez besoin
Le modèle est hébergé, il n'y a donc rien à entraîner et pas de GPU à louer. Vous avez besoin de Python 3.9 ou version ultérieure, du SDK OpenAI (pip install openai) et d'une clé. Inscrivez-vous, réclamez le crédit d'essai de 0,50 $ sur la page clé API, et conservez la clé dans une variable d'environnement :
# endpoint https://api.deepapi.cc/v1, model uncensored
export DEEPAPI_KEY="paste-your-key-here"
Le point de terminaison est https://api.deepapi.cc/v1 et l'ID de modèle est uncensored. Il s'agit d'une API compatible OpenAI, textuelle uniquement, servant un seul modèle à poids ouverts géré par un fournisseur indépendant, le code est donc identique à celui de n'importe quel client OpenAI. Il n'y a pas d'embeddings, d'images ou d'audio ici, uniquement du texte en entrée et du texte en sortie.
L'idée centrale : le modèle n'a pas de mémoire
Chaque requête est indépendante. L'API ne se souvient pas de ce que vous avez dit il y a une minute. Pour avoir une conversation, vous envoyez toute la conversation à chaque fois : un message système, puis des messages alternés utilisateur et assistant, se terminant par le nouveau message utilisateur. La réponse est ajoutée à la liste, et le tour suivant envoie la liste plus longue.
Ce seul fait explique la plupart des choix de conception d'un chatbot. C'est pourquoi les longs chats coûtent plus cher par tour, pourquoi vous avez besoin d'un plan pour les anciens messages, et pourquoi la fenêtre de contexte est importante. Ce service dispose de 100 000 tokens au total pour le prompt plus la réponse.
Un chatbot en 40 lignes
Cette version diffuse la réponse, conserve l'historique et affiche l'utilisation des tokens après chaque tour.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.deepapi.cc/v1",
api_key=os.environ["DEEPAPI_KEY"],
)
SYSTEM = {"role": "system", "content": "You are a friendly, concise assistant."}
history = [] # user and assistant messages only
MAX_TURNS = 10 # keep about the last 10 exchanges
def reply(user_text):
history.append({"role": "user", "content": user_text})
window = history[-MAX_TURNS * 2:]
stream = client.chat.completions.create(
model="uncensored",
messages=[SYSTEM] + window,
stream=True,
temperature=0.7,
)
text, usage = "", None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
print(piece, end="", flush=True)
text += piece
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
history.append({"role": "assistant", "content": text})
return usage
while True:
user = input("you> ").strip()
if user in {"", "exit", "quit"}:
break
u = reply(user)
if u:
cost = u.prompt_tokens * 0.15 / 1e6 + u.completion_tokens * 0.50 / 1e6
print(f"[{u.prompt_tokens} in, {u.completion_tokens} out, ${cost:.5f}]")
Exécutez-le, discutez pendant quelques tours et regardez le nombre "in" augmenter. La réponse diffusée rapporte l'utilisation à la fin, donc le chiffre est exact et ne nécessite pas d'estimation.
Gestion du budget de tokens : pourquoi la réduction est importante
Supposons que le prompt système fasse 200 tokens, et que chaque tour ajoute 100 tokens de l'utilisateur et 250 de l'assistant. Sans réduction, le tour k envoie 200 + 350 x (k - 1) + 100 tokens d'entrée. Sur une conversation de 50 tours :
- Total entrée : 50 x 300 + 350 x (0 + 1 + ... + 49) = 15 000 + 350 x 1 225 = 443 750 tokens
- Total sortie : 50 x 250 = 12 500 tokens
- Coût : 443 750 x $0,15 / 1M = $0,0666, plus 12 500 x $0,50 / 1M = $0,0063, ce qui représente environ $0,073
Conservez maintenant uniquement les 10 derniers échanges. Les 10 premiers tours coûtent 18 750 tokens d'entrée, et chacun des 40 suivants envoie 3 700, soit 148 000. Le total est de 166 750 tokens d'entrée, soit environ 62 % de moins qu'avant, pour un coût de $0,0250 en entrée.
L'économie est plus importante avec des messages plus longs ou plus d'utilisateurs. Un chatbot servant des milliers de conversations par jour voit la différence sur son solde.
Mieux que la suppression : résumer
Supprimer les anciens tours perd les faits mentionnés tôt par l'utilisateur, comme un nom ou une préférence. Une solution courante est de demander au modèle un résumé court lorsque l'historique s'allonge, et de conserver le résumé au lieu des anciens messages.
# uses the client from above (base_url https://api.deepapi.cc/v1)
def compress(history, keep=6):
if len(history) <= keep * 2:
return history
old, recent = history[:-keep * 2], history[-keep * 2:]
summary = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Summarise this conversation in under 120 words. Keep names, facts and open questions."},
{"role": "user", "content": "\n".join(m["role"] + ": " + m["content"] for m in old)},
],
).choices[0].message.content
return [{"role": "user", "content": "Summary of earlier chat: " + summary}] + recent
Appelez-le de temps en temps, par exemple lorsque l'historique dépasse 20 messages : history = compress(history). L'appel de résumé coûte quelques milliers de tokens une fois, puis chaque tour suivant est moins cher. Définissez également un budget approximatif. Un comptage de caractères divisé par quatre est une bonne estimation des tokens pour l'anglais, et le bloc d'utilisation donne le nombre réel après chaque appel.
Tester le bot avant que les vrais utilisateurs ne le voient
Un chatbot qui fonctionne pour trois messages amicaux peut encore échouer en production. Passez d'abord par cette courte liste de vérification.
- Réponses longues. Demandez une histoire de 1 000 mots et confirmez que le streaming ne se bloque pas et que le texte complet atterrit dans
history. - Entrée vide et énorme. Envoyez une ligne vide et un mur de texte collé. La boucle ci-dessus ignore l'entrée vide, mais vous devriez également limiter la longueur d'un message avant qu'il n'atteigne l'API.
- Connexion interrompue. Coupez le réseau au milieu d'un streaming. La réponse partielle ne doit pas être sauvegardée comme si elle était complète, donc ajoutez à
historyuniquement après la fin de la boucle sans exception. - Mémoire des faits précoces. Dites au bot votre nom au tour un, puis demandez-le au tour quinze. S'il échoue, passez de la simple réduction à l'approche du résumé.
- Coût par conversation. Exécutez un chat de 20 tours et additionnez les coûts imprimés. Multipliez par le nombre de conversations que vous attendez par jour.
Gardez le prompt système court et spécifique. Indiquez le rôle du bot, le ton et toute règle de format en quelques lignes, et testez les modifications une par une. Chaque mot du prompt système est envoyé à nouveau à chaque tour, donc un prompt de 200 tokens coûte environ 0,00003 $ par requête en entrée, ce qui est faible mais s'accumule sur des milliers de requêtes.
Gestion des limites et des erreurs
Un chatbot mono-utilisateur atteint rarement les limites, mais un déploiement le fera. Une clé complète permet 8 requêtes simultanées et 300 par minute, une clé d'essai 2 et 60. Au-delà d'une limite, l'API renvoie HTTP 429 avec le code rate_limited ou concurrency. Une surcharge temporaire renvoie également 429 avec Retry-After: 5. Comme une requête diffusée conserve sa place jusqu'à la fin du streaming, un chat web avec de nombreux streams ouverts doit mettre en file d'attente ou rejeter les nouveaux. Les requêtes échouées ou refusées ne sont pas facturées, donc réessayer ne coûte rien de plus.
Autres paramètres utiles : temperature et top_p pour la variété, stop pour des fins personnalisées, et seed pour des exécutions de test reproductibles. Le mode JSON et l'appel de fonctions sont disponibles pour des réponses structurées et l'utilisation de fonctions. La documentation les couvre tous.
Le mettre sur un site web
Le même schéma fonctionne derrière un endpoint web. Gardez la clé API sur le serveur, jamais dans le JavaScript du navigateur, car n'importe qui peut lire le code client. Le navigateur envoie le nouveau message utilisateur à votre serveur, votre serveur charge l'historique de cet utilisateur, appelle l'API et diffuse la réponse en retour.
Trois détails évitent les ennuis. Stockez l'historique par session pour que les utilisateurs ne voient pas les conversations des autres. Limitez la longueur d'un message utilisateur avant de le transmettre, car un roman collé coûte de l'argent réel. Et limitez les streams simultanés par clé à la concurrence de votre plan : avec une clé complète, c'est 8 à la fois, et un neuvième doit attendre dans une file d'attente. Pour un petit outil interne, cela prend quelques dizaines de lignes, et l'URL de base et la clé sont les seules parties spécifiques au fournisseur.
Où aller ensuite
Entourez reply dans un petit serveur web, stockez l'historique par utilisateur dans une base de données, et ajoutez un personnage dans le prompt système. Si vous voulez comparer les fournisseurs avant de vous engager, l'article sur les alternatives à l'API DeepSeek liste les critères. Pour les coûts à votre échelle, voir la page de tarification. Les recharges vont de 20 $ à 500 $, en crypto uniquement, avec des bonus à partir de 50 $, et le crédit n'expire jamais.
Plus de guides
FAQ
Dois-je entraîner un modèle pour utiliser une API d'apprentissage profond pour le texte ?
Non. Le modèle est déjà entraîné et hébergé. Vous envoyez des messages via HTTPS et recevez du texte en retour.
L'API se souvient-elle des messages précédents ?
Non. Chaque requête est indépendante, votre code doit donc renvoyer l'historique de la conversation à chaque tour.
Combien de tokens une conversation peut-elle utiliser ?
La fenêtre de contexte est de 100 000 tokens pour le prompt et la complétion. Réduisez ou résumez avant d'approcher cette limite.
Puis-je l'utiliser depuis JavaScript ?
Oui. Utilisez le SDK Node.js d'OpenAI avec baseURL défini sur https://api.deepapi.cc/v1 et le modèle uncensored, ou appelez l'endpoint avec fetch.
Obtenez votre clé API instantanément
Inscrivez-vous, copiez votre clé, mettez à jour votre URL de base. C'est tout.