QwQ 模型的用法_大模型服务平台百炼(Model Studio)-阿里云帮助中心

QwQ 模型具有强大的推理能力，模型会先输出思考过程，再输出回答内容。QwQ 模型当前仅支持通过流式输出方式调用。

本文介绍的 QwQ 模型使用方法不适用于 qwq-32b-preview，如果您使用 qwq-32b-preview 模型，请参考文本生成。

概述

相比于 Qwen-Max 等文本生成模型，QwQ 模型会“三思而后言”，在回复前先进行思考：

以上组件仅供您参考，并未真实发送请求。

QwQ 模型介绍

商业版模型

基于 Qwen2.5 模型训练的 QwQ 推理模型，通过强化学习大幅度提升了模型推理能力。模型数学代码等核心指标（AIME 24/25、LiveCodeBench）以及部分通用指标（IFEval、LiveBench等）达到DeepSeek-R1 满血版水平。相较于开源版，商业版具有最新的能力和改进。

模型名称	版本	上下文长度	最大输入	最大思维链长度	最大回复长度	输入成本	输出成本	免费额度（注）
模型名称	版本	（Token数）				（每千Token）		免费额度（注）

模型名称	版本	上下文长度	最大输入	最大思维链长度	最大回复长度	输入成本	输出成本	免费额度（注）
		（Token数）				（每千Token）
qwq-plus 当前等同 qwq-plus-2025-03-05	稳定版	131,072	98,304	32,768	8,192	0.0016元 Batch调用：0.0008元	0.004元 Batch调用：0.002元	各100万 Token 有效期：百炼开通后180天内
qwq-plus-latest 始终等同最新快照版	最新版					0.0016元	0.004元
qwq-plus-2025-03-05 又称qwq-plus-0305	快照版

开源版模型

基于 Qwen2.5-32B 模型训练的 QwQ 推理模型，于2025年3月6日发布。通过强化学习大幅度提升了模型推理能力。模型数学代码等核心指标（AIME 24/25、LiveCodeBench）以及部分通用指标（IFEval、LiveBench等）达到DeepSeek-R1 满血版水平，各指标均显著超过同样基于 Qwen2.5-32B 的 DeepSeek-R1-Distill-Qwen-32B。

模型名称	上下文长度	最大输入	最大思维链长度	最大回复长度	输入成本	输出成本	免费额度（注）
模型名称	（Token数）				（每千Token）		免费额度（注）

模型名称

上下文长度

最大输入

最大思维链长度

最大回复长度

输入成本

输出成本

免费额度

（注）

（Token数）

（每千Token）

qwq-32b

131,072

98,304

32,768

8,192

0.002元

0.006元

100万 Token

有效期：百炼开通后180天内

并发限流请参考限流。

快速开始

API 使用前提：已获取API Key并完成配置API Key到环境变量。如果通过SDK调用，需要安装 OpenAI 或 DashScope SDK（DashScope Java SDK 版本需要不低于2.18.2）。

重要

QwQ 模型当前仅支持通过流式输出方式调用。
如果您使用 DashScope 方式调用 QwQ 模型：
1. incremental_output 参数默认为 true，且不支持设置为 false，仅支持增量流式返回；
2. response_format参数默认为"message"。

OpenAI兼容

DashScope

Python

Node.js

HTTP

示例代码

from openai import OpenAI
import os

# 初始化OpenAI客户端
client = OpenAI(
    # 如果没有配置环境变量，请用百炼API Key替换：api_key="sk-xxx"
    api_key = os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

reasoning_content = ""  # 定义完整思考过程
answer_content = ""     # 定义完整回复
is_answering = False   # 判断是否结束思考过程并开始回复

# 创建聊天完成请求
completion = client.chat.completions.create(
    model="qwq-32b",  # 此处以 qwq-32b 为例，可按需更换模型名称
    messages=[
        {"role": "user", "content": "9.9和9.11谁大"}
    ],
    # QwQ 模型仅支持流式输出方式调用
    stream=True,
    # 解除以下注释会在最后一个chunk返回Token使用量
    # stream_options={
    #     "include_usage": True
    # }
)

print("\n" + "=" * 20 + "思考过程" + "=" * 20 + "\n")

for chunk in completion:
    # 如果chunk.choices为空，则打印usage
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
    else:
        delta = chunk.choices[0].delta
        # 打印思考过程
        if hasattr(delta, 'reasoning_content') and delta.reasoning_content != None:
            print(delta.reasoning_content, end='', flush=True)
            reasoning_content += delta.reasoning_content
        else:
            # 开始回复
            if delta.content != "" and is_answering is False:
                print("\n" + "=" * 20 + "完整回复" + "=" * 20 + "\n")
                is_answering = True
            # 打印回复过程
            print(delta.content, end='', flush=True)
            answer_content += delta.content

# print("=" * 20 + "完整思考过程" + "=" * 20 + "\n")
# print(reasoning_content)
# print("=" * 20 + "完整回复" + "=" * 20 + "\n")
# print(answer_content)

返回结果

====================思考过程====================

嗯，用户问的是9.9和9.11谁大。首先我要确定这两个数字的具体含义，因为有时候在不同的上下文中可能会有不同的解释。不过通常来说，这里的数字应该是指十进制的小数，也就是数学上的数值比较。

首先，我需要比较这两个小数的大小。9.9和9.11。先看整数部分，都是9，所以整数部分相同。接下来比较小数部分。小数点后的第一位，9.9的小数点后第一位是9，而9.11的小数点后第一位是1。这时候，9比1大，所以9.9的小数部分在第一位就已经更大了，那么整个数自然更大。不过，可能有人会疑惑，因为9.11的小数点后有两位，而9.9只有两位？或者说是不是应该补零来比较？

比如，9.9可以写成9.90，而9.11是9.11，这样比较的话，第二位小数的话，9.90的第二位是0，而9.11的是1，这时候第二位的话，0比1小。不过这时候第一位已经分出胜负了，第一位9比1大，所以不管后面的小数位如何，第一位已经决定了。因此，9.9比9.11大。

不过，也有可能用户在这里的写法有其他意思，比如9.9和9.11可能指的是日期，比如9月9日和9月11日，这样的话比较的话，9.11会更大，因为11日比9日晚。但通常数字比较的话，如果没有特别说明是日期的话，应该按数值来比较。不过用户的问题用的是“谁大”，也就是数值大小，而不是日期先后，所以应该还是数值比较。

再仔细检查一遍，9.9和9.11的数值比较：

9.9 = 9 + 0.9 = 9.900...

9.11 = 9 + 0.11 = 9.110...

比较的时候，先比较整数部分，都是9，相同。然后比较小数点后的第一位，0.9的十分位是9，而0.11的十分位是1，所以9.9的十分位更大，因此整个数更大。后面的百分位虽然9.11有1，但因为十分位已经分出高下了，所以不影响结果。

所以结论应该是9.9比9.11大。不过可能有人会因为小数点后的位数不同而产生混淆，比如认为9.11有两位小数，所以更精确或者数值更大，但其实不是的，数值的大小不取决于小数点后的位数，而是每一位的数值比较。

比如，比如比较1.5和1.499，虽然1.499有三位小数，但数值上还是小于1.5。同理，9.9虽然写成一位小数，但等价于9.90，所以比9.11大。

不过，也有可能用户在这里的写法有其他意思，比如货币单位？比如9.9元和9.11元，这时候同样是9.9元更多。或者其他的上下文，但如果没有特别说明的话，应该按数值比较。

所以最终结论是9.9比9.11大。不过，为了确保正确，再举个例子，比如用分数来比较：

9.9 = 99/10 = 9.9

9.11 = 911/100 = 9.11

将它们通分比较：

99/10 = 990/100

911/100 = 911/100

显然，990 > 911，所以9.9更大。

这样确认下来，答案应该是9.9更大。不过用户可能在输入时有笔误，或者有其他意图，但按照常规数学比较的话，结论应该是正确的。
====================完整回复====================

9.9比9.11大。以下是详细分析：

1. **整数部分比较**：  
   两个数的整数部分均为 **9**，因此整数部分相等。

2. **小数部分比较**：  
   - **第一位小数**：  
     9.9 的小数点后第一位是 **9**，而 9.11 的小数点后第一位是 **1**。  
     **9 > 1**，因此仅凭这一位即可判断 **9.9 > 9.11**。

   - **后续小数位**（补充说明）：  
     即使补零为相同位数（如 9.9 = 9.90），比较第二位小数时：  
     - 9.90 的第二位是 **0**，而 9.11 的第二位是 **1**。  
     但此时第一位小数已分出胜负，后续位数不影响最终结果。

3. **分数形式验证**：  
   - 9.9 = \( \frac{99}{10} = \frac{990}{100} \)  
   - 9.11 = \( \frac{911}{100} \)  
   显然，\( 990 > 911 \)，因此 **9.9 > 9.11**。

**结论**：  
在数值大小比较中，**9.9 大于 9.11**。

示例代码

import OpenAI from "openai";
import process from 'process';

// 初始化 openai 客户端
const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY, // 从环境变量读取
    baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1'
});

let reasoningContent = '';
let answerContent = '';
let isAnswering = false;

async function main() {
    try {
        const stream = await openai.chat.completions.create({
            model: 'qwq-32b',
            messages: [{ role: 'user', content: '9.9和9.11谁大' }],
            // QwQ 模型仅支持流式输出方式调用
            stream: true
        });

        console.log('\n' + '='.repeat(20) + '思考过程' + '='.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;
            
            // 处理思考过程
            if (delta.reasoning_content) {
                process.stdout.write(delta.reasoning_content);
                reasoningContent += delta.reasoning_content;
            } 
            // 处理正式回复
            else if (delta.content) {
                if (!isAnswering) {
                    console.log('\n' + '='.repeat(20) + '完整回复' + '='.repeat(20) + '\n');
                    isAnswering = true;
                }
                process.stdout.write(delta.content);
                answerContent += delta.content;
            }
        }
    } catch (error) {
        console.error('Error:', error);
    }
}

main();

返回结果

====================思考过程====================

嗯，用户问的是9.9和9.11谁大。首先我要确定这两个数字的具体含义，因为有时候在不同的上下文中可能会有不同的解释。不过通常来说，这里的数字应该是指十进制的小数，也就是数学上的数值比较。

首先，我需要比较这两个小数的大小。9.9和9.11。先看整数部分，都是9，所以整数部分相同。接下来比较小数部分。小数点后的第一位，9.9的小数点后第一位是9，而9.11的小数点后第一位是1。这时候，9比1大，所以9.9的小数部分在第一位就已经更大了，那么整个数自然更大。不过，可能有人会疑惑，因为9.11的小数点后有两位，而9.9只有两位？或者说是不是应该补零来比较？

比如，9.9可以写成9.90，而9.11是9.11，这样比较的话，第二位小数的话，9.90的第二位是0，而9.11的是1，这时候第二位的话，0比1小。不过这时候第一位已经分出胜负了，第一位9比1大，所以不管后面的小数位如何，第一位已经决定了。因此，9.9比9.11大。

不过，也有可能用户在这里的写法有其他意思，比如9.9和9.11可能指的是日期，比如9月9日和9月11日，这样的话比较的话，9.11会更大，因为11日比9日晚。但通常数字比较的话，如果没有特别说明是日期的话，应该按数值来比较。不过用户的问题用的是“谁大”，也就是数值大小，而不是日期先后，所以应该还是数值比较。

再仔细检查一遍，9.9和9.11的数值比较：

9.9 = 9 + 0.9 = 9.900...

9.11 = 9 + 0.11 = 9.110...

比较的时候，先比较整数部分，都是9，相同。然后比较小数点后的第一位，0.9的十分位是9，而0.11的十分位是1，所以9.9的十分位更大，因此整个数更大。后面的百分位虽然9.11有1，但因为十分位已经分出高下了，所以不影响结果。

所以结论应该是9.9比9.11大。不过可能有人会因为小数点后的位数不同而产生混淆，比如认为9.11有两位小数，所以更精确或者数值更大，但其实不是的，数值的大小不取决于小数点后的位数，而是每一位的数值比较。

比如，比如比较1.5和1.499，虽然1.499有三位小数，但数值上还是小于1.5。同理，9.9虽然写成一位小数，但等价于9.90，所以比9.11大。

不过，也有可能用户在这里的写法有其他意思，比如货币单位？比如9.9元和9.11元，这时候同样是9.9元更多。或者其他的上下文，但如果没有特别说明的话，应该按数值比较。

所以最终结论是9.9比9.11大。不过，为了确保正确，再举个例子，比如用分数来比较：

9.9 = 99/10 = 9.9

9.11 = 911/100 = 9.11

将它们通分比较：

99/10 = 990/100

911/100 = 911/100

显然，990 > 911，所以9.9更大。

这样确认下来，答案应该是9.9更大。不过用户可能在输入时有笔误，或者有其他意图，但按照常规数学比较的话，结论应该是正确的。
====================完整回复====================

9.9比9.11大。以下是详细分析：

1. **整数部分比较**：  
   两个数的整数部分均为 **9**，因此整数部分相等。

2. **小数部分比较**：  
   - **第一位小数**：  
     9.9 的小数点后第一位是 **9**，而 9.11 的小数点后第一位是 **1**。  
     **9 > 1**，因此仅凭这一位即可判断 **9.9 > 9.11**。

   - **后续小数位**（补充说明）：  
     即使补零为相同位数（如 9.9 = 9.90），比较第二位小数时：  
     - 9.90 的第二位是 **0**，而 9.11 的第二位是 **1**。  
     但此时第一位小数已分出胜负，后续位数不影响最终结果。

3. **分数形式验证**：  
   - 9.9 = \( \frac{99}{10} = \frac{990}{100} \)  
   - 9.11 = \( \frac{911}{100} \)  
   显然，\( 990 > 911 \)，因此 **9.9 > 9.11**。

**结论**：  
在数值大小比较中，**9.9 大于 9.11**。

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwq-32b",
    "messages": [
        {
            "role": "user", 
            "content": "9.9和9.11谁大"
        }
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    }
}'

返回结果

data: {"choices":[{"delta":{"content":null,"role":"assistant","reasoning_content":""},"index":0,"logprobs":null,"finish_reason":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"finish_reason":null,"delta":{"content":null,"reasoning_content":"嗯"},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"，"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"用户"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}
......

data: {"choices":[{"delta":{"content":"需","reasoning_content":null},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":"进一步","reasoning_content":null},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":"确认","reasoning_content":null},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":"规则","reasoning_content":null},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"delta":{"content":"。","reasoning_content":null},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[{"finish_reason":"stop","delta":{"content":"","reasoning_content":null},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: {"choices":[],"object":"chat.completion.chunk","usage":{"prompt_tokens":18,"completion_tokens":1015,"total_tokens":1033},"created":1741185359,"system_fingerprint":null,"model":"qwq-32b","id":"chatcmpl-6c2000e7-b744-9e61-bd03-fc4333d0e5d1"}

data: [DONE]

Python

Java

HTTP

示例代码

import os
import dashscope

messages = [
    {'role': 'user', 'content': '你是谁？'}
]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx"
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="qwq-32b",  # 此处以qwq-32b为例，可按需更换模型名称
    messages=messages,
    # QwQ 模型仅支持流式输出方式调用
    stream=True,
)

# 定义完整思考过程
reasoning_content = ""
# 定义完整回复
answer_content = ""
# 判断是否结束思考过程并开始回复
is_answering = False

print("=" * 20 + "思考过程" + "=" * 20)

for chunk in response:
    # 如果思考过程与回复皆为空，则忽略
    if (chunk.output.choices[0].message.content == "" and 
        chunk.output.choices[0].message.reasoning_content == ""):
        pass
    else:
        # 如果当前为思考过程
        if (chunk.output.choices[0].message.reasoning_content != "" and 
            chunk.output.choices[0].message.content == ""):
            print(chunk.output.choices[0].message.reasoning_content, end="",flush=True)
            reasoning_content += chunk.output.choices[0].message.reasoning_content
        # 如果当前为回复
        elif chunk.output.choices[0].message.content != "":
            if not is_answering:
                print("\n" + "=" * 20 + "完整回复" + "=" * 20)
                is_answering = True
            print(chunk.output.choices[0].message.content, end="",flush=True)
            answer_content += chunk.output.choices[0].message.content

# 如果您需要打印完整思考过程与完整回复，请将以下代码解除注释后运行
# print("=" * 20 + "完整思考过程" + "=" * 20 + "\n")
# print(f"{reasoning_content}")
# print("=" * 20 + "完整回复" + "=" * 20 + "\n")
# print(f"{answer_content}")

返回结果

====================思考过程====================
嗯，用户问“你是谁？”，我需要先确定他们想知道什么。可能他们刚接触我，想了解我的基本信息。首先，我应该介绍自己的身份，比如我是通义千问，阿里巴巴集团旗下的超大规模语言模型。然后，说明我的功能，比如回答问题、创作文字、编程等。还要提到我的特点，比如多语言支持和持续学习的能力。

接下来，用户可能想知道如何与我互动，所以需要给出使用建议，比如直接提问或给出任务。同时，要确保回答简洁明了，避免技术术语太多，让用户容易理解。另外，可能需要考虑用户的使用场景，比如是个人使用还是商业用途，但问题比较基础，暂时不需要深入。还要检查是否有遗漏的重要信息，比如我的训练数据截止时间或者更新情况，但用户可能不需要这么详细。最后，保持友好和开放的态度，鼓励用户进一步提问，这样能促进更深入的交流。
====================完整回复====================
你好！我是通义千问，阿里巴巴集团旗下的超大规模语言模型。我能够回答问题、创作文字，比如写故事、写公文、写邮件、写剧本、逻辑推理、编程等等，还能表达观点，玩游戏等。我熟练掌握多种语言，包括但不限于中文、英文、德语、法语、西班牙语等。

你可以直接告诉我你需要什么帮助，或者有任何问题想问我，我会尽力为你提供支持！有什么我可以帮到你的吗？

示例代码

// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 io.reactivex.Flowable;
import java.lang.System;

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;

    private static void handleGenerationResult(GenerationResult message) {
        String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();

        if (!reasoning.isEmpty()) {
            reasoningContent.append(reasoning);
            if (isFirstPrint) {
                System.out.println("====================思考过程====================");
                isFirstPrint = false;
            }
            System.out.print(reasoning);
        }

        if (!content.isEmpty()) {
            finalContent.append(content);
            if (!isFirstPrint) {
                System.out.println("\n====================完整回复====================");
                isFirstPrint = true;
            }
            System.out.print(content);
        }
    }
    private static GenerationParam buildGenerationParam(Message userMsg) {
        return GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // 此处以 qwq-32b 为例，可按需更换模型名称
                .model("qwq-32b")
                .messages(Arrays.asList(userMsg))
                .build();
    }
    public static void streamCallWithMessage(Generation gen, Message userMsg)
            throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(userMsg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message userMsg = Message.builder().role(Role.USER.getValue()).content("你是谁？").build();
            streamCallWithMessage(gen, userMsg);
//             打印最终结果
//            if (reasoningContent.length() > 0) {
//                System.out.println("\n====================完整回复====================");
//                System.out.println(finalContent.toString());
//            }
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

====================思考过程====================
好的，用户问“你是谁？”，我需要根据之前的设定来回答。首先，我的角色是通义千问，阿里巴巴集团旗下的超大规模语言模型。要保持口语化，简洁易懂。

用户可能刚接触我，或者想确认我的身份。应该先直接回答我是谁，然后简要说明我的功能和用途，比如回答问题、创作文字、编程等。还要提到支持多语言，这样用户知道我可以处理不同语言的需求。

另外，根据指导方针，要保持拟人性，所以语气要友好，可能用表情符号增加亲切感。同时，可能需要引导用户进一步提问或使用我的功能，比如问他们需要什么帮助。

需要注意不要使用复杂术语，避免冗长。检查是否有遗漏的关键点，比如多语言支持和具体能力。确保回答符合所有要求，包括口语化和简洁。
====================完整回复====================
你好！我是通义千问，阿里巴巴集团旗下的超大规模语言模型。我能够回答问题、创作文字，比如写故事、写公文、写邮件、写剧本、逻辑推理、编程等等，还能表达观点，玩游戏等。我熟练掌握多种语言，包括但不限于中文、英文、德语、法语、西班牙语等。有什么需要我帮忙的吗？

示例代码

curl

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
    "model": "qwq-32b",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    }
}'

返回结果

id:1
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"嗯","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":14,"input_tokens":11,"output_tokens":3},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:2
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"，","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":15,"input_tokens":11,"output_tokens":4},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:3
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"用户","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":16,"input_tokens":11,"output_tokens":5},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:4
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"问","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":17,"input_tokens":11,"output_tokens":6},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:5
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"“","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":18,"input_tokens":11,"output_tokens":7},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}
......

id:358
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"帮助","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":373,"input_tokens":11,"output_tokens":362},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:359
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"，","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":374,"input_tokens":11,"output_tokens":363},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:360
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"欢迎","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":375,"input_tokens":11,"output_tokens":364},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:361
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"随时","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":376,"input_tokens":11,"output_tokens":365},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:362
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"告诉我","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":377,"input_tokens":11,"output_tokens":366},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:363
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"！","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":378,"input_tokens":11,"output_tokens":367},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

id:364
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"","role":"assistant"},"finish_reason":"stop"}]},"usage":{"total_tokens":378,"input_tokens":11,"output_tokens":367},"request_id":"25d58c29-c47b-9e8d-a0f1-d6c309ec58b1"}

多轮对话

QwQ 模型 API 默认不会记录您的历史对话信息。多轮对话功能可以让大模型“拥有记忆”，满足如追问、信息采集等需要连续交流的场景。您在使用 QwQ 模型时，会接收到reasoning_content字段（思考过程）与content（回复内容），您可以将content字段通过{'role': 'assistant', 'content':拼接后的流式输出content}添加到上下文，无需添加reasoning_content字段。

OpenAI兼容

DashScope

您可以通过 OpenAI SDK 或 OpenAI 兼容的 HTTP 方式使用多轮对话功能。

Python

Node.js

HTTP

示例代码

from openai import OpenAI
import os

# 初始化OpenAI客户端
client = OpenAI(
    # 如果没有配置环境变量，请用百炼API Key替换：api_key="sk-xxx"
    api_key = os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

reasoning_content = ""  # 定义完整思考过程
answer_content = ""     # 定义完整回复
is_answering = False   # 判断是否结束思考过程并开始回复

messages = []
conversation_idx = 1
while True:
    print("="*20+f"第{conversation_idx}轮对话"+"="*20)
    conversation_idx += 1
    user_msg = {"role": "user", "content": input("请输入你的消息：")}
    messages.append(user_msg)
    # 创建聊天完成请求
    completion = client.chat.completions.create(
        model="qwq-32b",  # 此处以 qwq-32b 为例，可按需更换模型名称
        messages=messages,
        # QwQ 模型仅支持流式输出方式调用
        stream=True
    )
    print("\n" + "=" * 20 + "思考过程" + "=" * 20 + "\n")
    for chunk in completion:
        # 如果chunk.choices为空，则打印usage
        if not chunk.choices:
            print("\nUsage:")
            print(chunk.usage)
        else:
            delta = chunk.choices[0].delta
            # 打印思考过程
            if hasattr(delta, 'reasoning_content') and delta.reasoning_content != None:
                print(delta.reasoning_content, end='', flush=True)
                reasoning_content += delta.reasoning_content
            else:
                # 开始回复
                if delta.content != "" and is_answering is False:
                    print("\n" + "=" * 20 + "完整回复" + "=" * 20 + "\n")
                    is_answering = True
                # 打印回复过程
                print(delta.content, end='', flush=True)
                answer_content += delta.content
    messages.append({"role": "assistant", "content": answer_content})
    print("\n")
    # print("=" * 20 + "完整思考过程" + "=" * 20 + "\n")
    # print(reasoning_content)
    # print("=" * 20 + "完整回复" + "=" * 20 + "\n")
    # print(answer_content)

示例代码

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

// 初始化 readline 接口
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 初始化 openai 客户端
const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY, // 从环境变量读取
    baseURL: 'https://dashscope.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) + `第${conversationIdx}轮对话` + "=".repeat(20));
        conversationIdx++;
        
        // 读取用户输入
        const userInput = await rl.question("请输入你的消息：");
        messages.push({ role: 'user', content: userInput });

        // 重置状态
        reasoningContent = '';
        answerContent = '';
        isAnswering = false;

        try {
            const stream = await openai.chat.completions.create({
                model: 'qwq-32b',
                messages: messages,
                // QwQ 模型仅支持流式输出方式调用
                stream: true
            });

            console.log("\n" + "=".repeat(20) + "思考过程" + "=".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;
                
                // 处理思考过程
                if (delta.reasoning_content) {
                    process.stdout.write(delta.reasoning_content);
                    reasoningContent += delta.reasoning_content;
                }
                
                // 处理正式回复
                if (delta.content) {
                    if (!isAnswering) {
                        console.log('\n' + "=".repeat(20) + "完整回复" + "=".repeat(20) + "\n");
                        isAnswering = true;
                    }
                    process.stdout.write(delta.content);
                    answerContent += delta.content;
                }
            }
            
            // 将完整回复加入消息历史
            messages.push({ role: 'assistant', content: answerContent });
            console.log("\n");
            
        } catch (error) {
            console.error('Error:', error);
        }
    }
}

// 启动程序
main().catch(console.error);

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwq-32b",
    "messages": [
        {
            "role": "user", 
            "content": "你好"
        },
        {
            "role": "assistant",
            "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
        },
        {
            "role": "user",
            "content": "你是谁？"
        }
    ],
    "stream": true
}'

您可以通过 DashScope SDK 或 HTTP 方式使用多轮对话功能。

Python

Java

HTTP

示例代码

import os
import dashscope

messages = []
conversation_idx = 1
while True:
    print("=" * 20 + f"第{conversation_idx}轮对话" + "=" * 20)
    conversation_idx += 1
    user_msg = {"role": "user", "content": input("请输入你的消息：")}
    messages.append(user_msg)
    response = dashscope.Generation.call(
        # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
        api_key=os.getenv('DASHSCOPE_API_KEY'),
        model="qwq-32b",  # 此处以qwq-32b为例，可按需更换模型名称。
        messages=messages,
        # QwQ 模型仅支持流式输出方式调用
        stream=True,
    )
    # 定义完整思考过程
    reasoning_content = ""
    # 定义完整回复
    answer_content = ""
    # 判断是否结束思考过程并开始回复
    is_answering = False
    print("=" * 20 + "思考过程" + "=" * 20)
    for chunk in response:
        # 如果思考过程与回复皆为空，则忽略
        if (chunk.output.choices[0].message.content == "" and 
            chunk.output.choices[0].message.reasoning_content == ""):
            pass
        else:
            # 如果当前为思考过程
            if (chunk.output.choices[0].message.reasoning_content != "" and 
                chunk.output.choices[0].message.content == ""):
                print(chunk.output.choices[0].message.reasoning_content, end="",flush=True)
                reasoning_content += chunk.output.choices[0].message.reasoning_content
            # 如果当前为回复
            elif chunk.output.choices[0].message.content != "":
                if not is_answering:
                    print("\n" + "=" * 20 + "完整回复" + "=" * 20)
                    is_answering = True
                print(chunk.output.choices[0].message.content, end="",flush=True)
                answer_content += chunk.output.choices[0].message.content
    messages.append({"role": "assistant", "content": answer_content})
    print("\n")
    # 如果您需要打印完整思考过程与完整回复，请将以下代码解除注释后运行
    # print("=" * 20 + "完整思考过程" + "=" * 20 + "\n")
    # print(f"{reasoning_content}")
    # print("=" * 20 + "完整回复" + "=" * 20 + "\n")
    # print(f"{answer_content}")

示例代码

// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 io.reactivex.Flowable;
import java.lang.System;
import java.util.List;

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;

    private static void handleGenerationResult(GenerationResult message) {
        String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();

        if (!reasoning.isEmpty()) {
            reasoningContent.append(reasoning);
            if (isFirstPrint) {
                System.out.println("====================思考过程====================");
                isFirstPrint = false;
            }
            System.out.print(reasoning);
        }

        if (!content.isEmpty()) {
            finalContent.append(content);
            if (!isFirstPrint) {
                System.out.println("\n====================完整回复====================");
                isFirstPrint = true;
            }
            System.out.print(content);
        }
    }
    private static GenerationParam buildGenerationParam(List Msg) {
        return GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // 此处以 qwq-32b 为例，可按需更换模型名称
                .model("qwq-32b")
                .messages(Msg)
                .incrementalOutput(true)
                .build();
    }
    public static void streamCallWithMessage(Generation gen, List Msg)
            throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(Msg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message userMsg1 = Message.builder()
                    .role(Role.USER.getValue())
                    .content("你好")
                    .build();
            Message AssistantMsg = Message.builder()
                    .role(Role.ASSISTANT.getValue())
                    .content("你好！很高兴见到你，有什么我可以帮忙的吗？")
                    .build();
            Message userMsg2 = Message.builder()
                    .role(Role.USER.getValue())
                    .content("你是谁")
                    .build();
            List Msg = Arrays.asList(userMsg1,AssistantMsg,userMsg2);
            streamCallWithMessage(gen, Msg);
//             打印最终结果
//            if (reasoningContent.length() > 0) {
//                System.out.println("\n====================完整回复====================");
//                System.out.println(finalContent.toString());
//            }
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
        System.exit(0);
    }
}

示例代码

curl

curl -X POST "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
    "model": "qwq-32b",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你好"
            },
            {
                "role": "assistant",
                "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
            },
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    }
}'

Function Calling（工具调用）

QwQ 模型在回答需要实时信息的问题时效果不佳。您可以使用 Function Calling 功能，通过引入外部工具，使得 QwQ 模型可以与外部世界进行交互。

QwQ 模型会在思考完成后进行工具调用信息的输出，tool_choice参数只支持设置为"auto"（默认值，表示由模型自主选择工具）或"none"（强制模型不选择工具）。

OpenAI兼容

DashScope

Python

Node.js

HTTP

示例代码

import os
from openai import OpenAI

# 初始化OpenAI客户端，配置阿里云DashScope服务
client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # 从环境变量读取API密钥
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 定义可用工具列表
tools = [
    # 工具1 获取当前时刻的时间
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "当你想知道现在的时间时非常有用。",
            "parameters": {}  # 无需参数
        }
    },  
    # 工具2 获取指定城市的天气
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "当你想查询指定城市的天气时非常有用。",
            "parameters": {  
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                "required": ["location"]  # 必填参数
            }
        }
    }
]

# 定义问题，请不要设置 System Message
messages = [{"role": "user", "content": input("请输入问题：")}]
completion = client.chat.completions.create(
    model="qwq-plus",  # 此处以qwq-plus为例，可更换为其它qwq模型
    messages=messages,
    tools=tools,
    parallel_tool_calls=True,
    stream=True,
    # 解除注释后，可以获取到token消耗信息
    # stream_options={
    #     "include_usage": True
    # }
)

reasoning_content = ""  # 定义完整思考过程
answer_content = ""     # 定义完整回复
tool_info = []          # 存储工具调用信息
is_answering = False   # 判断是否结束思考过程并开始回复
print("="*20+"思考过程"+"="*20)
for chunk in completion:
    if not chunk.choices:
        # 处理用量统计信息
        print("\n"+"="*20+"Usage"+"="*20)
        print(chunk.usage)
    else:
        delta = chunk.choices[0].delta
        # 处理AI的思考过程（链式推理）
        if hasattr(delta, 'reasoning_content') and delta.reasoning_content is not None:
            reasoning_content += delta.reasoning_content
            print(delta.reasoning_content,end="",flush=True)  # 实时输出思考过程
            
        # 处理最终回复内容
        else:
            if not is_answering:  # 首次进入回复阶段时打印标题
                is_answering = True
                print("\n"+"="*20+"回复内容"+"="*20)
            if delta.content is not None:
                answer_content += delta.content
                print(delta.content,end="",flush=True)  # 流式输出回复内容
            
            # 处理工具调用信息（支持并行工具调用）
            if delta.tool_calls is not None:
                for tool_call in delta.tool_calls:
                    index = tool_call.index  # 工具调用索引，用于并行调用
                    
                    # 动态扩展工具信息存储列表
                    while len(tool_info) <= index:
                        tool_info.append({})
                    
                    # 收集工具调用ID（用于后续函数调用）
                    if tool_call.id:
                        tool_info[index]['id'] = tool_info[index].get('id', '') + tool_call.id
                    
                    # 收集函数名称（用于后续路由到具体函数）
                    if tool_call.function and tool_call.function.name:
                        tool_info[index]['name'] = tool_info[index].get('name', '') + tool_call.function.name
                    
                    # 收集函数参数（JSON字符串格式，需要后续解析）
                    if tool_call.function and tool_call.function.arguments:
                        tool_info[index]['arguments'] = tool_info[index].get('arguments', '') + tool_call.function.arguments
            
print(f"\n"+"="*19+"工具调用信息"+"="*19)
if not tool_info:
    print("没有工具调用")
else:
    print(tool_info)

返回结果

输入“四个直辖市的天气”，得到以下返回结果：

请输入问题：四个直辖市的天气
====================思考过程====================
好的，用户问的是四个直辖市的天气。首先，我需要明确中国的四个直辖市分别是哪几个。北京、上海、天津和重庆，对吧？所以用户需要这四个城市的天气情况。

接下来，我需要调用获取天气的函数get_current_weather，每个城市都要单独查询。不过这个函数每次只能查询一个地点，所以得分别调用四次。首先，我应该检查函数的参数是否需要其他信息，但根据描述，参数只需要location，类型是字符串，比如城市名。所以应该没问题。

然后，我需要确保每个城市的名称正确。比如北京应该用“北京市”，上海是“上海市”，天津是“天津市”，重庆的话可能是“重庆市”或者直接“重庆”，但为了统一，可能用全称更好。用户可能希望得到每个城市的当前天气，所以需要依次调用四次函数。

不过，用户可能希望一次性得到所有四个直辖市的天气，但根据工具的限制，可能需要多次调用。这时候可能需要分四次调用，然后把结果汇总。所以在回复里，我应该生成四个tool_call，每个对应一个城市。

另外，还要注意用户是否可能有其他意图，比如是否只需要今天的天气还是未来几天的？不过根据问题描述，函数是获取当前天气，所以应该没问题。不需要额外处理。

最后，确保每个tool_call的格式正确，参数正确，名称正确。然后按顺序生成四个调用，这样用户就能得到所有四个直辖市的天气数据了。
====================回复内容====================

===================工具调用信息===================
[{'id': 'call_0bfdb95b784e46fab218c0', 'name': 'get_current_weather', 'arguments': '{"location": "北京市"}'}, {'id': 'call_9631576c3ccd419f8d8bc7', 'name': 'get_current_weather', 'arguments': '{"location": "上海市"}'}, {'id': 'call_d862b1bfe8374d2d97f508', 'name': 'get_current_weather', 'arguments': '{"location": "天津市"}'}, {'id': 'call_7222cdcc3cd04c839f2427', 'name': 'get_current_weather', 'arguments': '{"location": "重庆市"}'}]

示例代码

import OpenAI from "openai";
import readline from 'node:readline/promises';
import { stdin as input, stdout as output } from 'node:process';

const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

const tools = [
    {
        type: "function",
        function: {
            name: "get_current_time",
            description: "当你想知道现在的时间时非常有用。",
            parameters: {}
        }
    },
    {
        type: "function",
        function: {
            name: "get_current_weather",
            description: "当你想查询指定城市的天气时非常有用。",
            parameters: {
                type: "object",
                properties: {
                    location: {
                        type: "string",
                        description: "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                required: ["location"]
            }
        }
    }
];

async function main() {
    const rl = readline.createInterface({ input, output });
    const question = await rl.question("请输入您的问题："); 
    rl.close();
    
    const messages = [{ role: "user", content: question }];
    
    let reasoningContent = "";
    let answerContent = "";
    const toolInfo = [];
    let isAnswering = false;

    console.log("=".repeat(20) + "思考过程" + "=".repeat(20));
    
    try {
        const stream = await openai.chat.completions.create({
            model: "qwq-plus",
            messages,
            tools,
            stream: true,
            parallel_tool_calls: true
        });

        for await (const chunk of stream) {
            if (!chunk.choices?.length) {
                console.log("\n" + "=".repeat(20) + "Usage" + "=".repeat(20));
                console.log(chunk.usage);
                continue;
            }

            const delta = chunk.choices[0]?.delta;
            if (!delta) continue;

            // 处理思考过程
            if (delta.reasoning_content) {
                reasoningContent += delta.reasoning_content;
                process.stdout.write(delta.reasoning_content);
            }
            // 处理回复内容
            else {
                if (!isAnswering) {
                    isAnswering = true;
                    console.log("\n" + "=".repeat(20) + "回复内容" + "=".repeat(20));
                }
                if (delta.content) {
                    answerContent += delta.content;
                    process.stdout.write(delta.content);
                }
                // 处理工具调用
                if (delta.tool_calls) {
                    for (const toolCall of delta.tool_calls) {
                        const index = toolCall.index;
                        
                        // 确保数组长度足够
                        while (toolInfo.length <= index) {
                            toolInfo.push({});
                        }
                        
                        // 更新工具ID
                        if (toolCall.id) {
                            toolInfo[index].id = (toolInfo[index].id || "") + toolCall.id;
                        }
                        
                        // 更新函数名称
                        if (toolCall.function?.name) {
                            toolInfo[index].name = (toolInfo[index].name || "") + toolCall.function.name;
                        }
                        
                        // 更新参数
                        if (toolCall.function?.arguments) {
                            toolInfo[index].arguments = (toolInfo[index].arguments || "") + toolCall.function.arguments;
                        }
                    }
                }
            }
        }

        console.log("\n" + "=".repeat(19) + "工具调用信息" + "=".repeat(19));
        console.log(toolInfo.length ? toolInfo : "没有工具调用");

    } catch (error) {
        console.error("发生错误:", error);
    }
}

main();

返回结果

输入“四个直辖市的天气”，得到以下返回结果：

请输入您的问题：四个直辖市的天气
====================思考过程====================
好的，用户问的是四个直辖市的天气。首先，我需要明确中国的四个直辖市分别是哪几个。北京、上海、天津和重庆，对吧？接下来，我需要为每个城市调用天气查询功能。

但是用户的问题可能需要我分别获取这四个城市的天气情况。每个城市都需要调用一次get_current_weather函数，参数是各自的城市名称。我需要确保参数正确，比如直辖市的全名，比如“北京市”、“上海市”、“天津市”和“重庆市”。

然后，我需要按照顺序依次调用这四个城市的天气接口。每个调用都需要单独的tool_call。用户可能希望得到每个城市的当前天气信息，所以需要确保每个调用都正确无误。可能需要注意每个城市的正确拼写和名称，避免出现错误。例如，重庆有时可能被简称为“重庆市”，所以参数里应该用全称。

现在，我需要生成四个tool_call，每个对应一个直辖市。检查每个参数是否正确，然后按顺序排列。这样用户就能得到四个直辖市的天气数据了。
====================回复内容====================

===================工具调用信息===================
[
  {
    id: 'call_21dc802e717f491298d1b2',
    name: 'get_current_weather',
    arguments: '{"location": "北京市"}'
  },
  {
    id: 'call_2cd3be1d2f694c4eafd4e5',
    name: 'get_current_weather',
    arguments: '{"location": "上海市"}'
  },
  {
    id: 'call_48cf3f78e02940bd9085e4',
    name: 'get_current_weather',
    arguments: '{"location": "天津市"}'
  },
  {
    id: 'call_e230a2b4c64f4e658d223e',
    name: 'get_current_weather',
    arguments: '{"location": "重庆市"}'
  }
]

示例代码

curl

curl -X POST https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwq-plus",
    "messages": [
        {
            "role": "user", 
            "content": "杭州天气怎么样"
        }
    ],
    "tools": [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "当你想知道现在的时间时非常有用。",
            "parameters": {}
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "当你想查询指定城市的天气时非常有用。",
            "parameters": {
                "type": "object",
                "properties": {
                    "location":{
                        "type": "string",
                        "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                "required": ["location"]
            }
        }
    }
  ],
  "stream": true
}'

返回结果

data: {"choices":[{"delta":{"content":null,"reasoning_content":"好的，用户问","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"的是杭州的天气怎么样"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"。我需要使用"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"get_current_weather这个"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"函数来获取信息"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"。首先，确认函数的"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"参数要求，里面"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"需要location参数，类型是"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"字符串，比如城市"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"或县区。"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"用户提到的是杭州市"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"，所以参数应该"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"填“杭州市”。然后检查"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"是否有其他可能的参数或"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"需要注意的地方，这里没有"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"其他参数。所以"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"正确的调用应该是调"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"用get_current_weather，参数"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"location设为“杭州市"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"”。不需要调用其他"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"函数，因为用户"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"只问了天气。"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"确认没有遗漏必要"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"参数，然后生成"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":"对应的tool_call。"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"content":null,"reasoning_content":null,"tool_calls":[{"function":{"name":"get_current_weather","arguments":"{\"location\": \"杭州市"},"index":0,"id":"call_c7fe3e2aa1fc4b67a79995","type":"function"}]},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"delta":{"tool_calls":[{"function":{"arguments":"\"}"},"index":0,"id":"","type":"function"}]},"index":0}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: {"choices":[{"finish_reason":"tool_calls","delta":{},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1742287815,"system_fingerprint":null,"model":"qwq-plus","id":"chatcmpl-423eb42c-57d8-90b8-a976-15d30c588792"}

data: [DONE]

Python

Java

HTTP

示例代码

import os
import dashscope


tools = [
    # 工具1 获取当前时刻的时间
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "当你想知道现在的时间时非常有用。",
            "parameters": {}  # 因为获取当前时间无需输入参数，因此parameters为空字典
        }
    },  
    # 工具2 获取指定城市的天气
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "当你想查询指定城市的天气时非常有用。",
            "parameters": {  
                "type": "object",
                "properties": {
                    # 查询天气时需要提供位置，因此参数设置为location
                    "location": {
                        "type": "string",
                        "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# 定义问题
messages = [{"role": "user", "content": input("请输入问题：")}]
completion = dashscope.Generation.call(
    model="qwq-plus",  # 此处以qwq-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
    messages=messages,
    tools=tools,
    parallel_tool_calls=True,
    stream=True
)

reasoning_content = ""
answer_content = ""
tool_info = []
is_answering = False
print("="*20+"思考过程"+"="*20)

for chunk in completion:
    if chunk.status_code == 200:
        msg = chunk.output.choices[0].message
        
        # 处理思考过程
        if 'reasoning_content' in msg and msg.reasoning_content:
            reasoning_content += msg.reasoning_content
            print(msg.reasoning_content, end="", flush=True)
        
        # 处理回复内容
        if 'content' in msg and msg.content:
            if not is_answering:
                is_answering = True
                print("\n"+"="*20+"回复内容"+"="*20)
            answer_content += msg.content
            print(msg.content, end="", flush=True)
        
        # 处理工具调用
        if 'tool_calls' in msg and msg.tool_calls:
            for tool_call in msg.tool_calls:
                index = tool_call['index']
                
                while len(tool_info) <= index:
                    tool_info.append({'id': '', 'name': '', 'arguments': ''})  # 初始化所有字段
                
                # 增量更新工具ID
                if 'id' in tool_call:
                    tool_info[index]['id'] += tool_call.get('id', '')
                
                # 增量更新函数信息
                if 'function' in tool_call:
                    func = tool_call['function']
                    # 增量更新函数名称
                    if 'name' in func:
                        tool_info[index]['name'] += func.get('name', '')
                    # 增量更新参数
                    if 'arguments' in func:
                        tool_info[index]['arguments'] += func.get('arguments', '')

print(f"\n"+"="*19+"工具调用信息"+"="*19)
if not tool_info:
    print("没有工具调用")
else:
    print(tool_info)

返回结果

输入“四个直辖市的天气”，得到以下返回结果：

请输入问题：四个直辖市的天气
====================思考过程====================
好的，用户问的是四个直辖市的天气。首先，我需要确认中国的四个直辖市分别是哪些。北京、上海、天津和重庆，对吧？接下来，用户需要每个城市的天气情况，所以我需要调用天气查询功能。

不过，问题来了，用户没有指定具体的城市名称，只是说四个直辖市。可能需要我明确每个直辖市的名称，然后分别查询。比如，北京、上海、天津、重庆这四个直辖市。我需要确保每个城市都正确无误。

然后，我要检查可用的工具，用户提供的函数是get_current_weather，参数是location。因此，我需要为每个直辖市调用这个函数，传入对应的城市名称作为参数。比如，第一次调用location是北京市，第二次是上海市，第三次是天津市，第四次是重庆市。

不过，可能需要注意，像重庆这样的直辖市，有时候可能需要更具体的区，但用户可能只需要市级的天气。所以直接使用直辖市名称应该没问题。接下来，我需要生成四个独立的函数调用，每个对应一个直辖市。这样用户就能得到四个城市的天气情况了。

最后，确保每个调用的参数正确，并且没有遗漏。这样用户的问题就能得到完整的回答了。
===================工具调用信息===================
[{'id': 'call_2f774ed97b0e4b24ab10ec', 'name': 'get_current_weather', 'arguments': '{"location": "北京市"}'}, {'id': 'call_dc3b05b88baa48c58bc33a', 'name': 'get_current_weather', 'arguments': '{"location": "上海市"}}'}, {'id': 'call_249b2de2f73340cdb46cbc', 'name': 'get_current_weather', 'arguments': '{"location": "天津市"}'}, {'id': 'call_833333634fda49d1b39e87', 'name': 'get_current_weather', 'arguments': '{"location": "重庆市"}}'}]

示例代码

import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 com.alibaba.dashscope.utils.JsonUtils;
import com.alibaba.dashscope.tools.ToolFunction;
import com.alibaba.dashscope.tools.FunctionDefinition;
import io.reactivex.Flowable;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.lang.System;
import com.github.victools.jsonschema.generator.Option;
import com.github.victools.jsonschema.generator.OptionPreset;
import com.github.victools.jsonschema.generator.SchemaGenerator;
import com.github.victools.jsonschema.generator.SchemaGeneratorConfig;
import com.github.victools.jsonschema.generator.SchemaGeneratorConfigBuilder;
import com.github.victools.jsonschema.generator.SchemaVersion;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static ObjectNode jsonSchemaWeather;
    private static ObjectNode jsonSchemaTime;

    static class TimeTool {
        public String call() {
            LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            return "当前时间：" + now.format(formatter) + "。";
        }
    }

    static class WeatherTool {
        private String location;

        public WeatherTool(String location) {
            this.location = location;
        }

        public String call() {
            return location + "今天是晴天";
        }
    }

    static {
        SchemaGeneratorConfigBuilder configBuilder = new SchemaGeneratorConfigBuilder(
                SchemaVersion.DRAFT_2020_12, OptionPreset.PLAIN_JSON);
        SchemaGeneratorConfig config = configBuilder
                .with(Option.EXTRA_OPEN_API_FORMAT_VALUES)
                .without(Option.FLATTENED_ENUMS_FROM_TOSTRING)
                .build();
        SchemaGenerator generator = new SchemaGenerator(config);
        jsonSchemaWeather = generator.generateSchema(WeatherTool.class);
        jsonSchemaTime = generator.generateSchema(TimeTool.class);
    }

    private static void handleGenerationResult(GenerationResult message) {
        System.out.println(JsonUtils.toJson(message));
    }

    public static void streamCallWithMessage(Generation gen, Message userMsg)
            throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(userMsg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    private static GenerationParam buildGenerationParam(Message userMsg) {
        FunctionDefinition fdWeather = buildFunctionDefinition(
                "get_current_weather", "获取指定地区的天气", jsonSchemaWeather);
        FunctionDefinition fdTime = buildFunctionDefinition(
                "get_current_time", "获取当前时刻的时间", jsonSchemaTime);

        return GenerationParam.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("qwq-plus")
                .messages(Arrays.asList(userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput(true)
                .tools(Arrays.asList(
                        ToolFunction.builder().function(fdWeather).build(),
                        ToolFunction.builder().function(fdTime).build()))
                .build();
    }

    private static FunctionDefinition buildFunctionDefinition(
            String name, String description, ObjectNode schema) {
        return FunctionDefinition.builder()
                .name(name)
                .description(description)
                .parameters(JsonUtils.parseString(schema.toString()).getAsJsonObject())
                .build();
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message userMsg = Message.builder()
                    .role(Role.USER.getValue())
                    .content("请告诉我杭州的天气")
                    .build();
            streamCallWithMessage(gen, userMsg);
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":6,"total_tokens":244},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"好的，用户让我"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":12,"total_tokens":250},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"告诉杭州的天气。我"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":16,"total_tokens":254},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"需要先确定是否有"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":22,"total_tokens":260},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"相关的工具可用。查看提供的"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":28,"total_tokens":266},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"工具，发现有一个get_current"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":34,"total_tokens":272},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"_weather函数，参数是location"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":38,"total_tokens":276},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"。所以应该调"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":43,"total_tokens":281},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"用这个函数，参数"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":48,"total_tokens":286},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"设为杭州。不需要"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":52,"total_tokens":290},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"其他工具，因为"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":56,"total_tokens":294},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"用户只问了"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":60,"total_tokens":298},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"天气。接下来构造"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":64,"total_tokens":302},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"tool_call，把"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":68,"total_tokens":306},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"名称和参数填"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":73,"total_tokens":311},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"进去。确保参数是"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":78,"total_tokens":316},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"JSON对象，location是"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":82,"total_tokens":320},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"字符串。检查无"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":88,"total_tokens":326},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"误后返回。"}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":106,"total_tokens":344},"output":{"choices":[{"finish_reason":"null","message":{"role":"assistant","content":"","reasoning_content":"","tool_calls":[{"type":"function","id":"call_ecc41296dccc47baa01567","function":{"name":"get_current_weather","arguments":"{\"location\": \"杭州"}}]}}]}}
{"requestId":"4edb81cd-4647-9d5d-88f9-a4f30bc6d8dd","usage":{"input_tokens":238,"output_tokens":108,"total_tokens":346},"output":{"choices":[{"finish_reason":"tool_calls","message":{"role":"assistant","content":"","reasoning_content":"","tool_calls":[{"type":"function","id":"","function":{"arguments":"\"}"}}]}}]}}

示例代码

curl

curl --location "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--header "X-DashScope-SSE: enable" \
--data '{
    "model": "qwq-plus",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "杭州天气"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "tools": [{
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "当你想知道现在的时间时非常有用。",
                "parameters": {}
            }
        },{
            "type": "function",
            "function": {
                "name": "get_current_weather",
                "description": "当你想查询指定城市的天气时非常有用。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "城市或县区，比如北京市、杭州市、余杭区等。"
                        }
                    },
                    "required": ["location"]
                }
            }
        }]
    }
}'

返回结果

id:1
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"好的，用户问","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":228,"input_tokens":222,"output_tokens":6},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:2
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"的是杭州的天气，","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":233,"input_tokens":222,"output_tokens":11},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:3
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"我需要调用天气查询","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":239,"input_tokens":222,"output_tokens":17},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

......

id:22
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"最后确保格式正确，用","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":338,"input_tokens":222,"output_tokens":116},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:23
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"XML标签包裹JSON对象。","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":344,"input_tokens":222,"output_tokens":122},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:24
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"这样应该就能正确","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":348,"input_tokens":222,"output_tokens":126},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:25
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"获取杭州的天气信息","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":353,"input_tokens":222,"output_tokens":131},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:26
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"tool_calls":[{"index":0,"id":"call_758d97beb1224496b77293","type":"function","function":{"name":"get_current_weather","arguments":"{\""}}],"role":"assistant","content":"","reasoning_content":""},"finish_reason":"null"}]},"usage":{"total_tokens":371,"input_tokens":222,"output_tokens":149},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:27
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"tool_calls":[{"index":0,"id":"","type":"function","function":{"arguments":"location\": \"杭州市\"}"}}],"role":"assistant","content":"","reasoning_content":""},"finish_reason":"null"}]},"usage":{"total_tokens":377,"input_tokens":222,"output_tokens":155},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

id:28
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"tool_calls":[{"index":0,"id":"","type":"function","function":{}}],"role":"assistant","content":"","reasoning_content":""},"finish_reason":"tool_calls"}]},"usage":{"total_tokens":377,"input_tokens":222,"output_tokens":155},"request_id":"351adfc9-47cc-9055-83ba-7300c1a4ef56"}

在得到 Function Calling 输出的工具信息后，您可以参考运行工具函数与大模型总结工具函数输出，使大模型能够根据工具运行的结果进行回答。

注意事项

不支持的功能与参数
- 不支持的功能
  结构化输出、前缀续写、上下文缓存
- 不支持的参数
  temperature、top_p、presence_penalty、frequency_penalty、logprobs、top_logprobs
  设置这些参数都不会生效，即使没有输出错误提示。
- 为了达到模型的最佳推理效果，不建议设置 System Message。
我的应用：工作流应用已支持QwQ模型；智能体应用已支持QwQ模型（不包括插件、流程、音视频交互能力）。
模型在线体验：支持体验 QwQ 模型。

常见问题

Q：怎么关闭思考过程？

A：无法关闭，QwQ 模型的推理模式是先输出思考内容，再输出回复内容。

Q：免费额度用完后如何购买 Token？

A：您可以访问费用与成本中心进行充值，确保您的账户没有欠费即可调用 QwQ 模型。

超出免费额度后，调用 QwQ 模型会自动扣费，出账周期为一小时，消费明细请前往账单详情进行查看。

Q：如何接入Chatbox或Cherry Studio？

A：请根据您的使用情况参考以下步骤：

此处以使用较多的工具为例，其它大模型工具接入的方法较为类似。

Dify 云服务暂时不支持接入 QwQ 模型。

Chatbox

Cherry Studio

在设置界面的模型提供方选择添加自定义提供方。
进行 API 设置
1. 名称输入“阿里云”（可自定义）；
2. API 域名输入https://dashscope.aliyuncs.com/compatible-mode/v1；
3. API 路径输入/chat/completions；
4. API 密钥输入您的 API Key，获取方法请参见：获取API Key；
5. 模型输入您需要使用的 QwQ模型，此处以 qwq-plus 为例（请注意字母的大小写）；
6. 单击保存，完成设置。
进行对话测试
在输入框输入“你是谁？”进行测试：

单击左下角的设置按钮，在模型服务栏中找到阿里云百炼，API 密钥输入您的 API Key，获取方法请参见：获取API Key；API 地址填入https://dashscope.aliyuncs.com/compatible-mode/v1/；单击添加。
在模型 ID填入您需要使用的 QwQ 模型，此处以 qwq-plus 为例（请注意模型 ID的大小写）； 模型名称与分组名称会自动生成。
如果您点击 API 密钥位置的检查后报错：“连接失败 400 This model only support stream mode, please enable the stream parameter to access the model”，请忽略该信息，您仍可以在对话框中与 QwQ 模型正常对话。
在界面上方选中添加的模型。输入“你是谁”进行测试：

Q：可以上传图片或文档进行提问吗？

A：QwQ 模型仅支持文本输入，不支持输入图片或文档。通义千问VL模型支持图片输入，Qwen- Long模型支持文档输入。

Q：如何在使用 LangChain 时输出思考过程？

A：请参考以下步骤：

更新依赖库
确保 langchain_community 和 dashscope 为最新版本：
```
pip install -U langchain_community dashscope
```

调用 QwQ 模型

QwQ 模型目前仅支持流式输出，通过以下代码来分开打印“思考过程”与“回复内容”：

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage

chatLLM = ChatTongyi(
    model="qwq-plus",   # 此处以qwq-plus为例，您可按需更换模型名称。
)
completion = chatLLM.stream([HumanMessage(content="你是谁")])
is_answering = False
print("="*20+"思考过程 "+"="*20)
for chunk in completion:
    if chunk.additional_kwargs.get("reasoning_content"):
        print(chunk.additional_kwargs.get("reasoning_content"),end="",flush=True)
    else:   
        if not is_answering:
            print("\n"+"="*20+"回复内容"+"="*20)
            is_answering = True
        print(chunk.content,end="",flush=True)

可以获得如下输出：

====================思考过程 ====================
嗯，用户问我“你是谁”，我需要先确定他们想了解什么。可能他们刚接触我的时候，或者想确认我的身份。首先，我应该简要介绍自己是通义千问，阿里巴巴集团旗下的超大规模语言模型。然后说明我的功能，比如回答问题、创作文字、编程等，这样用户知道我能做什么。还要提到我支持多语言，这样用户知道语言不是障碍。接下来，可能需要解释我的应用场景，比如写故事、写公文、写邮件、写剧本等，这样用户能具体了解我的用途。还要提到我的训练数据截止时间，这样用户知道我的知识更新到什么时候。最后，邀请用户提问，保持友好和开放的态度。需要确保回答简洁明了，信息全面，同时口语化，避免使用专业术语。可能用户是普通用户，不需要太技术性的解释。还要注意不要遗漏关键点，比如我的研发公司、功能、多语言支持、应用场景和训练时间。检查有没有重复或冗余的信息，确保流畅自然。可能用户还想知道如何与我互动，所以最后的邀请提问很重要。总之，结构应该是先介绍身份，再功能，应用场景，训练数据，最后邀请提问。这样用户能快速获取所需信息，并知道下一步该怎么做。
====================回复内容====================
你好！我是通义千问，阿里巴巴集团旗下的超大规模语言模型。我能够回答问题、创作文字，比如写故事、写公文、写邮件、写剧本、逻辑推理、编程等等，还能表达观点，玩游戏等。我支持多种语言，包括但不限于中文、英文、德语、法语、西班牙语等。

我的训练数据截止时间是2024年12月，这意味着我对2024年之前的信息有较好的了解，但对之后发生的事情可能不了解。如果你有任何问题或需要帮助，欢迎随时告诉我！

Q：如何查看Token消耗量及调用次数？

A：模型调用完一小时后，在模型观测页面的模型列表区域，找到目标模型，然后单击监控，即可查看调用统计。具体请参见模型观测文档。

数据按小时更新，高峰期可能有小时级延迟，请您耐心等待。

错误码

如果执行报错，请参见错误信息进行解决。