> ## Documentation Index
> Fetch the complete documentation index at: https://docs.acedata.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# GLM Chat Completion API demande et utilisation

> GLM API guide - Ace Data Cloud

GLM (General Language Model) est une nouvelle génération de modèles de langage lancée par Zhipu AI (Zhipu AI / Z.ai), dotée de puissantes capacités de compréhension et de génération en chinois et en anglais, avec d'excellentes performances dans des tâches telles que les scénarios en chinois, la génération de code, le raisonnement et les dialogues multi-tours. Les nouveaux modèles de la génération GLM-5.3, GLM-5.2, GLM-4.7, etc., ont été largement optimisés pour les contextes longs, les appels d'outils et les tâches de code, et peuvent être largement appliqués à des scénarios tels que les questions-réponses intelligentes, la création de contenu, l'assistance à la programmation, et les robots de service client.

Ce document présente principalement le processus d'utilisation de l'API GLM Chat Completion, qui vous permet d'appeler facilement les modèles de la série GLM via une interface compatible avec OpenAI.

## Processus de demande

Pour utiliser l'API GLM Chat Completion, commencez par obtenir votre token API sur le [tableau de bord Ace Data Cloud](https://platform.acedata.cloud/console/applications) pour le garder en réserve.

![](https://cdn.acedata.cloud/dvc3cg.jpg)

Si vous n'êtes pas encore connecté ou inscrit, vous serez automatiquement redirigé vers la page de connexion pour vous inviter à vous inscrire et à vous connecter, après quoi vous serez automatiquement renvoyé à la page actuelle.

**Un seul token API suffit pour appeler tous les services de la plateforme, sans avoir besoin de demander séparément pour chaque service.** La première demande vous donnera un quota gratuit pour une expérience sans frais ; lorsque le quota est insuffisant, vous pouvez recharger le solde général dans le [tableau de bord](https://platform.acedata.cloud/console/coin).

> 📘 Documentation complète : [GLM Chat Completion API →](https://platform.acedata.cloud/documents/glm-chat-completions)

## Utilisation de base

L'adresse de requête de l'API GLM Chat Completion est `https://api.acedata.cloud/glm/chat/completions`, utilisant l'authentification Bearer Token, le corps de la requête étant compatible avec le protocole OpenAI Chat Completions.

Lors de la première utilisation de cette interface, nous devons remplir au moins trois contenus :

* `authorization` : sélectionnez simplement le Bearer Token dans la liste déroulante.
* `model` : choisissez le modèle GLM à appeler, les modèles actuellement pris en charge incluent :
  * `glm-5.3` : le modèle phare le plus récent, prenant en charge 1M de contexte et jusqu'à 128K de sortie, adapté aux tâches de raisonnement complexes, de code et d'agent. Le raisonnement est toujours activé, et vous pouvez choisir `reasoning_effort` comme `low`, `high` ou `max`.
  * `glm-5.2` : le modèle phare de la génération précédente, avec de fortes capacités globales.
  * `glm-5.1` : modèle phare mature, adapté aux tâches complexes générales.
  * `glm-4.7` : excellent dans les tâches de raisonnement, d'appels d'outils et de code.
  * `glm-4.6` : modèle de dialogue général, équilibrant efficacité et coût.
  * `glm-3-turbo` : modèle de dialogue classique, adapté aux tâches de génération de texte général.
* `messages` : tableau de messages, chaque message contenant `role` et `content`, `role` prenant en charge trois rôles : `user`, `assistant`, `system`.

Paramètres optionnels courants :

* `max_tokens` : limite le nombre maximum de tokens pour une seule réponse.
* `temperature` : aléatoire de génération, entre 0 et 2, plus la valeur est élevée, plus elle est dispersée.
* `top_p` : paramètre d'échantillonnage nucléaire, contrôlant le seuil de probabilité cumulée des tokens candidats.
* `n` : combien de réponses candidates générer à la fois.
* `stream` : active ou non la réponse en continu, par défaut `false`.
* `stop` : séquence d'arrêt personnalisée.

Voici un exemple d'appel Python le plus simple :

```python theme={null}
import requests

url = "https://api.acedata.cloud/glm/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "glm-5.2",
    "messages": [
        {"role": "user", "content": "hello"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
```

Après l'appel, nous constatons que le résultat retourné est le suivant :

```json theme={null}
{
  "id": "msg_202604262252030313862701a04e33",
  "model": "glm-5.2",
  "object": "chat.completion",
  "created": 1777215124,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! 👋 How can I assist you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 23,
    "total_tokens": 33
  }
}
```

Les principales explications des champs de retour sont les suivantes :

* `id` : l'ID unique de cette tâche de dialogue.
* `created` : le temps de création de cette tâche de dialogue (timestamp Unix, en secondes).
* `model` : le nom du modèle GLM réellement appelé.
* `choices` : liste des réponses générées par le modèle. `choices[i].message.content` est le texte spécifique de la réponse du modèle, `finish_reason` indique la raison de la fin (`stop`, `length`, `tool_calls`, `content_filter`, etc.).
* `usage` : statistiques d'utilisation des tokens pour cette demande, incluant `prompt_tokens`, `completion_tokens`, `total_tokens`.

## Réponse en continu

Cette interface prend en charge les réponses en continu (Server-Sent Events), ce qui est très utile pour l'intégration web, permettant d'afficher les résultats lettre par lettre.

Si vous souhaitez retourner une réponse en continu, il suffit de définir le paramètre `stream` dans le corps de la requête sur `true`.

Exemple de code d'appel Python :

```python theme={null}
import requests

url = "https://api.acedata.cloud/glm/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "glm-4.7",
    "messages": [{"role": "user", "content": "hi"}],
    "stream": True
}

response = requests.post(url, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))
```

L'effet de sortie est le suivant (extrait) :

```text theme={null}
data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {"content": "", "role": "assistant"}, "finish_reason": null, "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {"content": "Bonjour ! Que puis-je"}, "finish_reason": null, "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {"content": "faire pour vous"}, "finish_reason": null, "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {"content": "?"}, "finish_reason": null, "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {}, "finish_reason": "stop", "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [], "usage": {"prompt_tokens": 1420, "completion_tokens": 18, "total_tokens": 1438}}

data: [DONE]
```

On peut voir que la réponse contient de nombreuses `data`, chaque `data` contient un segment incrémental. `choices[i].delta.content` est le segment de texte nouvellement ajouté dans le chunk actuel, vous pouvez assembler ces segments pour former une réponse complète. Lorsque le contenu de `data` est `[DONE]`, cela indique que la réponse en streaming est terminée. Le dernier chunk avec `usage` résumera l'utilisation des tokens pour cette demande.

Exemple en JavaScript (Node.js) :

```javascript theme={null}
const options = {
  method: "POST",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json"
  },
  body: JSON.stringify({
    model: "glm-4.7",
    messages: [{ role: "user", content: "salut" }],
    stream: true
  })
};

const response = await fetch("https://api.acedata.cloud/glm/chat/completions", options);
const reader = response.body.getReader();
const decoder = new TextDecoder("utf-8");
while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  process.stdout.write(decoder.decode(value));
}
```

Exemple de code Java :

```java theme={null}
JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "glm-4.7");
jsonObject.put("messages", new JSONArray().put(new JSONObject().put("role", "user").put("content", "salut")));
jsonObject.put("stream", true);
MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
RequestBody body = RequestBody.create(jsonObject.toString(), mediaType);
Request request = new Request.Builder()
  .url("https://api.acedata.cloud/glm/chat/completions")
  .post(body)
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer {token}")
  .addHeader("content-type", "application/json")
  .build();

OkHttpClient client = new OkHttpClient();
Response response = client.newCall(request).execute();
System.out.println(response.body().string());
```

D'autres langages peuvent être réécrits de la même manière, le principe est le même.

## Dialogue multi-tours

Si vous souhaitez réaliser une fonctionnalité de dialogue multi-tours, vous devez placer les dialogues historiques dans le tableau `messages` et conserver l'ordre alterné entre `user` et `assistant`.

Exemple d'appel en Python :

```python theme={null}
import requests

url = "https://api.acedata.cloud/glm/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "user", "content": "Bonjour"},
        {"role": "assistant", "content": "Salut ! Comment puis-je vous aider aujourd'hui ?"},
        {"role": "user", "content": "Qu'est-ce que j'ai dit tout à l'heure ?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)
```

En téléchargeant plusieurs questions, vous pouvez facilement réaliser un dialogue multi-tours et obtenir la réponse suivante :

```json theme={null}
{
  "id": "msg_20260426225208b95324e9945a48d3",
  "model": "glm-4.7",
  "object": "chat.completion",
  "created": 1777215128,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Vous avez dit : **\"Bonjour\"** 😊\n\nFaites-moi savoir si vous avez besoin de quelque chose d'autre !"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 37,
    "total_tokens": 85
  }
}
```

On peut voir que les informations contenues dans `choices` sont cohérentes avec l'utilisation de base, le modèle répond sur la base de l'historique complet de la conversation, permettant ainsi une interaction contextuelle multi-tours.

## Message de système (System Prompt)

Vous pouvez ajouter un message avec un `role` de `system` au début de `messages` pour contraindre le rôle, le style ou le comportement du modèle :

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "system", "content": "Vous êtes un assistant d'écriture en chinois expérimenté, veuillez répondre de manière concise et professionnelle."},
        {"role": "user", "content": "Veuillez présenter le modèle GLM en trois phrases."}
    ]
}
```

## Appel d'outils (Function Calling)

Le modèle GLM prend en charge l'appel de fonctions compatible avec OpenAI, vous pouvez déclarer les fonctions appelables via le paramètre `tools`, le modèle renverra des informations structurées sur l'appel de fonction dans `choices[i].message.tool_calls` lorsque cela est nécessaire.

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "user", "content": "Quel temps fait-il à Pékin aujourd'hui ?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Vérifier la météo d'une ville donnée",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "Nom de la ville"}
                    },
                    "required": ["city"]
                }
            }
        }
    ]
}
```

Si le modèle décide d'appeler un outil, la raison de fin dans le résultat changera en `tool_calls`, et le nom de la fonction ainsi que les paramètres sous forme de chaîne JSON seront fournis dans `message.tool_calls`. Vous pouvez exécuter cette fonction et renvoyer le résultat en tant que message avec `role` de `tool` au modèle, complétant ainsi le cycle d'appel d'outil.

## Suggestions de choix de modèle

````
| Modèle          | Scénarios d'application                             |
| --------------- | -------------------------------------------------- |
| `glm-5.3`      | Dernier fleuron, 1M de contexte, sortie maximale de 128K, recommandé pour des raisonnements complexes, des tâches de code et d'agent |
| `glm-5.2`      | Fleuron de la génération précédente, adapté aux raisonnements complexes, aux tâches de code et d'agent                    |
| `glm-5.1`      | Fleuron mature, adapté aux raisonnements complexes, à l'analyse de longs documents                            |
| `glm-4.7`      | Appels d'outils, génération de code, orchestration d'agents, etc.                        |
| `glm-4.6`      | Choix équilibré pour les dialogues généraux et la création de contenu                               |
| `glm-3-turbo`  | Tâches générales de génération de texte, scénarios sensibles aux coûts                            |

## Gestion des erreurs

Lors de l'appel de l'API, si une erreur se produit, l'API renverra le code d'erreur et les informations correspondantes. Par exemple :

- `400 token_mismatched` : Paramètres de demande manquants ou invalides.
- `400 api_not_implemented` : Utilisation de paramètres ou de modèles non pris en charge.
- `401 invalid_token` : Non autorisé, Bearer Token manquant ou expiré.
- `429 too_many_requests` : Limite de fréquence atteinte, veuillez réessayer plus tard.
- `500 api_error` : Erreur interne du serveur ou indisponibilité temporaire en amont.

### Exemple de réponse d'erreur

```json
{
  "trace_id": "69ea9bcf-c5da-41a3-be97-c80912a08523",
  "error": {
    "code": "api_error",
    "message": "Le service est temporairement indisponible, veuillez réessayer plus tard."
  }
}
````

Lorsque `api_error` est renvoyé et que le message est `Le service est temporairement indisponible, veuillez réessayer plus tard.`, cela indique généralement que le service GLM en amont est temporairement indisponible, il est conseillé de réessayer avec un backoff exponentiel, ou de passer à un autre modèle GLM disponible (par exemple, passer temporairement de `glm-5.1` à `glm-4.7` ou `glm-4.6`).

## Conclusion

Grâce à ce document, vous avez compris comment utiliser l'API GLM Chat Completion pour appeler les modèles de la série GLM de Zhiyu AI, y compris les appels de base, les réponses en streaming, les dialogues multi-tours, les invites système et les appels d'outils, etc. Nous espérons que ce document vous aidera à mieux intégrer et utiliser cette API. Si vous avez des questions, n'hésitez pas à contacter notre équipe de support technique.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.