DeepSeek

Chamada. DeepSeek Modelos através da API compatível com OpenAI ou DashScope SDK em QwenCloud.

-Começo rápido.

deepseek-v4-pro-0813 é o modelo principal na DeepSeek Série com parâmetros totais de 1.6T e parâmetros ativados de 49B. Ele suporta janelas de contexto de até 1 milhão de fichas e oferece desempenho de topo em codificação, matemática e tarefas gerais. Você pode usar o enable_thinking parâmetro para mudar entre modos de pensar e não pensar. O exemplo a seguir chama deepseek-v4-pro-0813 em modo de pensar.

A mais nova adição, deepseek-v4.1-flash, é um carro leve com parâmetros 552B total e apenas 8B ativado para entrada. Também aceita entrada de imagem. Chamando-o funciona da mesma forma que os exemplos abaixo, exceto que seu ponto final DashScope difere - veja [Exemplos Multimodal] (#multimodal-examples).

Antes de começar, pegue uma chave API (/api-reference/preparation/api-key) e defini-lo como uma variável de ambiente. Se você chamar o modelo através de um SDK, [instalar o OpenAI ou DashScope SDK] (/api-reference/preparation/install-sdk).

OpenAI compatible

  O `enable_thinking` O parâmetro não faz parte da API padrão OpenAI. No OpenAI Python SDK, passe-o através `extra_body`. No SDK de Node.js, passe-o como um parâmetro de nível superior. O `reasoning_effort`  parâmetro é um parâmetro padrão OpenAI que você pode passar diretamente como um parâmetro de nível superior.

Python

    **Exemplo código**

    ```python
    from openai import OpenAI
    import os

    client = OpenAI(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
    )

    messages = [{"role": "user", "content": "Who are you?"}]
    completion = client.chat.completions.create(
      model="deepseek-v4-pro-0813",
      messages=messages,
      extra_body={"enable_thinking": True},
      stream=True,
      stream_options={"include_usage": True},
    )

    reasoning_content = ""
    answer_content = ""
    is_answering = False
    print("\n" + "=" * 20 + "Thinking process" + "=" * 20 + "\n")

    for chunk in completion:
      if not chunk.choices:
        print("\n" + "=" * 20 + "Token usage" + "=" * 20 + "\n")
        print(chunk.usage)
        continue

      delta = chunk.choices[0].delta

      if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
          print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content

      if hasattr(delta, "content") and delta.content:
        if not is_answering:
          print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
          is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content
    ```

Node.js

    **Exemplo código**

    ```javascript
    import OpenAI from "openai";
    import process from 'process';

    const openai = new OpenAI({
      apiKey: process.env.DASHSCOPE_API_KEY,
      baseURL: 'https://maas.qwencloudapi.com/compatible-mode/v1'
    });

    let reasoningContent = '';
    let answerContent = '';
    let isAnswering = false;

    async function main() {
      const messages = [{ role: 'user', content: 'Who are you?' }];

      const stream = await openai.chat.completions.create({
        model: 'deepseek-v4-pro-0813',
        messages,
        enable_thinking: true,
        stream: true,
        stream_options: { include_usage: true },
      });

      console.log('\n' + '='.repeat(20) + 'Thinking process' + '='.repeat(20) + '\n');

      for await (const chunk of stream) {
        if (!chunk.choices?.length) {
          console.log('\n' + '='.repeat(20) + 'Token usage' + '='.repeat(20) + '\n');
          console.log(chunk.usage);
          continue;
        }

        const delta = chunk.choices[0].delta;

        if (delta.reasoning_content !== undefined && delta.reasoning_content !== null) {
          if (!isAnswering) {
            process.stdout.write(delta.reasoning_content);
          }
          reasoningContent += delta.reasoning_content;
        }

        if (delta.content !== undefined && delta.content) {
          if (!isAnswering) {
            console.log('\n' + '='.repeat(20) + 'Full response' + '='.repeat(20) + '\n');
            isAnswering = true;
          }
          process.stdout.write(delta.content);
          answerContent += delta.content;
        }
      }
    }

    main();
    ```

curl

    **Exemplo código**

    ```bash
    curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-v4-pro-0813",
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        "stream": true,
        "stream_options": {
            "include_usage": true
        },
        "enable_thinking": true
    }'
    ```

Anthropic compatible

Python

    **Exemplo código**

    ```python
    import anthropic
    import os

    client = anthropic.Anthropic(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.com/apps/anthropic",
    )

    message = client.messages.create(
      model="deepseek-v4-pro-0813",
      max_tokens=1024,
      messages=[
        {"role": "user", "content": "Who are you?"}
      ],
      stream=True,
    )

    for event in message:
      if event.type == "content_block_delta":
        if hasattr(event.delta, "thinking"):
          print(event.delta.thinking, end="", flush=True)
        if hasattr(event.delta, "text"):
          print(event.delta.text, end="", flush=True)
    ```

curl

    **Exemplo código**

    ```bash
    curl -X POST https://maas.qwencloudapi.com/apps/anthropic/v1/messages \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
        "model": "deepseek-v4-pro-0813",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ]
    }'
    ```

DashScope

   Os exemplos da DashScope abaixo usam o `text-generation` Endpoint. `deepseek-v4.1-flash` É um modelo multimodal e só está disponível no DashScope. `multimodal-generation` Endpoint, que requer `MultiModalConversation` - Veja [Exemplos Multimodal] (#multimodal-examples).

Python

    **Exemplo código**

    ```python
    import os
    from dashscope import Generation

    messages = [{"role": "user", "content": "Who are you?"}]

    completion = Generation.call(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      model="deepseek-v4-pro-0813",
      messages=messages,
      result_format="message",
      enable_thinking=True,
      stream=True,
      incremental_output=True,
    )

    reasoning_content = ""
    answer_content = ""
    is_answering = False

    print("\n" + "=" * 20 + "Thinking process" + "=" * 20 + "\n")

    for chunk in completion:
      message = chunk.output.choices[0].message
      if "reasoning_content" in message:
        if not is_answering:
          print(message.reasoning_content, end="", flush=True)
        reasoning_content += message.reasoning_content

      if message.content:
        if not is_answering:
          print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
          is_answering = True
        print(message.content, end="", flush=True)
        answer_content += message.content

    print("\n" + "=" * 20 + "Token usage" + "=" * 20 + "\n")
    print(chunk.usage)
    ```

Java

    **Exemplo código**

    

      A versão Java SDK deve ser 2.19.4 ou posterior.
    


    ```java
    import com.alibaba.dashscope.aigc.generation.Generation;
    import com.alibaba.dashscope.aigc.generation.GenerationParam;
    import com.alibaba.dashscope.aigc.generation.GenerationResult;
    import com.alibaba.dashscope.common.Message;
    import com.alibaba.dashscope.common.Role;
    import com.alibaba.dashscope.exception.ApiException;
    import com.alibaba.dashscope.exception.InputRequiredException;
    import com.alibaba.dashscope.exception.NoApiKeyException;
    import io.reactivex.Flowable;
    import java.lang.System;
    import java.util.Arrays;

    public class Main {
      private static StringBuilder reasoningContent = new StringBuilder();
      private static StringBuilder finalContent = new StringBuilder();
      private static boolean isFirstPrint = true;
      private static void handleGenerationResult(GenerationResult message) {
        String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();
        if (reasoning != null && !reasoning.isEmpty()) {
          reasoningContent.append(reasoning);
          if (isFirstPrint) {
            System.out.println("====================Thinking process====================");
            isFirstPrint = false;
          }
          System.out.print(reasoning);
        }
        if (content != null && !content.isEmpty()) {
          finalContent.append(content);
          if (!isFirstPrint) {
            System.out.println("\n====================Full response====================");
            isFirstPrint = true;
          }
          System.out.print(content);
        }
      }
      private static GenerationParam buildGenerationParam(Message userMsg) {
        return GenerationParam.builder()
          .apiKey(System.getenv("DASHSCOPE_API_KEY"))
          .model("deepseek-v4-pro-0813")
          .enableThinking(true)
          .incrementalOutput(true)
          .resultFormat("message")
          .messages(Arrays.asList(userMsg))
          .build();
      }
      public static void streamCallWithMessage(Generation gen, Message userMsg)
        throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(userMsg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
      }
      public static void main(String[] args) {
        try {
          Generation gen = new Generation();
          Message userMsg = Message.builder().role(Role.USER.getValue()).content("Who are you?").build();
          streamCallWithMessage(gen, userMsg);
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
          System.err.println("An exception occurred: " + e.getMessage());
        }
      }
    }
    ```

curl

    **Exemplo código**

    ```bash
    curl -X POST "https://maas.qwencloudapi.com/api/v1/services/aigc/text-generation/generation" \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -H "X-DashScope-SSE: enable" \
    -d '{
        "model": "deepseek-v4-pro-0813",
        "input":{
            "messages":[
                {
                    "role": "user",
                    "content": "Who are you?"
                }
            ]
        },
        "parameters":{
            "enable_thinking": true,
            "incremental_output": true,
            "result_format": "message"
        }
    }'
    ```

Esforço de raciocínio

deepseek-v4.1-flash, deepseek-v4-pro-0813, deepseek-v4-pro, e deepseek-v4-flash-0731 tem modo de pensamento ativado por padrão. Você pode usar o reasoning_effort parâmetro para controlar a intensidade do raciocínio. Valores válidos: low (suportado apenas por deepseek-v4.1-flash, deepseek-v4-flash-0731, e deepseek-v4-pro-0813), high, e max. O valor padrão é high.

Por deepseek-v4-pro, low e medium produzir o mesmo comportamento que high, e xhigh produz o mesmo comportamento que max. Por deepseek-v4.1-flash, minimal é mapeado para low, medium e xhigh são mapeados para high, e ultra é mapeado para max.

OpenAI compatible

Python

    ```python
    from openai import OpenAI
    import os

    client = OpenAI(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
    )

    completion = client.chat.completions.create(
      model="deepseek-v4-pro-0813",
      messages=[{"role": "user", "content": "Which is larger, 9.9 or 9.11?"}],
      reasoning_effort="high",
    )
    print(completion.choices[0].message.content)
    ```

Node.js

    ```javascript
    import OpenAI from "openai";

    const openai = new OpenAI({
      apiKey: process.env.DASHSCOPE_API_KEY,
      baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
    });

    const completion = await openai.chat.completions.create({
      model: "deepseek-v4-pro-0813",
      messages: [{ role: "user", content: "Which is larger, 9.9 or 9.11?" }],
      reasoning_effort: "high",
    });
    console.log(completion.choices[0].message.content);
    ```

curl

    ```bash
    curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-v4-pro-0813",
        "messages": [{"role": "user", "content": "Which is larger, 9.9 or 9.11?"}],
        "reasoning_effort": "high"
    }'
    ```

DashScope

```python
import os
from dashscope import Generation

response = Generation.call(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="deepseek-v4-pro-0813",
  messages=[{"role": "user", "content": "Which is larger, 9.9 or 9.11?"}],
  reasoning_effort="high",
  result_format="message",
)
print(response.output.choices[0].message.content)
```

API de respostas

deepseek-v4.1-flash, deepseek-v4-pro-0813, deepseek-v4-flash-0731, e deepseek-v4-pro Chamadas de suporte através da API de Respostas Compatíveis com OpenAI.

Ao chamar a API de Respostas, você pode adicionar o web_search ([Busca na Web])/developer-guides/tool-calling/web-search)), web_extractor (Extrator web), e code_interpreter (Código Intérprete) ferramentas para o tools parâmetro.

Python

```python
from openai import OpenAI
import os

client = OpenAI(
  # If the environment variable is not configured, replace the following line with your API key: api_key="sk-xxx"
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)
response = client.responses.create(
  model="deepseek-v4-flash-0731",
  input="Hello! Please introduce yourself in one sentence.",
  # Optional: enable the web search, web extractor, and code interpreter tools
  tools=[
    {"type": "web_search"},
    {"type": "web_extractor"},
    {"type": "code_interpreter"},
  ],
)
# Get the model response
print(response.output_text)
```

Node.js

```javascript
import OpenAI from "openai";

const openai = new OpenAI({
  // If the environment variable is not configured, replace the following line with your API key: apiKey: "sk-xxx"
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
});
const response = await openai.responses.create({
  model: "deepseek-v4-flash-0731",
  input: "Hello! Please introduce yourself in one sentence.",
  // Optional: enable the web search, web extractor, and code interpreter tools
  tools: [
    { type: "web_search" },
    { type: "web_extractor" },
    { type: "code_interpreter" },
  ],
});
// Get the model response
console.log(response.output_text);
```

curl

```bash
curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "deepseek-v4-flash-0731",
    "input": "Hello! Please introduce yourself in one sentence.",
    "tools": [
        {"type": "web_search"},
        {"type": "web_extractor"},
        {"type": "code_interpreter"}
    ]
}'
```

Exemplos multimodais

deepseek-v4.1-flash tem compreensão visual nativa e aceita texto e entrada de imagem, retornando texto. Todos os outros DeepSeek Modelos aceitam apenas entrada de texto.

Através da API compatível com OpenAI, passe imagens como image_url Blocos de conteúdo. Através da DashScope, use o multimodal-generation Endpoint com MultiModalConversation e passar imagens no image Campo.

OpenAI compatible

Python

    ```python
    from openai import OpenAI
    import os

    client = OpenAI(
      # If the environment variable is not configured, replace with your API key: api_key="sk-xxx"
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
    )

    # Single image
    completion = client.chat.completions.create(
      model="deepseek-v4.1-flash",
      messages=[
        {
          "role": "user",
          "content": [
            {"type": "text", "text": "What is in this image?"},
            {
              "type": "image_url",
              "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}
            }
          ]
        }
      ],
    )
    print(completion.choices[0].message.content)

    # Multiple images (uncomment to use)
    # completion = client.chat.completions.create(
    #     model="deepseek-v4.1-flash",
    #     messages=[
    #         {
    #             "role": "user",
    #             "content": [
    #                 {"type": "text", "text": "What is in these images?"},
    #                 {
    #                     "type": "image_url",
    #                     "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}
    #                 },
    #                 {
    #                     "type": "image_url",
    #                     "image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/tiger.png"}
    #                 }
    #             ]
    #         }
    #     ],
    # )
    # print(completion.choices[0].message.content)
    ```

Node.js

    ```javascript
    import OpenAI from "openai";
    import process from 'process';

    const openai = new OpenAI({
      // If the environment variable is not configured, replace with your API key: apiKey: "sk-xxx"
      apiKey: process.env.DASHSCOPE_API_KEY,
      baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1"
    });

    const completion = await openai.chat.completions.create({
      model: "deepseek-v4.1-flash",
      messages: [
        {
          role: "user",
          content: [
            { type: "text", text: "What is in this image?" },
            {
              type: "image_url",
              image_url: { url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg" }
            }
          ]
        }
      ]
    });
    console.log(completion.choices[0].message.content);
    ```

curl

    ```bash
    curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-v4.1-flash",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "What is in this image?"},
                    {"type": "image_url", "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}}
                ]
            }
        ]
    }'
    ```

DashScope

Python

    ```python
    import os
    from dashscope import MultiModalConversation

    messages = [
      {
        "role": "user",
        "content": [
          {"image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"},
          {"text": "What is in this image?"}
        ]
      }
    ]

    response = MultiModalConversation.call(
      # If the environment variable is not configured, replace with your API key: api_key="sk-xxx"
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      model="deepseek-v4.1-flash",
      messages=messages,
    )
    print(response.output.choices[0].message.content[0]["text"])
    ```

curl

    ```bash
    curl -X POST "https://maas.qwencloudapi.com/api/v1/services/aigc/multimodal-generation/generation" \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-v4.1-flash",
        "input":{
            "messages":[
                {
                    "role": "user",
                    "content": [
                        {"image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"},
                        {"text": "What is in this image?"}
                    ]
                }
            ]
        }
    }'
    ```

Outras características

Parâmetro padrão

• Um hífen (-) indica que o parâmetro não é suportado.
• Para descrições de parâmetros, veja a API de chat compatível com OpenAI (/api-reference/chat/openai-chat).