GLM

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

-Começo rápido.

glm-5.3, glm-5.2, e glm-5.2-fast-preview são as últimas GLM Modelos com 1M de comprimento de contexto. glm-5.2 e glm-5.2-fast-preview Apoiar o pensamento e modos não pensantes através do enable_thinking parâmetro; glm-5.3 suporta apenas o modo de pensar, que não pode ser desativado. Passe o seguinte código para ligar. glm-5.2 em modo de pensar.

Pré-requisitos: obter uma chave API e configurá-la como uma variável de ambiente. Se ligar via SDK, instale o OpenAI ou DashScope SDK.

OpenAI compatible

  O `enable_thinking`  parâmetro não é um parâmetro padrão OpenAI. No OpenAI Python SDK, passe-o através de `extra_body`; no SDK de Node.js, passe-o 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="glm-5.2",
      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 " + "=" * 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 + " 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: 'glm-5.2',
        messages,
        enable_thinking: true,
        stream: true,
        stream_options: { include_usage: true },
      });

      console.log('\n' + '='.repeat(20) + ' Thinking ' + '='.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) + ' 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": "glm-5.2",
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        "stream": true,
        "stream_options": {
            "include_usage": true
        },
        "enable_thinking": true
    }'
    ```

DashScope

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="glm-5.2",
      messages=messages,
      result_format="message",
      enable_thinking=True,
      stream=True,
      incremental_output=True,
    )

    reasoning_content = ""
    answer_content = ""
    is_answering = False

    print("\n" + "=" * 20 + " Thinking " + "=" * 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 + " 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 ====================");
            isFirstPrint = false;
          }
          System.out.print(reasoning);
        }
        if (content != null && !content.isEmpty()) {
          finalContent.append(content);
          if (!isFirstPrint) {
            System.out.println("\n==================== Response ====================");
            isFirstPrint = true;
          }
          System.out.print(content);
        }
      }
      private static GenerationParam buildGenerationParam(Message userMsg) {
        return GenerationParam.builder()
          .apiKey(System.getenv("DASHSCOPE_API_KEY"))
          .model("glm-5.2")
          .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": "glm-5.2",
        "input":{
            "messages":[
                {
                    "role": "user",
                    "content": "Who are you?"
                }
            ]
        },
        "parameters":{
            "enable_thinking": true,
            "incremental_output": true,
            "result_format": "message"
        }
    }'
    ```

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="glm-5.2",
      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": "glm-5.2",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ]
    }'
    ```

Ferramenta de transmissão chamando

glm-5.3, glm-5.2, glm-5.2-fast-preview, glm-5.1, e glm-5 Apoiar o tool_stream parâmetro (booleano). Ele é predefinido para true para glm-5.3 e para false para os outros modelos, e é eficaz apenas quando stream É true. Quando habilitado, argumentos de chamada de funções são retornados incrementalmente em vários pedaços ao invés de todos de uma vez.

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",
    )

    tools = [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Get weather information for a city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
          }
        }
      }
    ]

    messages = [{"role": "user", "content": "What's the weather like in Singapore?"}]

    completion = client.chat.completions.create(
      model="glm-5.2",
      tools=tools,
      messages=messages,
      extra_body={"tool_stream": True},
      stream=True,
      stream_options={"include_usage": True},
    )

    for chunk in completion:
      if chunk.choices:
        delta = chunk.choices[0].delta
        if hasattr(delta, 'content') and delta.content:
          print(f"[content] {delta.content}")
        if hasattr(delta, 'tool_calls') and delta.tool_calls:
          for tc in delta.tool_calls:
            print(f"[tool_call] id={tc.id}, name={tc.function.name}, args={tc.function.arguments}")
        if chunk.choices[0].finish_reason:
          print(f"[finish_reason] {chunk.choices[0].finish_reason}")
      if not chunk.choices and chunk.usage:
        print(f"[usage] {chunk.usage}")
    ```

Node.js

    ```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'
    });

    const tools = [
      {
        type: "function",
        function: {
          name: "get_weather",
          description: "Get weather information for a city",
          parameters: {
            type: "object",
            properties: {
              city: { type: "string", description: "City name" }
            },
            required: ["city"]
          }
        }
      }
    ];

    async function main() {
      const stream = await openai.chat.completions.create({
        model: 'glm-5.2',
        messages: [{ role: 'user', content: "What's the weather like in Singapore?" }],
        tools: tools,
        tool_stream: true,
        stream: true,
        stream_options: { include_usage: true },
      });

      for await (const chunk of stream) {
        if (!chunk.choices?.length) {
          if (chunk.usage) {
            console.log(`[usage] ${JSON.stringify(chunk.usage)}`);
          }
          continue;
        }

        const delta = chunk.choices[0].delta;
        if (delta.content) {
          console.log(`[content] ${delta.content}`);
        }
        if (delta.tool_calls) {
          for (const tc of delta.tool_calls) {
            console.log(`[tool_call] id=${tc.id}, name=${tc.function.name}, args=${tc.function.arguments}`);
          }
        }
        if (chunk.choices[0].finish_reason) {
          console.log(`[finish_reason] ${chunk.choices[0].finish_reason}`);
        }
      }
    }

    main();
    ```

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": "glm-5.2",
        "messages": [
            {
                "role": "user",
                "content": "What is the weather like in Singapore?"
            }
        ],
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_weather",
                    "description": "Get weather information for a city",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "city": {"type": "string", "description": "City name"}
                        },
                        "required": ["city"]
                    }
                }
            }
        ],
        "stream": true,
        "stream_options": {"include_usage": true},
        "tool_stream": true
    }'
    ```

DashScope

Python

    ```python
    import os
    from dashscope import Generation

    tools = [
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Get weather information for a city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
          }
        }
      }
    ]

    messages = [{"role": "user", "content": "What's the weather like in Singapore?"}]

    completion = Generation.call(
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      model="glm-5.2",
      messages=messages,
      tools=tools,
      result_format="message",
      stream=True,
      tool_stream=True,
      incremental_output=True,
    )

    for chunk in completion:
      msg = chunk.output.choices[0].message
      if msg.content:
        print(f"[content] {msg.content}")
      if "tool_calls" in msg and msg.tool_calls:
        for tc in msg.tool_calls:
          fn = tc.get("function", {})
          print(f"[tool_call] id={tc.get('id','')}, name={fn.get('name','')}, args={fn.get('arguments','')}")
      finish = chunk.output.choices[0].get("finish_reason", "")
      if finish and finish != "null":
        print(f"[finish_reason] {finish}")
    ```

curl

    ```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": "glm-5.2",
        "input": {
            "messages": [
                {
                    "role": "user",
                    "content": "What is the weather like in Singapore?"
                }
            ]
        },
        "parameters": {
            "tools": [
                {
                    "type": "function",
                    "function": {
                        "name": "get_weather",
                        "description": "Get weather information for a city",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "city": {"type": "string", "description": "City name"}
                            },
                            "required": ["city"]
                        }
                    }
                }
            ],
            "tool_stream": true,
            "incremental_output": true,
            "result_format": "message"
        }
    }'
    ```

Esforço de raciocínio

glm-5.3, glm-5.2, glm-5.2-fast-preview, e glm-5.1 tem modo de pensamento ativado por padrão. O modelo primeiro produz o processo de pensamento (reasoning_content) e então fornece a resposta final. Você pode usar o reasoning_effort parâmetro para ajustar a profundidade do raciocínio. Um valor maior indica um pensamento mais completo. invalid_parameter_error Erro.

Para desativar o modo de pensar, definir enable_thinking para false no modo OpenAI compatível ou DashScope. Este parâmetro tem prioridade maior que reasoning_effort. glm-5.3 Não suporta desativar o modo de pensar. Setting enable_thinking para false não tem efeito.

O modo Antrópico compatível não suporta o reasoning_effort parâmetro. Para obter conteúdo de pensamento, use o antropólogo nativo thinking parâmetro: {"thinking":{"type":"enabled","budget_tokens":1024}}.

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="glm-5.2",
      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: "glm-5.2",
      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": "glm-5.2",
        "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="glm-5.2",
  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)
```

História de pensamento clara (claro)

O clear_thinking parâmetro controla se o reasoning_content (Pensando processo) de turnos anteriores é incluído como entrada de contexto para o modelo em conversas multi-turnos. Só GLM Modelos de série suportam este parâmetro.

• trueIgnore reasoning_content de turnos anteriores. Apenas texto visível, chamadas de ferramentas e resultados são usados como contexto, reduzindo o tamanho do contexto e o custo.
• false Mantenha reasoning_content de voltas anteriores e passe-o para o modelo como parte do contexto. Para permitir o Pensamento Preservado, você deve passar o completo, não modificado reasoning_content de turnos anteriores na ordem original. Desaparecido, aparado, reescrito ou reordenado conteúdo pode degradar a eficácia ou impedi-lo de funcionar.

O valor padrão varia de acordo com o modelo: true para glm-5.3 e false para o outro GLM Modelos.

Este parâmetro só afeta o conteúdo do pensamento de turnos anteriores. Não muda se o modelo gera ou sai pensando na volta atual.

O exemplo a seguir usa as mesmas mensagens multi-volta (com reasoning_content na assistant - Mensagens. Quando clear_thinking Está pronto para true, o conteúdo histórico do pensamento é excluído do contexto, resultando em menos prompt_tokens comparado com false (padrão). A diferença real depende do comprimento do histórico reasoning_content.

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",
    )
    messages = [
      {"role": "user", "content": "What is 15 * 23?"},
      {"role": "assistant", "content": "15 times 23 equals 345.", "reasoning_content": "15 * 23 = 345"},
      {"role": "user", "content": "Now add 55 to that."},
      {"role": "assistant", "content": "345 plus 55 equals 400.", "reasoning_content": "345 + 55 = 400"},
      {"role": "user", "content": "What were the intermediate results?"},
    ]
    completion = client.chat.completions.create(
      model="glm-5.2",
      messages=messages,
      extra_body={
        "thinking": {
          "type": "enabled",
          "clear_thinking": False  # False = retain thinking content
        }
      }
    )
    print(completion.usage.prompt_tokens)  # fewer when true vs false
    ```

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": "glm-5.2",
      "messages": [
        {"role": "user", "content": "What is 15 * 23?"},
        {"role": "assistant", "content": "15 times 23 equals 345.", "reasoning_content": "15 * 23 = 345"},
        {"role": "user", "content": "Now add 55 to that."},
        {"role": "assistant", "content": "345 plus 55 equals 400.", "reasoning_content": "345 + 55 = 400"},
        {"role": "user", "content": "What were the intermediate results?"}
      ],
      "thinking": {
        "type": "enabled",
        "clear_thinking": false
      }
    }'
    ```

API de respostas

glm-5.2 e glm-5.3 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])/developer-guides/tool-calling/web-scraping)), e code_interpreter ([Interpretador de código])/developer-guides/tool-calling/code-interpreter)) ferramentas para o tools parâmetro.

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",
)

response = client.responses.create(
  model="glm-5.2",
  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

**Exemplo código**

```javascript
import OpenAI from "openai";

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

const response = await openai.responses.create({
  model: "glm-5.2",
  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": "glm-5.2",
    "input": "Hello! Please introduce yourself in one sentence.",
    "tools": [
      {"type": "web_search"},
      {"type": "web_extractor"},
      {"type": "code_interpreter"}
    ]
  }'
```

Outras características

Parâmetro padrão

Precauções

Modelos de terceiros em nuvem de código aberto (como glm-5.2A versão oficial realiza validação de limiares em hiperparâmetros e cai para valores padrão quando os limiares são ultrapassados; a versão desempregada pela nuvem passa diretamente através de valores de parâmetros fornecidos pelo usuário sem validação de limiares. Portanto, configurações inadequadas de hiperparametros (como configurações) repetition_penalty para 0.1) pode causar saída inesperada (como impressão repetida). Recomendamos usar os valores padrão de hiperparametro (veja os valores padrão acima) para modelos de código aberto de terceiros e evitando parâmetros personalizados.