Skip to main content
Geração de texto

Conversas de múltiplos turnos

A API do Qwen é stateless. Para implementar conversas de múltiplos turnos, transmita o histórico da conversa em cada requisição. Use truncamento, resumo ou recuperação para gerencie o contexto e reduzir o consumo de tokens.

Este tópico aborda as interfaces de Chat Completion compatíveis com OpenAI e DashScope. Para uma alternativa mais simples, consulte OpenAI-compatible - Responses .

Como funciona

Para implementar conversas de múltiplos turnos, mantenha um array messages. Após cada turno, adicione a pergunta do usuário e a resposta do modelo ao array e use o array atualizado na próxima requisição. O exemplo a seguir demonstra como o estado do array messages muda durante uma conversa de múltiplos turnos:
  1. Primeiro turno Adicione a pergunta do usuário ao array 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?"}]
// }
  1. Segundo turno Adicione a resposta do modelo e a pergunta mais recente do usuário ao array 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?"}
//]

Primeiros passos

  • OpenAI compatible
  • 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"),
        # 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",
    )
    # For a list of models, see https://www.alibabacloud.com/help/en/model-studio/getting-started/models
    completion = client.chat.completions.create(model="qwen3.8-max", messages=messages)
    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")

Para modelos multimodais

Modelos multimodais aceitam imagens e áudio nas conversas. A implementação difere dos modelos de texto nos seguintes aspectos:
  • Construção de mensagens do usuário: As mensagens do usuário para modelos multimodais podem conter informações multimodais, como imagens e áudio, além de texto.
  • Interface do SDK DashScope: Ao usar o SDK DashScope para Python, chame a interface MultiModalConversation. Para o SDK DashScope para Java, use a classe MultiModalConversation.
Para modelos multimodais, consulte: Image and video understanding , e Kimi . Para o Qwen-Omni , consulte Non-real-time (Qwen-Omni) . O Qwen-VL-OCR e o Qwen3-Omni-Captioner são projetados para tarefas específicas de turno único e não suportam conversas de múltiplos turnos.
  • OpenAI compatible
  • 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/document_detail/2795253.html
    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}")

Para modelos de raciocínio

Os modelos de raciocínio retornam reasoning_content (processo de pensamento) e content (resposta). Ao atualizar as mensagens, mantenha apenas o content e ignore o 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?"}
]
Para mais informações sobre modelos de raciocínio, consulte Deep thinking , Image and video understanding e Visual reasoning .
Para mais detalhes sobre a implementação de conversas de múltiplos turnos com o Qwen3-Omni-Flash (modo de raciocínio), consulte omni-modal .
  • OpenAI compatible
  • DashScope
  • Python
  • Node.js
  • HTTP

Código de exemplo 

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="qwen3.8-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})
    print("\n")

Entrando em produção

Conversas de múltiplos turnos podem consumir muitos tokens e exceder o comprimento de contexto do modelo, causando erros. Adote estas estratégias para gerencie o contexto e controlar custos.

1. Gerenciamento de contexto

O array messages cresce a cada turno e pode ultrapassar o limite de tokens do modelo. Use estes métodos para gerencie o tamanho do contexto:

1,1. Truncamento de contexto

Mantenha apenas os N turnos mais recentes quando o histórico ficar muito longo. Essa abordagem é simples de implementar, mas perde informações anteriores da conversa.

1,2. Resumo contínuo

Resuma o contexto à medida que a conversa avança para compactar o histórico e controlar o tamanho sem perder informações essenciais: a. Quando o histórico atingir 70% do tamanho máximo de contexto, extraia uma parte anterior (como a primeira metade) e faça uma chamada de API separada para gerar um "resumo de memória". b. Na próxima requisição, substitua o histórico extenso pelo "resumo de memória" e anexe os turnos recentes.

1,3. Recuperação vetorizada

Resumos contínuos podem perder algumas informações. Para permitir que o modelo recupere dados relevantes de grandes históricos de conversa, use recuperação sob demanda em vez de passagem linear de contexto: a. Após cada turno de conversa, armazene a interação em um banco de dados vetorial. b. Quando um usuário fizer uma pergunta, recupere registros de conversa relevantes com base na similaridade. c. Combine os registros recuperados com a entrada mais recente do usuário e envie o conteúdo combinado para o modelo.

2. Controle de custos

Os tokens de entrada aumentam a cada turno, elevando significativamente os custos. Aplique estas estratégias de gerenciamento financeiro:

2,1. Reduzir tokens de entrada

Use as estratégias de gerenciamento de contexto descritas anteriormente para diminuir os tokens de entrada e reduzir custos.

2,2. Usar modelos com suporte a cache de contexto

Em requisições de múltiplos turnos, o array messages é processado e faturado repetidamente. O Model Studio oferece context cache para modelos como qwen-max e qwen-plus, o que reduz custos e melhora a velocidade de resposta. Priorize modelos que suportam cache de contexto.
O cache de contexto é ativado automaticamente — nenhuma alteração de código é necessária.

Códigos de erro

Se a chamada do modelo falhar e retornar uma mensagem de erro, consulte Error codes para resolução.
Começar
Faturamento
Plano de Tokens
Playground de Modelos
Clientes e Ferramentas de Desenvolvedor
Inferência do Modelo
Ajuste fino
Implantação
Avaliação
Compressão de Modelos
Estatísticas e Monitoramento
Segurança e Conformidade
Melhores Práticas
Suporte
Registro de alterações