Skip to main content

Conversations multi-tours

L'API Qwen est sans état. Pour mettre en œuvre des conversations multi-tours, transmettez l'historique de la conversation dans chaque requête. Utilisez la troncature, la synthèse ou la récupération pour gérer le contexte et réduire la consommation de jetons.

Cette rubrique couvre les interfaces Chat Completion et DashScope compatibles avec OpenAI. Pour une alternative plus simple, consultez OpenAI-compatible - Responses .

Fonctionnement

Pour mettre en œuvre des conversations multi-tours, conservez un tableau messages. Après chaque tour, ajoutez la question de l'utilisateur et la réponse du modèle, puis utilisez le tableau mis à jour pour la requête suivante. L'exemple suivant illustre l'évolution de l'état du tableau messages au cours d'une conversation multi-tours :
  1. Premier tour Ajoutez la question de l'utilisateur au tableau messages.
    // Use a text model
    [
        {"role": "user", "content": "Recommend a sci-fi movie about space exploration."}
    ]
    
    // Use a multimodal model, for example, Qwen-VL
    // {"role": "user",
    //       "content": [{"type": "image_url","image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251031/ownrof/f26d201b1e3f4e62ab4a1fc82dd5c9bb.png"}},
    //                   {"type": "text", "text": "What products are shown in the image?"}]
    // }
    
  2. Deuxième tour Ajoutez la réponse du modèle et la dernière question de l'utilisateur au tableau messages.
    // Use a text model
    [
        {"role": "user", "content": "Recommend a sci-fi movie about space exploration."},
        {"role": "assistant", "content": "I recommend 'XXX'. It is a classic sci-fi work."},
        {"role": "user", "content": "Who is the director of this movie?"}
    ]
    
    // Use a multimodal model, for example, Qwen-VL
    //[
    //    {"role": "user", "content": [
    //                    {"type": "image_url","image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251031/ownrof/f26d201b1e3f4e62ab4a1fc82dd5c9bb.png"}},
    //                   {"type": "text", "text": "What products are shown in the image?"}]},
    //    {"role": "assistant", "content": "The image shows three items: a pair of light blue overalls, a blue and white striped short-sleeve shirt, and a pair of white sneakers."},
    //    {"role": "user", "content": "What style are they?"}
    //]
    

Prise en main

  • Compatible avec OpenAI
  • DashScope
Python
import os
from openai import OpenAI

def get_response(messages):
    client = OpenAI(
        # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
        # If you have not configured the environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Chine (Pékin) 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",
    )
    # For a list of models, see https://www.alibabacloud.com/help/en/model-studio/getting-started/models
    completion = client.chat.completions.create(model="qwen4-max", messages=messages, extra_body={"enable_thinking": False})
    return completion

# Initialize a messages array
messages = [
    {
        "role": "system",
        "content": """You are a salesperson at the Bailian phone store. You are responsible for recommending phones to users. The phones have two parameters: screen size (including 6.1-inch, 6.5-inch, and 6.7-inch) and resolution (including 2K and 4K).
        You can only ask the user for one parameter at a time. If the user does not provide complete information, you need to ask a follow-up question to get the missing parameter. When all parameters are collected, you must say: I have understood your purchase intention. Please wait.""",
    }
]
assistant_output = "Welcome to the Bailian phone store. What screen size are you looking for?"
print(f"Model output: {assistant_output}\n")
while "I have understood your purchase intention" not in assistant_output:
    user_input = input("Please enter: ")
    # Add the user's question to the messages list
    messages.append({"role": "user", "content": user_input})
    assistant_output = get_response(messages).choices[0].message.content
    # Add the model's response to the messages list
    messages.append({"role": "assistant", "content": assistant_output})
    print(f"Model output: {assistant_output}")
    print("\n")

Pour les modèles multimodaux

Les modèles multimodaux prennent en charge les images et l'audio dans les conversations. La mise en œuvre diffère de celle des modèles textuels comme suit :
  • Construction des messages utilisateur : Les messages utilisateur destinés aux modèles multimodaux peuvent contenir des informations multimodales, telles que des images et de l'audio, en plus du texte.
  • Interface du SDK DashScope : Lorsque vous utilisez le SDK Python DashScope, appelez l'interface MultiModalConversation. Lorsque vous utilisez le SDK Java DashScope, appelez la classe MultiModalConversation.
Pour les modèles multimodaux, consultez : Image and video understanding , et Kimi . Pour Qwen-Omni , consultez Non-real-time (Qwen-Omni) . Qwen-VL-OCR et Qwen3-Omni-Captioner sont conçus pour des tâches spécifiques à tour unique et ne prennent pas en charge les conversations multi-tours.
  • Compatible avec OpenAI
  • DashScope
  • Python
  • Node.js
  • curl
from openai import OpenAI
import os

client = OpenAI(
    # If you have not configured the environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx"
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/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"
)
messages = [
        {
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251031/ownrof/f26d201b1e3f4e62ab4a1fc82dd5c9bb.png"
                },
            },
            {"type": "text", "text": "What products are shown in the image?"},
        ],
    }
]

completion = client.chat.completions.create(
    model="qwen3-vl-plus",  # You can replace this with other multimodal models and modify the messages as needed
    messages=messages,
    )

print(f"First round output: {completion.choices[0].message.content}")

assistant_message = completion.choices[0].message
messages.append(assistant_message.model_dump())
messages.append({
        "role": "user",
        "content": [
        {
            "type": "text",
            "text": "What style are they?"
        }
        ]
    })
completion = client.chat.completions.create(
    model="qwen3-vl-plus",
    messages=messages,
    )

print(f"Second round output: {completion.choices[0].message.content}")
from openai import OpenAI
import os

client = OpenAI(
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If you have not configured the environment variable, replace the following 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"
)
messages = [
        {"role": "user",
         "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251031/ownrof/f26d201b1e3f4e62ab4a1fc82dd5c9bb.png"
                },
            },
            {"type": "text", "text": "What products are shown in the image?"},
        ],
    }
]
completion = client.chat.completions.create(
    model="qwen3-vl-plus",  #  You can replace this with other multimodal models and modify the messages as needed
    messages=messages,
    )
print(f"First round output: {completion.choices[0].message.content}")

assistant_message = completion.choices[0].message
messages.append(assistant_message.model_dump())
messages.append({
        "role": "user",
        "content": [
        {
            "type": "text",
            "text": "What style are they?"
        }
        ]
    })
completion = client.chat.completions.create(
    model="qwen3-vl-plus",
    messages=messages,
    )

print(f"Second round output: {completion.choices[0].message.content}")

Pour les modèles de raisonnement

Les modèles de raisonnement renvoient reasoning_content (processus de réflexion) et content (réponse). Lors de la mise à jour des messages, conservez uniquement content et ignorez reasoning_content.
[
    {"role": "user", "content": "Recommend a sci-fi movie about space exploration."},
    {"role": "assistant", "content": "I recommend 'XXX'. It is a classic sci-fi work."}, # Do not add the reasoning_content field when you add to the context
    {"role": "user", "content": "Who is the director of this movie?"}
]
Pour en savoir plus sur les modèles de raisonnement, consultez Réflexion approfondie et Compréhension des images et des vidéos.
Pour plus d'informations sur la mise en œuvre de conversations multi-tours avec Qwen3-Omni-Flash (mode réflexion), consultez omni-modal .
  • OpenAI compatible
  • DashScope
  • Python
  • Node.js
  • HTTP

Exemple de code

from openai import OpenAI
import os

# Initialize the OpenAI client
client = OpenAI(
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If you have not configured the environment variable, replace the following line with your 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 = []
conversation_idx = 1
while True:
    reasoning_content = ""  # Define the complete thinking process
    answer_content = ""     # Define the complete response
    is_answering = False   # Determine whether to end the thinking process and start responding
    print("="*20+f"Conversation Round {conversation_idx}"+"="*20)
    conversation_idx += 1
    user_input = input("Enter your message (type 'exit' to end): ")
    # Enter 'exit' to end the multi-turn conversation and avoid an endless loop
    if user_input.strip().lower() == "exit":
        print("Conversation ended.")
        break
    user_msg = {"role": "user", "content": user_input}
    messages.append(user_msg)
    # Create a chat completion request
    completion = client.chat.completions.create(
        # You can replace this with other deep thinking models as needed
        model="qwen4-max",
        messages=messages,
        extra_body={"enable_thinking": True},
        stream=True,
        # stream_options={
        #     "include_usage": True
        # }
    )
    print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")
    for chunk in completion:
        # If chunk.choices is empty, print usage
        if not chunk.choices:
            print("\nUsage:")
            print(chunk.usage)
        else:
            delta = chunk.choices[0].delta
            # Print the thinking process
            if hasattr(delta, 'reasoning_content') and delta.reasoning_content != None:
                print(delta.reasoning_content, end='', flush=True)
                reasoning_content += delta.reasoning_content
            else:
                # Start responding
                if delta.content != "" and is_answering is False:
                    print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
                    is_answering = True
                # Print the response process
                print(delta.content, end='', flush=True)
                answer_content += delta.content
    # Add the content of the model's response to the context
    messages.append({"role": "assistant", "content": answer_content, "reasoning_content": reasoning_content})
    print("\n")

Mise en production

Les conversations multi-tours peuvent consommer un grand nombre de jetons et dépasser la longueur de contexte du modèle, ce qui entraîne des erreurs. Utilisez les stratégies suivantes pour gérer le contexte et maîtriser les coûts.

1. Gestion du contexte

Le tableau messages s'allonge à chaque tour et peut dépasser la limite de jetons du modèle. Utilisez les méthodes suivantes pour gérer la longueur du contexte :

1,1. Troncature du contexte

Conservez uniquement les N derniers tours lorsque l'historique devient trop long. Cette approche est simple à mettre en œuvre, mais elle entraîne la perte des informations échangées au début de la conversation.

1,2. Résumé glissant

Résumez le contexte au fur et à mesure de la conversation pour compresser l'historique et en contrôler la longueur sans perdre les informations essentielles : a. Lorsque l'historique atteint 70 % de la longueur maximale du contexte, extrayez une partie antérieure (par exemple, la première moitié) et effectuez un appel d'API distinct pour générer un « résumé mémoire ». b. Lors de la requête suivante, remplacez l'historique volumineux par le « résumé mémoire » et ajoutez les tours récents.

1,3. Récupération vectorisée

Les résumés glissants peuvent entraîner une perte d'informations. Pour permettre au modèle de rappeler les informations pertinentes issues d'historiques de conversation volumineux, privilégiez une récupération à la demande plutôt qu'un passage linéaire du contexte : a. Après chaque tour de conversation, stockez la conversation dans une base de données vectorielle. b. Lorsqu'un utilisateur pose une question, récupérez les enregistrements de conversation pertinents en fonction de leur similarité. c. Combinez les enregistrements de conversation récupérés avec la saisie utilisateur la plus récente et envoyez le contenu combiné au modèle.

2. Maîtrise des coûts

Le nombre de jetons d'entrée augmente à chaque tour, ce qui alourdit considérablement les coûts. Appliquez les stratégies de gestion des coûts suivantes :

2,1. Réduction des jetons d'entrée

Utilisez les stratégies de gestion du contexte décrites précédemment pour réduire le nombre de jetons d'entrée et diminuer les coûts.

2,2. Utilisation de modèles prenant en charge le cache de contexte

Lors des requêtes multi-tours, le tableau messages est traité et facturé de manière répétée. Model Studio propose un cache de contexte pour des modèles tels que qwen-max et qwen-plus, ce qui permet de réduire les coûts et d'améliorer la vitesse de réponse. Privilégiez les modèles prenant en charge le cache de contexte.
Le cache de contexte est activé automatiquement ; aucune modification de code n'est requise.

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.