Conversaciones de múltiples turnos

Este tema cubre las interfaces de Chat Completion compatible con OpenAI y DashScope. Para una alternativa más sencilla, consulte Respuestas compatibles con OpenAI.

Funcionamiento

Para implementar conversaciones de múltiples turnos, mantenga un arreglo messages. Después de cada ronda, añada la pregunta del usuario y la respuesta del modelo, y luego utilice el arreglo actualizado para la siguiente solicitud. El siguiente ejemplo muestra cómo cambia el estado del arreglo messages durante una conversación de múltiples turnos:

Primera ronda Agregue la pregunta del usuario al arreglo 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?"}]
// }

Segunda ronda Agregue la respuesta del modelo y la última pregunta del usuario al arreglo 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?"}
//]

Introducción

Compatible con 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/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/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")

Python
Java
curl

El código de ejemplo proporciona un caso de un vendedor de una tienda de teléfonos móviles que entabla una conversación de múltiples turnos con un cliente para determinar sus intenciones de compra y luego finaliza la sesión.

import os
import dashscope

# La siguiente es la configuración de la región Singapur (ap-southeast-1). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustituya la siguiente línea por su API Key de Model Studio: api_key="sk-xxx",
    # Las API Key difieren según la región. Para obtener una API Key, consulte https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

def get_response(messages):
    response = client.chat.completions.create(
        # Para consultar la lista de modelos, véase https://www.alibabacloud.com/help/model-studio/getting-started/models
        model="qwen-plus",
        messages=messages,
    )
    return response

# Inicialice un array de messages
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"Salida del modelo: {assistant_output}\n")
while "I have understood your purchase intention" not in assistant_output:
    user_input = input("Please enter: ")
    # Añada la pregunta del usuario a la lista de messages
    messages.append({"role": "user", "content": user_input})
    assistant_output = get_response(messages).choices[0].message.content
    # Añada la respuesta del modelo a la lista de messages
    messages.append({"role": "assistant", "content": assistant_output})
    print(f"Salida del modelo: {assistant_output}")
    print("\n")

import java.util.ArrayList;
import java.util.List;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import java.util.Scanner;
import com.alibaba.dashscope.protocol.Protocol;

public class Main {
    public static GenerationParam createGenerationParam(List<Message> messages) {
        return GenerationParam.builder()
                // API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
                // If you have not configured the environment variable, replace the following line with your Model Studio API key: .apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // For a list of models, see https://www.alibabacloud.com/help/model-studio/getting-started/models
                .model("qwen-plus")
                .messages(messages)
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
    }
    public static GenerationResult callGenerationWithMessages(GenerationParam param) throws ApiException, NoApiKeyException, InputRequiredException {
        // Singapore region URL. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.

        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            List<Message> messages = new ArrayList<>();
            messages.add(createMessage(Role.SYSTEM, "You are a helpful assistant."));
            for (int i = 0; i < 3;i++) {
                Scanner scanner = new Scanner(System.in);
                System.out.print("Please enter: ");
                String userInput = scanner.nextLine();
                if ("exit".equalsIgnoreCase(userInput)) {
                    break;
                }
                messages.add(createMessage(Role.USER, userInput));
                GenerationParam param = createGenerationParam(messages);
                GenerationResult result = callGenerationWithMessages(param);
                System.out.println("Model output: "+result.getOutput().getChoices().get(0).getMessage().getContent());
                messages.add(result.getOutput().getChoices().get(0).getMessage());
            }
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }
    private static Message createMessage(Role role, String content) {
        return Message.builder().role(role.getValue()).content(content).build();
    }
}

# ======= Important =======
# API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key

# === Delete this comment before execution ===

curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "input":{
        "messages":[
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "Hello"
            },
            {
                "role": "assistant",
                "content": "Hello, I am Qwen."
            },
            {
                "role": "user",
                "content": "What can you do?"
            }
        ]
    }
}'

Para modelos multimodales

Los modelos multimodales admiten imágenes y audio en las conversaciones. La implementación difiere de los modelos de texto de la siguiente manera:

Construcción de mensajes de usuario: Los mensajes de usuario para modelos multimodales pueden contener información multimodal, como imágenes y audio, además de texto.
Interfaz del SDK de DashScope: Cuando utilice el SDK de Python de DashScope, llame a la interfaz MultiModalConversation. Cuando utilice el SDK de Java de DashScope, llame a la clase MultiModalConversation.

Para modelos multimodales, consulte: Comprensión de imágenes y videos y Kimi. Para Qwen-Omni, consulte No en tiempo real (Qwen-Omni). Qwen-VL-OCR y Qwen3-Omni-Captioner están diseñados para tareas específicas de un solo turno y no admiten conversaciones de múltiples turnos.

Compatible con OpenAI
DashScope

Python

from openai import OpenAI
import os

client = OpenAI(
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/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}")

Python

import os
import dashscope

# La siguiente es la configuración de la región Singapur (ap-southeast-1). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustituya la siguiente línea por su API Key de Model Studio: api_key="sk-xxx"
    # Las API Key difieren según la región. Para obtener una API Key, consulte https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

messages = [
    {
        "role": "user",
        "content": [
            {
                "image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251031/ownrof/f26d201b1e3f4e62ab4a1fc82dd5c9bb.png"
            },
            {"text": "What products are shown in the image?"},
        ],
    }
]
response = client.multimodal.chat.create(
    model='qwen3-vl-plus',  # Puede sustituirlo por otros modelos multimodales y modificar los messages según sea necesario
    messages=messages)

print(f"Salida del modelo en la primera ronda {response.output_text}")
messages.append(response.choices[0].message.model_dump(exclude_none=True))
user_msg = {"role": "user", "content": [{"text": "What style are they?"}]}
messages.append(user_msg)
response = client.multimodal.chat.create(
    model='qwen3-vl-plus',
    messages=messages)

print(f"Salida del modelo en la segunda ronda {response.output_text}")

Para modelos de pensamiento

Los modelos de pensamiento devuelven reasoning_content (proceso de pensamiento) y content (respuesta). Al actualizar los mensajes, conserve solo content e ignore 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 obtener más información sobre los modelos de pensamiento, consulte Pensamiento profundo y Comprensión de imágenes y videos.

Para obtener más información sobre la implementación de conversaciones de múltiples turnos con Qwen3-Omni-Flash (modo de pensamiento), consulte omni-modal.

Compatible con OpenAI
DashScope

Python
Node.js
HTTP

Código de ejemplo

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/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")

Código de ejemplo

import OpenAI from "openai";
import process from 'process';
import readline from 'readline/promises';

// Initialize the readline interface
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// Initialize the openai client
const openai = new OpenAI({
    // API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    apiKey: process.env.DASHSCOPE_API_KEY, // Read from environment variables
    baseURL: 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1'
});

let reasoningContent = '';
let answerContent = '';
let isAnswering = false;
let messages = [];
let conversationIdx = 1;

async function main() {
    while (true) {
        console.log("=".repeat(20) + `Conversation Round ${conversationIdx}` + "=".repeat(20));
        conversationIdx++;

        // Read user input
        const userInput = await rl.question("Enter your message (type 'exit' to end): ");
        // Enter 'exit' to end the multi-turn conversation and avoid an endless loop
        if (userInput.trim().toLowerCase() === "exit") {
            console.log("Conversation ended.");
            rl.close();
            break;
        }
        messages.push({ role: 'user', content: userInput });

        // Reset state
        reasoningContent = '';
        answerContent = '';
        isAnswering = false;

        try {
            const stream = await openai.chat.completions.create({
                // You can replace this with other deep thinking models as needed
                model: 'qwen-plus',
                messages: messages,
                enable_thinking: true,
                stream: true,
                // stream_options:{
                //     include_usage: true
                // }
            });

            console.log("\n" + "=".repeat(20) + "Thinking Process" + "=".repeat(20) + "\n");

            for await (const chunk of stream) {
                if (!chunk.choices?.length) {
                    console.log('\nUsage:');
                    console.log(chunk.usage);
                    continue;
                }

                const delta = chunk.choices[0].delta;

                // Process the thinking process
                if (delta.reasoning_content) {
                    process.stdout.write(delta.reasoning_content);
                    reasoningContent += delta.reasoning_content;
                }

                // Process the formal response
                if (delta.content) {
                    if (!isAnswering) {
                        console.log('\n' + "=".repeat(20) + "Complete Response" + "=".repeat(20) + "\n");
                        isAnswering = true;
                    }
                    process.stdout.write(delta.content);
                    answerContent += delta.content;
                }
            }

            // Add the complete response to the message history
            messages.push({ role: 'assistant', content: answerContent });
            console.log("\n");

        } catch (error) {
            console.error('Error:', error);
        }
    }
}

// Start the program
main().catch(console.error);

Código de ejemplo

curl

# ======= Important =======

# API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
# === Delete this comment before execution ===

curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.8-max",
    "messages": [
        {
            "role": "user",
            "content": "Hello"
        },
        {
            "role": "assistant",
            "content": "Hello! Nice to meet you. Is there anything I can help you with?"
        },
        {
            "role": "user",
            "content": "Who are you?"
        }
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    },
    "enable_thinking": true
}'

Python
Java
HTTP

Código de ejemplo

import os
import dashscope

# La siguiente es la configuración de la región Singapur (ap-southeast-1). Sustituya {WorkspaceId} por el ID real de su espacio de trabajo. El valor de region varía según la región.
client = dashscope.Client(
    # Si no ha configurado la variable de entorno, sustituya la siguiente línea por su API Key de Model Studio: api_key="sk-xxx"
    # Las API Key difieren según la región. Para obtener una API Key, consulte https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)

messages = []
conversation_idx = 1
while True:
    print("=" * 20 + f"Conversation Round {conversation_idx}" + "=" * 20)
    conversation_idx += 1
    user_input = input("Enter your message (type 'exit' to end): ")
    # Introduzca 'exit' para finalizar la conversación multironda y evitar un bucle infinito
    if user_input.strip().lower() == "exit":
        print("Conversation ended.")
        break
    user_msg = {"role": "user", "content": [{"text": user_input}]}
    messages.append(user_msg)
    stream = client.multimodal.chat.create(
        # Este ejemplo usa qwen3.8-max. Puede sustituirlo por otros modelos de pensamiento profundo según sea necesario
        model="qwen3.8-max",
        messages=messages,
        enable_thinking=True,
        stream=True,
    )
    # Defina el proceso de pensamiento completo
    reasoning_content = ""
    # Defina la respuesta completa
    answer_content = ""
    # Determine si finaliza el proceso de pensamiento y comienza la respuesta
    is_answering = False
    print("=" * 20 + "Thinking Process" + "=" * 20)
    for chunk in stream:
        # Obtenga el contenido del chunk actual (la salida en streaming es incremental por defecto)
        content_text = chunk.choices[0].delta.content or ""
        reasoning_text = chunk.choices[0].delta.reasoning_content or ""
        # Si tanto el proceso de pensamiento como la respuesta están vacíos, ignórelo
        if content_text == "" and reasoning_text == "":
            pass
        else:
            # Si es el proceso de pensamiento actual
            if reasoning_text != "" and content_text == "":
                print(reasoning_text, end="",flush=True)
                reasoning_content += reasoning_text
            # Si es la respuesta actual
            elif content_text != "":
                if not is_answering:
                    print("\n" + "=" * 20 + "Complete Response" + "=" * 20)
                    is_answering = True
                print(content_text, end="",flush=True)
                answer_content += content_text
    # Añada el contenido de la respuesta del modelo al contexto
    messages.append({"role": "assistant", "content": [{"text": answer_content}]})
    print("\n")
    # Para imprimir el proceso de pensamiento completo y la respuesta completa, quite los comentarios y ejecute el siguiente código
    # print("=" * 20 + "Complete Thinking Process" + "=" * 20 + "\n")
    # print(f"{reasoning_content}")
    # print("=" * 20 + "Complete Response" + "=" * 20 + "\n")
    # print(f"{answer_content}")

Código de ejemplo

// DashScope SDK version >= 2.19.4
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversation;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationParam;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationResult;
import com.alibaba.dashscope.common.MultiModalMessage;
import java.util.Collections;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.UploadFileException;
import com.alibaba.dashscope.utils.Constants;
import io.reactivex.Flowable;
import java.lang.System;
import java.util.List;
import java.util.Map;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static StringBuilder reasoningContent = new StringBuilder();
    private static StringBuilder finalContent = new StringBuilder();
    private static boolean isFirstPrint = true;
    static {
        // Singapore region URL. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.

        Constants.baseHttpApiUrl="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1";
    }
    private static void handleMultiModalConversationResult(MultiModalConversationResult message) {
        if (message != null && message.getOutput() != null
            && message.getOutput().getChoices() != null
            && !message.getOutput().getChoices().isEmpty()
            && message.getOutput().getChoices().get(0) != null
            && message.getOutput().getChoices().get(0).getMessage() != null) {

            String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
            List<Map<String, Object>> contentList = message.getOutput().getChoices().get(0).getMessage().getContent();
            String content = "";
            if (contentList != null && !contentList.isEmpty()) {
                Object textObj = contentList.get(0).get("text");
                if (textObj != null) {
                    content = textObj.toString();
                }
            }

            if (reasoning != null && !reasoning.isEmpty()) {
                reasoningContent.append(reasoning);
                if (isFirstPrint) {
                    System.out.println("====================Thinking Process====================");
                    isFirstPrint = false;
                }
                System.out.print(reasoning);
            }

            if (content != null && !content.isEmpty()) {
                finalContent.append(content);
                if (!isFirstPrint) {
                    System.out.println("\n====================Complete Response====================");
                    isFirstPrint = true;
                }
                System.out.print(content);
            }
        }
    }

    private static MultiModalConversationParam buildMultiModalConversationParam(List<MultiModalMessage> messages) {
        return MultiModalConversationParam.builder()
                // If you have not configured the environment variable, replace the following line with your Model Studio API key: .apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // This example uses qwen3.8-max. You can replace it with other model names as needed.
                .model("qwen3.8-max")
                .enableThinking(true)
                .messages(messages)
                .incrementalOutput(true)
                .build();
    }

    public static void streamCallWithMessage(MultiModalConversation conv, List<MultiModalMessage> messages)
            throws NoApiKeyException, ApiException, InputRequiredException, UploadFileException {
        MultiModalConversationParam param = buildMultiModalConversationParam(messages);
        Flowable<MultiModalConversationResult> result = conv.streamCall(param);
        result.doOnError(throwable -> logger.error("Error occurred in stream processing: {}", throwable.getMessage(), throwable))
              .blockingForEach(Main::handleMultiModalConversationResult);
    }

    public static void main(String[] args) {
        try {
            MultiModalConversation conv = new MultiModalConversation();
            MultiModalMessage userMsg1 = MultiModalMessage.builder()
                    .role(Role.USER.getValue())
                    .content(Arrays.asList(Collections.singletonMap("text", "Hello")))
                    .build();
            MultiModalMessage assistantMsg = MultiModalMessage.builder()
                    .role(Role.ASSISTANT.getValue())
                    .content(Arrays.asList(Collections.singletonMap("text", "Hello! Nice to meet you. Is there anything I can help you with?")))
                    .build();
            MultiModalMessage userMsg2 = MultiModalMessage.builder()
                    .role(Role.USER.getValue())
                    .content(Arrays.asList(Collections.singletonMap("text", "Who are you")))
                    .build();
            List<MultiModalMessage> messages = Arrays.asList(userMsg1, assistantMsg, userMsg2);
            streamCallWithMessage(conv, messages);
        } catch (ApiException | NoApiKeyException | InputRequiredException | UploadFileException e) {
            logger.error("An exception occurred: {}", e.getMessage(), e);
        } catch (Exception e) {
            logger.error("Unexpected error occurred: {}", e.getMessage(), e);
        } finally {
            // Ensure the program exits normally
            System.exit(0);
        }
    }
}

Código de ejemplo

curl

# ======= Important =======
# API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key

# === Delete this comment before execution ===
curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
    "model": "qwen3.8-max",
    "input":{
        "messages":[
            {
                "role": "user",
                "content": [{"text": "Hello"}]
            },
            {
                "role": "assistant",
                "content": [{"text": "Hello! Nice to meet you. Is there anything I can help you with?"}]
            },
            {
                "role": "user",
                "content": [{"text": "Who are you?"}]
            }
        ]
    },
    "parameters":{
        "enable_thinking": true,
        "incremental_output": true
    }
}'

Puesta en marcha

Las conversaciones de múltiples turnos pueden consumir muchos tokens y exceder la longitud de contexto del modelo, lo que provoca errores. Utilice estas estrategias para gestionar el contexto y controlar los costos.

1. Gestión de contexto

El arreglo messages crece con cada ronda y puede exceder el límite de tokens del modelo. Utilice estos métodos para gestionar la longitud del contexto:

1.1. Truncamiento de contexto

Conserve solo las N rondas más recientes cuando el historial sea demasiado extenso. Esto es sencillo de implementar, pero se pierde información de conversaciones anteriores.

1.2. Resumen continuo

Resuma el contexto a medida que avanza la conversación para comprimir el historial y controlar la longitud sin perder información esencial: a. Cuando el historial alcance el 70% de la longitud máxima de contexto, extraiga una parte anterior (como la primera mitad) y realice una llamada de API por separado para generar un "resumen de memoria". b. En la siguiente solicitud, reemplace el historial extenso con el "resumen de memoria" y añada las rondas recientes.

1.3. Recuperación vectorizada

Los resúmenes continuos pueden perder cierta información. Para permitir que el modelo recuerde información relevante de historiales de conversación extensos, utilice la recuperación bajo demanda en lugar del paso lineal de contexto: a. Después de cada ronda de conversación, almacene la conversación en una base de datos vectorial. b. Cuando un usuario haga una pregunta, recupere los registros de conversación relevantes basándose en la similitud. c. Combine los registros de conversación recuperados con la entrada más reciente del usuario y envíe el contenido combinado al modelo.

2. Control de costos

Los tokens de entrada aumentan con cada ronda, lo que incrementa significativamente los costos. Utilice estas estrategias de gestión de costos:

2.1. Reducir tokens de entrada

Utilice las estrategias de gestión de contexto descritas anteriormente para reducir los tokens de entrada y disminuir los costos.

2.2. Usar modelos compatibles con caché de contexto

En las solicitudes de múltiples turnos, el arreglo messages se procesa y factura repetidamente. Model Studio proporciona caché de contexto para modelos como qwen-max y qwen-plus, lo que reduce los costos y mejora la velocidad de respuesta. Priorice los modelos que admiten caché de contexto.

La caché de contexto se habilita automáticamente; no se requieren cambios en el código.

Códigos de error

Si la llamada al modelo falla y devuelve un mensaje de error, consulte Códigos de error para su resolución.

​Funcionamiento

​Introducción

​Para modelos multimodales

​Para modelos de pensamiento

Código de ejemplo

​Puesta en marcha

​1. Gestión de contexto

​1.1. Truncamiento de contexto

​1.2. Resumen continuo

​1.3. Recuperación vectorizada

​2. Control de costos

​2.1. Reducir tokens de entrada

​2.2. Usar modelos compatibles con caché de contexto

​Códigos de error

Funcionamiento

Introducción

Para modelos multimodales

Para modelos de pensamiento

Puesta en marcha

1. Gestión de contexto

1.1. Truncamiento de contexto

1.2. Resumen continuo

1.3. Recuperación vectorizada

2. Control de costos

2.1. Reducir tokens de entrada

2.2. Usar modelos compatibles con caché de contexto

Códigos de error