面向 AI 助手：本页的 Markdown 版本位于 https://ark.volcengine.com/region:cn-beijing/docs/responses-api-deep-thinking.md，全部文档索引见 https://ark.volcengine.com/llms.txt。

深度思考

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

支持模型#

250615 及之后版本的大语言模型，如无特殊说明，默认支持 Responses API，具体请参见文本生成能力 中能力标签含"深度思考"的模型。

API 文档#

Responses API

流式输出#

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

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
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
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
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}
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}

控制深度思考#

通过 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。
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
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
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
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();
    }
}
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)

输出思考内容摘要#

支持模型#

  • 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

使用说明#

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

字段说明：

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

回传思考内容#

在多轮工具调用场景，需要回传思考内容，支持的回传方式如下。回传思考内容示例参见回传思考内容加密原文。

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

调节思考长度#

通过 reasoning.effort 调节思维链长度，平衡不同场景对效果、时延、成本的需求。取值如下：

  • none：关闭思考。
  • minimal：关闭思考，直接回答。
  • low：轻量思考，侧重快速响应。
  • medium：均衡模式，兼顾速度与深度。
  • high：深度分析，处理复杂问题。
  • xhigh：更高强度思考。
  • max：最高强度思考，适配高难度推理任务。

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

支持模型 默认取值 兼容映射
  • 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
 high
  • 传入 minimal：将关闭思考
  • 传入 none：将映射为 minimal
  • 传入 none：将映射为 minimal
  • 传入 xhigh / max：将映射为 high
  • doubao-seed-2-0-lite-260428
  • doubao-seed-2-0-mini-260428
  • doubao-seed-2-0-pro-260215
  • doubao-seed-2-0-lite-260215
  • doubao-seed-2-0-mini-260215
  • doubao-seed-2-0-code-preview-260215
  • doubao-seed-character-260628
 medium
  • 传入 minimal：将关闭思考
  • 传入 none：将映射为 minimal
  • 传入 xhigh / max：将映射为 high
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
  • deepseek-v4-flash-ga-260731
 high
  • 传入 none / minimal：将关闭思考
  • 传入 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 为其他取值时会报错。
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
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
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
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();
    }
}
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)

设置最大输出长度#

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

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
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
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
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();
    }
}
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)

工作原理#

  • 多轮对话场景

流程图 说明
deep-thinking-01.flowchart
  • 在每一轮对话过程中，深度思考模型会输出思维链内容（CoT）和最终回答（Answer）。
  • 在下一轮对话中，之前输出的思维链内容不会被拼接到上下文中。

思维链内容展现的是模型处理问题的过程，包括将问题拆分为多个问题进行处理，生成多种回复综合得出更好回答等过程。

  • 工具调用场景

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

流程图 说明
deep-thinking-02.flowchart
  • 回答问题 1 时（请求 1.1 - 1.2），模型进行多次思考 + 工具调用后给出答案，方舟会输入完整上下文包括思维链内容给模型处理。
  • 开始回答问题 2 时（请求 2.1），方舟会自行判断并删除之前上下文中的思维链，输入给模型。

QPS 限流#

Responses API QPS 限流如下。如果需要提升限流值，请提交 工单。

接口名称 账号维度的 QPS 限流
创建模型响应 无
查询模型响应 20
列出输入项 20
删除模型响应 20