QwenCloudBRASIL
Início›Biblioteca›Documentação
Tradução de apoio para consulta. Código e identificadores técnicos preservados. Consultar referência original ↗

Pensando

Resolva tarefas complexas com o pensamento passo a passo

Pensar (razão) modelos razão antes de responder - saída reasoning_content (Compleções de bate-papo / DashScope) ou reasoning_text eventos (Responsáveis API). Modelos suportam o pensamento em um dos dois modos:

Ativar o pensamento

OpenAI Chat Completions

  ```python Python {8}
  import os
  from openai import OpenAI
  client = OpenAI(api_key=os.getenv("DASHSCOPE_API_KEY"), base_url="https://maas.qwencloudapi.com/compatible-mode/v1")

  completion = client.chat.completions.create(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": "If 3x + 7 = 22, what is x?"}],
    extra_body={"enable_thinking": True},              # ← enable thinking
    stream=True,
  )
  for chunk in completion:
    if not chunk.choices:
      continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content:
      print(delta.reasoning_content, end="", flush=True)  # ← phase 1: thinking
    if hasattr(delta, "content") and delta.content:
      print(delta.content, end="", flush=True)             # ← phase 2: answer
  ```

  ```javascript Node.js {7}
  import OpenAI from "openai";
  const client = new OpenAI({ apiKey: process.env.DASHSCOPE_API_KEY, baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1" });

  const stream = await client.chat.completions.create({
    model: "qwen3.8-max",
    messages: [{ role: "user", content: "If 3x + 7 = 22, what is x?" }],
    enable_thinking: true,                             // ← enable thinking
    stream: true,
  });
  for await (const chunk of stream) {
    if (!chunk.choices?.length) continue;
    const delta = chunk.choices[0].delta;
    if (delta.reasoning_content)
      process.stdout.write(delta.reasoning_content); // ← phase 1: thinking
    if (delta.content)
      process.stdout.write(delta.content);            // ← phase 2: answer
  }
  ```

  ```bash curl
  curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" --no-buffer \
    -d '{"model":"qwen3.8-max","messages":[{"role":"user","content":"If 3x + 7 = 22, what is x?"}],"stream":true,"enable_thinking":true}'
  ```

OpenAI Responses API

 Pensar chega como `response.reasoning_text.delta`  eventos, seguidos por `response.output_text.delta` para a resposta.



  ```python Python {8}
  import os
  from openai import OpenAI
  client = OpenAI(api_key=os.getenv("DASHSCOPE_API_KEY"), base_url="https://maas.qwencloudapi.com/compatible-mode/v1")

  stream = client.responses.create(
    model="qwen3.8-max",
    input="If 3x + 7 = 22, what is x?",
    extra_body={"enable_thinking": True},              # ← enable thinking
    stream=True,
  )
  for chunk in stream:
    if chunk.type == "response.reasoning_text.delta":
      print(chunk.delta, end="", flush=True)         # ← phase 1: thinking
    elif chunk.type == "response.output_text.delta":
      print(chunk.delta, end="", flush=True)         # ← phase 2: answer
  ```

  ```javascript Node.js {7}
  import OpenAI from "openai";
  const client = new OpenAI({ apiKey: process.env.DASHSCOPE_API_KEY, baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1" });

  const stream = await client.responses.create({
    model: "qwen3.8-max",
    input: "If 3x + 7 = 22, what is x?",
    enable_thinking: true,                             // ← enable thinking
    stream: true,
  });
  for await (const chunk of stream) {
    if (chunk.type === "response.reasoning_text.delta")
      process.stdout.write(chunk.delta);             // ← phase 1: thinking
    else if (chunk.type === "response.output_text.delta")
      process.stdout.write(chunk.delta);             // ← phase 2: answer
  }
  ```

  ```bash curl
  curl -X POST https://maas.qwencloudapi.com/compatible-mode/v1/responses \
    -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
    -H "Content-Type: application/json" --no-buffer \
    -d '{"model":"qwen3.8-max","input":"If 3x + 7 = 22, what is x?","stream":true,"enable_thinking":true}'
  ```

DashScope

  ```python Python {8,10}
  import dashscope
  dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'
  from dashscope import MultiModalConversation

  responses = MultiModalConversation.call(
    model="qwen3.8-max",
    messages=[{"role": "user", "content": [{"text": "If 3x + 7 = 22, what is x?"}]}],
    enable_thinking=True,                              # ← enable thinking
    stream=True,
    incremental_output=True,                           # ← recommended: new tokens only
  )
  for chunk in responses:
    msg = chunk.output.choices[0].message
    if msg.reasoning_content:
      print(msg.reasoning_content, end="", flush=True)   # ← phase 1: thinking
    if msg.content and msg.content[0].get("text"):
      print(msg.content[0]["text"], end="", flush=True)   # ← phase 2: answer
  ```

  ```java Java {5,15,16}
  import java.util.*;
  import com.alibaba.dashscope.aigc.multimodalconversation.*;
  import com.alibaba.dashscope.common.Role;
  import com.alibaba.dashscope.utils.Constants;
  Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";

  // DashScope Java SDK 2.19.4+ required
  MultiModalMessage userMsg = MultiModalMessage.builder()
    .role(Role.USER.getValue())
    .content(List.of(Map.of("text", "If 3x + 7 = 22, what is x?")))
    .build();
  MultiModalConversationParam param = MultiModalConversationParam.builder()
    .apiKey(apiKey).model("qwen3.8-max")
    .enableThinking(true)                              // ← enable thinking
    .incrementalOutput(true)                           // ← recommended: new tokens only
    .messages(Arrays.asList(userMsg))
    .build();
  conv.streamCall(param).blockingForEach(result -> {
    var msg = result.getOutput().getChoices().get(0).getMessage();
    if (msg.getReasoningContent() != null)
      System.out.print(msg.getReasoningContent());   // ← phase 1: thinking
    if (msg.getContent() != null && !msg.getContent().isEmpty())
      System.out.print(msg.getContent().get(0).get("text"));  // ← phase 2
  });
  ```

  ```bash curl
  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" \
    -H "X-DashScope-SSE: enable" \
    -d '{"model":"qwen3.8-max","input":{"messages":[{"role":"user","content":[{"text":"If 3x + 7 = 22, what is x?"}]}]},"parameters":{"enable_thinking":true,"incremental_output":true}}'
  ```

Quando o modo de pensar está ativado (enable_thinking É true), a gama válida para o max_tokens parâmetro é [1, 32768]. Valores fora desta faixa retornam um erro de 400 (InvalidParameter: Range of max_tokens should be [1, 32768]). Modo não pensante não tem esse limite.

Nós recomendamos usar max_completion_tokens Em vez de max_tokens: max_completion_tokens limita a produção completa do modelo (incluindo a cadeia de pensamento e resposta final) e não está sujeito ao cap 32768; max_tokens Só limita a resposta final e está sendo despreparado. Novas integrações devem usar max_completion_tokens.

# When thinking mode is enabled, use max_completion_tokens to limit output length
completion = client.chat.completions.create(
  model="qwen3.8-max",
  messages=[{"role": "user", "content": "Who are you?"}],
  extra_body={"enable_thinking": True},
  # max_completion_tokens limits the total output length (chain of thought + reply), no 32768 cap
  max_completion_tokens=65536,
)

Controle a profundidade do pensamento

Orçamento do token

Use thinking_budget para limitar o número de fichas de pensamento. Se o limite for alcançado, o modelo para de pensar e gera sua resposta imediatamente. Apoiado por Qwen3.8, Qwen3.7, Qwen3.6, Qwen3.5, Qwen3-VL, Qwen3, GLM, e Kimi modelos de série, e o Qwen3.8 Série de código aberto. Complementos de bate-papo e apenas DashScope - não suportado pela API Responses.

OpenAI Chat Completions

```python
extra_body={"enable_thinking": True, "thinking_budget": 500}
```

DashScope

```python
enable_thinking=True,
thinking_budget=500,
```

Raciocínio:

Use reasoning_effort Para controlar a intensidade do pensamento por nível em vez de especificar uma contagem de fichas. Valores e padrões suportados variam de acordo com o modelo. Exemplo com qwen3.8-max (opções: low, medium, xhigh; padrão xhigh):

OpenAI Chat Completions

```python
extra_body={"enable_thinking": True, "reasoning_effort": "medium"}
```

DashScope

```python
enable_thinking=True,
reasoning_effort="medium",
```

qwen3.8-max Não suporta a configuração. reasoning_effort e thinking_budget Ao mesmo tempo, fazer isso, retorna um erro. Quando nenhum deles é definido, o modelo usa seu padrão.

Este não é um parâmetro padrão OpenAI. Ao usar o Python SDK, passe-o através extra_body. Para níveis suportados, padrões, e o mapeamento entre reasoning_effort e thinking_budget Para cada modelo, veja a [Referência API] (/api-reference/chat/openai-chat).

Experimente o pensamento profundo no console.

  1. Entre no carro. QwenCloud console.
  2. No painel de navegação do lado esquerdo, escolha Playground para abrir o centro de experiência do modelo.
  3. O Qwen3.7-Max O modelo é exibido por padrão. Você também pode clicar no nome do modelo para selecionar outro Qwen3 Modelos de série da lista suspensa.
  4. Clique em ** Pensamento profundo** na parte inferior da caixa de entrada para permitir o modo de raciocínio e ver o processo de pensamento do modelo.
  5. Mude para a aba Modelo de depuração e defina o thinking_budget parâmetro no painel de configuração para controlar o número máximo de fichas para a saída da cadeia de pensamento. Faixa de valor: 1-32768, padrão: 4000. Para tentar mais modelos, visite o mercado de modelos.

Controle de nível imediato.

Com enable_thinking: true, adicionar /no_think Para pular o pensamento por uma vez. /think restaura. Última instrução ganha. Apoiado por código aberto Qwen3 Modelos híbridos e qwen-plus-2025-04-28.

Preservar o pensamento em multi-volta

Por padrão, os modelos não lêem reasoning_content De onde você está? messages Array em conversas multi-turnos. Preparar. preserve_thinking para true para adicionar o reasoning_content em mensagens assistentes para a próxima entrada, permitindo que o modelo refira o raciocínio anterior.

Modelos apoiados: qwen3.8-max, qwen3.8-max-0902, qwen3.8-flash, qwen3.8-omni-flash (permitido por padrão), qwen3.7-max, qwen3.7-max-2026-06-08, qwen3.7-max-2026-05-20, qwen3.7-max-preview, qwen3.7-max-2026-05-17, qwen3.7-plus, qwen3.7-plus-2026-05-26, qwen3.6-plus, qwen3.6-plus-2026-04-02, qwen3.7-flash, qwen3.7-flash-2026-07-15, kimi-k2.7-code (traduzido em QwenCloud).

OpenAI Chat Completions

```python
extra_body={"enable_thinking": True, "preserve_thinking": True}
```



  `preserve_thinking`  Não é um parâmetro padrão do OpenAI.  Ao usar o Python SDK, passe-o através `extra_body`.

DashScope

```python
enable_thinking=True,
preserve_thinking=True,
```

Chamada de função com modo de pensar

Quando o pensamento é ativado durante [chamada de função] (/developer-guides/tool-calling/function-calling), as razões do modelo sobre quais ferramentas para ligar e como usar os resultados antes de responder. A resposta inclui: reasoning_content Antes de cada chamada de ferramentas.

** Pontos-chave:**

Contagem

Pensar que os símbolos são cobrados como símbolos de saída. Alguns modelos de pensamento híbrido têm preços diferentes para o modo de pensar vs. modo não pensante. Se um modelo no modo de pensar não produz nenhum conteúdo de pensamento, é cobrado pelo preço do modo não pensante.

Para preços de modo de pensamento específico, veja [Modelos] (https://home.qwencloud.com/models).

Notas

FAQ

Por que está qwen3.7-plus Lento para responder, e como eu soluciono isso?

qwen3.7-plus é um modelo de pensamento híbrido com modo de pensamento ativado por padrão. O processo de pensamento gera um grande número de símbolos de raciocínio - mais de 60% do total de fichas de saída em medições - então a latência total de uma única chamada é muito maior do que no modo não pensante. A velocidade da geração de símbolos em si é normal, entre 52 e 54 fichas/s. A latência total mais longa vem do número de fichas que o processo de pensamento produz, não de um modelo mais lento ou uma falha de rede.

Para solucionar a latência:

  1. Verifique se o modo de pensar está ativado. Está ativado por padrão para qwen3.7-plus. Se a resposta retornar o reasoning_content Campo, modo de pensar está ativo.

  2. Revisão completion_tokens e reasoning_tokens nas estatísticas de uso da resposta. Uma alta proporção de reasoning_tokens significa que a longa latência total é o comportamento esperado do modo de pensar.

  3. Se não precisa do processo de raciocínio, prepare-se. enable_thinking para false no pedido para desativar o modo de pensar. Isso reduz muito a saída de fichas e reduz a latência total em 60% a 75% nas medições.

  4. Se você want Para manter a capacidade de raciocínio, use a saída de streaming. Você recebe o primeiro símbolo mais cedo e pode assistir o raciocínio em tempo real em vez de esperar pela resposta completa.

    Estatísticas de uso mostram a latência total de uma única chamada, incluindo o tempo gasto gerando símbolos de raciocínio. Esta não é a latência de geração de um símbolo individual.

O que eu faço se um longo prompt não gerar uma resposta ou tempo fora?

Se uma chamada com um longo prompt falhar ou se o tempo for, modo de pensar (enable_thinking=true- É geralmente permitido. O modo de pensar aumenta o tempo de processamento, que pode truncar a resposta ou fazer com que o pedido de tempo limite quando o prompt for longo.

Soluções:

Meu cliente de terceiros se desconecta depois que a tag pensante é saída. O que eu faço?

Este é um problema do lado do cliente, não uma restrição de plataforma em expor o processo de pensamento. QwenCloud usa o enable_thinking parâmetro para alternar o modo de pensamento, e o reasoning_content campo na resposta contém o processo de pensamento completo, então o modelo retorna o conteúdo do pensamento como esperado. A desconexão é causada por condições de rede de clientes instáveis ou problemas de compatibilidade com versões de clientes.

Passos de solução de problemas:

Você também pode ligar para o modelo diretamente através da API DashScope para verificar se a capacidade de pensar funciona como esperado.