Skip to main content

GLM

Cette rubrique explique comment utiliser les API pour appeler les modèles de la série GLM sur la plateforme Alibaba Cloud Model Studio. Chaque modèle inclut 1 million de tokens gratuits.

Chaque modèle inclut 1 million de tokens gratuits.

Endpoints de service

Les endpoints de service varient selon la région. Configurez l'URL de base correspondant à la région sélectionnée.
  • OpenAI compatible
  • DashScope
  • China (Beijing)
  • US (Virginia)
  • Germany (Frankfurt)
  • China (Hong Kong)
  • Singapore
L'URL base_url pour les appels SDK est : https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1Endpoint de requête HTTP : POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions
Remplacez {WorkspaceId} par votre véritable ID d'espace de travail.

Premiers pas

Les modèles glm-5,2 et glm-5,2-fast-preview sont les plus récents de la série GLM. Ils disposent d'une longueur de contexte de 1M et permettent d'activer ou de désactiver le mode réflexion via le paramètre enable_thinking. Exécutez le code suivant pour appeler rapidement le modèle glm-5,2 en mode réflexion. Avant de commencer, obtenez une clé API et configurez-la comme variable d'environnement. Si vous utilisez un SDK, vous devez également installer le SDK OpenAI ou DashScope.
  • OpenAI compatible
  • DashScope
  • Anthropic compatible
Le paramètre enable_thinking n'est pas un paramètre standard OpenAI. Dans le SDK Python OpenAI, il se transmet via extra_body. Dans le SDK Node.js, il s'agit d'un paramètre de premier niveau.
  • Python
  • Node.js
  • HTTP

Exemple de code

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

Réponse

====================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)

Appel d'outils en streaming

Les modèles glm-5,2, glm-5,2-fast-preview, glm-5,1 et glm-5 prennent en charge le paramètre tool_stream. Ce paramètre booléen, dont la valeur par défaut est false, ne prend effet que lorsque stream est défini sur true. Une fois activé, les arguments du paramètre tool_call issu du Function Calling sont renvoyés de manière incrémentielle dans le flux, plutôt qu'en une seule fois après la génération complète. Le comportement combiné de stream et tool_stream est le suivant :

stream

tool_stream

Mode de retour de tool_call

true

true

Les arguments sont renvoyés de manière incrémentielle en plusieurs chunks.

true

false (par défaut)

Les arguments sont renvoyés intégralement dans un seul chunk.

false

true/false

tool_stream n'a aucun effet. Les arguments sont renvoyés en une seule fois dans la réponse complète.

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

Exemple de code

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

Niveau de raisonnement (reasoning_effort)

Les modèles glm-5,2, glm-5,2-fast-preview et glm-5,1 ont le mode réflexion activé par défaut. Le modèle génère d'abord le processus de réflexion (reasoning_content) avant de fournir la réponse finale. Utilisez le paramètre reasoning_effort pour ajuster l'intensité du raisonnement. Une valeur plus élevée indique une réflexion plus approfondie. Les valeurs prises en charge varient selon le modèle. Si vous transmettez une valeur non prise en charge, une erreur invalid_parameter_error est renvoyée. Sélectionnez une valeur dans le tableau suivant.

Modèle

Valeurs disponibles pour reasoning_effort

glm-5,2

none (aucun raisonnement, reasoning_tokens=0), minimal, low, medium, high, xhigh, max (maximum)

glm-5,2-fast-preview

none (aucun raisonnement, reasoning_tokens=0), minimal, low, medium, high, xhigh, max (maximum)

glm-5,1

none, minimal, low, medium, high, xhigh (maximum, max n'est pas pris en charge)

Pour désactiver le mode réflexion, définissez le paramètre enable_thinking sur false en mode compatible OpenAI ou DashScope. Ce paramètre est prioritaire sur reasoning_effort.
Le mode compatible Anthropic ne prend pas en charge le paramètre reasoning_effort. Pour obtenir le contenu de réflexion, utilisez le paramètre natif Anthropic thinking : {"thinking":{"type":"enabled","budget_tokens":1024}}. Une fois activé, le content de la réponse inclura un bloc de réflexion avec type défini sur 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)

Effacer l'historique de réflexion (clear_thinking)

Le paramètre clear_thinking contrôle si le reasoning_content (processus de réflexion) des tours précédents d'une conversation multi-tours est transmis au modèle comme contexte. Seuls les modèles de la série GLM prennent en charge ce paramètre.
  • true : Ignore le reasoning_content des tours précédents. Seul le contenu non lié au raisonnement, tel que le texte visible, les appels d'outils et les résultats, est utilisé comme entrée de contexte. Cela réduit la longueur du contexte et le coût.
  • false (par défaut) : Conserve le reasoning_content des tours précédents et le fournit au modèle avec le contexte. Pour activer la conservation de la réflexion, vous devez transmettre l'historique complet du reasoning_content, sans modification et dans l'ordre d'origine au sein des messages. L'absence, la troncature, la réécriture ou le réordonnancement du contenu peut dégrader les performances ou provoquer l'échec de la fonctionnalité.
Ce paramètre affecte uniquement le contenu de réflexion historique entre les tours et ne modifie pas la génération ou la sortie du contenu de réflexion par le modèle lors du tour en cours.
L'exemple suivant utilise le même ensemble de messages multi-tours, où le message assistant contient du reasoning_content. Lorsque clear_thinking est défini sur true, le contenu de réflexion historique n'est pas inclus dans le contexte. Par conséquent, le nombre de prompt_tokens est inférieur à celui obtenu lorsqu'il est défini sur false (par défaut). La valeur réelle dépend de la longueur du reasoning_content historique.
  • 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

Autres fonctionnalités

ModèleConversation multi-toursFunction CallingSortie structuréeRecherche WebMode partielCache de contexte
glm-5,2Pris en chargePris en chargePris en charge
Uniquement en mode sans réflexion
Non pris en chargeNon pris en chargePris en charge
Seul le cache implicite est pris en charge
glm-5,2-fast-previewPris en chargePris en chargePris en charge
Uniquement en mode sans réflexion
Non pris en chargeNon pris en chargePris en charge
Seul le cache implicite est pris en charge
glm-5,1Pris en chargePris en chargePris en charge
Uniquement en mode sans réflexion
Non pris en chargeNon pris en chargePris en charge
Les caches explicite et implicite sont tous deux pris en charge
glm-5Pris en chargePris en chargePris en charge
Uniquement en mode sans réflexion
Non pris en chargeNon pris en chargePris en charge
Seul le cache implicite est pris en charge

Valeurs par défaut des paramètres

Modèle

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

Pour plus d'informations sur les paramètres, consultez Compatible OpenAI - Chat.

Précautions

Les modèles open source tiers déployés dans le cloud (tels que glm-5,2) gèrent les hyperparamètres différemment de la version officielle du modèle : la version officielle effectue une validation des seuils sur les hyperparamètres et revient aux valeurs par défaut lorsque ces seuils sont dépassés ; la version déployée dans le cloud transmet directement les valeurs de paramètres fournies par l'utilisateur sans validation de seuil. Par conséquent, des réglages inappropriés des hyperparamètres (comme définir repetition_penalty sur 0.1) peuvent entraîner des sorties inattendues (telles que des impressions répétées). Nous recommandons d'utiliser les valeurs d'hyperparamètres par défaut (voir le tableau des valeurs par défaut ci-dessus) pour les modèles open source tiers et d'éviter les paramètres personnalisés.
Lorsque vous appelez le modèle, respectez les types de paramètres et les champs obligatoires de l'API utilisée. En particulier :
  • max_tokens doit être un entier, tel que 1024, et non la valeur booléenne true. Lors d'un appel à glm-5.3, true peut être traité comme 1, ce qui tronque la sortie après 1 token sans renvoyer d'erreur de paramètre. La sortie peut contenir uniquement le contenu de réflexion, sans réponse finale.
  • Lorsque vous utilisez l'API compatible Anthropic, chaque outil du tableau tools doit inclure name, par exemple "name": "get_weather". L'absence de name entraîne l'échec de la requête. Renseignez le nom de l'outil avant d'envoyer la requête.

Modèles et facturation

Les modèles de la série GLM sont des modèles de raisonnement hybrides conçus par Zhipu AI pour les agents. Ils offrent à la fois des modes avec et sans réflexion.
  • glm-5,2 : Le modèle GLM avec une longueur de contexte de 1M. Il prend en charge le Function Calling, la sortie structurée et le cache implicite. Vous pouvez l'appeler via les interfaces compatibles OpenAI, DashScope et Anthropic.
Pour obtenir des informations sur la longueur de contexte des modèles et leur tarification, consultez la console Model Studio. La facturation est basée sur le nombre de tokens d'entrée et de sortie.
En mode réflexion, la chaîne de pensée est facturée comme des tokens de sortie.

Codes d'erreur

En cas d'erreur, consultez la rubrique Codes d'erreur pour obtenir des informations de dépannage.