---
title: "Streaming des réponses LLM en server-sent events · API UE"
description: "Recevez les tokens des modèles ouverts au fil de la génération, en server-sent events aux formats OpenAI et Anthropic. Exemples, fragments et erreurs."
canonical: "https://inference.eu/fr/api/streaming/"
language: "fr"
---

Guides · Streaming

# Diffuser les réponses d'un LLM en streaming avec les server-sent events

Le streaming vous transmet la réponse du modèle token par token pendant sa génération, au lieu d'attendre la fin. L'utilisateur voit du texte tout de suite, les longues réponses paraissent plus rapides et vous pouvez interrompre la génération. L'API inference.eu diffuse au format OpenAI pour chat completions et Responses, et au format Anthropic pour Messages.

[Contacter l'équipe](https://inference.eu/fr/contact/)[Exemple de requête](#example)

1.  01Format d'API: OpenAI et Anthropic
2.  02Centres de données dans l'UE
3.  03Couvert par un seul DPA

stream.py

```
import os
from openai import OpenAI

client = OpenAI(base_url="https://api.inference.eu/v1", api_key=os.environ["INFERENCE_EU_API_KEY"])

stream = client.chat.completions.create(
    model="gpt-oss-120b",
    messages=[{"role": "user", "content": "Explain the difference between a GmbH and an AG in five sentences."}],
    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(f"\n\n{chunk.usage.total_tokens} tokens")
```

## Comment fonctionne le streaming

Passez `stream` à `true` dans la requête. L'API garde la connexion HTTP ouverte et envoie des server-sent events : des lignes qui commencent par `data:` suivies d'un objet JSON. Pour chat completions, chaque objet est un `chat.completion.chunk` dont `choices[0].delta` contient le nouveau morceau de texte dans `content`. Le flux se termine par la ligne `data: [DONE]`.

Les SDK officiels se chargent de l'analyse. En Python, vous itérez sur le flux renvoyé ; en JavaScript, vous utilisez `for await`. Si vous appelez l'API avec votre propre client HTTP, lisez le corps ligne par ligne, ignorez les lignes vides et les commentaires, et analysez chaque charge `data:` comme du JSON.

## Consommation, motifs d'arrêt et appels d'outils

Par défaut, les fragments diffusés n'incluent pas la consommation de tokens. Ajoutez `stream_options: {"include_usage": true}` : le dernier fragment avant `[DONE]` contient alors un objet `usage` et un tableau `choices` vide, d'où la vérification de `chunk.choices` dans l'exemple.

Le fragment qui clôt la réponse porte un `finish_reason`, comme `stop` ou `length`. Les appels d'outils sont aussi diffusés : `delta.tool_calls` arrive par morceaux, le nom de la fonction d'abord, puis les arguments JSON répartis sur plusieurs fragments. Concaténez les chaînes d'arguments par `index` et ne les analysez que lorsque `finish_reason` vaut `tool_calls`. Les modèles de raisonnement peuvent diffuser leur réflexion dans un champ distinct avant la réponse.

## Les événements de Responses et d'Anthropic Messages

L'API Responses diffuse des événements typés plutôt que des fragments. Le texte arrive dans des événements `response.output_text.delta`, les appels d'outils et autres éléments de sortie ont leurs propres événements, et `response.completed` transporte l'objet de réponse final avec la consommation. Écoutez les types utiles et ignorez les autres.

Le point de terminaison Messages suit la séquence d'Anthropic : `message_start`, puis `content_block_start`, une série d'événements `content_block_delta` avec `text_delta` ou `input_json_delta`, `content_block_stop`, un `message_delta` avec `stop_reason` et la consommation, et enfin `message_stop`. Les SDK Anthropic proposent des aides comme `text_stream` qui ne renvoient que le texte.

## Erreurs, délais d'attente et proxys

Les erreurs survenues avant le début de la génération, comme une clé invalide ou un modèle inconnu, renvoient une erreur HTTP classique, sans flux. Une erreur pendant la génération arrive sous forme d'événement d'erreur dans le flux, puis la connexion se ferme ; votre boucle doit la traiter et décider d'une éventuelle reprise.

Proxys et répartiteurs de charge mettent parfois les réponses en mémoire tampon, transformant le flux en un bloc de texte tardif. Désactivez ce tampon pour ces routes, par exemple avec `X-Accel-Buffering: no` sous nginx, et prévoyez des délais d'inactivité plus longs que les pauses entre tokens des modèles de raisonnement. Si l'utilisateur ferme la page, annulez la requête.

## Streaming

Catégorie

Guides

Format d'API

OpenAI et Anthropic

Base URL

api.inference.eu/v1

Traitement

Centres de données dans l'UE

Entraînement sur vos données

Jamais

## Streaming : questions fréquentes

Les questions que nous posent le plus les achats, les développeurs et les juristes. Il en manque une ? Posez-la-nous directement.

Passez \`stream\` à \`true\` dans une requête chat completions, Responses ou Messages. L'API renvoie des server-sent events au fil de la génération. Avec le SDK OpenAI ou Anthropic, itérez sur l'objet de flux renvoyé et affichez ou transmettez chaque morceau de texte dès son arrivée.

Pour chat completions, ajoutez \`stream\_options: {"include\_usage": true}\`. Le dernier fragment avant \`data: \[DONE\]\` contient alors un objet \`usage\` avec les tokens du prompt et de la réponse, et une liste \`choices\` vide. Les formats Responses et Messages incluent automatiquement la consommation dans leurs événements finaux.

Oui. Les noms et arguments des appels d'outils arrivent par morceaux dans \`delta.tool\_calls\`. Rassemblez les fragments d'arguments pour chaque \`index\`, assemblez-les en une chaîne et analysez le JSON lorsque \`finish\_reason\` vaut \`tool\_calls\`. Exécutez ensuite votre fonction et renvoyez le résultat comme d'habitude.

Le modèle génère les mêmes tokens dans les deux cas : le travail total est identique. Le streaming change seulement le moment où vous les recevez, les premiers mots apparaissant presque immédiatement. La facturation repose sur les tokens, que vous diffusiez ou non.

Un élément entre l'API et l'utilisateur met la réponse en tampon : souvent un proxy inverse, une plateforme serverless ou un middleware de compression. Désactivez le tampon et la compression sur la route de streaming, videz le tampon après chaque écriture et assurez-vous que votre serveur relaie chaque événement dès réception.

Fermez la connexion, ou sortez de la boucle et fermez l'objet de flux. La génération s'arrête peu après, et seuls les tokens produits jusque-là sont facturés. Dans une application web, annulez la requête en amont quand l'utilisateur quitte la page ou appuie sur stop.

N'appelez pas l'API depuis le navigateur avec votre clé secrète. Diffusez depuis votre serveur et relayez les événements vers le navigateur par server-sent events, réponse fetch en flux ou WebSockets. Des frameworks comme le Vercel AI SDK s'en chargent pour vous.

Oui, avec les noms d'événements d'Anthropic. Les requêtes \`/v1/messages\` avec \`stream: true\` renvoient \`message\_start\`, \`content\_block\_delta\` et les autres événements standard : les SDK Anthropic et des outils comme Claude Code diffusent exactement comme ailleurs.

[Poser une question](https://inference.eu/fr/contact/)

## Pages liées

[Présentation de l'API](https://inference.eu/fr/api/)

-   [Chat completionsEnvoyez vos messages à des modèles open-weight au format chat completions d'OpenAI. Traitement dans des centres de données de l'UE, sans entraînement.Endpoints](https://inference.eu/fr/api/chat-completions/)
-   [ResponsesUtilisez le format de l'API Responses d'OpenAI avec des modèles open-weight sur inference.eu. Sorties typées, outils intégrés, traitement dans l'UE.Endpoints](https://inference.eu/fr/api/responses/)
-   [Messages (Anthropic format)Appelez des modèles open-weight au format Messages d'Anthropic sur inference.eu. Compatible avec les SDK Anthropic et Claude Code, traité dans l'UE.Endpoints](https://inference.eu/fr/api/messages/)
-   [Tool callingLaissez des modèles ouverts appeler vos fonctions et vos API grâce à l'appel d'outils compatible OpenAI. Définir les outils, gérer la boucle, dans l'UE.Guides](https://inference.eu/fr/api/tool-calling/)

## Faites passer vos charges IA sur une infrastructure européenne

Dites-nous quels modèles vous utilisez et votre volume approximatif. Nous répondons sous un jour ouvré avec un tarif et la suite.

-   Réponse sous un jour ouvré
-   Tarif adapté à votre volume
-   DPA prêt à signer