# 深度思考

> 全部文档的索引见 [llms.txt](https://ark.volcengine.com/llms.txt)；在任一文档页面地址后追加 `.md` 可获取该页的 Markdown 版本。

具备深度思考能力的模型可高效处理复杂任务。模型在输出回答前，先对输入问题进行系统性分析和逻辑拆解，再基于拆解结果生成回答，确保内容全面且有深度。

> **说明**
>
> 方舟平台的新用户？获取 API Key 及 开通模型等准备工作，请参见 [快速入门](/docs/quick-start)。

<span id="b6d5721d"></span>
## 支持模型

250615 及之后版本的大语言模型，如无特殊说明，默认支持 Responses API，具体请参见[文本生成能力](/docs/model-list#32e9e053) 中能力标签含"深度思考"的模型。
<span id="7f1098c3"></span>
## API 文档

[Responses API](/docs/create-model-responses-api)
<span id="ec8a2a6b"></span>
## 流式输出

深度思考模型在回复前需进行思考，在非流式输出场景中容易因超时导致任务失败，推荐使用流式输出。

> **说明**
>
> 若应用是非流式输出场景，建议先以流式输出方式获取完整内容后再输出，这样既能避免任务超时失败，又能满足应用的输出需求。

**选项：Curl**

```Bash
curl https://ark.cn-beijing.volces.com/api/v3/responses \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "model": "doubao-seed-2-1-pro-260915",
      "input": "常见的十字花科植物有哪些？",
      "thinking":{"type": "enabled"},
      "stream": true
  }'
```

输出示例：

```
event: response.created
data: {"type":"response.created","response":{"created_at":1764229579,"id":"resp_021764229578658fe9a0f6cb2cc6c828e7a59adbdb971872aee70","max_output_tokens":32768,"model":"doubao-seed-2-1-pro-260915","object":"response","thinking":{"type":"enabled"},"service_tier":"default","caching":{"type":"disabled"},"store":true,"expire_at":1764488778},"sequence_number":0}

event: response.in_progress
data: {"type":"response.in_progress","response":{"created_at":1764229579,"id":"resp_021764229578658fe9a0f6cb2cc6c828e7a59adbdb971872aee70","max_output_tokens":32768,"model":"doubao-seed-2-1-pro-260915","object":"response","thinking":{"type":"enabled"},"service_tier":"default","caching":{"type":"disabled"},"store":true,"expire_at":1764488778},"sequence_number":1}

event: response.output_item.added
data: {"type":"response.output_item.added","output_index":0,"item":{"id":"rs_02176422957963700000000000000000000ffffac15dd335c9c43","type":"reasoning","status":"in_progress"},"sequence_number":2}

event: response.reasoning_summary_part.added
data: {"type":"response.reasoning_summary_part.added","item_id":"rs_02176422957963700000000000000000000ffffac15dd335c9c43","output_index":0,"summary_index":0,"part":{"type":"summary_text"},"sequence_number":3}

event: response.reasoning_summary_text.delta
data: {"type":"response.reasoning_summary_text.delta","summary_index":0,"delta":"\n","item_id":"rs_02176422957963700000000000000000000ffffac15dd335c9c43","output_index":0,"sequence_number":4}

event: response.reasoning_summary_text.delta
data: {"type":"response.reasoning_summary_text.delta","summary_index":0,"delta":"用户","item_id":"rs_02176422957963700000000000000000000ffffac15dd335c9c43","output_index":0,"sequence_number":5}

event: response.reasoning_summary_text.delta
data: {"type":"response.reasoning_summary_text.delta","summary_index":0,"delta":"问","item_id":"rs_02176422957963700000000000000000000ffffac15dd335c9c43","output_index":0,"sequence_number":6}
...
```

**选项：Python**

```Python
import os
from arkruntime import Ark
from arkruntime.types.responses.response_completed_event import ResponseCompletedEvent
from arkruntime.types.responses.response_reasoning_summary_text_delta_event import ResponseReasoningSummaryTextDeltaEvent
from arkruntime.types.responses.response_output_item_added_event import ResponseOutputItemAddedEvent
from arkruntime.types.responses.response_text_delta_event import ResponseTextDeltaEvent
from arkruntime.types.responses.response_text_done_event import ResponseTextDoneEvent

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="常见的十字花科植物有哪些？",
    thinking={"type": "enabled"},
    stream=True
)

for event in response:
    if isinstance(event, ResponseReasoningSummaryTextDeltaEvent):
        print(event.delta, end="")
    if isinstance(event, ResponseOutputItemAddedEvent):
        print("\noutPutItem " + event.type + " start:")
    if isinstance(event, ResponseTextDeltaEvent):
        print(event.delta,end="")
    if isinstance(event, ResponseTextDoneEvent):
        print("\noutPutTextDone.")
    if isinstance(event, ResponseCompletedEvent):
        print("Response Completed. Usage = " + event.response.usage.model_dump_json())
```

输出示例：

```

outPutItem response.output_item.added start:
用户问常见的十字花科植物有哪些，首先我得回忆一下十字花科的主要特征，比如花是十字形花冠，四强雄蕊（四长两短），果实多为角果（长角果或短角果）。然后要列举常见的种类，分几个类别可能更清楚，比如蔬菜类、观赏类、野生类这些。
....
现在组织语言，先总述十字花科的特征，然后分蔬菜、观赏、野生杂草三类列举常见例子，每个例子简要说明。这样结构清晰，用户容易理解。
outPutItem response.output_item.added start:
十字花科植物是被子植物中常见的一科，其核心特征为**十字形花冠（4片花瓣呈十字排列）、四强雄蕊（4长2短）、果实多为角果**（分长角果如油菜，短角果如荠菜）。以下是几类常见的十字花科植物：
### **一、常见蔬菜类**
这是十字花科最广为人知的类别，很多日常食材都属于此类：
1. **白菜类**：大白菜、小白菜、娃娃菜（均为芸薹属变种，叶用为主）；
2. ...
...
### **总结**
十字花科植物与人类生活密切相关——从日常蔬菜到观赏花卉，再到田间杂草，其多样性和实用性都很强。记住“十字花、四强雄蕊、角果”这三个特征，就能轻松识别大部分十字花科植物啦！
outPutTextDone.
Response Completed. Usage = {"input_tokens":42,"input_tokens_details":{"cached_tokens":0},"output_tokens":1089,"output_tokens_details":{"reasoning_tokens":431},"total_tokens":1131,"tool_usage":null,"tool_usage_details":null}
```

**选项：Go**

```Go
package main

import (
    "context"
    "fmt"
    "io"
    "os"

    "github.com/volcengine/ark-runtime-go/arkruntime"
    "github.com/volcengine/ark-runtime-go/arkruntime/model/responses"
)

func main() {
    client := arkruntime.NewClientWithApiKey(
        // Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
        os.Getenv("ARK_API_KEY"),
        arkruntime.WithBaseUrl("https://ark.cn-beijing.volces.com/api/v3"),
    )
    ctx := context.Background()

    resp, err := client.CreateResponsesStream(ctx, &responses.ResponsesRequest{
        Model:    "doubao-seed-2-1-pro-260915",
        Input:    responses.NewStringResponsesInput("常见的十字花科植物有哪些？"),

        Thinking: responses.NewOptThinking(responses.Thinking{Type: responses.NewOptThinkingMode(responses.ThinkingModeEnabled)}),
    })
    if err != nil {
        fmt.Printf("stream error: %v", err)
        return
    }
    for {
        event, err := resp.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            fmt.Printf("stream error: %v", err)
            return
        }
        handleEvent(event)
    }
}
func handleEvent(event *responses.ResponseStreamEvent) {
    switch event.OneOf.Type {
    case responses.ResponseReasoningSummaryTextDeltaEventResponseStreamEventSum:
        print(event.OneOf.ResponseReasoningSummaryTextDeltaEvent.Delta.Or(""))
    case responses.ResponseReasoningSummaryTextDoneEventResponseStreamEventSum:
        fmt.Printf("\nAggregated reasoning text: %s\n", event.OneOf.ResponseReasoningSummaryTextDoneEvent.Text.Or(""))
    case responses.ResponseTextDeltaEventResponseStreamEventSum:
        print(event.OneOf.ResponseTextDeltaEvent.Delta.Or(""))
    case responses.ResponseTextDoneEventResponseStreamEventSum:
        fmt.Printf("\nAggregated output text: %s\n", event.OneOf.ResponseTextDoneEvent.Text.Or(""))
    }
}
```

输出示例：

```
用户问常见的十字花科植物有哪些，我需要先回忆一下十字花科的主要特征，然后列举常见的例子，最好分分类，比如蔬菜类、花卉类、野生类之类的，这样用户看起来清楚。首先，十字花科的特征是十字形花冠，四强雄蕊（四长两短），角果（长角果或短角果）。
...
Aggregated reasoning text:
十字花科植物因**十字形花冠**（四片花瓣呈十字排列）、**四强雄蕊**（四长两短）和**角果**（果实类型）为主要特征，在蔬菜、观赏花卉中十分常见。以下是几类典型代表：
...
**答案总结：**
常见十字花科植物包括白菜、萝卜、卷心菜、西兰花、油菜、荠菜、紫罗兰、二月兰等（按蔬菜/花卉分类列举即可）。
（注：若需更简洁，可直接列出核心例子：如白菜、萝卜、西兰花、荠菜、紫罗兰、二月兰等）。
Aggregated output text: 十字花科植物因**十字形花冠**（四片花瓣呈十字排列）、**四强雄蕊**（四长两短）和**角果**（果实类型）为主要特征，在蔬菜、观赏花卉中十分常见。以下是几类典型代表：
...
**答案总结：**
常见十字花科植物包括白菜、萝卜、卷心菜、西兰花、油菜、荠菜、紫罗兰、二月兰等（按蔬菜/花卉分类列举即可）。
（注：若需更简洁，可直接列出核心例子：如白菜、萝卜、西兰花、荠菜、紫罗兰、二月兰等）。
```

**选项：Java**

```Java
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.models.responses.*;
public class demo {
    public static void main(String[] args) {
        String apiKey = System.getenv("ARK_API_KEY");
        // The base URL for model invocation
        ArkService arkService = ArkService.builder().apiKey(apiKey)
                .baseUrl("https://ark.cn-beijing.volces.com/api/v3")
                .build();

        ResponsesRequest request = ResponsesRequest.builder()
                .model("doubao-seed-2-1-pro-260915")
                .stream(true)
                .input(ResponsesInput.ofString("常见的十字花科植物有哪些？"))

                .thinking(Thinking.builder().type(ThinkingMode.ENABLED).build())
                .build();
        arkService.streamResponse(request)
            .doOnError(Throwable::printStackTrace)
            .blockingForEach(event -> {
                if (event instanceof ResponseReasoningSummaryTextDeltaEvent) {
                    System.out.print(((ResponseReasoningSummaryTextDeltaEvent) event).getDelta());
                }
                if (event instanceof ResponseOutputItemAddedEvent) {
                    System.out.println("OutputItem " + (((ResponseOutputItemAddedEvent) event).getItem().getType()) + " Start: ");
                }
                if (event instanceof ResponseTextDeltaEvent) {
                    System.out.print(((ResponseTextDeltaEvent) event).getDelta());
                }
                if (event instanceof ResponseTextDoneEvent) {
                    System.out.println("OutputText End.");
                }
                if (event instanceof ResponseOutputItemDoneEvent) {
                    System.out.println("OutputItem " + ((ResponseOutputItemDoneEvent) event).getItem().getType() + " End.");
                }
                if (event instanceof ResponseFunctionCallArgumentsDoneEvent) {
                    System.out.println("FunctionCall Arguments: " + ((ResponseFunctionCallArgumentsDoneEvent) event).getArguments());
                }
                if (event instanceof ResponseCompletedEvent) {
                    System.out.println("Response Completed. Usage = " + ((ResponseCompletedEvent) event).getResponse().getUsage());
                }
            });

        arkService.shutdownExecutor();
    }
}
```

输出示例：

```
OutputItem reasoning Start:
用户问常见的十字花科植物有哪些，首先我得回忆一下十字花科的主要特征，比如十字形花冠、四强雄蕊这些，但用户可能不需要特征，直接要例子。首先想到的是蔬菜类，因为很多日常吃的蔬菜都是十字花科的。
...
OutputItem message Start:
十字花科植物种类丰富，其中很多是日常常见的蔬菜、观赏植物或野菜，以下是一些典型例子：
...
这些植物在饮食、农业或景观中都很常见，你平时吃的蔬菜里大概率就有它们的身影！ 🌱🥦🥬OutputText End.
OutputItem message End.
Response Completed. Usage = Usage{inputTokens=42, outputTokens=759, totalTokens=801, inputTokensDetails=InputTokensDetails{cachedTokens=0}, outputTokensDetails=com.volcengine.ark.runtime.model.responses.usage.OutputTokensDetails@73d983ea, toolUsage=null, toolUsageDetails=null}
```

**选项：OpenAI SDK**

```Python
import os
from openai import OpenAI

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="常见的十字花科植物有哪些？",
    stream=True,
    extra_body={
        "thinking": {"type": "enabled"},
    }
)

for event in response:
    if event.type == "response.reasoning_summary_text.delta":
        print(event.delta, end="")
    if event.type == "response.output_item.added":
        print("\noutPutItem " + event.type + " start:")
    if event.type == "response.output_text.delta":
        print(event.delta,end="")
    if event.type == "response.output_item.done":
        print("\noutPutTextDone.")
    if event.type == "response.completed":
        print("\nResponse Completed. Usage = " + event.response.usage.model_dump_json())
```

输出示例：

```

outPutItem response.output_item.added start:
用户问常见的十字花科植物有哪些，首先我得回忆一下十字花科的主要特征，比如十字形花冠、四强雄蕊这些，但用户可能不需要特征，直接要例子。然后要分常见的类别，比如蔬菜类的，这个应该最多，还有观赏类的，可能还有野生的杂草类？
...
outPutTextDone.
outPutItem response.output_item.added start:
十字花科植物是被子植物中较大的一科，特征为**十字形花冠**（4瓣呈十字排列）、**四强雄蕊**（6枚雄蕊，4长2短），很多种类是常见的蔬菜、观赏植物或野菜。以下是几类典型的常见十字花科植物：
...
**答案总结：**
常见的十字花科植物包括白菜、萝卜、甘蓝（圆白菜/西兰花/花椰菜）、油菜、芥菜、荠菜、二月兰、紫罗兰等，涵盖蔬菜、观赏、野菜三大类。
...
outPutTextDone.
Response Completed. Usage = {"input_tokens":42,"input_tokens_details":{"cached_tokens":0},"output_tokens":1467,"output_tokens_details":{"reasoning_tokens":574},"total_tokens":1509}
```

<span id="19c1bd32"></span>
## 控制深度思考

通过 **thinking** 字段控制是否关闭深度思考能力。

* `enabled`：强制开启，强制开启深度思考能力。
* `disabled`：强制关闭深度思考能力。
* `auto`：模型自行判断是否进行深度思考。

支持 Responses API 中 **thinking** 字段来控制深度思考的模型如下：
* doubao-seed-evolving：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-1-pro-260915：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-1-lite-260915：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-1-pro-260628：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-1-turbo-260628：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-lite-260428：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-mini-260428：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-pro-260215：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-lite-260215：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-mini-260215：支持 `enabled`（默认）、`disabled`。
* doubao-seed-2-0-code-preview-260215：支持 `enabled`（默认）、`disabled`。
* glm-5-3-flash-260828：支持 `enabled`（默认）。(**始终启用思考，不再支持禁用思考。**)
* glm-5-2-260617：支持 `enabled`（默认）、`disabled`。
* doubao-seed-character-260628：支持 `enabled`（默认）、`disabled`。
* deepseek-v4-1-flash-260910：支持 `enabled`（默认）、`disabled`。
* deepseek-v4-pro-ga-260813：支持 `enabled`（默认）、`disabled`。
* deepseek-v4-flash-ga-260731：支持 `enabled`（默认）、`disabled`。
* deepseek-v4-pro-260425：支持 `enabled`（默认）、`disabled`。

**选项：Curl**

```Bash
curl https://ark.cn-beijing.volces.com/api/v3/responses \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "model": "doubao-seed-2-1-pro-260915",
      "input": "推理模型与非推理模型区别。",
      "thinking":{"type": "enabled"}
  }'
```

**选项：Python**

```Python
import os
from arkruntime import Ark

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="推理模型与非推理模型区别。",
    thinking={"type": "enabled"},
)

print(response)
```

**选项：Go**

```Go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/volcengine/ark-runtime-go/arkruntime"
    "github.com/volcengine/ark-runtime-go/arkruntime/model/responses"
)

func main() {
    client := arkruntime.NewClientWithApiKey(
        // Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
        os.Getenv("ARK_API_KEY"),
        arkruntime.WithBaseUrl("https://ark.cn-beijing.volces.com/api/v3"),
    )
    ctx := context.Background()

    resp, err := client.CreateResponses(ctx, &responses.ResponsesRequest{
        Model:    "doubao-seed-2-1-pro-260915",
        Input:    responses.NewStringResponsesInput("推理模型与非推理模型区别。"),
        Thinking: responses.NewOptThinking(responses.Thinking{Type: responses.NewOptThinkingMode(responses.ThinkingModeEnabled)}),
    })
    if err != nil {
        fmt.Printf("response error: %v\n", err)
        return
    }
    fmt.Println(resp)
}
```

**选项：Java**

```Java
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.models.responses.*;
public class demo {
    public static void main(String[] args) {
        String apiKey = System.getenv("ARK_API_KEY");
        // The base URL for model invocation
        ArkService arkService = ArkService.builder().apiKey(apiKey)
                .baseUrl("https://ark.cn-beijing.volces.com/api/v3")
                .build();

        ResponsesRequest request = ResponsesRequest.builder()
                .model("doubao-seed-2-1-pro-260915")
                .input(ResponsesInput.ofString("推理模型与非推理模型区别。"))

                .thinking(Thinking.builder().type(ThinkingMode.ENABLED).build())
                .build();
        Response resp = arkService.createResponse(request);
        System.out.println(resp);
        arkService.shutdownExecutor();
    }
}
```

**选项：OpenAI SDK**

```Python
import os
from openai import OpenAI

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="推理模型与非推理模型区别。",
    extra_body={
        "thinking": {"type": "enabled"},
    }
)

print(response)
```

<span id="d30d6976"></span>
## 输出思考内容摘要

<span id="7e7354e3"></span>
### 支持模型

* doubao-seed-evolving
* doubao-seed-2-1-pro-260915
* doubao-seed-2-1-lite-260915
* doubao-seed-2-1-pro-260628
* doubao-seed-2-1-turbo-260628
* doubao-seed-2-0-lite-260428
<span id="06003963"></span>
### 使用说明

默认会开启 thinking summary 能力，不会输出模型原始的思考内容，会返回模型思考内容摘要字段 **summary**、思考内容加密原文字段 **encrypted_content**。

> **说明**
>
> 默认开启 thinking summary 能力后，可能会有较高的包间延迟，请调大请求超时时间（**timeout**），并做好兼容适配。

字段说明：

* **reasoning.effort**：仅作用于模型的原始思考内容，不适用于思考摘要。
* **usage.output_tokens_details.reasoning_tokens**：为原始思考内容的 tokens，计费仍然按原始思考内容 token 计算。

<span id="cde1bf53"></span>
### 回传思考内容

在多轮工具调用场景，需要回传思考内容，支持的回传方式如下。回传思考内容示例参见[回传思考内容加密原文](/docs/deep-thinking#8cfd447b)。

* **previous_response_id**（推荐）： 自动获取原始思考内容并回传给模型参与推理。
* 手动回传 **encrypted_content**：按接收到的完整格式**回传思考内容加密原文**，被篡改后则无法还原思考内容。

<span id="dc4c1547"></span>
## 调节思考长度

通过 **reasoning.effort** 调节思维链长度，平衡不同场景对效果、时延、成本的需求。取值如下：
* `none`：关闭思考。
* `minimal`：关闭思考，直接回答。
* `low`：轻量思考，侧重快速响应。
* `medium`：均衡模式，兼顾速度与深度。
* `high`：深度分析，处理复杂问题。
* `xhigh`：更高强度思考。
* `max`：最高强度思考，适配高难度推理任务。

下表展示支持调节思考长度的模型，以及各模型对 **reasoning.effort** 的支持取值、默认取值与兼容映射规则。所有支持该字段的模型均接受全部 7 档取值，部分取值将按表中规则自动映射至等效档位。

| 支持模型 | 默认取值 | 兼容映射 |
| --- | --- | --- |
|* `doubao-seed-evolving` | `high` |* 传入 `minimal`：将关闭思考 | \
|* `doubao-seed-2-1-pro-260915` | |* 传入 `none`：将映射为 `minimal` | \
|* `doubao-seed-2-1-lite-260915` | |* 传入 `none`：将映射为 `minimal` | \
|* `doubao-seed-2-1-pro-260628` | |* 传入 `xhigh` / `max`：将映射为 `high` | \
|* `doubao-seed-2-1-turbo-260628` | | |
|* `doubao-seed-2-0-lite-260428` | `medium` |* 传入 `minimal`：将关闭思考 | \
|* `doubao-seed-2-0-mini-260428` | |* 传入 `none`：将映射为 `minimal` | \
|* `doubao-seed-2-0-pro-260215` | |* 传入 `xhigh` / `max`：将映射为 `high` | \
|* `doubao-seed-2-0-lite-260215` | | | \
|* `doubao-seed-2-0-mini-260215` | | | \
|* `doubao-seed-2-0-code-preview-260215` | | | \
|* `doubao-seed-character-260628` | | |
| `glm-5-3-flash-260828` | `max` |* 传入 `none` / `minimal` / `low`：将映射为 `low` | \
| | |* 传入 `medium` / `high`：将映射为 `high` | \
| | |* 传入 `xhigh` / `max`：将映射为 `max` |
| `glm-5-2-260617` | `high` |* 传入 `none` / `minimal`：将关闭思考 | \
| | |* 传入 `low` / `medium`：将映射为 `high` | \
| | |* 传入 `xhigh`：将映射为 `max` |
| `deepseek-v4-1-flash-260910` | `high` |* 传入 `none`：将关闭思考 | \
| | |* 传入 `minimal`：将映射为 `low` | \
| | |* 传入 `medium` / `xhigh`：将映射为 `high` |
|* `deepseek-v4-pro-ga-260813` | `high` |* 传入 `none` / `minimal`：将关闭思考 | \
|* `deepseek-v4-flash-ga-260731` | |* 传入 `medium`：将映射为 `low` | \
| | |* 传入 `xhigh`：将映射为 `high` |
|* `deepseek-v4-pro-260425` | `high` |* 传入 `minimal`：将关闭思考 | \

关于 **thinking.type**、**reasoning.effort** 的使用说明如下：

* **thinking.type** 取值为 `enabled`：支持配置 **reasoning.effort**。当 **reasoning.effort** 取值为 `minimal` 时，则关闭思考，直接回答。
* **thinking.type** 取值为 `disabled`：**reasoning.effort** 仅支持取值 `minimal`。当 **reasoning.effort** 为其他取值时会报错。

**选项：Curl**

```Bash
curl https://ark.cn-beijing.volces.com/api/v3/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seed-2-1-pro-260915",
    "input": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": "https://arkdocs.tos-cn-beijing.volces.com/images/advanced-usage/ark_demo_img_1-zh.png"
                },
                {
                    "type": "input_text",
                    "text": "你看见了什么？"
                }
            ]
        }
    ],
    "thinking":{"type":"enabled"},
    "reasoning":{"effort": "low"}
}'
```

**选项：Python**

```Python
import os
from arkruntime import Ark

# 从环境变量中获取您的API KEY，配置方法见：https://ark.volcengine.com/region:cn-beijing/docs/quick-start
api_key = os.getenv('ARK_API_KEY')

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input=[
        {
            "role": "user",
            "content": [

                {
                    "type": "input_image",
                    "image_url": "https://arkdocs.tos-cn-beijing.volces.com/images/advanced-usage/ark_demo_img_1-zh.png"
                },
                {
                    "type": "input_text",
                    "text": "你看见了什么？"
                },
            ],
        }
    ],
    thinking={"type": "enabled"},
    reasoning={"effort": "low"}
)

print(response)
```

**选项：Go**

```Go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/volcengine/ark-runtime-go/arkruntime"
    "github.com/volcengine/ark-runtime-go/arkruntime/model/responses"
)

func main() {
    client := arkruntime.NewClientWithApiKey(
        //通过 os.Getenv 从环境变量中获取 ARK_API_KEY
        os.Getenv("ARK_API_KEY"),
        arkruntime.WithBaseUrl("https://ark.cn-beijing.volces.com/api/v3"),
    )
    // 创建一个上下文，通常用于传递请求的上下文信息，如超时、取消等
    ctx := context.Background()

    inputMessage := responses.InputItem{
        OneOf: responses.NewItemEasyMessageInputItemSum(
            responses.ItemEasyMessage{
                Role: responses.NewOptMessageRole(responses.MessageRoleUser),
                Content: responses.NewContentItemArrayMessageContent(
                    []responses.ContentItem{
            responses.ContentItem{OneOf: responses.NewContentItemImageContentItemSum(responses.ContentItemImage{Type: responses.ContentItemImageTypeInputImage, ImageURL: responses.NewOptString("https://arkdocs.tos-cn-beijing.volces.com/images/advanced-usage/ark_demo_img_1-zh.png")})},
            responses.ContentItem{OneOf: responses.NewContentItemTextContentItemSum(responses.ContentItemText{Type: responses.ContentItemTextTypeInputText, Text: "你看见了什么？"})},
                    },
                ),
            },
        ),
    }

    resp, err := client.CreateResponses(ctx, &responses.ResponsesRequest{
        Model: "doubao-seed-2-1-pro-260915",
        Input: responses.NewInputItemArrayResponsesInput([]responses.InputItem{inputMessage}),
        Thinking:  responses.NewOptThinking(responses.Thinking{Type: responses.NewOptThinkingMode(responses.ThinkingModeEnabled)}),
        Reasoning: responses.NewOptReasoning(responses.Reasoning{Effort: responses.NewOptReasoningEffort(responses.ReasoningEffortLow)}),
    })
    if err != nil {
        fmt.Printf("response error: %v", err)
        return
    }
    fmt.Println(resp)
}
```

**选项：Java**

```Java
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.models.responses.*;
public class demo {
    public static void main(String[] args) {
        String apiKey = System.getenv("ARK_API_KEY");
        // 创建ArkService实例
        ArkService arkService = ArkService.builder().apiKey(apiKey)
                .baseUrl("https://ark.cn-beijing.volces.com/api/v3")
                .build();

        ResponsesRequest request = ResponsesRequest.builder()
                .model("doubao-seed-2-1-pro-260915")
                .input(ResponsesInput.ofList(java.util.Arrays.asList(ItemEasyMessage.builder().role(MessageRole.USER).content(
                                MessageContent.ofList(java.util.Arrays.asList(ContentItemImage.builder().imageUrl("https://arkdocs.tos-cn-beijing.volces.com/images/advanced-usage/ark_demo_img_1-zh.png").build(), ContentItemText.builder().text("你看见了什么？").build()))
                        ).build())))
                .thinking(Thinking.builder().type(ThinkingMode.ENABLED).build())
                .reasoning(Reasoning.builder().effort(ReasoningEffort.LOW).build())
                .build();
        Response resp = arkService.createResponse(request);
        System.out.println(resp);

        arkService.shutdownExecutor();
    }
}
```

**选项：OpenAI SDK**

```Python
import os
from openai import OpenAI

# 从环境变量中获取您的API KEY，配置方法见：https://ark.volcengine.com/region:cn-beijing/docs/quick-start
api_key = os.getenv('ARK_API_KEY')

client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input=[
        {
            "role": "user",
            "content": [

                {
                    "type": "input_image",
                    "image_url": "https://arkdocs.tos-cn-beijing.volces.com/images/advanced-usage/ark_demo_img_1-zh.png"
                },
                {
                    "type": "input_text",
                    "text": "你看见了什么？"
                },
            ],
        }
    ],
    extra_body={
        "thinking": {"type": "enabled"},
    },
    reasoning={"effort": "low"}
)

print(response)
```

<span id="1460ba95"></span>
## 设置最大输出长度

模型输出长度 = 思维链长度（如果有） + 回答长度
通过设置 **max_output_tokens** 字段调整模型输出长度，达到控制成本或输出指定篇幅的目的。

**选项：Curl**

```Bash
curl https://ark.cn-beijing.volces.com/api/v3/responses \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "model": "doubao-seed-2-1-pro-260915",
      "input": "推理模型与非推理模型区别。",
      "max_output_tokens": 1024
  }'
```

**选项：Python**

```Python
import os
from arkruntime import Ark

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = Ark(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="推理模型与非推理模型区别。",
    max_output_tokens=1024
)

print(response)
```

**选项：Go**

```Go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/volcengine/ark-runtime-go/arkruntime"
    "github.com/volcengine/ark-runtime-go/arkruntime/model/responses"
)

func main() {
    client := arkruntime.NewClientWithApiKey(
        // Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
        os.Getenv("ARK_API_KEY"),
        arkruntime.WithBaseUrl("https://ark.cn-beijing.volces.com/api/v3"),
    )
    ctx := context.Background()

    resp, err := client.CreateResponses(ctx, &responses.ResponsesRequest{
        Model:    "doubao-seed-2-1-pro-260915",
        Input:    responses.NewStringResponsesInput("推理模型与非推理模型区别。"),
        MaxOutputTokens: responses.NewOptInt64(int64(1024)),
    })
    if err != nil {
        fmt.Printf("response error: %v\n", err)
        return
    }
    fmt.Println(resp)
}
```

**选项：Java**

```Java
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.models.responses.*;
public class demo {
    public static void main(String[] args) {
        String apiKey = System.getenv("ARK_API_KEY");
        // The base URL for model invocation
        ArkService arkService = ArkService.builder().apiKey(apiKey)
                .baseUrl("https://ark.cn-beijing.volces.com/api/v3")
                .build();

        ResponsesRequest request = ResponsesRequest.builder()
                .model("doubao-seed-2-1-pro-260915")
                .input(ResponsesInput.ofString("推理模型与非推理模型区别。"))

                .maxOutputTokens(1024L)
                .build();
        Response resp = arkService.createResponse(request);
        System.out.println(resp);
        arkService.shutdownExecutor();
    }
}
```

**选项：OpenAI SDK**

```Python
import os
from openai import OpenAI

# Get API Key: https://ark.volcengine.com/region:cn-beijing/apikey
api_key = os.getenv('ARK_API_KEY')

client = OpenAI(
    base_url='https://ark.cn-beijing.volces.com/api/v3',
    api_key=api_key,
)

# Create a request
response = client.responses.create(
    model="doubao-seed-2-1-pro-260915",
    input="推理模型与非推理模型区别。",
    max_output_tokens=1024
)

print(response)
```

<span id="6e31a6ef"></span>
## 工作原理

* 多轮对话场景

    |流程图 |说明 |
    | --- | --- |
    |![deep-thinking-01.flowchart](https://arkdocs.tos-cn-beijing.volces.com/flowcharts/advanced-usage/deep-thinking-01.svg) |* 在每一轮对话过程中，深度思考模型会输出思维链内容（CoT）和最终回答（Answer）。 | \
    | |* 在下一轮对话中，之前输出的思维链内容不会被拼接到上下文中。 | \
    | |> 思维链内容展现的是模型处理问题的过程，包括将问题拆分为多个问题进行处理，生成多种回复综合得出更好回答等过程。 |

* 工具调用场景

    工具调用场景中开启深度思考后，为给出更详尽准确的回答，将不会直接丢弃思维链内容，历史轮次的思维链内容按需（模型自主判断）参与推理。在整个请求过程中，用户回传完整上下文即可，由服务端自行判断，是否保留思维链内容。未输入给模型的思维链内容，不会计算 token 用量。代码示例参见[回传思考内容](/docs/deep-thinking#3e8661f7)。

    |流程图 |说明 |
    | --- | --- |
    |![deep-thinking-02.flowchart](https://arkdocs.tos-cn-beijing.volces.com/flowcharts/advanced-usage/deep-thinking-02.svg) |* 回答问题 1 时（请求 1.1 - 1.2），模型进行多次思考 + 工具调用后给出答案，方舟会输入完整上下文包括思维链内容给模型处理。 | \
    | |* 开始回答问题 2 时（请求 2.1），方舟会自行判断并删除之前上下文中的思维链，输入给模型。 |

<span id="d3e6f353"></span>
## QPS 限流

Responses API  QPS 限流如下。如果需要提升限流值，请提交 [工单](https://console.volcengine.com/workorder/create?step=2&SubProductID=P00001166)。
|接口名称 |账号维度的 QPS 限流 |
| --- | --- |
|创建模型响应 |无 |
|查询模型响应 |20 |
|列出输入项 |20 |
|删除模型响应 |20 |