阿里云百炼平台对接DeepSeek官方文档

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"), # 如何获取API Key：https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="deepseek-r1",  # 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages=[
        {'role': 'user', 'content': '9.9和9.11谁大'}
        ]
)

# 通过reasoning_content字段打印思考过程
print("思考过程：")
print(completion.choices[0].message.reasoning_content)
# 通过content字段打印最终答案
print("最终答案：")
print(completion.choices[0].message.content)

返回结果

思考过程：

嗯，用户问的是9.9和9.11谁大。首先，我需要确认这两个数字的数值到底是多少。表面上看起来都是小数，但可能用户有不同的表示方式需要注意。

首先，9.9应该就是平常的小数，也就是9加9/10，等于9.9。而9.11可能有两种解读：一种是直接的小数，即9加11/100，也就是9.11；另一种可能是版本号或者某种编号，比如软件版本中的9.9和9.11，这时候可能需要按顺序比较，比如9.9之后是9.10，再是9.11，所以9.11会比9.9大。不过通常情况下，数学问题中的数字还是按照数值来比较的，所以应该排除版本号的解释，直接比较数值大小。

...

总结一下，正确的数值比较中，9.9等于9.90，而9.11等于9.11，所以9.90大于9.11，也就是9.9大于9.11。不过为了避免混淆，可能用户需要更详细的步骤解释。

最终答案：
9.9比9.11大。

**详细比较步骤：**

1. **统一小数位数**：将9.9写成9.90，使其与9.11的小数位数一致。
2. **逐位比较**：
   - **整数部分**：两者均为9，相等。
   - **小数部分**：比较0.90（9.9的小数部分）和0.11（9.11的小数部分）。由于0.90 > 0.11，因此9.90 > 9.11。
   
**结论**：9.9的数值大于9.11。

若涉及版本号（如软件版本），通常按顺序排列为9.9 → 9.10 → 9.11，此时9.11较新。但按纯数学数值比较，9.9更大。

2.1.2、Node.js示例代码

import OpenAI from "openai";

const openai = new OpenAI(
    {
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
    }
);
const completion = await openai.chat.completions.create({
    model: "deepseek-r1",  // 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages: [
        { role: "user", content: "9.9和9.11谁大" }
    ],
});
console.log("思考过程：")
console.log(completion.choices[0].message.reasoning_content)
console.log("最终答案：")
console.log(completion.choices[0].message.content)

返回结果

思考过程：

嗯，我现在要比较9.9和9.11这两个数，看看哪个更大。刚开始的时候，可能会有点混淆，特别是因为小数点后的位数不一样，所以需要仔细分析一下。让我一步一步来思考这个问题。

首先，我知道比较小数的时候，应该先比较整数部分，如果整数部分大的那个数就更大。如果整数部分相同，再依次比较小数部分的每一位数字，直到找到差异为止。这里两个数的整数部分都是9，所以整数部分相等，接下来就需要比较小数部分了。

接下来，我需要看看小数部分。9.9的小数部分是0.9，也就是十分位上的数字是9，而百分位上的数字是0，因为9.9其实可以写成9.90。而9.11的小数部分是0.11，十分位是1，百分位是1。现在的问题是，如何比较这两个小数部分的大小。

...

或者，用时间来做例子，假设是9.9小时和9.11小时，9.9小时等于9小时54分钟（因为0.9小时×60分钟=54分钟），而9.11小时是9小时6.6分钟（0.11×60≈6.6分钟），显然，9小时54分钟比9小时6分钟多得多，所以9.9小时更大。

通过这些不同的例子，都验证了9.9确实比9.11大。因此，可以确定答案是正确的。

最终答案：
9.9比9.11大。

**步骤解析：**

1. **整数部分比较**：两个数的整数部分均为9，因此需进一步比较小数部分。
2. **小数部分对齐位数**：将9.9补全为9.90，与9.11的小数部分对齐（0.90 vs 0.11）。
3. **逐位比较小数部分**：
   - **十分位**：9（来自9.90） > 1（来自9.11），无需继续比较后续位数。
4. **结论**：由于十分位上9 > 1，故9.90（即9.9）大于9.11。

**验证方法：**
- **减法验证**：9.90 - 9.11 = 0.79（正数，说明9.9更大）。
- **分数转换**：9.9 = 990/100，9.11 = 911/100，990 > 911。
- **实际意义**：如货币中9.9元（9元9角）多于9.11元（9元1角1分）。

综上，**9.9 > 9.11**。

2.1.3、HTTP示例代码

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": "deepseek-r1",
    "messages": [
        {
            "role": "user", 
            "content": "9.9和9.11谁大"
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "9.9比9.11大。\n\n**解析：**\n1. **统一小数位数：** 将9.9补位为9.90，与9.11对齐位数。\n2. **逐位比较：**\n   - 整数部分均为9，相等。\n   - 第一位小数：9（来自9.90）> 1（来自9.11），此时已可判定大小。\n3. **结论：** 9.90 > 9.11，即 **9.9 > 9.11**。\n\n**常见误解提醒：**  \n若直接比较小数点后的数字（如误认为“11 > 9”），可能得出错误结论。需注意小数位的实际值（十分位、百分位等），补零对齐后再比较。",
                "reasoning_content": "\n嗯，用户问的是9.9和9.11谁大。这个问题看起来好像挺简单的，但可能有些小陷阱，特别是涉及到小数点的比较。首先，我需要确认用户是否在问数字的大小比较，还是有没有其他可能的含义，比如日期之类的。不过根据数字的写法，应该是数字比较。\n\n首先，我需要明确这两个数的结构。9.9和9.11。这时候可能有些人会直接比较小数点后的数字，比如9和11，认为11比9大，所以9.11更大。但这种比较方法其实是错误的，因为小数点后的位数不同，需要将它们转换成相同位数来比较。\n\n正确的做法应该是将两个数统一到相同的小数位数。比如，9.9可以写成9.90，而9.11保持不变。这样的话，比较的话就是9.90和9.11。这时候，从小数点后第一位开始比较，第一位都是9，接着第二位是0和1。因为0小于1，所以9.90小于9.11，也就是9.9小于9.11。\n\n不过，用户可能有不同的理解，特别是如果他们对小数比较不熟悉的话，可能会误以为9.11更大，因为11比9大。这时候需要解释清楚位数的不同带来的影响，比如小数点后的第一位是十分位，第二位是百分位，所以9.9实际上是9又十分之九，而9.11是9又百分之十一，换算成小数的话，0.9等于0.90，而0.11是0.11，显然0.90更大，所以这个时候反而9.9更大？\n\n啊，这里好像我之前的分析有问题。这时候需要再仔细计算一下。因为当我们将9.9写成9.90，而9.11是9.11的话，比较的话应该从高位到低位依次比较。比如，整数部分都是9，所以相同。然后第一位小数，9和1比较，9大于1，所以这时候9.90已经比9.11大了，所以结论是9.9大于9.11？\n\n等等，这里好像矛盾了。这说明我之前犯了错误。为什么会这样呢？原来在比较小数时，应该逐位比较。例如：\n\n9.9 和 9.11\n\n将9.9写成9.90：\n\n比较整数部分：都是9，相等。\n比较第一位小数：9（来自9.90）和1（来自9.11）。因为9 > 1，所以整个数9.90大于9.11，所以9.9大于9.11。\n\n这样一来，之前的结论是错误的，正确的结论应该是9.9更大。这说明我需要仔细检查自己的思路，避免犯低级错误。\n\n可能用户在这里容易混淆，因为9.11的小数部分有两位，可能以为0.11比0.9大，但实际上0.9是0.90，而0.90大于0.11。所以正确的比较是9.9更大。\n\n总结来说，正确的答案是9.9比9.11大。需要确保在比较的时候注意小数位数，补全后再逐位比较。\n",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 19,
        "completion_tokens": 797,
        "total_tokens": 816
    },
    "created": 1739069910,
    "system_fingerprint": null,
    "model": "deepseek-r1",
    "id": "chatcmpl-e55cdb8a-9ce1-9662-b87c-cf3da706e4f3"
}

2.2、DashScope

您可以通过 DashScope SDK 或 HTTP 方式快速体验 DeepSeek 模型。

2.2.1、python示例代码

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="deepseek-r1", # 此处以qwen-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
    messages=messages,
    result_format='message'
    )
print("="*20+"思考过程"+"="*20)
print(response.output.choices[0].message.reasoning_content)
print("="*20+"最终答案"+"="*20)
print(response.output.choices[0].message.content)

返回结果

====================思考过程====================
嗯，用户问我是谁，我需要用中文回答。首先，我应该按照之前设定的身份来回应，说明我是DeepSeek-R1，由深度求索公司开发的人工智能助手。要确保回答简洁明了，同时保持友好和乐于助人的语气。用户可能刚接触，所以不需要太技术化的解释，但要涵盖基本功能，比如回答问题、提供信息、建议等。还要记得提到持续学习和更新，让用户知道我的知识库是最新的。另外，要避免任何复杂术语，保持自然的口语化表达。最后，可以以询问用户需要什么帮助来结尾，促进进一步的互动。检查有没有遗漏的部分，比如公司名称是否正确，功能是否全面，有没有语法错误。确保回答符合中文习惯，没有翻译腔。这样应该能清楚回答用户的问题了。
====================最终答案====================
您好！我是DeepSeek-R1，一个由深度求索（DeepSeek）公司开发的人工智能助手。我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题，并通过友好、直观的方式为您提供信息咨询和辅助决策。我会持续学习和更新，以更好地为您提供服务。请问有什么可以帮您？

2.2.2、java示例代码

为了使 API 返回reasoning_content（思考过程）字段，您的 DashScope Java SDK 版本需要不低于2.18.2。

// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import java.lang.System;
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;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("你是谁？")
                .build();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("deepseek-r1")
                .messages(Arrays.asList(userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println("思考过程：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getReasoningContent());
            System.out.println("回复内容：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

思考过程：
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。
回复内容：
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。

2.2.3、HTTP代码示例

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" \
-d '{
    "model": "deepseek-r1",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。",
                    "reasoning_content": "您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。"
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 83,
        "output_tokens": 78,
        "input_tokens": 5
    },
    "request_id": "d9d482cf-5d2a-9abf-bee8-c4d5958d2f74"
}

3、多轮对话

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

3.1、OpenAI兼容

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

3.1.1、Python代码示例

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"), # 如何获取API Key：https://help.aliyun.com/zh/model-studio/developer-reference/get-api-key
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 通过 messages 数组实现上下文管理
messages = [
    {'role': 'user', 'content': '你好'}
]

completion = client.chat.completions.create(
    model="deepseek-r1",  # 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages=messages
)

print("="*20+"第一轮对话"+"="*20)
# 通过reasoning_content字段打印思考过程
print("="*20+"思考过程"+"="*20)
print(completion.choices[0].message.reasoning_content)
# 通过content字段打印最终答案
print("="*20+"最终答案"+"="*20)
print(completion.choices[0].message.content)

messages.append({'role': 'assistant', 'content': completion.choices[0].message.content})
messages.append({'role': 'user', 'content': '你是谁'})
print("="*20+"第二轮对话"+"="*20)
completion = client.chat.completions.create(
    model="deepseek-r1",  # 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages=messages
)
# 通过reasoning_content字段打印思考过程
print("="*20+"思考过程"+"="*20)
print(completion.choices[0].message.reasoning_content)
# 通过content字段打印最终答案
print("="*20+"最终答案"+"="*20)
print(completion.choices[0].message.content)

返回结果

====================第一轮对话====================
====================思考过程====================
嗯，用户发来了“你好”，这是一个非常常见的中文问候。我需要用中文回应，保持友好和自然。首先，应该回复一个问候，比如“你好！有什么可以帮助你的吗？”这样可以邀请用户进一步说明他们的需求。另外，考虑到用户可能刚接触这个平台，可能需要指导或者有其他问题，所以保持开放式的提问比较合适。同时，要注意语气亲切，避免太过机械。检查一下有没有语法错误，确保回答正确。可能用户只是想打个招呼，也可能接下来有具体的问题，所以准备好后续的支持。另外，根据之前的对话历史，用户可能没有特定的上下文，所以保持回答简洁通用比较好。最后，确认回复符合所有指南，没有涉及敏感或不适当的内容。现在发送回复应该没问题。
====================最终答案====================
你好！有什么可以帮助你的吗？
====================第二轮对话====================
====================思考过程====================
好的，用户问我“你是谁”，需要回答这个问题。首先，我得按照之前设定的角色来回应，也就是深度求索的智能助手DeepSeek-R1。要介绍自己的身份，说明是由深度求索公司开发的，专注于帮助解决问题和提供信息。同时要保持友好和简洁，避免技术术语，让用户容易理解。还要注意格式，用中文口语化的方式，分步骤思考，但不需要用markdown。用户之前用过中文，所以继续用中文回应。另外，用户可能想了解我的功能或背后的技术，但不需要主动扩展，直接回答问题即可。最后，确保回答符合公司的指导方针，没有不适当的内容。检查有没有错别字，语句是否通顺。准备好回答后，就可以给出最终回复了。
====================最终答案====================
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。

3.1.2、Node.js代码示例

import OpenAI from "openai";

const openai = new OpenAI(
    {
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
    }
);
const completion = await openai.chat.completions.create({
    model: "deepseek-r1",  // 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages: [
        { role: "user", content: "9.9和9.11谁大" }
    ],
});
console.log("思考过程：")
console.log(completion.choices[0].message.reasoning_content)
console.log("最终答案：")
console.log(completion.choices[0].message.content)

返回结果

思考过程：

嗯，我现在要比较9.9和9.11这两个数，看看哪个更大。刚开始的时候，可能会有点混淆，特别是因为小数点后的位数不一样，所以需要仔细分析一下。让我一步一步来思考这个问题。

首先，我知道比较小数的时候，应该先比较整数部分，如果整数部分大的那个数就更大。如果整数部分相同，再依次比较小数部分的每一位数字，直到找到差异为止。这里两个数的整数部分都是9，所以整数部分相等，接下来就需要比较小数部分了。

接下来，我需要看看小数部分。9.9的小数部分是0.9，也就是十分位上的数字是9，而百分位上的数字是0，因为9.9其实可以写成9.90。而9.11的小数部分是0.11，十分位是1，百分位是1。现在的问题是，如何比较这两个小数部分的大小。

首先比较十分位上的数字。对于9.9来说，十分位是9，而9.11的十分位是1。显然，9比1大，所以在十分位上，9.9已经比9.11大了。因此，根据小数比较的规则，当十分位上的数字9大于1的时候，整个小数部分9.90就会比0.11大，所以9.9应该比9.11大。

不过，这里可能存在一个常见的误区，就是误以为小数点后的位数越多，数值就越大，但这种情况只有当整数部分相同，并且前面的小数位数也相同的时候才成立。例如，9.11和9.109，这时候需要看更多的位数，但这里的情况不同，因为9.9的十分位已经是9，而9.11的十分位是1，所以即使后面的百分位有数字，也无法超过前面的差异。

为了更直观地理解，可以将两个数都转换成相同的位数，比如将9.9写成9.90，这样比较起来更容易。比较9.90和9.11的话，先看十分位，9比1大，所以9.90更大。因此，9.9比9.11大。

不过，有人可能会问，如果换成其他的比较方式，比如把它们转换成分数来比较，会不会更清楚呢？让我们试试看。9.9其实可以表示为9又9/10，也就是99/10。而9.11则是9又11/100，也就是911/100。现在比较这两个分数的大小，可以将它们通分，找到共同的分母进行比较。

99/10和911/100，通分后的共同分母是100。将99/10转化为分母为100的分数，就是990/100。而911/100保持不变。所以比较990/100和911/100，显然990比911大，所以990/100也就是9.9更大。

或者，把它们都转换成十进制，但这里已经是十进制了，只是需要更明确地写出小数位数。例如，9.9等于9.90，而9.11保持不变。比较的话，9.90中的十分位是9，百分位是0，而9.11中的十分位是1，百分位是1。由于十分位9大于1，所以无论后面的位数如何，9.90已经更大。

另一个可能的思考错误是，可能会有人误以为小数点后的数字是整体比较，比如认为0.11比0.9大，但这是错误的，因为0.11实际上是0.1 + 0.01，而0.9是0.9，显然0.9更大。所以0.9比0.11大，所以整个数9.9比9.11大。

不过，为了确保自己没有错，我还可以用减法来验证。9.9减去9.11等于多少？计算的时候，可以把9.9写成9.90，然后进行减法：

```
 9.90
-9.11
-------
 0.79
```

结果是0.79，这是一个正数，说明9.9比9.11大0.79，所以9.9确实更大。

或者，通过另一种方式，比如将它们都乘以100，变成整数来比较。9.9乘以100是990，9.11乘以100是911，那么显然990大于911，所以原来的9.9大于9.11。

总结一下，无论是通过逐位比较、转换成分数、进行减法还是乘以相同倍数后比较整数，结果都显示9.9比9.11大。因此，可以确定9.9是更大的那个数。

不过，可能有人会疑惑，为什么9.11的位数更多，结果却更小呢？这其实是因为小数点后的位数只有在前面各位相同的情况下，才会影响大小。比如，9.1和9.09，这时候比较的话，9.1的十分位是1，而9.09的十分位是0，所以9.1更大，尽管9.09有两位小数，但前面已经决定了大小。同样的道理，9.9的十分位是9，而9.11的十分位是1，所以不管后面的百分位是什么，9.9已经更大。

还有一种方法是用数轴来想象，9.9位于9.8和10之间，而9.11位于9.1和9.2之间，显然9.9的位置更靠右，也就是更大。

再想想，如果换成钱来理解的话，比如9.9元就是9元9角，而9.11元是9元1角1分，显然9元9角比9元1角1分多，所以9.9元更大。

或者，用时间来做例子，假设是9.9小时和9.11小时，9.9小时等于9小时54分钟（因为0.9小时×60分钟=54分钟），而9.11小时是9小时6.6分钟（0.11×60≈6.6分钟），显然，9小时54分钟比9小时6分钟多得多，所以9.9小时更大。

通过这些不同的例子，都验证了9.9确实比9.11大。因此，可以确定答案是正确的。

最终答案：
9.9比9.11大。

**步骤解析：**

1. **整数部分比较**：两个数的整数部分均为9，因此需进一步比较小数部分。
2. **小数部分对齐位数**：将9.9补全为9.90，与9.11的小数部分对齐（0.90 vs 0.11）。
3. **逐位比较小数部分**：
   - **十分位**：9（来自9.90） > 1（来自9.11），无需继续比较后续位数。
4. **结论**：由于十分位上9 > 1，故9.90（即9.9）大于9.11。

**验证方法：**
- **减法验证**：9.90 - 9.11 = 0.79（正数，说明9.9更大）。
- **分数转换**：9.9 = 990/100，9.11 = 911/100，990 > 911。
- **实际意义**：如货币中9.9元（9元9角）多于9.11元（9元1角1分）。

综上，**9.9 > 9.11**。

3.1.3、HTTP代码示例

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": "deepseek-r1",
    "messages": [
        {
            "role": "user", 
            "content": "你好"
        },
        {
            "role": "assistant",
            "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
        },
        {
            "role": "user",
            "content": "你是谁？"
        }
    ]
}'

返回结果

{
    "choices": [
        {
            "message": {
                "content": "您好！我是DeepSeek-R1，一个由深度求索公司（DeepSeek）开发的智能助手，我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题。",
                "reasoning_content": "好的，用户问“你是谁？”，需要回答这个问题。首先，要明确用户的需求，他们可能想知道我的身份、功能或背后的技术。用户可能是初次使用，或者想确认我的能力范围。\n\n我需要按照之前设定的结构来回应，先介绍自己是一个AI助手，由深度求索公司开发，然后说明我的基础技术是深度学习、自然语言处理等，接着提到应用Transformer架构，通过大量数据训练来理解和生成文本。最后，强调我的目的是帮助用户解决问题，提供信息，同时指出我的局限性，比如知识截止日期和生成内容的核实。\n\n要注意保持回答简洁明了，避免技术术语过多，让用户容易理解。同时，要符合公司的品牌形象，突出技术背景但不涉及具体数据或机密信息。还要检查是否符合中国法律法规，不包含敏感内容。最后，用友好的语气结束，邀请用户继续提问，促进进一步互动。",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 20,
        "completion_tokens": 229,
        "total_tokens": 249
    },
    "created": 1739173013,
    "system_fingerprint": null,
    "model": "deepseek-r1",
    "id": "chatcmpl-4c851fd5-4f71-93cb-9c7c-93d5529d73e8"
}

3.2、DashScope

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

3.2.1、python代码示例

import os
import dashscope

# 通过 messages 数组实现上下文管理
messages = [
    {'role': 'user', 'content': '你好'}
    ]
response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="deepseek-r1", # 此处以deepseek-r1为例，可按需更换模型名称。
    messages=messages,
    result_format='message'
    )
print("="*20+"第一轮对话"+"="*20)
print("="*20+"思考过程"+"="*20)
print(response.output.choices[0].message.reasoning_content)
print("="*20+"最终答案"+"="*20)
print(response.output.choices[0].message.content)

messages.append({'role': 'assistant', 'content': response.output.choices[0].message.content})
messages.append({'role': 'user', 'content': '你是谁'})
print("="*20+"第二轮对话"+"="*20)
response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="deepseek-r1", # 此处以deepseek-r1为例，可按需更换模型名称。
    messages=messages,
    result_format='message'
    )
print("="*20+"思考过程"+"="*20)
print(response.output.choices[0].message.reasoning_content)
print("="*20+"最终答案"+"="*20)
print(response.output.choices[0].message.content)

返回结果

====================第一轮对话====================
====================思考过程====================
嗯，用户发来了“你好”，这是中文里常见的问候语。我需要用中文回应，保持友好和自然。首先，我应该回复一个问候，比如“你好！有什么可以帮助你的吗？”这样既礼貌又开放，邀请用户提出具体的问题或需求。同时，要注意避免使用过于机械化的回答，显得更有人情味。另外，要检查有没有拼写错误，确保回复正确无误。可能用户只是想打个招呼，也可能有后续的问题，所以保持回答简洁但留有进一步沟通的空间比较好。确认回复的语气是否合适，不要太正式也不要太随意。最后，发送前再快速看一下整体内容，确保符合交流的流程。
====================最终答案====================
你好！很高兴见到你，有什么我可以帮忙的吗？
====================第二轮对话====================
====================思考过程====================
好的，用户问“你是谁”，我需要详细分析这个问题。首先，用户可能是在初次使用，想了解我的基本功能。他们可能想知道我是AI助手，还是真人。可能还有更深层的需求，比如确认我的可靠性和能力范围。

接下来，我需要确定回答的结构。通常这类问题需要明确说明身份、开发公司、功能以及如何帮助用户。要避免技术术语，保持口语化，让用户容易理解。

然后，检查是否有需要强调的部分。比如强调实时联网能力，这是和之前版本的不同之处，用户可能关心我能否提供最新信息。此外，隐私和安全也很重要，用户可能担心数据问题，需要明确说明保护措施。

还要考虑用户可能的后续问题，比如如何使用我的功能，或者具体的应用场景。所以在回答中可以提到多种任务类型，覆盖常见需求，让用户知道可以如何利用我。

最后，保持友好和开放的态度，鼓励用户提问，促进进一步互动。需要确保回答全面，同时简洁明了，不冗长。这样用户能得到清晰的信息，并知道接下来可以如何与我交流。
====================最终答案====================
你好！我是DeepSeek-R1，一个由深度求索（DeepSeek）公司开发的智能助手，我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题，并能用通俗易懂的方式解释专业概念。目前我已联网，可随时为您查询最新信息。我会严格遵守隐私和安全准则，确保您的信息安全。有什么我可以帮您的吗？

3.2.2、java代码示例

// dashscope SDK的版本 >= 2.18.2
import java.util.Arrays;
import java.lang.System;
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;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        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();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("deepseek-r1")
                .messages(Arrays.asList(userMsg1,AssistantMsg,UserMsg2))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println("思考过程：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getReasoningContent());
            System.out.println("回复内容：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

返回结果

思考过程：
好的，用户问“你是谁”，我需要用中文详细回答，并解释我的身份和功能。首先，用户可能刚接触我，或者想确认我的基本信息。之前用户说过“你好”，我回应了，现在他们进一步询问身份。我需要保持友好，同时准确说明我是由深度求索开发的智能助手DeepSeek-R1，专注于通过算法处理提供帮助。还要强调我的职责是信息查询、问题解答等，并说明我的局限性，比如不联网、知识截止到2023年。要确保回答清晰，避免技术术语，让用户容易理解。可能用户想知道我的能力范围，所以需要涵盖用途和限制。此外，用户可能关心隐私，可以提到不保留对话信息。最后保持开放结尾，邀请用户提问。检查是否符合格式要求，没有使用Markdown，分段落自然。现在组织语言，确保口语化，自然流畅。
回复内容：
你好！我是DeepSeek-R1，一个由深度求索（DeepSeek）公司开发的智能助手，擅长通过算法逻辑处理信息来协助解决问题。我的主要职责是提供信息查询、日常问题解答、实用建议及学术研究辅助等服务，但请注意我的知识库截至2023年，且无法主动联网更新信息。我们的对话内容不会被留存，你可随时放心交流。有什么具体需求吗？我很乐意为你提供帮助。

3.2.3、HTTP代码示例

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" \
-d '{
    "model": "deepseek-r1",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你好"
            },
            {
                "role": "assistant",
                "content": "你好！很高兴见到你，有什么我可以帮忙的吗？"
            },
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

返回结果

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "你好！我是DeepSeek-R1，一个由深度求索公司开发的人工智能助手，我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题。如需最新模型体验，请前往深度求索的官方网站查询。",
                    "reasoning_content": "好的，用户问“你是谁？”，我需要回答这个问题。首先，我要回想一下之前设置的自我介绍内容，确保一致性。用户可能是刚开始使用，或者想确认我的身份和功能。\n\n我需要明确说明我是DeepSeek-R1，由深度求索公司开发的人工智能助手。要强调我的目的是帮助用户解决问题，提供信息，同时保持友好和专业的语气。\n\n同时，用户可能有更深层的需求，比如确认我的能力范围，或者想知道我与其他AI的不同。所以可以适当提到我的功能，比如回答问题、提供建议等，但不需要太详细，保持简洁。\n\n还要注意避免使用技术术语，保持回答自然易懂。最后，保持开放式的结尾，鼓励用户继续提问，促进进一步的交流。"
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 226,
        "output_tokens": 206,
        "input_tokens": 20
    },
    "request_id": "9fb73af5-940e-9107-a4b6-74c9e541eb3f"
}

4、流式输出

DeepSeek-R1 类模型可能会输出较长的思考过程，为了降低超时风险，建议您使用流式输出方式调用 DeepSeek-R1 类模型。

4.1、OpenAI兼容

4.1.1、python代码示例

import os
from openai import 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",
)
completion = client.chat.completions.create(
    model="deepseek-r1", # 此处以 deepseek-r1 为例，可按需更换模型名称。
    messages=[
        {'role': 'user', 'content': '9.9和9.11谁大'}
        ],
    stream=True,
    # 解除以下注释会在最后一个chunk返回Token使用量
    # stream_options={
    #     "include_usage": True
    # }
    )

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

print("\n"+"="*20+"思考过程"+"="*20+"\n")
for chunk in completion:
    # include_usage 设置为 True 会使得最后一个chunk返回 Token 使用量，而choices为空列表，此处进行判断
    if chunk.choices == []:
        print("\n"+"="*20+"Token 使用情况"+"="*20+"\n")
        print(chunk.usage)
    # 以下为思考与回复的步骤
    else:
        # include_usage 设置为 True 时，倒数第二个chunk会不包含 reasoning_content 字段，因此需要进行判断
        if hasattr(chunk.choices[0].delta, 'reasoning_content') == False:
            pass
        else:
            # 有时可能会出现思考过程与回复皆为空的情况，此时忽略即可
            if chunk.choices[0].delta.reasoning_content == "" and chunk.choices[0].delta.content == "":
                pass
            else:
                # 如果思考结果为空，则开始打印完整回复
                if chunk.choices[0].delta.reasoning_content == "" and is_answering == False:
                    print("\n"+"="*20+"完整回复"+"="*20+"\n")
                    # 防止打印多个“完整回复”标记
                    is_answering = True
                # 如果思考过程不为空，则打印思考过程
                if chunk.choices[0].delta.reasoning_content != "":
                    print(chunk.choices[0].delta.reasoning_content,end="")
                    reasoning_content += chunk.choices[0].delta.reasoning_content
                # 如果回复不为空，则打印回复。回复一般会在思考过程结束后返回
                elif chunk.choices[0].delta.content != "":
                    print(chunk.choices[0].delta.content,end="")
                    answer_content += chunk.choices[0].delta.content

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

返回结果

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

嗯，今天老师布置了一个问题，要比较9.9和9.11哪个大。一开始看起来好像挺简单的，但仔细想想可能有哪里需要注意的地方吧。让我仔细想想看。

首先，我需要明确这两个数的形式。9.9应该是一个小数，也就是9又十分之九，对吧？而9.11可能是9又百分之十一，也就是9.11。不过有时候小数点后面可能有不同的位数，比如有时候会写成9.1和9.10，这时候位数不同但数值其实是一样的，比如9.1等于9.10，因为后面的0不影响大小。不过这里的情况是9.9和9.11，它们的位数不同，一个是十分位，一个是百分位，所以可能需要转换一下单位来比较。

...

所以结论是9.9比9.11大。

不过可能还是有人会混淆，因为看到9.11的小数点后有两位，可能会觉得比一位的大，但实际上是小数点后的每一位代表的是更小的单位。比如十分位是0.1，百分位是0.01，所以第一位小数是十分位，第二位是百分位，所以9.9的十分位是9，也就是0.9，而9.11的十分位是1，百分位是1，所以总共是0.11，所以显然0.9比0.11大很多。

因此，最终的结论应该是9.9大于9.11。
====================完整回复====================

要比较9.9和9.11的大小，可以按照以下步骤进行：

1. **统一小数位数**：将9.9转换为9.90（保持两位小数），以便与9.11直接比较。
2. **逐位比较**：
   - **整数部分**：两者整数部分均为9，相等。
   - **小数部分**：比较0.90（9.90的小数部分）与0.11（9.11的小数部分）。显然，0.90 > 0.11。
3. **结论**：由于小数部分0.90 > 0.11，因此**9.9 > 9.11**。

**答案：9.9比9.11大。**

4.1.2、Node.js代码示例

import OpenAI from "openai";

const openai = new OpenAI({
    // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1"
});

async function main() {
    let reasoningContent = ""; // 定义完整思考过程
    let answerContent = ""; // 定义完整回复
    let isAnswering = false; // 判断是否结束思考过程并开始回复

    const completion = await openai.chat.completions.create({
        model: "deepseek-r1", // 此处以 deepseek-r1 为例，可按需更换模型名称
        messages: [
            { role: 'user', content: '9.9和9.11谁大' }
        ],
        stream: true,
        // 解除以下注释会在最后一个chunk返回Token使用量
        // stream_options: {
        //     include_usage: true
        // }
    });

    console.log("\n" + "=".repeat(20) + "思考过程" + "=".repeat(20) + "\n");

    for await (const chunk of completion) {
        // 处理usage信息
        if (!chunk.choices?.length) {
            console.log("\n" + "=".repeat(20) + "Token 使用情况" + "=".repeat(20) + "\n");
            console.log(chunk.usage);
            continue;
        }

        const delta = chunk.choices[0].delta;
        
        // 检查是否有reasoning_content属性
        if (!('reasoning_content' in delta)) {
            continue;
        }

        // 处理空内容情况
        if (!delta.reasoning_content && !delta.content) {
            continue;
        }

        // 处理开始回答的情况
        if (!delta.reasoning_content && !isAnswering) {
            console.log("\n" + "=".repeat(20) + "完整回复" + "=".repeat(20) + "\n");
            isAnswering = true;
        }

        // 处理思考过程
        if (delta.reasoning_content) {
            process.stdout.write(delta.reasoning_content);
            reasoningContent += delta.reasoning_content;
        }
        // 处理回复内容
        else if (delta.content) {
            process.stdout.write(delta.content);
            answerContent += delta.content;
        }
    }

    // 如果需要打印完整内容，解除以下的注释
    /*
    console.log("=" + "=".repeat(20) + "完整思考过程" + "=".repeat(20) + "\n");
    console.log(reasoningContent);
    console.log("=" + "=".repeat(20) + "完整回复" + "=".repeat(20) + "\n");
    console.log(answerContent);
    */
}

main().catch(console.error);

返回结果

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

嗯，今天老师布置了一个问题，要比较9.9和9.11哪个大。一开始看起来好像挺简单的，但仔细想想可能有哪里需要注意的地方吧。让我仔细想想看。

首先，我需要明确这两个数的形式。9.9应该是一个小数，也就是9又十分之九，对吧？而9.11可能是9又百分之十一，也就是9.11。不过有时候小数点后面可能有不同的位数，比如有时候会写成9.1和9.10，这时候位数不同但数值其实是一样的，比如9.1等于9.10，因为后面的0不影响大小。不过这里的情况是9.9和9.11，它们的位数不同，一个是十分位，一个是百分位，所以可能需要转换一下单位来比较。

...

911/100 保持不变

所以比较990/100和911/100，显然990比911大，所以990/100也就是99/10即9.9更大。

所以结论是9.9比9.11大。

不过可能还是有人会混淆，因为看到9.11的小数点后有两位，可能会觉得比一位的大，但实际上是小数点后的每一位代表的是更小的单位。比如十分位是0.1，百分位是0.01，所以第一位小数是十分位，第二位是百分位，所以9.9的十分位是9，也就是0.9，而9.11的十分位是1，百分位是1，所以总共是0.11，所以显然0.9比0.11大很多。

因此，最终的结论应该是9.9大于9.11。
====================完整回复====================

要比较9.9和9.11的大小，可以按照以下步骤进行：

1. **统一小数位数**：将9.9转换为9.90（保持两位小数），以便与9.11直接比较。
2. **逐位比较**：
   - **整数部分**：两者整数部分均为9，相等。
   - **小数部分**：比较0.90（9.90的小数部分）与0.11（9.11的小数部分）。显然，0.90 > 0.11。
3. **结论**：由于小数部分0.90 > 0.11，因此**9.9 > 9.11**。

**答案：9.9比9.11大。**

4.1.3、HTTP代码示例

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": "deepseek-r1",
    "messages": [
        {
            "role": "user", 
            "content": "9.9和9.11谁大"
        }
    ],
    "stream": true,
    "stream_options": {
        "include_usage": true
    }
}'

返回结果

data: {"choices":[{"delta":{"content":"","reasoning_content":"","role":"assistant"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071776,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a351a53b-00a6-9cf6-9c64-ce491bc462a8"}

data: {"choices":[{"delta":{"content":"","reasoning_content":"\n"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071776,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a351a53b-00a6-9cf6-9c64-ce491bc462a8"}

data: {"choices":[{"delta":{"content":"","reasoning_content":"好的"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071776,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a351a53b-00a6-9cf6-9c64-ce491bc462a8"}

data: {"choices":[{"delta":{"content":"","reasoning_content":"，"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071776,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a351a53b-00a6-9cf6-9c64-ce491bc462a8"}

data: {"choices":[{"delta":{"content":"","reasoning_content":"我现在"},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071776,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a351a53b-00a6-9cf6-9c64-ce491bc462a8"}

......

data: {"choices":[{"delta":{"content":"{","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"delta":{"content":"9","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"delta":{"content":".","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"delta":{"content":"9","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"delta":{"content":"}\n","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"delta":{"content":"\\]","reasoning_content":""},"finish_reason":null,"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[{"finish_reason":"stop","delta":{"content":""},"index":0,"logprobs":null}],"object":"chat.completion.chunk","usage":null,"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: {"choices":[],"object":"chat.completion.chunk","usage":{"prompt_tokens":13,"completion_tokens":1436,"total_tokens":1449},"created":1739071797,"system_fingerprint":null,"model":"deepseek-r1","id":"chatcmpl-a2282bc4-2a01-99c5-a0a6-c1862a058f19"}

data: [DONE]

4.2、DashScope

4.2.1、python代码示例

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="deepseek-r1", # 此处以qwen-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
    messages=messages,
    result_format='message',
    stream=True,
    incremental_output=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="")
            reasoning_content += chunk.output.choices[0].message.reasoning_content
        # 如果当前为回复
        elif chunk.output.choices[0].message.content != "":
            if is_answering == False:
                print("\n"+"="*20+"完整回复"+"="*20)
                is_answering = True
            print(chunk.output.choices[0].message.content,end="")
            answer_content += chunk.output.choices[0].message.content

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

返回结果

====================思考过程====================
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。
====================完整回复====================
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。

4.2.2、Java代码示例

// 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"))
                .model("deepseek-r1")
                .messages(Arrays.asList(userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput(true)
                .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);
    }
}

返回结果

====================思考过程====================
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。
====================完整回复====================
您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何问题，我会尽我所能为您提供帮助。

4.2.3、HTTP代码示例

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": "deepseek-r1",
    "input":{
        "messages":[      
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message",
        "incremental_output": true
    }
}'

返回结果

id:1
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"您好","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":8,"input_tokens":5,"output_tokens":3},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

id:2
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"！","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":9,"input_tokens":5,"output_tokens":4},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

id:3
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"我是","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":10,"input_tokens":5,"output_tokens":5},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

......

id:74
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"提供","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":81,"input_tokens":5,"output_tokens":76},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

id:75
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"帮助","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":82,"input_tokens":5,"output_tokens":77},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

id:76
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"。","reasoning_content":"","role":"assistant"},"finish_reason":"null"}]},"usage":{"total_tokens":83,"input_tokens":5,"output_tokens":78},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

id:77
event:result
:HTTP_STATUS/200
data:{"output":{"choices":[{"message":{"content":"","reasoning_content":"","role":"assistant"},"finish_reason":"stop"}]},"usage":{"total_tokens":83,"input_tokens":5,"output_tokens":78},"request_id":"94bc32c6-c193-99a6-870e-7b790a6e8a76"}

5、注意事项

5.1、稳定性

如果执行后没有响应、响应超时或者报错An internal error has occured, please try again later or contact service support，请尝试重试或者更换其他DeepSeek模型，也可以尝试使用Qwen最新模型qwen-max-2025-01-25。

高峰期任务可能排队或失败，阿里云百炼持续扩容中，调用失败请稍后重试。

5.2、DeepSeek-R1 类模型

不支持的功能

Function Calling、JSON Output、对话前缀续写、上下文硬盘缓存。
不支持的参数

temperature、top_p、presence_penalty、frequency_penalty、logprobs、top_logprobs。

设置这些参数都不会生效，即使没有输出错误提示。
不建议设置 System Message。

5.3、DeepSeek-V3

参数默认值：
- temperature：0.7（取值范围是[0:2)）；
- top_p：0.6；
- presence_penalty：0.95。
不支持设置的参数和功能：frequency_penalty、logprobs、top_logprobs参数；不支持 Function Call、JSON Output 等功能，敬请关注后续动态。

5.4、联网搜索与深度思考

当前暂不支持联网搜索；只要调用 DeepSeek-R1 类模型即代表开启深度思考（深度思考过程通过reasoning_content返回）。

6、常见问题

问题1：免费额度用完后如何购买Token？

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

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

问题2：如何接入Chatbox 或 Dify？

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

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

Chatbox：

（1）在设置界面的模型提供方选择添加自定义提供方。

（2）进行 API 设置

名称输入“阿里云-DeepSeek-R1”（可自定义）；
API 域名输入https://dashscope.aliyuncs.com/compatible-mode/v1；
API 路径输入/chat/completions；
API 密钥输入您的 API Key，获取方法请参见：获取API Key；
模型输入您需要使用的 DeepSeek 模型，此处以 deepseek-r1 为例；
单击保存，完成设置。

（3）进行对话测试

在输入框输入“你是谁？”进行测试：

Dify：

（1）添加模型

打开设置界面，单击模型供应商，找到 OpenAI-API-compatible 卡片，单击添加模型。

（2）API 设置

模型类型选择 LLM；
模型名称输入您需要使用的 DeepSeek 模型，此处以 deepseek-r1 为例；
API Key 输入您的 API Key，获取方法请参见：获取API Key；
API endpoint URL 输入https://dashscope.aliyuncs.com/compatible-mode/v1；
其它保持默认，单击右下角的保存。
确认 OpenAI-API-compatible 卡片中的 DeepSeek 模型按钮处于开启状态。

（3）对话测试

进入应用，在右上角的模型选择位置选择 OpenAI-API-compatible 下的 DeepSeek 模型，即可开始对话。

7、错误码

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