火山方舟
火山方舟
文档指南
请输入
调用
视频生成
工具调用
进阶使用
使用 Responses API
- 火山方舟
调用使用 Responses API深度思考
复制全文
下载 pdf使用 Responses API
深度思考
复制全文下载 pdf深度思考
文档反馈具备深度思考能力的模型可高效处理复杂任务。模型在输出回答前，先对输入问题进行系统性分析和逻辑拆解，再基于拆解结果生成回答，确保内容全面且有深度。
说明
支持模型
API 文档
流式输出
深度思考模型在回复前需进行思考，在非流式输出场景中容易因超时导致任务失败，推荐使用流式输出。
说明
若应用是非流式输出场景，建议先以流式输出方式获取完整内容后再输出，这样既能避免任务超时失败，又能满足应用的输出需求。
Curl
Python
Go
Java
OpenAI SDK
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-260628",
"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-260628","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-260628","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}
...
import os
from volcenginesdkarkruntime import Ark
from volcenginesdkarkruntime.types.responses.response_completed_event import ResponseCompletedEvent
from volcenginesdkarkruntime.types.responses.response_reasoning_summary_text_delta_event import ResponseReasoningSummaryTextDeltaEvent
from volcenginesdkarkruntime.types.responses.response_output_item_added_event import ResponseOutputItemAddedEvent
from volcenginesdkarkruntime.types.responses.response_text_delta_event import ResponseTextDeltaEvent
from volcenginesdkarkruntime.types.responses.response_text_done_event import ResponseTextDoneEvent
# Get API Key: https://console.volcengine.com/ark/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-260628",
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}
package main
import (
"context"
"fmt"
"io"
"os"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model/responses"
)
func main() {
client := arkruntime.NewClientWithApiKey(
// Get API Key: https://console.volcengine.com/ark/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-260628",
Input: &responses.ResponsesInput{Union: &responses.ResponsesInput_StringValue{StringValue: "常见的十字花科植物有哪些？"}},
Thinking: &responses.ResponsesThinking{Type: responses.ThinkingType_enabled.Enum()},
})
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.Event) {
switch event.GetEventType() {
case responses.EventType_response_reasoning_summary_text_delta.String():
print(event.GetReasoningText().GetDelta())
case responses.EventType_response_reasoning_summary_text_done.String(): // aggregated reasoning text
fmt.Printf("\nAggregated reasoning text: %s\n", event.GetReasoningText().GetText())
case responses.EventType_response_output_text_delta.String():
print(event.GetText().GetDelta())
case responses.EventType_response_output_text_done.String(): // aggregated output text
fmt.Printf("\nAggregated output text: %s\n", event.GetTextDone().GetText())
default:
return
}
}
输出示例：
用户问常见的十字花科植物有哪些，我需要先回忆一下十字花科的主要特征，然后列举常见的例子，最好分分类，比如蔬菜类、花卉类、野生类之类的，这样用户看起来清楚。首先，十字花科的特征是十字形花冠，四强雄蕊（四长两短），角果（长角果或短角果）。
...
Aggregated reasoning text:
十字花科植物因**十字形花冠**（四片花瓣呈十字排列）、**四强雄蕊**（四长两短）和**角果**（果实类型）为主要特征，在蔬菜、观赏花卉中十分常见。以下是几类典型代表：
...
**答案总结：**
常见十字花科植物包括白菜、萝卜、卷心菜、西兰花、油菜、荠菜、紫罗兰、二月兰等（按蔬菜/花卉分类列举即可）。
（注：若需更简洁，可直接列出核心例子：如白菜、萝卜、西兰花、荠菜、紫罗兰、二月兰等）。
Aggregated output text: 十字花科植物因**十字形花冠**（四片花瓣呈十字排列）、**四强雄蕊**（四长两短）和**角果**（果实类型）为主要特征，在蔬菜、观赏花卉中十分常见。以下是几类典型代表：
...
**答案总结：**
常见十字花科植物包括白菜、萝卜、卷心菜、西兰花、油菜、荠菜、紫罗兰、二月兰等（按蔬菜/花卉分类列举即可）。
（注：若需更简洁，可直接列出核心例子：如白菜、萝卜、西兰花、荠菜、紫罗兰、二月兰等）。
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.model.responses.request.*;
import com.volcengine.ark.runtime.model.responses.response.ResponseObject;
import com.volcengine.ark.runtime.model.responses.constant.ResponsesConstants;
import com.volcengine.ark.runtime.model.responses.common.ResponsesThinking;
import com.volcengine.ark.runtime.model.responses.event.functioncall.FunctionCallArgumentsDoneEvent;
import com.volcengine.ark.runtime.model.responses.event.outputitem.OutputItemAddedEvent;
import com.volcengine.ark.runtime.model.responses.event.outputitem.OutputItemDoneEvent;
import com.volcengine.ark.runtime.model.responses.event.outputtext.OutputTextDeltaEvent;
import com.volcengine.ark.runtime.model.responses.event.outputtext.OutputTextDoneEvent;
import com.volcengine.ark.runtime.model.responses.event.reasoningsummary.ReasoningSummaryTextDeltaEvent;
import com.volcengine.ark.runtime.model.responses.event.response.ResponseCompletedEvent;
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();
CreateResponsesRequest request = CreateResponsesRequest.builder()
.model("doubao-seed-2-1-pro-260628")
.stream(true)
.input(ResponsesInput.builder().stringValue("常见的十字花科植物有哪些？").build())
.thinking(ResponsesThinking.builder().type(ResponsesConstants.THINKING_TYPE_ENABLED).build())
.build();
arkService.streamResponse(request)
.doOnError(Throwable::printStackTrace)
.blockingForEach(event -> {
if (event instanceof ReasoningSummaryTextDeltaEvent) {
System.out.print(((ReasoningSummaryTextDeltaEvent) event).getDelta());
}
if (event instanceof OutputItemAddedEvent) {
System.out.println("OutputItem " + (((OutputItemAddedEvent) event).getItem().getType()) + " Start: ");
}
if (event instanceof OutputTextDeltaEvent) {
System.out.print(((OutputTextDeltaEvent) event).getDelta());
}
if (event instanceof OutputTextDoneEvent) {
System.out.println("OutputText End.");
}
if (event instanceof OutputItemDoneEvent) {
System.out.println("OutputItem " + ((OutputItemDoneEvent) event).getItem().getType() + " End.");
}
if (event instanceof FunctionCallArgumentsDoneEvent) {
System.out.println("FunctionCall Arguments: " + ((FunctionCallArgumentsDoneEvent) 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}
import os
from openai import OpenAI
# Get API Key: https://console.volcengine.com/ark/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-260628",
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-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。
- doubao-seed-1-8-251228：支持 enabled（默认）、disabled。
- glm-5-2-260617：支持enabled（默认）、disabled。
- glm-4-7-251222：支持enabled（默认）、disabled。
- doubao-seed-character-260628：支持enabled（默认）、disabled。
- doubao-seed-code-preview-251028：支持 enabled（默认）、disabled。
- doubao-seed-1-6-vision-250815：支持 enabled（默认）、disabled。
- doubao-seed-1-6-250615：支持 enabled（默认）、disabled、auto。
- doubao-seed-1-6-251015：支持 enabled（默认）、disabled。
- doubao-seed-1-6-flash-250828：支持 enabled（默认）、disabled。
- doubao-seed-1-6-flash-250615：支持 enabled（默认）、disabled。
- deepseek-v4-pro-ga-260813：支持 enabled（默认）、disabled。
- deepseek-v4-flash-ga-260731：支持 enabled（默认）、disabled。
- deepseek-v4-pro-260425：支持 enabled（默认）、disabled。
- deepseek-v4-flash-260425：支持 enabled（默认）、disabled。
Curl
Python
Go
Java
OpenAI SDK
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-260628",
"input": "推理模型与非推理模型区别。",
"thinking":{"type": "enabled"}
}'
import os
from volcenginesdkarkruntime import Ark
# Get API Key: https://console.volcengine.com/ark/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-260628",
input="推理模型与非推理模型区别。",
thinking={"type": "enabled"},
)
print(response)
package main
import (
"context"
"fmt"
"os"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model/responses"
)
func main() {
client := arkruntime.NewClientWithApiKey(
// Get API Key: https://console.volcengine.com/ark/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-260628",
Input: &responses.ResponsesInput{Union: &responses.ResponsesInput_StringValue{StringValue: "推理模型与非推理模型区别。"}},
Thinking: &responses.ResponsesThinking{Type: responses.ThinkingType_enabled.Enum()},
})
if err != nil {
fmt.Printf("response error: %v\n", err)
return
}
fmt.Println(resp)
}
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.model.responses.request.*;
import com.volcengine.ark.runtime.model.responses.response.ResponseObject;
import com.volcengine.ark.runtime.model.responses.constant.ResponsesConstants;
import com.volcengine.ark.runtime.model.responses.common.ResponsesThinking;
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();
CreateResponsesRequest request = CreateResponsesRequest.builder()
.model("doubao-seed-2-1-pro-260628")
.input(ResponsesInput.builder().stringValue("推理模型与非推理模型区别。").build())
.thinking(ResponsesThinking.builder().type(ResponsesConstants.THINKING_TYPE_ENABLED).build())
.build();
ResponseObject resp = arkService.createResponse(request);
System.out.println(resp);
arkService.shutdownExecutor();
}
}
import os
from openai import OpenAI
# Get API Key: https://console.volcengine.com/ark/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-260628",
input="推理模型与非推理模型区别。",
extra_body={
"thinking": {"type": "enabled"},
}
)
print(response)
输出思考内容摘要
支持模型
- doubao-seed-evolving
- doubao-seed-2-1-pro-260628
- doubao-seed-2-1-turbo-260628
- doubao-seed-2-0-lite-260428
-
使用说明
默认会开启 thinking summary 能力，不会输出模型原始的思考内容，会返回模型思考内容摘要。
说明
默认开启 thinking summary 能力后，可能会有较高的包间延迟，请调大请求超时时间（ timeout ），并做好兼容适配。
字段说明：
- reasoning.effort ：仅作用于模型的原始思考内容，不适用于思考摘要。
- usage.output_tokens_details.reasoning_tokens ：为原始思考内容的 tokens，计费仍然按原始思考内容 token 计算。
输出思考内容加密原文
开启深度思考后，支持输出思考内容加密原文字段 encrypted_content ：需要在 include 参数中指定 reasoning.encrypted_content 时，才会在生成响应时返回该字段。示例如下：
curl https://ark.cn-beijing.volces.com/api/v3/responses \
-H "Authorization: Bearer $ARK_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "<model_id>",
"input": "推理模型与非推理模型区别。",
"thinking":{"type": "enabled"},
"include":["reasoning.encrypted_content"]
}'
回传思考内容
- previous_response_id （推荐）： 自动获取原始思考内容并回传给模型参与推理。
- 手动回传 encrypted_content ：按接收到的完整格式回传思考内容，被篡改后则无法还原思考内容。
调节思考长度
通过 reasoning.effort 调节思维链长度，平衡不同场景对效果、时延、成本的需求。取值如下：
- minimal：关闭思考，直接回答。
- low：轻量思考，侧重快速响应。
- medium（默认值）：均衡模式，兼顾速度与深度。
- high：深度分析，处理复杂问题。
注意
reasoning.effort 的默认取值为 medium。
- 以下模型的默认取值为 high：
- doubao-seed-evolving
- doubao-seed-2-1-pro-260628
- doubao-seed-2-1-turbo-260628
- glm-5-2-260617 默认取值为 max。为保证兼容性，会对该模型部分取值进行处理：
- 传入 minimal：关闭思考；
- 传入 low / medium：按 high 等效处理；
- 传入 xhigh：按 max 等效处理。
关于 thinking.type 、 reasoning.effort 的使用说明如下：
- thinking.type 取值为enabled：支持配置 reasoning.effort 。当 reasoning.effort 取值为minimal时，则关闭思考，直接回答。
- thinking.type 取值为disabled： reasoning.effort 仅支持取值minimal。当 reasoning.effort 取值为low、medium、high时会报错。
支持模型：
- doubao-seed-evolving
- doubao-seed-2-1-pro-260628
- doubao-seed-2-1-turbo-260628
- 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-1-8-251228
- doubao-seed-1-6-251015
- doubao-seed-character-260628
- glm-5-2-260617
Curl
Python
Go
Java
OpenAI SDK
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-260628",
"input": [
{
"role": "user",
"content": [
{
"type": "input_image",
"image_url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/ark_demo_img_1.png"
},
{
"type": "input_text",
"text": "你看见了什么？"
}
]
}
],
"thinking":{"type":"enabled"},
"reasoning":{"effort": "low"}
}'
import os
from volcenginesdkarkruntime import Ark
# 从环境变量中获取您的API KEY，配置方法见：https://www.volcengine.com/docs/82379/1399008
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-260628",
input=[
{
"role": "user",
"content": [
{
"type": "input_image",
"image_url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/ark_demo_img_1.png"
},
{
"type": "input_text",
"text": "你看见了什么？"
},
],
}
],
thinking={"type": "enabled"},
reasoning={"effort": "low"}
)
print(response)
package main
import (
"context"
"fmt"
"os"
"github.com/samber/lo"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
"github.com/volcengine/volcengine-go-sdk/service/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.ItemInputMessage{
Role: responses.MessageRole_user,
Content: []*responses.ContentItem{
{
Union: &responses.ContentItem_Image{
Image: &responses.ContentItemImage{
Type: responses.ContentItemType_input_image,
ImageUrl: lo.ToPtr("https://ark-project.tos-cn-beijing.volces.com/doc_image/ark_demo_img_1.png"),
},
},
},
{
Union: &responses.ContentItem_Text{
Text: &responses.ContentItemText{
Type: responses.ContentItemType_input_text,
Text: "你看见了什么？",
},
},
},
},
}
resp, err := client.CreateResponses(ctx, &responses.ResponsesRequest{
Model: "doubao-seed-2-1-pro-260628",
Input: &responses.ResponsesInput{
Union: &responses.ResponsesInput_ListValue{
ListValue: &responses.InputItemList{ListValue: []*responses.InputItem{{
Union: &responses.InputItem_InputMessage{
InputMessage: inputMessage,
},
}}},
},
},
Thinking: &responses.ResponsesThinking{Type: responses.ThinkingType_enabled.Enum()},
Reasoning: &responses.ResponsesReasoning{Effort: responses.ReasoningEffort_low},
})
if err != nil {
fmt.Printf("response error: %v", err)
return
}
fmt.Println(resp)
}
package com.ark.example;
import com.volcengine.ark.runtime.model.responses.common.ResponsesReasoning;
import com.volcengine.ark.runtime.model.responses.common.ResponsesThinking;
import com.volcengine.ark.runtime.model.responses.content.InputContentItemImage;
import com.volcengine.ark.runtime.model.responses.content.InputContentItemText;
import com.volcengine.ark.runtime.model.responses.item.ItemEasyMessage;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.model.responses.request.*;
import com.volcengine.ark.runtime.model.responses.response.ResponseObject;
import com.volcengine.ark.runtime.model.responses.constant.ResponsesConstants;
import com.volcengine.ark.runtime.model.responses.item.MessageContent;
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();
CreateResponsesRequest request = CreateResponsesRequest.builder()
.model("doubao-seed-2-1-pro-260628")
.input(ResponsesInput.builder().addListItem(
ItemEasyMessage.builder().role(ResponsesConstants.MESSAGE_ROLE_USER).content(
MessageContent.builder()
.addListItem(InputContentItemImage.builder().imageUrl("https://ark-project.tos-cn-beijing.volces.com/doc_image/ark_demo_img_1.png").build())
.addListItem(InputContentItemText.builder().text("你看见了什么？").build())
.build()
).build()
).build())
.thinking(ResponsesThinking.builder().type(ResponsesConstants.THINKING_TYPE_ENABLED).build())
.reasoning(ResponsesReasoning.builder().effort("low").build())
.build();
ResponseObject resp = arkService.createResponse(request);
System.out.println(resp);
arkService.shutdownExecutor();
}
}
import os
from openai import OpenAI
# 从环境变量中获取您的API KEY，配置方法见：https://www.volcengine.com/docs/82379/1399008
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-260628",
input=[
{
"role": "user",
"content": [
{
"type": "input_image",
"image_url": "https://ark-project.tos-cn-beijing.volces.com/doc_image/ark_demo_img_1.png"
},
{
"type": "input_text",
"text": "你看见了什么？"
},
],
}
],
extra_body={
"thinking": {"type": "enabled"},
},
reasoning={"effort": "low"}
)
print(response)
设置最大输出长度
模型输出长度 = 思维链长度（如果有） + 回答长度
通过设置 max_output_tokens 字段调整模型输出长度，达到控制成本或输出指定篇幅的目的。
Curl
Python
Go
Java
OpenAI SDK
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-260628",
"input": "推理模型与非推理模型区别。",
"max_output_tokens": 1024
}'
import os
from volcenginesdkarkruntime import Ark
# Get API Key: https://console.volcengine.com/ark/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-260628",
input="推理模型与非推理模型区别。",
max_output_tokens=1024
)
print(response)
package main
import (
"context"
"fmt"
"os"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model/responses"
"github.com/volcengine/volcengine-go-sdk/volcengine"
)
func main() {
client := arkruntime.NewClientWithApiKey(
// Get API Key: https://console.volcengine.com/ark/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-260628",
Input: &responses.ResponsesInput{Union: &responses.ResponsesInput_StringValue{StringValue: "推理模型与非推理模型区别。"}},
MaxOutputTokens: volcengine.Int64(1024),
})
if err != nil {
fmt.Printf("response error: %v\n", err)
return
}
fmt.Println(resp)
}
package com.ark.example;
import com.volcengine.ark.runtime.service.ArkService;
import com.volcengine.ark.runtime.model.responses.request.*;
import com.volcengine.ark.runtime.model.responses.response.ResponseObject;
import com.volcengine.ark.runtime.model.responses.constant.ResponsesConstants;
import com.volcengine.ark.runtime.model.responses.common.ResponsesThinking;
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();
CreateResponsesRequest request = CreateResponsesRequest.builder()
.model("doubao-seed-2-1-pro-260628")
.input(ResponsesInput.builder().stringValue("推理模型与非推理模型区别。").build())
.maxOutputTokens(1024L)
.build();
ResponseObject resp = arkService.createResponse(request);
System.out.println(resp);
arkService.shutdownExecutor();
}
}
import os
from openai import OpenAI
# Get API Key: https://console.volcengine.com/ark/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-260628",
input="推理模型与非推理模型区别。",
max_output_tokens=1024
)
print(response)
工作原理
- 多轮对话场景
- 流程图说明流程图说明
- 在每一轮对话过程中，深度思考模型会输出思维链内容（CoT）和最终回答（Answer）。
- 在下一轮对话中，之前输出的思维链内容不会被拼接到上下文中。
思维链内容展现的是模型处理问题的过程，包括将问题拆分为多个问题进行处理，生成多种回复综合得出更好回答等过程。
- 工具调用场景（doubao-seed-1.8 及后续模型）
- 工具调用场景中开启深度思考后，为给出更详尽准确的回答，将不会直接丢弃思维链内容，历史轮次的思维链内容按需（模型自主判断）参与推理。在整个请求过程中，用户回传完整上下文即可，由服务端自行判断，是否保留思维链内容。未输入给模型的思维链内容，不会计算 token 用量。代码示例参见工具调用。
- 流程图说明流程图说明
- 回答问题 1 时（请求 1.1 - 1.2），模型进行多次思考 + 工具调用后给出答案，方舟会输入完整上下文包括思维链内容给模型处理。
- 开始回答问题2时（请求 2.1），方舟会自行判断并删除之前上下文中的思维链，输入给模型。
QPS 限流
接口名称 | 账号维度的 QPS 限流 |
接口名称 | 账号维度的 QPS 限流 |
创建模型响应 | 无 |
查询模型响应 | 20 |
列出输入项 | 20 |
删除模型响应 | 20 |
最近更新时间：2026.08.21 11:18:08
这个页面对您有帮助吗？
有用
有用
无用
无用