Ce que vous apporte le streaming
Sans streaming, l'API conserve toute la réponse jusqu'à ce que le modèle ait terminé, puis l'envoie dans un seul corps de requête/réponse JSON. Pour une longue réponse, cela peut signifier plusieurs secondes d'écran vide. Avec stream: true, le serveur envoie la même réponse sous forme d'une série de petits événements, chacun contenant quelques caractères de la réponse, et votre interface utilisateur peut les afficher au fur et à mesure de leur arrivée.
Le format de transmission est les événements envoyés par le serveur (SSE) sur une réponse HTTP standard. Chaque événement est une ligne commençant par data: suivie d'un fragment JSON, et le flux se termine par data: [DONE]. Vous rarement analyser cela à la main, car les SDK OpenAI le font pour vous. Si vous voulez voir les octets bruts, la vue d'ensemble pour les développeurs montre la disposition de l'endpoint et la documentation de l'API liste chaque paramètre.
Deux choses méritent d'être décidées avant d'écrire du code. Premièrement, qui lit le flux : un navigateur communiquant avec votre serveur, ou votre serveur seul. Deuxièmement, ce que vous faites lorsque la connexion se brise à mi-parcours. Le reste de cette page couvre les deux aspects.
Python : stream avec le SDK OpenAI
Installez le SDK avec pip install openai, créez un client avec notre URL de base, et passez stream=True. L'ID du modèle est uncensored.
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredllmapi.com/v1",
api_key="YOUR_KEY",
)
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about rain."}],
stream=True,
)
text = []
usage = None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text.append(piece)
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
print("tokens:", usage)
Attention à la garde chunk.choices and .... Le dernier chunk contenant les informations d'utilisation peut avoir une liste choices vide, et y accéder provoquerait une erreur. Collecter les morceaux dans une liste puis les joindre à la fin est également moins coûteux que des concaténations de chaînes répétées sur les longues réponses.
Node : le même appel en JavaScript
Avec le package officiel openai pour Node, le flux est un itérateur asynchrone. Cet exemple utilise des modules ES.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredllmapi.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Name three uses for a stream." }],
stream: true,
});
let full = "";
let usage = null;
for await (const chunk of stream) {
const piece = chunk.choices?.[0]?.delta?.content;
if (piece) {
full += piece;
process.stdout.write(piece);
}
if (chunk.usage) usage = chunk.usage;
}
console.log("\nusage:", usage);
Si vous ne voulez pas utiliser le SDK, fetch fonctionne aussi : envoyez le même corps JSON avec stream: true, puis lisez response.body avec un TextDecoder et divisez sur les lignes vides. Le SDK vous épargne la gestion des événements qui sont coupés en deux à une limite de fragment, ce qui est le bug habituel dans les analyseurs écrits à la main.
Lecture de l'utilisation et du solde
L'utilisation est signalée à la fin du flux. C'est le nombre à journaliser pour le suivi des coûts, car c'est ce contre quoi votre solde est facturé. À $0,15 par 1M de tokens d'entrée et $0,50 par 1M de tokens de sortie, une réponse avec 1 200 tokens d'entrée et 800 tokens de sortie coûte 1 200 x 0,15 / 1 000 000 + 800 x 0,50 / 1 000 000 = $0,00018 + $0,0004 = $0,00058.
Chaque réponse contient également un en-tête X-Balance-USD avec votre crédit restant, afin que vous puissiez afficher un avertissement de solde faible sans une deuxième requête. Vous pouvez également appeler GET /v1/balance sur une minuterie. Les requêtes échouées ou refusées ne sont pas facturées, ce qui signifie qu'une erreur avant le premier token ne coûte rien.
Les mêmes en-têtes de réponse incluent X-Request-Id. Stockez-le à côté de votre propre ligne de journal pour chaque flux. Si un flux se comporte de manière étrange, cet ID est ce que vous donnez au support pour que la requête puisse être trouvée.
Flux interrompus et comment y remédier
Les flux se coupent. Un téléphone passe du Wi-Fi aux données mobiles, un proxy ferme une connexion inactive, un utilisateur ferme l'onglet. Prévoyez-le dès le début.
Conservez le texte partiel
Ajoutez chaque morceau à un tampon au fur et à mesure de son arrivée, et sauvegardez le tampon lorsque la boucle se termine ou lève une exception. Si le flux a échoué, vous avez une demi-réponse utilisable. Affichez-le avec un bouton de nouvelle tentative au lieu de le jeter.
Nouvelle tentative ou continuation
La récupération la plus simple consiste à renvoyer la requête originale. Pour une réponse courte, c'est suffisant. Pour une réponse longue, vous pouvez envoyer le texte partiel enregistré en tant que message assistant et demander au modèle de continuer à partir de là où il s'est arrêté. Le résultat peut ne pas correspondre à ce que le premier flux aurait produit, donc traitez-le comme un meilleur effort et étiquetez-le dans votre interface utilisateur si l'exactitude est importante.
Fermez ce que vous abandonnez
Une requête en streaming occupe son emplacement de concurrence jusqu'à la fin du flux. Une clé complète permet 8 requêtes à la fois, et une clé d'essai seulement 2. Si votre serveur continue de lire un flux pour un utilisateur qui est parti, cet emplacement reste occupé. Annulez la requête lorsque le client se déconnecte. En Python, appelez stream.close() ; en Node, appelez stream.controller.abort().
Relayer un flux vers un navigateur
Ne mettez jamais votre clé API dans le code du navigateur. La configuration habituelle est un petit endpoint sur votre propre serveur qui appelle l'API avec stream: true et transmet chaque morceau à la page. En Node avec Express, définissez Content-Type: text/event-stream, écrivez chaque morceau comme data: ... suivi d'une ligne vide, et écoutez l'événement close sur la requête pour annuler l'appel amont. Sur la page, EventSource gère les points de terminaison GET, tandis que fetch avec un lecteur gère les corps POST, ce dont vous avez besoin lorsque vous envoyez un historique de messages.
Conservez l'historique des messages sur votre serveur ou dans le corps de la requête, et réduisez les tours les plus anciens lorsque la conversation devient longue. La fenêtre de contexte est de 100 000 tokens pour le prompt plus la complétion, ce qui est beaucoup de chat, mais une session de longue durée l'atteindra éventuellement.
Limites de débit pendant le streaming
Les limites sont de 300 requêtes par minute et 8 requêtes concurrentes sur une clé complète, et 60 par minute et 2 concurrentes sur une clé d'essai. Le dépassement du seuil renvoie HTTP 429. Le code d'erreur vous indique quelle limite vous avez atteinte : rate_limited signifie trop de requêtes par minute, et concurrency signifie trop de requêtes à la fois. En cas de surcharge temporaire, l'API renvoie également 429 avec un en-tête Retry-After: 5.
Puisqu'un 429 arrive avant que des tokens ne soient diffusés, gérez-le avant de commencer à lire. Un petit wrapper de nouvelle tentative est suffisant :
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.uncensoredllmapi.com/v1", api_key="YOUR_KEY")
def open_stream(messages, tries=4):
for n in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, stream=True
)
except RateLimitError as e:
wait = 5 if n == 0 else 5 * (n + 1)
time.sleep(wait)
raise RuntimeError("still rate limited")
Pour les applications de chat avec de nombreux utilisateurs, la véritable correction aux erreurs de concurrency est une petite file d'attente de votre côté qui n'autorise pas plus de 8 flux en direct simultanément.
Liste de contrôle avant de déployer un chat en streaming
- Protégez-vous contre les
choicesvides dans le dernier fragment. - Mettez en tampon le texte partiel et enregistrez-le en cas d'erreur.
- Interrompez la requête amont lorsque le navigateur se déconnecte.
- Plafonnez les flux en direct à votre limite de concurrence.
- Enregistrez l'utilisation et l'ID de requête par flux.
- Désactivez la mise en mémoire tampon de la réponse sur tout proxy inverse devant votre serveur, sinon les tokens arriveront par rafales.
Le dernier point fait trébucher beaucoup de premiers déploiements. Nginx, par exemple, met en mémoire tampon les réponses proxy par défaut, donc le flux fonctionne sur localhost et semble gelé en production jusqu'à ce que la mise en mémoire tampon soit désactivée pour cette route. Pour une sortie JSON au lieu de texte libre, voir les notes sur le mode JSON. Pour essayer le code ci-dessus, créez une clé API ; les nouveaux comptes peuvent réclamer $0,50 de crédit d'essai en un clic, valable 7 jours. Les recharges sont uniquement en crypto (USDT sur TRC20 ou USDC sur Base), à partir de 20 $.
