Skip to main content

GLM

Este tópico descreve como usar APIs para chamar modelos da série GLM na plataforma Alibaba Cloud Model Studio. Cada modelo inclui 1 milhão de tokens gratuitos.

Cada modelo inclui 1 milhão de tokens gratuitos.

Endpoints de service

Os endpoints de service variam conforme a região. Configure a URL base correspondente à região selecionada.
  • OpenAI compatible
  • DashScope
  • China (Beijing)
  • US (Virginia)
  • Germany (Frankfurt)
  • China (Hong Kong)
  • Singapore
O base_url para chamadas via SDK é: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1Endpoint de solicitação HTTP: POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions
Substitua {WorkspaceId} pelo seu workspace ID real.

Primeiros passos

Os modelos glm-5,2 e glm-5,2-fast-preview são da série GLM. Eles possuem comprimento de contexto de 1M e permitem definir o modo de raciocínio e o modo sem raciocínio por meio do parâmetro enable_thinking. Execute o código abaixo para chamar rapidamente o modelo glm-5,2 no modo de raciocínio. Antes de começar, obtenha uma chave de API e configure-a como variável de ambiente. Se você utilizar um SDK, também será necessário instale o SDK da OpenAI ou do DashScope.
  • OpenAI compatible
  • DashScope
  • Anthropic compatible
O parâmetro enable_thinking não é um parâmetro padrão da OpenAI. No SDK Python da OpenAI, ele é transmitido via extra_body. No SDK Node.js, ele é passado como um parâmetro de nível superior.
  • Python
  • Node.js
  • HTTP

Código de exemplo

from openai import OpenAI
import os

# Initialize the OpenAI client
client = OpenAI(
    # If the environment variable is not configured, replace the value with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # When you make a call, replace {WorkspaceId} with your actual Workspace ID.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

messages = [{"role": "user", "content": "Who are you?"}]
completion = client.chat.completions.create(
    model="glm-5.2",
    messages=messages,
    # Set enable_thinking in extra_body to enable the thinking mode
    extra_body={"enable_thinking": True},
    stream=True,
    stream_options={
        "include_usage": True
    },
)

reasoning_content = ""  # Complete thinking process
answer_content = ""  # Complete response
is_answering = False  # Indicates whether the response phase has started
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

    # Collect only the thinking content
    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

    # After content is received, start the response
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Complete response" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Resposta

====================Thinking process====================

Let me carefully consider the user's question. It seems simple, but it actually has depth.

From a linguistic perspective, the user is using Chinese, which means I should respond in Chinese. This is a basic self-introduction question, but it may have multiple layers of meaning.

First, I need to be clear that as a language model, I should honestly state my identity and nature. I am not a human, nor do I have real emotional awareness. I am an AI assistant trained with deep learning technology. This is the most basic fact.

Second, considering the user's potential scenarios, they might want to know:
1. What services can I provide?
2. What are my areas of expertise?
3. What are my limitations?
4. How can they interact with me better?

In my answer, I should express a friendly and open attitude while remaining professional and accurate. I should state my main areas of expertise, such as knowledge Q&A, writing assistance, and creative support, but also frankly point out my limitations, such as the lack of real emotional experience.

In addition, to make the answer more complete, I should also express a positive attitude of being willing to help users solve problems. I can appropriately guide users to ask more specific questions to better demonstrate my abilities.

Considering this is an open-ended opening, the answer should be both concise and informative, giving the user a clear understanding of my basic situation and laying a good foundation for subsequent conversations.

Finally, the tone should be humble and professional, neither too technical nor too casual, to make the user feel comfortable and natural.
====================Complete response====================

I am a GLM large language model trained by Zhipu AI, designed to provide users with information and help solve problems. I am designed to understand and generate human language, and I can answer questions, provide explanations, or participate in discussions on various topics.

I do not store your personal data, and our conversations are anonymous. Is there any topic I can help you understand or discuss?
====================Token usage====================

CompletionUsage(completion_tokens=344, prompt_tokens=7, total_tokens=351, completion_tokens_details=None, prompt_tokens_details=None)

Chamada de ferramentas em streaming

Os modelos glm-5,2, glm-5,2-fast-preview, glm-5,1 e glm-5 suportam o parâmetro tool_stream. Este parâmetro é booleano, tem como valor padrão false e só entra em vigor quando stream está definido como true. Quando ativado, os argumentos do parâmetro tool_call do Function Calling são retornados incrementalmente em fluxo, em vez de serem entregues todos de uma vez após a conclusão da geração. O comportamento combinado de stream e tool_stream é o seguinte:

stream

tool_stream

Método de retorno de tool_call

true

true

Os argumentos são retornados incrementalmente em múltiplos chunks.

true

false (padrão)

Os argumentos são retornados completamente em um único chunk.

false

true/false

tool_stream não tem efeito. Os argumentos são retornados de uma vez na resposta completa.

  • OpenAI compatible
  • DashScope
  • Python
  • Node.js
  • HTTP

Código de exemplo

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Singapore region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

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

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

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

Esforço de raciocínio (reasoning_effort)

Os modelos glm-5,2, glm-5,2-fast-preview e glm-5,1 têm o modo de raciocínio ativado por padrão. O modelo primeiro gera o processo de raciocínio (reasoning_content) e depois fornece a resposta final. Use o parâmetro reasoning_effort para ajustar o esforço de raciocínio. Um valor mais alto indica um raciocínio mais aprofundado. Os valores suportados variam conforme o modelo. Se você passar um valor não suportado, o sistema retornará um erro invalid_parameter_error. Selecione um valor na tabela a seguir.

Modelo

Valores disponíveis para reasoning_effort

glm-5.2

none (sem raciocínio, reasoning_tokens=0), minimal, low, medium, high, xhigh, max (máximo)

glm-5.2-fast-preview

none (sem raciocínio, reasoning_tokens=0), minimal, low, medium, high, xhigh, max (máximo)

glm-5.1

none, minimal, low, medium, high, xhigh (máximo, max não é suportado)

Para desativar o modo de raciocínio, defina o parâmetro enable_thinking como false no modo compatível com OpenAI ou DashScope. Este parâmetro tem prioridade sobre reasoning_effort.
O modo compatível com Anthropic não suporta o parâmetro reasoning_effort. Para obter o conteúdo de raciocínio, utilize o parâmetro nativo thinking da Anthropic: {"thinking":{"type":"enabled","budget_tokens":1024}}. Quando ativado, o content da resposta incluirá um bloco de raciocínio com type definido como thinking.
  • OpenAI compatible
  • DashScope
Python
from openai import OpenAI
import os
client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Singapore region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.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)

Limpar histórico de raciocínio (clear_thinking)

O parâmetro clear_thinking controla se o reasoning_content (processo de raciocínio) de turnos anteriores em uma conversa de múltiplos turnos é passado ao modelo como contexto. Apenas os modelos da série GLM suportam este parâmetro.
  • true: Ignora o reasoning_content de turnos anteriores. Somente conteúdos não relacionados ao raciocínio, como texto visível, chamadas de ferramentas e resultados, são usados como entrada de contexto. Isso reduz o comprimento do contexto e o custo.
  • false (padrão): Mantém o reasoning_content de turnos anteriores e o fornece ao modelo junto com o contexto. Para ative o Raciocínio Preservado, passe o reasoning_content histórico de forma completa, sem modificações e na ordem original dentro das mensagens. A ausência, corte, reescrita ou reordenação do conteúdo pode degradar o desempenho ou causar falha no recurso.
Este parâmetro afeta apenas o conteúdo histórico de raciocínio entre turnos e não altera se o modelo gera ou produz conteúdo de raciocínio no turno atual.
O exemplo a seguir utiliza o mesmo conjunto de mensagens de múltiplos turnos, onde a mensagem do assistant contém reasoning_content. Quando clear_thinking está definido como true, o conteúdo histórico de raciocínio não é incluído no contexto. Consequentemente, a contagem de prompt_tokens é menor do que quando definido como false (padrão). O valor real depende do comprimento do reasoning_content histórico.
  • OpenAI compatible
  • DashScope
Python
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # When you make a call, replace {WorkspaceId} with your actual Workspace ID.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

# Multi-turn conversation where the assistant message carries reasoning_content (historical thinking process)
messages = [
    {"role": "user", "content": "Please calculate 15 * 23."},
    {"role": "assistant", "content": "15 multiplied by 23 equals 345.", "reasoning_content": "15 * 23 = 345"},
    {"role": "user", "content": "What if you add 55 to that?"},
    {"role": "assistant", "content": "345 plus 55 equals 400.", "reasoning_content": "345 + 55 = 400"},
    {"role": "user", "content": "What was the intermediate result?"},
]

completion = client.chat.completions.create(
    model="glm-5.2",
    messages=messages,
    extra_body={
        "enable_thinking": True,
        # true: Ignores historical reasoning_content to reduce context length and cost
        # false (default): Retains historical reasoning_content (Preserved Thinking)
        "clear_thinking": True,
    },
)
print(completion.usage.prompt_tokens)  # The value is smaller when set to true than when set to false

Outros recursos

ModeloMulti-turn conversationFunction CallingStructured outputWeb searchPartial modeContext cache
glm-5,2SuportadoSuportadoSuportado
Apenas no modo sem raciocínio
Não suportadoNão suportadoSuportado
Apenas cache implícito é suportado
glm-5,2-fast-previewSuportadoSuportadoSuportado
Apenas no modo sem raciocínio
Não suportadoNão suportadoSuportado
Apenas cache implícito é suportado
glm-5,1SuportadoSuportadoSuportado
Apenas no modo sem raciocínio
Não suportadoNão suportadoSuportado
Cache explícito e implícito são suportados
glm-5SuportadoSuportadoSuportado
Apenas no modo sem raciocínio
Não suportadoNão suportadoSuportado
Apenas cache implícito é suportado

Valores padrão dos parâmetros

Modelo

enable_thinking

temperature

top_p

top_k

repetition_penalty

glm-5.2

true

1,0

0,95

20

1,0

glm-5.1

true

1,0

0,95

20

1,0

glm-5

true

1,0

0,95

20

1,0

Para mais informações sobre os parâmetros, consulte OpenAI compatible - Chat.

Precauções

Modelos open-source de terceiros implantados na cloud (como o glm-5,2) lidam com hiperparâmetros de maneira diferente da versão oficial do modelo: a versão oficial valida limiares nos hiperparâmetros e reverte para valores padrão quando os limites são excedidos; já a versão implantada na cloud repassa diretamente os valores fornecidos pelo usuário sem validação de limiar. Portanto, configurações inadequadas de hiperparâmetros (como definir repetition_penalty como 0.1) podem causar saídas inesperadas (como impressão repetida). Recomendamos utilizar os valores padrão de hiperparâmetros (consulte a tabela de valores padrão acima) para modelos open-source de terceiros e evitar parâmetros personalizados.
Ao chamar o modelo, siga os tipos de parâmetros e os campos obrigatórios da API utilizada. Em particular:
  • max_tokens deve ser um número inteiro, como 1024, e não o valor booleano true. Ao chamar glm-5.3, true pode ser tratado como 1, truncando a saída após 1 token sem retornar erro de parâmetro. A saída pode conter apenas o conteúdo de raciocínio, sem uma resposta final.
  • Ao usar a API compatível com Anthropic, cada ferramenta no array tools deve incluir name, como "name": "get_weather". A ausência de name faz a solicitação falhar. Inclua o nome da ferramenta antes de enviar a solicitação.

Modelos e faturamento

Os modelos da série GLM são modelos de raciocínio híbrido desenvolvidos pela Zhipu AI para agentes. Eles oferecem modos de raciocínio e sem raciocínio.
  • glm-5,2: O modelo GLM, com comprimento de contexto de 1M. Suporta Function Calling, saída estruturada e cache implícito. É possível chamá-lo através das interfaces compatíveis com OpenAI, DashScope e Anthropic.
Para informações sobre o comprimento de contexto do modelo e preços, consulte o console do Model Studio. O faturamento é baseado no número de tokens de entrada e saída.
No modo de raciocínio, a cadeia de pensamento é faturada como tokens de saída.

Códigos de erro

Se ocorrer um erro, consulte Error codes para obter informações de solução de problemas.