DeepSeek 新闻

图像理解

Invalid Date

deepseek-v4-flash-vision-exp 模型支持在文本之外输入图片，你可以让模型描述图片、识别截图中的文字、分析图表等。

支持的图片格式：JPEG、PNG、GIF、WebP。格式由文件实际内容判断，而非文件名或声明的 MIME 类型。

传入图片

共有三种方式向模型提供图片，均使用标准的 OpenAI 兼容对话补全格式，即 content 为一个块（block）数组，而非纯字符串。同样的三种方式也适用于 Responses API，图片以 input_image 内容块承载。

以下示例的 base_url 为 https://api.deepseek.com。

1. Base64 编码图片（内联）

将图片编码后以 data: URL 的形式直接嵌入请求。这是本地文件最简单的方式。编码后的数据会计入 48 MiB 请求体大小限制（见限制）。

import base64
from openai import OpenAI

client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

with open("image.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "这张图片里有什么？"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
                },
            ],
        }
    ],
)
print(response.choices[0].message.content)

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <DeepSeek API Key>" \
  -d '{
    "model": "deepseek-v4-flash-vision-exp",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "这张图片里有什么？"},
          {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,<BASE64_DATA>"}}
        ]
      }
    ]
  }'

2. 外部图片 URL

传入一个可公开访问的 http(s) 链接，模型会自动下载图片。URL 长度最多 8192 个字符，图片文件最大 32 MiB，且需在 60 秒内完成下载。如果链接超长，请改用 base64 data URL 或 Files API。

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "描述一下这张图片。"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/image.jpg"},
                },
            ],
        }
    ],
)
print(response.choices[0].message.content)

3. 引用通过 Files API 上传的文件

通过 Files API 上传一次图片，之后在请求中用其 file_id 引用。当你需要在多个请求中复用同一张图片，或图片会让请求体超过 48 MiB 内联限制时，这是最佳选择。与内联图片不同，通过 Files API file_id 引用的图片最大可达 64 MiB，且不受 32 MiB 单图检查限制。

使用 file 内容块，填入返回的 file_id（形如 file-api-...）：

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "这张图片里有什么？"},
                {"type": "file", "file_id": "file-api-xxxxxxxxxxxxxxxx"},
            ],
        }
    ],
)
print(response.choices[0].message.content)

此外，file 块也可以通过 file_data 以 base64 形式内联携带图片（file_data 与 file_id 二者互斥）：

{
  "type": "file",
  "file_data": "data:image/jpeg;base64,<BASE64_DATA>",
  "filename": "image.jpg"
}

细节级别（Detail Level）

对于 image_url 输入，你可以选填 detail 字段来控制图片的处理方式：

取值	行为
`low`	推理前将图片缩放到 512×512。当不需要精细视觉细节时更快、更省 token。
`high`	保留原图。（为兼容性提供，等价于 `original`。）
`original`	保留原图。
`auto`	自动选择。当前等价于 `original`。

{
  "type": "image_url",
  "image_url": {"url": "https://example.com/image.jpg", "detail": "low"}
}

何时使用 Files API

内联图片（base64 或 file_data）会计入 48 MiB 的请求体大小限制。以下情况建议使用 Files API：

单个请求会超过请求体大小限制。
图片超过 32 MiB（只有通过 Files API 才能使用）。
你在多个请求中引用同一张图片，希望避免每次重复上传。

Token 用量

图片会根据其尺寸换算成 token，并与文本 token 一起计费。

在进入模型前，每张图片都会被自动缩放：

总像素小于约 384×384 的图片会被保持长宽比放大；
更大的图片会被保持长宽比缩小，缩小后的总像素约相当于 800×800 的图片。

因此，每张图片消耗的 token 数存在上限（384 个）：例如 2000×2000 和 5000×5000 的图片，经缩放后消耗的 token 数是相同的。单个请求包含多张图片时，每张图片独立按同一规则计算，不存在额外的计算方式。

如需估算具体尺寸图片的 token 消耗，请使用 Token 与用量计算页面的图片 Token 计算器。

限制

限制项	数值
支持的格式	JPEG、PNG、GIF、WebP
外部 URL 长度	8192 个字符
请求体大小	48 MiB
单张图片最大大小（base64 / 外部 URL）	32 MiB
单张图片最大大小（Files API `file_id`）	64 MiB
单个请求最大图片数	600
单个请求图片总大小	不含 `file_id` 图片最多 64 MiB；包含 `file_id` 图片最高 200 MiB
图片最大尺寸	单边最长 8192 像素；单个请求包含 15 张及以上图片时，降为单边最长 4096 像素

Files API 上传文件的存储与上传配额见 Files API：限制。

使用限制

图片仅支持出现在 user 消息中：system 或 assistant 消息携带图片会返回 400 错误。
仅视觉模型（deepseek-v4-flash-vision-exp）接受图片，其他模型会返回 400 错误（“This model does not support image”）。
用户文本包含保留的图片占位 token 会被拒绝并返回 400 错误。

在 Anthropic API 中使用图片

除了上面的 OpenAI 兼容端点，你也可以通过 Anthropic 兼容的 /messages 端点发送图片（base_url 为 https://api.deepseek.com/anthropic）。基础配置请参考 Anthropic API。

区别在于图片内容块的结构。Anthropic 不使用 image_url，而是使用 image 块，其 source 对象的 type 为 base64、url 或 file 之一：

import anthropic

client = anthropic.Anthropic()  # ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic

message = client.messages.create(
    model="deepseek-v4-flash-vision-exp",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "这张图片里有什么？"},
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": "<BASE64_DATA>",
                    },
                },
            ],
        }
    ],
)
print(message.content)

三种 source 变体与上面的 OpenAI 方式一一对应：

`source.type`	对应的 OpenAI 方式	说明
`base64`	Base64 编码图片	需要 `media_type` 字段（`image/jpeg`、`image/png`、`image/gif` 或 `image/webp`）。
`url`	外部图片 URL	最多 8192 个字符。
`file`	Files API `file_id`	需要请求头 `anthropic-beta: files-api-2025-04-14`。

在 Responses API 中使用图片

deepseek-v4-flash-vision-exp 模型同样支持通过 OpenAI 兼容的 Responses API 传入图片。三种传入方式（base64 data URL、外部 http(s) URL、Files API file_id）与限制均与上文一致，只有内容块的结构不同——图片以 input_image 内容块承载，可出现在 user / developer 消息或 function_call_output / custom_tool_call_output item 的 output 中：

response = client.responses.create(
    model="deepseek-v4-flash-vision-exp",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "这张图片里有什么？"},
                {"type": "input_image", "image_url": "https://example.com/image.jpg", "detail": "low"},
            ],
        }
    ],
)
print(response.output_text)

input_image 内容块支持 detail 字段，语义与上文一致（low / high / original / auto）。通过 file_id 传图时 detail 被忽略；image_url 与 file_id 互斥。

字段语义、使用限制（system / assistant 消息中的图片会返回 400 错误）以及工具输出中的图片，请参阅 Responses API 指南。

思考模式

Invalid Date

DeepSeek 模型支持思考模式：在输出最终回答之前，模型会先输出一段思维链内容，以提升最终答案的准确性。

思考模式开关与思考强度控制

控制参数（OpenAI 格式）控制参数（Anthropic 格式）控制参数（Responses API 格式）
思考模式开关⁽¹⁾ {"thinking": {"type": "enabled/disabled"}} {"reasoning": {"effort": "none/low/high/max"}}
(none 表示关闭思考模式)
思考强度控制⁽²⁾ {"reasoning_effort": "low/high/max"} {"output_config": {"effort": "low/high/max"}}

(1) 思考模式默认打开，且 effort 默认为 high
(2) 用户设置的 effort 与模型推理 effort 映射表如下（deepseek-v4-flash 与 deepseek-v4-pro 一致）：

请求传入 effort	实际映射 effort
low	low
medium	high
high	high
xhigh	high
max	max

您在 OpenAI SDK 中使用 Chat Completion 设置 thinking 参数时，需要将 thinking 参数传入 extra_body 中：

response = client.chat.completions.create(
  model="deepseek-v4-pro",
  # ...
  reasoning_effort="high",
  extra_body={"thinking": {"type": "enabled"}}
)

输入输出参数

思考模式不支持 temperature、top_p、presence_penalty、frequency_penalty 参数。请注意，为了兼容已有软件，设置参数不会报错，但也不会生效。

在思考模式下，思维链内容通过 reasoning_content 参数返回，与 content 同级。在后续轮次的请求中，reasoning_content 是否需要回传、是否会被拼接进上下文，取决于请求是否携带 tools 参数：

若请求携带 tools 参数：历史轮次的 reasoning_content 均应回传给 API，并会被拼接进上下文。详见工具调用。
若请求未携带 tools 参数：reasoning_content 无需回传；即使传入 API，也会被忽略，不会拼接进上下文。详见多轮对话拼接。

多轮对话拼接

在每一轮对话过程中，模型会输出思维链内容（reasoning_content）和最终回答（content）。如果请求未携带 tools 参数，则在下一轮对话中，之前轮输出的思维链内容不会被拼接到上下文中，如下图所示：

样例代码

下面的代码以 Python 语言为例，展示了如何访问思维链和最终回答，以及如何在多轮对话中进行上下文拼接。

非流式
流式

from openai import OpenAI
client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

# Turn 1
messages = [{"role": "user", "content": "9.11 and 9.8, which is greater?"}]
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    reasoning_effort="high"
    extra_body={"thinking": {"type": "enabled"}},
)

reasoning_content = response.choices[0].message.reasoning_content
content = response.choices[0].message.content

# Turn 2
# The reasoning_content will be ignored by the API
messages.append(response.choices[0].message)
messages.append({'role': 'user', 'content': "How many Rs are there in the word 'strawberry'?"})
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    reasoning_effort="high"
    extra_body={"thinking": {"type": "enabled"}},
)
# ...

from openai import OpenAI
client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

# Turn 1
messages = [{"role": "user", "content": "9.11 and 9.8, which is greater?"}]
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    stream=True,
    reasoning_effort="high"
    extra_body={"thinking": {"type": "enabled"}},
)

reasoning_content = ""
content = ""

for chunk in response:
    if chunk.choices[0].delta.reasoning_content:
        reasoning_content += chunk.choices[0].delta.reasoning_content
    else:
        content += chunk.choices[0].delta.content

# Turn 2
# The reasoning_content will be ignored by the API
messages.append({"role": "assistant", "reasoning_content": reasoning_content, "content": content})
messages.append({'role': 'user', 'content': "How many Rs are there in the word 'strawberry'?"})
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    stream=True,
    reasoning_effort="high"
    extra_body={"thinking": {"type": "enabled"}},
)
# ...

工具调用

DeepSeek 模型的思考模式支持工具调用功能。模型在输出最终答案之前，可以进行多轮的思考与工具调用，以提升答案的质量。其调用模式如下图所示：

请注意，携带了 tools 参数的请求，在后续所有请求中，必须完整回传 reasoning_content 给 API——即使该轮模型未实际进行工具调用。若您的代码中未正确回传 reasoning_content，API 会返回 400 报错。正确回传方法请您参考下面的样例代码。

样例代码

下面是一个简单的在思考模式下进行工具调用的样例代码：

import os
import json
from openai import OpenAI
from datetime import datetime

# The definition of the tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_date",
            "description": "Get the current date",
            "parameters": { "type": "object", "properties": {} },
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply the location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": { "type": "string", "description": "The city name" },
                    "date": { "type": "string", "description": "The date in format YYYY-mm-dd" },
                },
                "required": ["location", "date"]
            },
        }
    },
]

# The mocked version of the tool calls
def get_date_mock():
    return datetime.now().strftime("%Y-%m-%d")

def get_weather_mock(location, date):
    return "Cloudy 7~13°C"

TOOL_CALL_MAP = {
    "get_date": get_date_mock,
    "get_weather": get_weather_mock
}

def run_turn(turn, messages):
    sub_turn = 1
    while True:
        response = client.chat.completions.create(
            model='deepseek-v4-pro',
            messages=messages,
            tools=tools,
            reasoning_effort="high",
            extra_body={ "thinking": { "type": "enabled" } },
        )
        messages.append(response.choices[0].message)
        reasoning_content = response.choices[0].message.reasoning_content
        content = response.choices[0].message.content
        tool_calls = response.choices[0].message.tool_calls
        print(f"Turn {turn}.{sub_turn}\n{reasoning_content=}\n{content=}\n{tool_calls=}")
        # If there is no tool calls, then the model should get a final answer and we need to stop the loop
        if tool_calls is None:
            break
        for tool in tool_calls:
            tool_function = TOOL_CALL_MAP[tool.function.name]
            tool_result = tool_function(**json.loads(tool.function.arguments))
            print(f"tool result for {tool.function.name}: {tool_result}\n")
            messages.append({
                "role": "tool",
                "tool_call_id": tool.id,
                "content": tool_result,
            })
        sub_turn += 1
    print()

client = OpenAI(
    api_key=os.environ.get('DEEPSEEK_API_KEY'),
    base_url=os.environ.get('DEEPSEEK_BASE_URL'),
)

# The user starts a question
turn = 1
messages = [{
    "role": "user",
    "content": "How's the weather in Hangzhou Tomorrow"
}]
run_turn(turn, messages)

# The user starts a new question
turn = 2
messages.append({
    "role": "user",
    "content": "How's the weather in Guangzhou Tomorrow"
})
run_turn(turn, messages)

在 Turn 1 的每个子请求中，都携带了该 Turn 下产生的 reasoning_content 给 API，从而让模型继续之前的思考。response.choices[0].message 携带了 assistant 消息的所有必要字段，包括 content、reasoning_content、tool_calls。简单起见，可以直接用如下代码将消息 append 到 messages 结尾：

messages.append(response.choices[0].message)

这行代码等价于：

messages.append({
    'role': 'assistant',
    'content': response.choices[0].message.content,
    'reasoning_content': response.choices[0].message.reasoning_content,
    'tool_calls': response.choices[0].message.tool_calls,
})

且在 Turn 2 的请求中，我们仍然携带着 Turn1 所产生的 reasoning_content 给 API。

该代码的样例输出如下：

Turn 1.1
reasoning_content="The user is asking about the weather in Hangzhou tomorrow. I need to get tomorrow's date first, then call the weather function."
content="Let me check tomorrow's weather in Hangzhou for you. First, let me get tomorrow's date."
tool_calls=[ChatCompletionMessageFunctionToolCall(id='call_00_kw66qNnNto11bSfJVIdlV5Oo', function=Function(arguments='{}', name='get_date'), type='function', index=0)]
tool result for get_date: 2026-04-19

Turn 1.2
reasoning_content="Today is 2026-04-19, so tomorrow is 2026-04-20. Now I'll call the weather function for Hangzhou."
content=''
tool_calls=[ChatCompletionMessageFunctionToolCall(id='call_00_H2SCW6136vWJGq9SQlBuhVt4', function=Function(arguments='{"location": "Hangzhou", "date": "2026-04-20"}', name='get_weather'), type='function', index=0)]
tool result for get_weather: Cloudy 7~13°C

Turn 1.3
reasoning_content='The weather result is in. Let me share this with the user.'
content="Here's the weather forecast for **Hangzhou tomorrow (April 20, 2026)**:\n\n- 🌤 **Condition:** Cloudy  \n- 🌡 **Temperature:** 7°C ~ 13°C (45°F ~ 55°F)\n\nIt'll be on the cooler side, so you might want to bring a light jacket if you're heading out! Let me know if you need anything else."
tool_calls=None

Turn 2.1
reasoning_content='The user is asking about the weather in Guangzhou tomorrow. Today is 2026-04-19, so tomorrow is 2026-04-20. I can directly call the weather function.'
content=''
tool_calls=[ChatCompletionMessageFunctionToolCall(id='call_00_8URkLt5NjmNkVKhDmMcNq9Mo', function=Function(arguments='{"location": "Guangzhou", "date": "2026-04-20"}', name='get_weather'), type='function', index=0)]
tool result for get_weather: Cloudy 7~13°C

Turn 2.2
reasoning_content='The weather result for Guangzhou is the same as Hangzhou. Let me share this with the user.'
content="Here's the weather forecast for **Guangzhou tomorrow (April 20, 2026)**:\n\n- 🌤 **Condition:** Cloudy  \n- 🌡 **Temperature:** 7°C ~ 13°C (45°F ~ 55°F)\n\nIt'll be cool and cloudy, so a light jacket would be a good idea if you're going out. Let me know if there's anything else you'd like to know!"
tool_calls=None

多轮对话

Invalid Date

本指南将介绍如何使用 DeepSeek /chat/completions API 进行多轮对话。

DeepSeek /chat/completions API 是一个“无状态” API，即服务端不记录用户请求的上下文，用户在每次请求时，需将之前所有对话历史拼接好后，传递给对话 API。

下面的代码以 Python 语言，展示了如何进行上下文拼接，以实现多轮对话。

from openai import OpenAI
client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

# Round 1
messages = [{"role": "user", "content": "What's the highest mountain in the world?"}]
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages
)

messages.append(response.choices[0].message)
print(f"Messages Round 1: {messages}")

# Round 2
messages.append({"role": "user", "content": "What is the second?"})
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages
)

messages.append(response.choices[0].message)
print(f"Messages Round 2: {messages}")

在第一轮请求时，传递给 API 的 messages 为：

[
    {"role": "user", "content": "What's the highest mountain in the world?"}
]

在第二轮请求时：

要将第一轮中模型的输出添加到 messages 末尾
将新的提问添加到 messages 末尾

最终传递给 API 的 messages 为：

[
    {"role": "user", "content": "What's the highest mountain in the world?"},
    {"role": "assistant", "content": "The highest mountain in the world is Mount Everest."},
    {"role": "user", "content": "What is the second?"}
]

对话前缀续写（Beta）

Invalid Date

对话前缀续写沿用 Chat Completion API，用户提供 assistant 开头的消息，来让模型补全其余的消息。

注意事项

使用对话前缀续写时，用户需确保 messages 列表里最后一条消息的 role 为 assistant，并设置最后一条消息的 prefix 参数为 True。
用户需要设置 base_url="https://api.deepseek.com/beta" 来开启 Beta 功能。

样例代码

下面给出了对话前缀续写的完整 Python 代码样例。在这个例子中，我们设置 assistant 开头的消息为 "```python\n" 来强制模型输出 python 代码，并设置 stop 参数为 ['```'] 来避免模型的额外解释。

from openai import OpenAI

client = OpenAI(
    api_key="<your api key>",
    base_url="https://api.deepseek.com/beta",
)

messages = [
    {"role": "user", "content": "Please write quick sort code"},
    {"role": "assistant", "content": "```python\n", "prefix": True}
]
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    stop=["```"],
)
print(response.choices[0].message.content)

FIM 补全（Beta）

Invalid Date

在 FIM (Fill In the Middle) 补全中，用户可以提供前缀和后缀（可选），模型来补全中间的内容。FIM 常用于内容续写、代码补全等场景。

注意事项

模型的最大补全长度为 4K。
用户需要设置 base_url="https://api.deepseek.com/beta" 来开启 Beta 功能。

样例代码

下面给出了 FIM 补全的完整 Python 代码样例。在这个例子中，我们给出了计算斐波那契数列函数的开头和结尾，来让模型补全中间的内容。

from openai import OpenAI

client = OpenAI(
    api_key="<your api key>",
    base_url="https://api.deepseek.com/beta",
)

response = client.completions.create(
    model="deepseek-v4-pro",
    prompt="def fib(a):",
    suffix="    return fib(a-1) + fib(a-2)",
    max_tokens=128
)
print(response.choices[0].text)

配置 Continue 代码补全插件

Continue 是一款支持代码补全的 VSCode 插件，您可以参考这篇文档来配置 Continue 以使用代码补全功能。

JSON Output

Invalid Date

在很多场景下，用户需要让模型严格按照 JSON 格式来输出，以实现输出的结构化，便于后续逻辑进行解析。

DeepSeek 提供了 JSON Output 功能，来确保模型输出合法的 JSON 字符串。

注意事项

设置 response_format 参数为 {'type': 'json_object'}。
用户传入的 system 或 user prompt 中必须含有 json 字样，并给出希望模型输出的 JSON 格式的样例，以指导模型来输出合法 JSON。
需要合理设置 max_tokens 参数，防止 JSON 字符串被中途截断。
在使用 JSON Output 功能时，API 有概率会返回空的 content。我们正在积极优化该问题，您可以尝试修改 prompt 以缓解此类问题。

样例代码

这里展示了使用 JSON Output 功能的完整 Python 代码：

import json
from openai import OpenAI

client = OpenAI(
    api_key="<your api key>",
    base_url="https://api.deepseek.com",
)

system_prompt = """
The user will provide some exam text. Please parse the "question" and "answer" and output them in JSON format. 

EXAMPLE INPUT: 
Which is the highest mountain in the world? Mount Everest.

EXAMPLE JSON OUTPUT:
{
    "question": "Which is the highest mountain in the world?",
    "answer": "Mount Everest"
}
"""

user_prompt = "Which is the longest river in the world? The Nile River."

messages = [{"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    response_format={
        'type': 'json_object'
    }
)

print(json.loads(response.choices[0].message.content))

模型将会输出：

{
    "question": "Which is the longest river in the world?",
    "answer": "The Nile River"
}

Tool Calls

Invalid Date

Tool Calls 让模型能够调用外部工具，来增强自身能力。

非思考模式

样例代码

这里以获取用户当前位置的天气信息为例，展示了使用 Tool Calls 的完整 Python 代码。

Tool Calls 的具体 API 格式请参考对话补全文档。

from openai import OpenAI

def send_messages(messages):
    response = client.chat.completions.create(
        model="deepseek-v4-pro",
        messages=messages,
        tools=tools
    )
    return response.choices[0].message

client = OpenAI(
    api_key="<your api key>",
    base_url="https://api.deepseek.com",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather of a location, the user should supply a location first.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    }
                },
                "required": ["location"]
            },
        }
    },
]

messages = [{"role": "user", "content": "How's the weather in Hangzhou, Zhejiang?"}]
message = send_messages(messages)
print(f"User>\t {messages[0]['content']}")

tool = message.tool_calls[0]
messages.append(message)

messages.append({"role": "tool", "tool_call_id": tool.id, "content": "24℃"})
message = send_messages(messages)
print(f"Model>\t {message.content}")

这个例子的执行流程如下：

用户：询问现在的天气
模型：返回 function get_weather({location: 'Hangzhou'})
用户：调用 function get_weather({location: 'Hangzhou'})，并传给模型。
模型：返回自然语言，"The current temperature in Hangzhou is 24°C."

注：上述代码中 get_weather 函数功能需由用户提供，模型本身不执行具体函数。

思考模式

从 DeepSeek-V3.2 开始，API 支持了思考模式下的工具调用能力，详见思考模式。

`strict` 模式（Beta）

在 strict 模式下，模型在输出 Function 调用时会严格遵循 Function 的 JSON Schema 的格式要求，以确保模型输出的 Function 符合用户的定义。在思考与非思考模式下的工具调用，均可使用 strict 模式。

要使用 strict 模式，需要：

用户需要设置 base_url="https://api.deepseek.com/beta" 来开启 Beta 功能
在传入的 tools 列表中，所有 function 均需设置 strict 属性为 true
服务端会对用户传入的 Function 的 JSON Schema 进行校验，如不符合规范，或遇到服务端不支持的 JSON Schema 类型，将返回错误信息

以下是 strict 模式下 tool 的定义样例：

{
    "type": "function",
    "function": {
        "name": "get_weather",
        "strict": true,
        "description": "Get weather of a location, the user should supply a location first.",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA",
                }
            },
            "required": ["location"],
            "additionalProperties": false
        }
    }
}

`strict` 模式支持的 JSON Schema 类型

object
string
number
integer
boolean
array
enum
anyOf

object 类型

object 定义一个包含键值对的深层结构，其中 properties 定义了对象中每个键（属性）的 schema。每个 object 的所有属性均需设置为 required，且 object 中 additionalProperties 属性必须为 false。

示例：

{
    "type": "object",
    "properties": {
        "name": { "type": "string" },
        "age": { "type": "integer" }
    },
    "required": ["name", "age"],
    "additionalProperties": false
}

string 类型

支持的参数：
- pattern：使用正则表达式来约束字符串的格式
- format：使用预定义的常见格式进行校验，目前支持：
  - email：电子邮件地址
  - hostname：主机名
  - ipv4：IPv4 地址
  - ipv6：IPv6 地址
  - uuid：uuid
不支持的参数
- minLength
- maxLength

示例：

{
    "type": "object",
    "properties": {
        "user_email": {
            "type": "string",
            "description": "The user's email address",
            "format": "email" 
        },
        "zip_code": {
            "type": "string",
            "description": "Six digit postal code",
            "pattern": "^\\d{6}$"
        }
    }
}

number/integer 类型

支持的参数
- const：固定数字为常数
- default：数字的默认值
- minimum：最小值
- maximum：最大值
- exclusiveMinimum：不小于
- exclusiveMaximum：不大于
- multipleOf：数字输出为这个值的倍数

示例：

{
    "type": "object",
    "properties": {
        "score": {
            "type": "integer",
            "description": "A number from 1-5, which represents your rating, the higher, the better",
            "minimum": 1,
            "maximum": 5
        }
    },
    "required": ["score"],
    "additionalProperties": false
}

array 类型

不支持的参数
- minItems
- maxItems

示例：

{
    "type": "object",
    "properties": {
        "keywords": {
            "type": "array",
            "description": "Five keywords of the article, sorted by importance",
            "items": {
                "type": "string",
                "description": "A concise and accurate keyword or phrase."
            }
        }
    },
    "required": ["keywords"],
    "additionalProperties": false
}

enum

enum 可以确保输出是预期的几个选项之一，例如在订单状态的场景下，只能是有限几个状态之一。

样例：

{
    "type": "object",
    "properties": {
        "order_status": {
            "type": "string",
            "description": "Ordering status",
            "enum": ["pending", "processing", "shipped", "cancelled"]
        }
    }
}

anyOf

匹配所提供的多个 schema 中的任意一个，可以处理可能具有多种有效格式的字段，例如用户的账户可能是邮箱或者手机号中的一个：

{
    "type": "object",
    "properties": {
    "account": {
        "anyOf": [
            { "type": "string", "format": "email", "description": "可以是电子邮件地址" },
            { "type": "string", "pattern": "^\\d{11}$", "description": "或11位手机号码" }
        ]
    }
  }
}

$ref 和 $def

可以使用 $def 定义模块，再用 $ref 引用以减少模式的重复和模块化，此外还可以单独使用 $ref 定义递归结构。

{
    "type": "object",
    "properties": {
        "report_date": {
            "type": "string",
            "description": "The date when the report was published"
        },
        "authors": {
            "type": "array",
            "description": "The authors of the report",
            "items": {
                "$ref": "#/$def/author"
            }
        }
    },
    "required": ["report_date", "authors"],
    "additionalProperties": false,
    "$def": {
        "author": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string",
                    "description": "author's name"
                },
                "institution": {
                    "type": "string",
                    "description": "author's institution"
                },
                "email": {
                    "type": "string",
                    "format": "email",
                    "description": "author's email"
                }
            },
            "additionalProperties": false,
            "required": ["name", "institution", "email"]
        }
    }
}

Files API

Invalid Date

Files API 让你上传图片，之后通过 file_id 引用。推荐在以下场景使用：

在多个请求中复用同一张图片，无需重复上传。
发送会超过 48 MiB 请求体限制或 32 MiB 单图内联限制的图片（见图像理解：限制）。

上传的文件与 deepseek-v4-flash-vision-exp 模型配合使用。如何在对话请求中引用已上传的文件，请参考图像理解。

支持的格式：JPEG、PNG、GIF、WebP。格式由文件实际内容判断。

以下示例的 base_url 为 https://api.deepseek.com。

上传文件

通过 multipart/form-data 请求向 POST /files 上传文件。单个文件最大 64 MiB，上传需在 10 分钟内完成。

表单字段：

字段	是否必填	说明
`file`	是	要上传的图片文件。
`purpose`	是	必须为 `user_data`。
`expires_after[anchor]`	否	若提供，必须为 `created_at`。需与 `expires_after[seconds]` 一起使用。
`expires_after[seconds]`	否	有效期（秒），取值在 `3600` 到 `2592000` 之间（1 小时到 30 天）。不传这两个 `expires_after` 字段则文件永久有效。

from openai import OpenAI

client = OpenAI(api_key="<DeepSeek API Key>", base_url="https://api.deepseek.com")

with open("image.jpg", "rb") as f:
    uploaded = client.files.create(file=f, purpose="user_data")

print(uploaded.id)  # file-api-xxxxxxxxxxxxxxxx

curl https://api.deepseek.com/files \
  -H "Authorization: Bearer <DeepSeek API Key>" \
  -F purpose="user_data" \
  -F file="@image.jpg"

响应描述了已存储的文件：

{
  "id": "file-api-xxxxxxxxxxxxxxxx",
  "object": "file",
  "bytes": 102400,
  "created_at": 1700000000,
  "filename": "image.jpg",
  "purpose": "user_data",
  "expires_at": 1700003600
}

只有在上传时设置了有效期，expires_at 才会出现。

列出文件

files = client.files.list()
for f in files.data:
    print(f.id, f.filename)

curl https://api.deepseek.com/files \
  -H "Authorization: Bearer <DeepSeek API Key>"

查询参数：

参数	说明
`after`	用于分页的 `file_id` 游标；返回此文件之后的文件。
`limit`	返回的文件数量，取值在 `1` 到 `1000` 之间。
`order`	按创建时间排序：`asc`（默认）或 `desc`。
`purpose`	按用途过滤。仅支持 `user_data`。

响应为分页列表：

{
  "object": "list",
  "data": [
    {
      "id": "file-api-xxxxxxxxxxxxxxxx",
      "object": "file",
      "bytes": 102400,
      "created_at": 1700000000,
      "filename": "image.jpg",
      "purpose": "user_data"
    }
  ],
  "first_id": "file-api-xxxxxxxxxxxxxxxx",
  "last_id": "file-api-xxxxxxxxxxxxxxxx",
  "has_more": false
}

查询文件信息

info = client.files.retrieve("file-api-xxxxxxxxxxxxxxxx")
print(info.filename, info.bytes)

curl https://api.deepseek.com/files/file-api-xxxxxxxxxxxxxxxx \
  -H "Authorization: Bearer <DeepSeek API Key>"

删除文件

client.files.delete("file-api-xxxxxxxxxxxxxxxx")

curl -X DELETE https://api.deepseek.com/files/file-api-xxxxxxxxxxxxxxxx \
  -H "Authorization: Bearer <DeepSeek API Key>"

{
  "id": "file-api-xxxxxxxxxxxxxxxx",
  "object": "file",
  "deleted": true
}

在对话请求中使用已上传的文件

使用 file 内容块引用返回的 file_id：

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "这张图片里有什么？"},
                {"type": "file", "file_id": "file-api-xxxxxxxxxxxxxxxx"},
            ],
        }
    ],
)
print(response.choices[0].message.content)

文件归属于你的 API key，可被任一 API 家族引用。注意：通过 Anthropic 兼容 /messages 端点引用文件时需携带 anthropic-beta: files-api-2025-04-14 请求头。

与内联（base64）图片不同，通过 file_id 引用的文件不受 32 MiB 单图限制，请求中单张最大 64 MiB。

file 块也可以通过 file_data 以 base64 形式内联携带图片，替代 file_id（二者互斥）。使用 file_data 时还可设置 filename；filename 不能与 file_id 同时出现。

Anthropic 兼容 Files API

同样的文件操作也可通过 Anthropic 兼容端点使用，base_url 为 https://api.deepseek.com/anthropic。所有请求必须带请求头 anthropic-beta: files-api-2025-04-14。

端点位于 /anthropic/v1/ 路径下：Anthropic SDK 设置上述 base URL 时会自动补上 /v1；直接用 curl 等裸 HTTP 客户端时需要写完整路径。

这些端点（POST /anthropic/v1/files、GET /anthropic/v1/files、GET /anthropic/v1/files/{file_id}、DELETE /anthropic/v1/files/{file_id}）遵循 Anthropic Files API 的形态，与上文 OpenAI 兼容版本存在差异：

	OpenAI 兼容	Anthropic 兼容
列表分页	`after`	`after_id` / `before_id`（互斥）
列表 `limit`	1–1000，默认 1000	1–1000，默认 20
列表 `order` / `purpose`	支持	不支持
列表顶层 `object`	`"list"`	无
文件对象大小字段	`bytes`	`size_bytes`
文件对象类型字段	`object`	`type`
`created_at`	Unix 时间戳（秒）	RFC 3339 字符串
必需请求头	无	`anthropic-beta: files-api-2025-04-14`

Anthropic 兼容端点返回的文件对象形如：

{
  "id": "file-api-xxxxxxxxxxxxxxxx",
  "type": "file",
  "size_bytes": 102400,
  "created_at": "2026-01-01T00:00:00+00:00",
  "filename": "image.jpg",
  "mime_type": "image/jpeg"
}

使用 after_id / before_id 游标列出文件：

curl "https://api.deepseek.com/anthropic/v1/files?limit=20" \
  -H "x-api-key: <DeepSeek API Key>" \
  -H "anthropic-beta: files-api-2025-04-14"

{
  "data": [
    {
      "id": "file-api-xxxxxxxxxxxxxxxx",
      "type": "file",
      "size_bytes": 102400,
      "created_at": "2026-01-01T00:00:00+00:00",
      "filename": "image.jpg",
      "mime_type": "image/jpeg"
    }
  ],
  "first_id": "file-api-xxxxxxxxxxxxxxxx",
  "last_id": "file-api-xxxxxxxxxxxxxxxx",
  "has_more": false
}

删除文件返回 { "id": "...", "type": "file_deleted" }。

限制

限制项	数值
支持的格式	JPEG、PNG、GIF、WebP
单个上传文件最大大小	64 MiB
文件名最大长度	512 个字符
单用户最大存储空间	25 GiB
单用户最大存储文件数	10000
文件有效期范围	1 小时到 30 天，或不传 `expires_after` 永久有效

上下文硬盘缓存

Invalid Date

DeepSeek API 上下文硬盘缓存技术对所有用户默认开启，用户无需修改代码即可享用。

用户的每一个请求都会触发硬盘缓存的构建。若后续请求与之前的请求在前缀上存在重复，则重复部分只需要从缓存中拉取，计入“缓存命中”。

缓存落盘与命中规则

缓存命中的前提是相应前缀已被“落盘”（写入硬盘缓存）。受 Sliding Window Attention 机制的影响，缓存前缀的存取与判别与之前有所不同。每条缓存前缀是一个独立的完整单元。后续请求只有在完整匹配缓存前缀单元时，才能命中缓存。

缓存前缀落盘时机：

请求结束位置落盘：每次请求的用户输入结束位置与模型输出结束位置，会产生两个缓存前缀单元。后续请求若完整匹配了它们，则可命中。
公共前缀检测落盘：当系统检测到多次请求之间存在公共前缀时，会将该公共前缀作为一个独立的缓存前缀单元进行落盘。后续请求若完整复用了该缓存前缀单元，则可命中。
按固定 token 间隔落盘：在长输入或长输出中，系统会以一定的 token 数量为间隔，截取缓存前缀单元，避免长前缀因迟迟未达到结束位置而完全无法被缓存。

举例 1：用户第一轮请求内容为 A + B，第二轮请求内容为 A + B + C，则第二轮请求能完整匹配 A + B 这个缓存前缀单元，可以命中 A + B 的缓存。详见下文例一。

举例 2：用户第一轮请求的内容为 A + B，第二轮请求的内容为 A + C，则第二轮请求无法命中缓存，因为 A + C 不能完整匹配第一轮的缓存前缀单元（A + B）。但此时系统会识别到两轮请求存在公共前缀 A，并将 A 作为缓存前缀单元落盘。当第三轮请求 A + D 到来时，能完整匹配 A 这个缓存前缀单元，可以命中 A 的缓存。详见下文例二。

例一：多轮对话

第一次请求

messages: [
    {"role": "system", "content": "你是一位乐于助人的助手"},
    {"role": "user", "content": "中国的首都是哪里？"}
]

第二次请求

messages: [
    {"role": "system", "content": "你是一位乐于助人的助手"},
    {"role": "user", "content": "中国的首都是哪里？"},
    {"role": "assistant", "content": "中国的首都是北京。"},
    {"role": "user", "content": "美国的首都是哪里？"}
]

在上例中，第二次请求可以完整复用第一次请求的缓存前缀单元，这部分会计入“缓存命中”。

例二：长文本问答

第一次请求

messages: [
    {"role": "system", "content": "你是一位资深的财报分析师..."}
    {"role": "user", "content": "<财报内容>\n\n请总结一下这份财报的关键信息。"}
]

第二次请求

messages: [
    {"role": "system", "content": "你是一位资深的财报分析师..."}
    {"role": "user", "content": "<财报内容>\n\n请分析一下这份财报的盈利情况。"}
]

第三次请求

messages: [
    {"role": "system", "content": "你是一位资深的财报分析师..."}
    {"role": "user", "content": "<财报内容>\n\n请分析一下公司收入与支出占比。"}
]

在上例中，前两次请求不会命中缓存。前两次请求完成后，系统会识别出 system 消息 + user 消息中的<财报内容>为缓存前缀单元，并进行落盘。在第三次请求中，由于完整匹配了前面落盘的缓存前缀单元，则可命中缓存。

查看缓存命中情况

在 DeepSeek API 的返回中，我们在 usage 字段中增加了两个字段，来反映请求的缓存命中情况：

prompt_cache_hit_tokens：本次请求的输入中，缓存命中的 tokens 数
prompt_cache_miss_tokens：本次请求的输入中，缓存未命中的 tokens 数

硬盘缓存与输出随机性

硬盘缓存只匹配到用户输入的前缀部分，输出仍然是通过计算推理得到的，仍然受到 temperature 等参数的影响，从而引入随机性。其输出效果与不使用硬盘缓存相同。

其它说明

缓存系统是“尽力而为”，不保证 100% 缓存命中
缓存构建耗时为秒级。缓存不再使用后会自动被清空，时间一般为几个小时到几天

使用 Responses API

Invalid Date

为了满足大家对 Codex 的需求，我们的 API 新增了对 Responses API 格式的支持，其 base_url 为 https://api.deepseek.com。

通过简单的配置，即可在 Codex 中使用 DeepSeek 模型。

将 DeepSeek 模型接入 Codex

请参考接入 Codex

通过 Responses API 调用 DeepSeek 模型

# Please install OpenAI SDK first: `pip3 install openai`
from openai import OpenAI

client = OpenAI(api_key="<your DeepSeek API Key>", base_url="https://api.deepseek.com")

response = client.responses.create(
    model="deepseek-v4-flash",
    instructions="You are a helpful assistant.",
    input="Hi, how are you?",
)

print(response.output_text)

流式输出

设置 stream: true，响应将以语义化的流式 SSE 事件序列返回。每个事件带有表示事件类型的 event 字段和递增的 sequence_number。流以 response.completed / response.incomplete / response.failed 事件结束，没有 data: [DONE] 消息。

stream = client.responses.create(
    model="deepseek-v4-flash",
    instructions="You are a helpful assistant.",
    input="Hi, how are you?",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

完整事件列表：

事件	说明
`response.created`	首个事件；响应已创建，状态为 `in_progress`
`response.in_progress`	响应正在生成中
`response.output_item.added` / `response.output_item.done`	一个输出 item（`reasoning` / `message` / `function_call` / `custom_tool_call` / `web_search_call`）开始 / 完成
`response.content_part.added` / `response.content_part.done`	输出 item 中的一个内容块开始 / 完成
`response.reasoning_text.delta` / `response.reasoning_text.done`	思维链文本增量 / 完整思维链文本
`response.output_text.delta` / `response.output_text.done`	输出文本增量 / 完整输出文本
`response.function_call_arguments.delta` / `response.function_call_arguments.done`	Function 调用参数增量 / 完整参数
`response.custom_tool_call_input.delta` / `response.custom_tool_call_input.done`	Custom 工具调用（`apply_patch`）输入增量 / 完整输入
`response.web_search_call.in_progress` / `response.web_search_call.searching` / `response.web_search_call.completed`	服务端联网搜索工具调用的状态更新
`response.completed`	响应正常完成时的最后一个事件，携带包含 `usage` 的完整 `response` 对象
`response.incomplete`	响应被截断（如达到 `max_output_tokens`）时的最后一个事件，携带完整 `response` 对象
`response.failed`	响应失败时的最后一个事件，携带含 `error` 详情的完整 `response` 对象

图片输入

Responses API 支持使用 deepseek-v4-flash-vision-exp 模型传入图片，适用的图片限制与支持格式与对话补全一致。

图片通过 message item 中的 input_image 内容块提供，使用 image_url（http(s) URL 或 base64 data URL）或 file_id（通过 Files API 上传的图片）二者之一：

response = client.responses.create(
    model="deepseek-v4-flash-vision-exp",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "这张图片里有什么？"},
                {"type": "input_image", "image_url": "https://example.com/image.jpg", "detail": "low"},
            ],
        }
    ],
)
print(response.output_text)

input_image 内容块也可以出现在 function_call_output / custom_tool_call_output item 的 output 中，让模型接收你的工具生成的图片：

input=[
    {"role": "user", "content": "读取工具返回的截图。"},
    {"type": "function_call", "call_id": "fc1", "name": "take_screenshot", "arguments": "{}"},
    {"type": "function_call_output", "call_id": "fc1",
     "output": [{"type": "input_image", "image_url": "data:image/png;base64,<BASE64_DATA>"}]},
]

`input_image` 字段

image_url：图片的 http(s) URL（最多 8192 个字符）或 base64 编码的 data URL（data:image/jpeg;base64,...）。支持的格式：JPEG、PNG、GIF、WebP。
file_id：通过 Files API 上传的图片文件 ID，形如 file-api-...。
detail：low / high / original / auto。low 在推理前将图片缩小到 512x512；其余取值保留原图。设置 file_id 时被忽略。

image_url 与 file_id 互斥：两者都不传返回 400 错误（"input_image must have image_url or file_id"），两者都传返回 400 错误（"input_image cannot have both image_url and file_id"）。

使用限制

图片仅允许出现在 user / developer 消息 item 以及 function_call_output / custom_tool_call_output 的输出中；system / assistant 消息中的图片会返回 400 错误。
只有视觉模型（deepseek-v4-flash-vision-exp）会真正处理 input_image 内容块，使用其他模型时会被替换为占位文本。
与对话补全相同的图片限制（内联单张 32 MiB、file_id 单张 64 MiB、不含 file_id 图片总计 64 MiB，含 file_id 图片最高 200 MiB、单请求 600 张等）同样适用，详见图像理解：限制。

兼容性明细

本小节罗列了 DeepSeek API 对 Responses API 的兼容性细节。Responses API 完整格式定义，请参考 OpenAI 官方 API 手册。

顶层请求参数

参数	支持情况
`model`	支持。`deepseek-v4-flash` / `deepseek-v4-pro` / `deepseek-v4-flash-vision-exp`，见模型 & 价格
`input`	支持。字符串或输入 item 列表；`input` 与 `instructions` 至少传一个
`instructions`	支持。作为第一条 system 消息
`stream`	支持
`temperature`	支持（范围 [0.0, 2.0]；思考模式下不生效）
`top_p`	支持（思考模式下不生效）
`max_output_tokens`	支持
`top_logprobs`	支持（范围 [0, 20]）
`tools`	部分支持。`function` / `web_search` 支持；其他类型忽略，见下方 Tools 表
`tool_choice`	支持。`none` / `auto` / `required` / 指定某个工具（`{"type": "function", "name": ...}` 或 `{"type": "web_search"}` / `{"type": "web_search_2025_08_26"}`）
`reasoning`	部分支持。`effort` 支持；`summary` 可传入但不生成摘要
`text`	部分支持。`format` 完整支持；`verbosity` 可传入但不生效
`user`	支持。参考限速与用户隔离
`parallel_tool_calls`	忽略（并行工具调用始终开启）
`max_tool_calls`	忽略
`previous_response_id`	不支持（无状态 API）
`conversation`	不支持（无状态 API）
`store`	不支持。响应中恒为 `store: false`
`background`	不支持
`metadata`	不支持
`include`	不支持
`prompt`	不支持
`truncation`	不支持。输入超出上下文窗口时返回 `400` 错误
`service_tier`	不支持
`safety_identifier`	不支持
`prompt_cache_key` / `prompt_cache_retention`	不支持。上下文缓存自动管理，见上下文硬盘缓存
`context_management`	不支持
`stream_options`	不支持

不支持的参数会被静默忽略、不会报错，因此现有的 Responses API 客户端无需修改即可接入。

输入 Items

类型	支持情况
`message`	支持。角色支持 `user` / `assistant` / `system` / `developer`（`developer` 视同 `user`）；content 支持字符串和 `input_text` / `output_text` / `input_image` 内容块。使用 `deepseek-v4-flash-vision-exp` 模型时，`input_image` 内容块会作为真实图片处理（仅允许出现在 `user` / `developer` 消息中，`system` / `assistant` 消息中的图片会返回 `400` 错误）；使用其他模型时会被替换为占位文本。文件输入不支持
`function_call`	支持。归并到相邻 assistant 消息
`function_call_output`	支持。`output` 可以是字符串或内容块列表；使用 `deepseek-v4-flash-vision-exp` 模型时，输出中的 `input_image` 内容块会作为真实图片处理
`reasoning`	支持。明文 `content` 归并到相邻 assistant 消息；`summary`、`encrypted_content` 不支持
`web_search_call`	支持。原样回传即可，服务端自动恢复搜索结果
`custom_tool_call` / `custom_tool_call_output`	支持（配合 `apply_patch` custom 工具使用，含 `call_id` 配对校验）。使用 `deepseek-v4-flash-vision-exp` 模型时，`output` 中的 `input_image` 内容块会作为真实图片处理
其他类型	忽略

Tools

类型	支持情况
`function`	支持
`web_search` / `web_search_2025_08_26`	支持，服务端执行。`search_context_size`、`user_location` 忽略；服务端自动续推上限 10 轮
`custom`	仅支持 `{"type": "custom", "name": "apply_patch"}`（用于 Codex 兼容）；其他名称返回 `400` 错误
`file_search` / `code_interpreter` / `computer_use` / `mcp` 等其他内置工具	忽略

响应字段

响应对象与 OpenAI Responses API 的 response 结构兼容。依赖未支持能力的字段恒为固定值（如 store: false、previous_response_id: null、parallel_tool_calls: true）。

Token 用量在 usage 中返回：

input_tokens：输入 token 数，其中 input_tokens_details.cached_tokens 为命中上下文缓存的 token 数
output_tokens：输出 token 数，其中 output_tokens_details.reasoning_tokens 为思维链 token 数

使用 Anthropic API

Invalid Date

为了满足大家对 Anthropic API 生态的使用需求，我们的 API 新增了对 Anthropic API 格式的支持，其 base_url 为 https://api.deepseek.com/anthropic。

通过简单的配置，即可将 DeepSeek 的能力，接入到 Anthropic API 生态中。

将 DeepSeek 模型接入 Claude Code

请参考接入 Claude Code

通过 Anthropic API 调用 DeepSeek 模型

安装 Anthropic SDK

pip install anthropic

配置环境变量

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_API_KEY=${YOUR_API_KEY}

调用 API

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="deepseek-v4-pro",
    max_tokens=1000,
    system="You are a helpful assistant.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Hi, how are you?"
                }
            ]
        }
    ]
)
print(message.content)

注意：当您给 DeepSeek 的 Anthropic API 传入不支持的模型名时，API 后端会自动将其映射到 deepseek-v4-flash 模型。

Anthropic 模型映射

您在使用 Anthropic API 时，我们会对您传入的 claude 模型名进行映射：

claude-opus 开头的模型，会映射到 deepseek-v4-pro
claude-haiku、claude-sonnet 开头的模型，会映射到 deepseek-v4-flash

通过这样的映射，您在使用新版 Claude Desktop APP 的 developer 模式时，可以绕过 APP 对模型名的限制，只需改动 base_url 和 api_key，即可在其中接入 DeepSeek 模型。

Anthropic API 兼容性细节

本小节罗列了 DeepSeek API 对 Anthropic API 的兼容性细节。Anthropic API 完整格式定义，请参考 Anthropic 官方 API 手册。

HTTP Header

字段	支持情况
anthropic-beta	`/messages` 忽略；Files API 端点必须携带（`files-api-2025-04-14`）——见 Files API
anthropic-version	忽略
x-api-key	完全支持

简单字段

字段	支持情况
model	改为使用 DeepSeek 模型
max_tokens	完全支持
container	忽略
mcp_servers	忽略
metadata	支持 `user_id`，其它字段忽略关于 `user_id` 参数的更多信息，请参考限速与隔离。
service_tier	忽略
stop_sequences	完全支持
stream	完全支持
system	完全支持
temperature	完全支持（范围 [0.0 ~ 2.0]）
thinking	支持（`budget_tokens` 被忽略）
output_config	仅支持 `effort`
top_k	忽略
top_p	完全支持

Tool 字段

tools

字段	支持情况
name	完全支持
input_schema	完全支持
description	完全支持
cache_control	忽略

tool_choice

取值	支持情况
none	完全支持
auto	支持（`disable_parallel_tool_use` 被忽略）
any	支持（`disable_parallel_tool_use` 被忽略）
tool	支持（`disable_parallel_tool_use` 被忽略）

Message 字段

字段	变体	子字段	支持情况
content	string		完全支持
	array, type="text"	text	完全支持
		cache_control	忽略
		citations	忽略
	array, type="image"	source	支持。`source.type` 可为 base64（媒体类型：jpeg、png、gif、webp）、url 或 file（file 形式需带请求头 `anthropic-beta: files-api-2025-04-14`）
	array, type = "document"		不支持
	array, type = "search_result"		不支持
	array, type = "thinking"		支持
	array, type="redacted_thinking"		不支持
	array, type = "tool_use"	id	完全支持
		input	完全支持
		name	完全支持
		cache_control	忽略
	array, type = "tool_result"	tool_use_id	完全支持
		content	完全支持
		cache_control	忽略
		is_error	忽略
	array, type = "server_tool_use"		支持
	array, type = "web_search_tool_result"		支持
	array, type = "code_execution_tool_result"		不支持
	array, type = "mcp_tool_use"		不支持
	array, type = "mcp_tool_result"		不支持
	array, type = "container_upload"		不支持

	控制参数（OpenAI 格式）	控制参数（Anthropic 格式）	控制参数（Responses API 格式）
思考模式开关⁽¹⁾	`{"thinking": {"type": "enabled/disabled"}}`		`{"reasoning": {"effort": "none/low/high/max"}}` (none 表示关闭思考模式)
思考强度控制⁽²⁾	`{"reasoning_effort": "low/high/max"}`	`{"output_config": {"effort": "low/high/max"}}`

DeepSeek 新闻

图像理解

传入图片

1. Base64 编码图片（内联）

2. 外部图片 URL

3. 引用通过 Files API 上传的文件

细节级别（Detail Level）

何时使用 Files API

Token 用量

限制

使用限制

在 Anthropic API 中使用图片

在 Responses API 中使用图片

思考模式

思考模式开关与思考强度控制

输入输出参数

多轮对话拼接

样例代码

工具调用

样例代码

多轮对话

对话前缀续写（Beta）

注意事项

样例代码

FIM 补全（Beta）

注意事项

样例代码

配置 Continue 代码补全插件

JSON Output

注意事项

样例代码

Tool Calls

非思考模式

样例代码

思考模式

strict 模式（Beta）

strict 模式支持的 JSON Schema 类型

object 类型

string 类型

number/integer 类型

array 类型

enum

anyOf

$ref 和 $def

Files API

上传文件

列出文件

查询文件信息

删除文件

在对话请求中使用已上传的文件

Anthropic 兼容 Files API

限制

上下文硬盘缓存

缓存落盘与命中规则

缓存前缀落盘时机：

例一：多轮对话

例二：长文本问答

查看缓存命中情况

硬盘缓存与输出随机性

其它说明

使用 Responses API

将 DeepSeek 模型接入 Codex

通过 Responses API 调用 DeepSeek 模型

流式输出

图片输入

input_image 字段

使用限制

兼容性明细

顶层请求参数

输入 Items

Tools

响应字段

使用 Anthropic API

将 DeepSeek 模型接入 Claude Code

通过 Anthropic API 调用 DeepSeek 模型

Anthropic 模型映射

Anthropic API 兼容性细节

HTTP Header

简单字段

Tool 字段

`strict` 模式（Beta）

`strict` 模式支持的 JSON Schema 类型

`input_image` 字段