Skip to main content

Streaming output

Dans les applications de chat en temps réel ou de génération de texte long, des temps d'attente prolongés dégradent l'expérience utilisateur et peuvent provoquer des délais d'expiration côté serveur, entraînant l'échec des tâches. Le streaming output résout ces problèmes en renvoyant continûment des fragments de texte au fur et à mesure que le modèle les génère.

Fonctionnement

Le streaming output utilise le protocole Server-Sent Events (SSE). Lorsqu'une requête en streaming démarre, le serveur établit une connexion HTTP persistante avec le client. Chaque fois que le modèle génère un bloc de texte (appelé chunk), il le transmet immédiatement via cette connexion. Une fois tout le contenu généré, le serveur envoie un signal de fin. Le client écoute le flux d'événements et reçoit les chunks de texte en temps réel pour les traiter, par exemple en affichant les caractères un par un dans l'interface. Cette approche diffère des appels non streamés, qui renvoient l'intégralité du contenu en une seule fois.

Facturation

Le streaming output suit les mêmes règles de facturation que les appels non streamés, avec une tarification basée sur le nombre de tokens d'entrée et de tokens de sortie dans la requête. Si une requête est interrompue, seuls les tokens de sortie générés avant que le serveur ne reçoive la demande d'arrêt sont comptabilisés.

Utilisation

La version open source de Qwen3, les versions commerciale et open source de QwQ, ainsi que QVQ et Qwen-Omni, prennent uniquement en charge le streaming output.

Étape 1 : Configurez votre clé API et sélectionnez une région

Vous devez avoir obtenu une clé API et l'avoir configurée en tant que variable d'environnement.
La configuration de votre clé API en tant que variable d'environnement ( DASHSCOPE_API_KEY ) est plus sécurisée que son codage en dur dans votre code.

Étape 2 : Effectuez une requête en streaming

  • OpenAI compatible
  • DashScope
  • Activation Définissez stream sur true.
  • Affichage de l'utilisation des tokens Le protocole OpenAI ne renvoie pas l'utilisation des tokens par défaut. Définissez stream_options={"include_usage": true} afin que le dernier chunk de données renvoyé inclue les informations d'utilisation des tokens.
  • Python
  • Node.js
  • curl
import os
from openai import OpenAI

# 1. Prepare: Initialize the client
client = OpenAI(
    # Configure the API key using an environment variable to avoid hard coding.
    api_key=os.environ["DASHSCOPE_API_KEY"],
    # The API key is tightly bound to a region. Ensure base_url matches the region of your API key.
    # Singapore region URL. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

# 2. Make a streaming request
completion = client.chat.completions.create(
    model="qwen-plus",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Please introduce yourself"}
    ],
    stream=True,
    stream_options={"include_usage": True}
)

# 3. Handle the streaming response
# Store response fragments in a list. Joining them at the end is more efficient than repeated string concatenation.
content_parts = []
print("AI: ", end="", flush=True)

for chunk in completion:
    if chunk.choices:
        content = chunk.choices[0].delta.content or ""
        print(content, end="", flush=True)
        content_parts.append(content)
    elif chunk.usage:
        print("\n--- Request usage ---")
        print(f"Input Tokens: {chunk.usage.prompt_tokens}")
        print(f"Output Tokens: {chunk.usage.completion_tokens}")
        print(f"Total Tokens: {chunk.usage.total_tokens}")

full_response = "".join(content_parts)
# print(f"\n--- Full response ---\n{full_response}")

Réponse

AI: Hello! I am Qwen, a large-scale language model independently developed by Tongyi Lab under Alibaba Group. I can answer questions, create content such as stories, official documents, emails, scripts, perform logical reasoning, programming, express opinions, play games, and more. I support multiple languages, including but not limited to Chinese, English, German, French, and Spanish. If you have any questions or need help, feel free to ask me anytime!
--- Request usage ---
Input Tokens: 26
Output Tokens: 87
Total Tokens: 113

Sortie en streaming pour les modèles multimodaux

Les modèles multimodaux permettent d'ajouter des images, de l'audio et d'autres contenus aux conversations. Leur implémentation de la sortie en streaming diffère de celle des modèles textuels purs sur les points suivants :
  • Construction du message utilisateur : les entrées des modèles multimodaux incluent non seulement du texte, mais aussi des images, de l'audio et d'autres informations multimodales.
  • Interface du SDK DashScope : utilisez l'interface MultiModalConversation dans le SDK Python DashScope. Utilisez la classe MultiModalConversation dans le SDK Java DashScope.
Pour les modèles multimodaux, consultez Compréhension d'images et de vidéos , Extraction de texte , Compréhension audio — Qwen3-Omni-Captioner , Kimi , etc. Le modèle Qwen-Omni prend uniquement en charge la sortie en streaming car sa sortie peut inclure du texte ou de l' audio et d'autres contenus multimodaux. L'analyse de ses résultats diffère de celle des autres modèles. Pour plus de détails, consultez Omni-modal .
  • OpenAI compatible
  • DashScope
  • Python
  • Node.js
  • curl
from openai import OpenAI
import os

client = OpenAI(
    # If you haven't configured an environment variable, replace the next line with your Model Studio API key: api_key="sk-xxx"
    # API keys differ by region. Get your API key: https://help.aliyun.com/zh/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),

    # China (Beijing) region URL. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3-vl-plus",  # Replace with other multimodal models as needed and adjust messages accordingly
    messages=[
        {"role": "user",
         "content": [{"type": "image_url",
                    "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"},},
                    {"type": "text", "text": "What scene is depicted in the image?"}]}],
    stream=True,
  # stream_options={"include_usage": True}
)
full_content = ""
print("Streaming output content:")
for chunk in completion:
    # If stream_options.include_usage is True, the last chunk's choices field is an empty list and should be skipped (token usage can be obtained via chunk.usage)
    if chunk.choices and chunk.choices[0].delta.content != "":
        full_content += chunk.choices[0].delta.content
        print(chunk.choices[0].delta.content)
print(f"Full content: {full_content}")
from openai import OpenAI
import os

client = OpenAI(
    # API keys differ by region. Get your API key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    # If you haven't configured an environment variable, replace the next line with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Singapore region URL. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen3-vl-plus",  # Replace with other multimodal models as needed and adjust messages accordingly
    messages=[
        {"role": "user",
        "content": [{"type": "image_url",
                    "image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg"},},
                    {"type": "text", "text": "What scene is depicted in the image?"}]}],
    stream=True,
  # stream_options={"include_usage": True}
)
full_content = ""
print("Streaming output content:")
for chunk in completion:
    # If stream_options.include_usage is True, the last chunk's choices field is an empty list and should be skipped (token usage can be obtained via chunk.usage)
    if chunk.choices and chunk.choices[0].delta.content != "":
        full_content += chunk.choices[0].delta.content
        print(chunk.choices[0].delta.content)
print(f"Full content: {full_content}")

Sortie en continu pour les modèles de raisonnement

Les modèles de raisonnement renvoient d'abord le champ reasoning_content (le processus de réflexion), puis le champ content (la réponse). Déterminez si l'étape actuelle correspond à la phase de réflexion ou de réponse en fonction du statut du paquet de données.
Pour plus d'informations sur les modèles de raisonnement, consultez les rubriques Réflexion approfondie et Compréhension des images et des vidéos.
Pour la mise en œuvre de la sortie en continu de Qwen3-Omni-Flash (mode réflexion), reportez-vous à la section Omni-modal .
  • OpenAI compatible
  • DashScope
Voici le format de réponse lors de l'appel au mode de réflexion du modèle qwen-plus à l'aide du SDK Python OpenAI en mode streaming :
# Thinking stage
...
ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='Cover all key points while')
ChoiceDelta(content=None, function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content='remaining natural and fluent.')
# Response stage
ChoiceDelta(content='Hello! I am **Qwen', function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=None)
ChoiceDelta(content='** (', function_call=None, refusal=None, role=None, tool_calls=None, reasoning_content=None)
...
  • Si reasoning_content n'est pas None et que content est None, l'étape actuelle correspond à la phase de réflexion.
  • Si reasoning_content est None et que content n'est pas None, l'étape actuelle correspond à la phase de réponse.
  • Si les deux champs sont None, l'étape reste identique à celle du paquet précédent.
  • Python
  • Node.js
  • HTTP

Exemple de code

from openai import OpenAI
import os

# Initialize the OpenAI client
client = OpenAI(
    # If you haven't configured an environment variable, replace with your Alibaba Cloud Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

messages = [{"role": "user", "content": "Who are you"}]

completion = client.chat.completions.create(
    model="qwen-plus",  # Replace with other deep-thinking models as needed
    messages=messages,
    # The enable_thinking parameter enables the thinking process. This parameter has no effect on models QwQ.
    extra_body={"enable_thinking": True},
    stream=True,
    # stream_options={
    #     "include_usage": True
    # },
)

reasoning_content = ""  # Full thought process
answer_content = ""  # Full response
is_answering = False  # Whether in the response stage
print("\n" + "=" * 20 + "Thought process" + "=" * 20 + "\n")

for chunk in completion:
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
        continue

    delta = chunk.choices[0].delta

    # Collect only thinking content
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content

    # Received content, start responding
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Réponse

====================Thought process====================

Okay, the user asked "Who are you," so I need to give an accurate and friendly answer. First, I should confirm my identity as Qwen, developed by Tongyi Lab under Alibaba Group. Next, explain my main functions, like answering questions, creating text, logical reasoning, etc. Keep the tone approachable and avoid overly technical terms so the user feels comfortable. Also, avoid complex jargon and ensure the answer is concise. Additionally, include some interactive elements to encourage further questions. Finally, check for any missing key information, such as my Chinese name "Tongyi Qianwen" and English name "Qwen," along with my company and lab. Make sure the response is comprehensive and meets user expectations.
====================Full response====================

Hello! I am Qwen, a large-scale language model independently developed by Tongyi Lab under Alibaba Group. I can answer questions, create text, perform logical reasoning, programming, and more, aiming to provide high-quality information and services. You can call me Qwen or simply Tongyi Qianwen. How can I help you?

Mise en production

  • Gestion des performances et des ressources : Dans les services backend, le maintien d'une connexion HTTP persistante pour chaque requête en streaming consomme des ressources. Configurez votre service avec une taille de pool de connexions et des valeurs de délai d'attente appropriées. Dans les scénarios de forte concurrence, surveillez l'utilisation des descripteurs de fichiers pour éviter leur épuisement.
  • Rendu côté client : Sur les interfaces web frontales, utilisez les API ReadableStream et TextDecoderStream pour gérer et restituer fluidement les flux d'événements SSE, offrant ainsi la meilleure expérience utilisateur.
  • Surveillance des modèles :
    • Métriques clés : Surveillez le Time to First Token (TTFT), la métrique centrale de l'expérience en streaming. Surveillez également le taux d'erreur de l'API et le temps de réponse moyen.
    • Alertes : Définissez des alertes pour les taux d'erreur d'API anormaux, en particulier les erreurs 4xx et 5xx.
  • Configuration du proxy Nginx : Si vous utilisez Nginx comme proxy inverse, sa mise en tampon de sortie par défaut (proxy_buffering) rompt la nature en temps réel des réponses en streaming. Pour garantir que les données soient poussées immédiatement vers les clients, désactivez cette fonctionnalité en définissant proxy_buffering off dans votre fichier de configuration Nginx.

Codes d'erreur

Si l'appel au modèle échoue et renvoie un message d'erreur, consultez les Codes d'erreur pour résoudre le problème.

FAQ

Q : Pourquoi n'y a-t-il aucune information d'utilisation dans la réponse ?

R : Le protocole OpenAI ne renvoie pas d'informations d'utilisation par défaut. Définissez le paramètre stream_options pour inclure les informations d'utilisation dans le dernier paquet renvoyé.

Q : L'activation de la sortie en streaming affecte-t-elle la qualité de la réponse du modèle ?

R : Non. Cependant, certains modèles ne prennent en charge que la sortie en streaming, et les appels non streamés peuvent provoquer des erreurs de délai d'attente. Nous recommandons d'utiliser la sortie en streaming.

Q : Quelle est la différence entre les appels non streamés et les appels en streaming ?

R : Différences principales :
  • Limite de délai d'attente : Pour les appels non streamés, le délai d'attente maximal est d'au moins 300 secondes et varie selon la région et le modèle. Si le traitement n'est pas terminé à temps, la requête est interrompue.
  • Structure de sortie : Les appels non streamés renvoient la réponse complète (un seul objet JSON) en une fois. Les appels en streaming renvoient progressivement des fragments de données via le protocole SSE, chaque fragment contenant une partie du contenu généré. Le client doit assembler ces fragments.
  • Compatibilité des fonctionnalités : Les deux méthodes prennent en charge des fonctionnalités telles que le mode JSON et Function Call, sans différences fonctionnelles.
Nous recommandons d'utiliser la sortie en streaming pour éviter les délais d'attente et améliorer l'expérience utilisateur.

Q : La sortie en streaming prend-elle en charge le mode JSON (sortie structurée) ?

R : Oui. Définissez stream sur true et response_format sur {"type": "json_object"} dans la requête. Le modèle renverra progressivement des fragments de contenu au format JSON. La sortie finale assemblée sera un JSON valide.