> ## 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 Antrag und Nutzung

> GLM API guide - Ace Data Cloud

GLM (General Language Model) ist eine neue Generation von großen Sprachmodellen, die von Zhipu AI (Zhipu AI / Z.ai) eingeführt wurde und über starke Fähigkeiten in der Verständnis- und Generierung von Chinesisch und Englisch verfügt. In chinesischen Szenarien, bei der Codegenerierung, beim Schlussfolgern und in mehrstufigen Dialogen zeigt es hervorragende Leistungen. Die neuen Modelle GLM-5.3, GLM-5.2, GLM-4.7 usw. wurden in Bezug auf lange Kontexte, Toolaufrufe und Codeaufgaben stark optimiert und können in intelligenten Frage-Antwort-Systemen, Inhaltskreation, Codeunterstützung, Kundenservice-Robotern und anderen Szenarien weit verbreitet eingesetzt werden.

Dieses Dokument beschreibt hauptsächlich den Ablauf der Nutzung der GLM Chat Completion API. Damit können Sie die GLM-Modellreihe einfach über eine einheitliche OpenAI-kompatible Schnittstelle aufrufen.

## Antragsprozess

Um die GLM Chat Completion API zu nutzen, müssen Sie zunächst im [Ace Data Cloud Dashboard](https://platform.acedata.cloud/console/applications) Ihr API-Token abrufen und für zukünftige Verwendung aufbewahren.

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

Wenn Sie noch nicht angemeldet oder registriert sind, werden Sie automatisch zur Anmeldeseite weitergeleitet, wo Sie zur Registrierung und Anmeldung eingeladen werden. Nach Abschluss werden Sie automatisch zur aktuellen Seite zurückgeleitet.

**Ein API-Token reicht aus, um alle Dienste der Plattform aufzurufen, es ist nicht erforderlich, für jeden Dienst separat zu beantragen.** Bei der ersten Beantragung erhalten Sie ein kostenloses Kontingent, um es kostenlos auszuprobieren; wenn das Kontingent nicht ausreicht, können Sie im [Dashboard](https://platform.acedata.cloud/console/coin) Ihr allgemeines Guthaben aufladen.

> 📘 Vollständige Dokumentation: [GLM Chat Completion API →](https://platform.acedata.cloud/documents/glm-chat-completions)

## Grundlegende Nutzung

Die Anforderungsadresse der GLM Chat Completion API lautet `https://api.acedata.cloud/glm/chat/completions`, die Authentifizierung erfolgt über Bearer Token, der Anforderungstext ist mit dem OpenAI Chat Completions-Protokoll kompatibel.

Bei der ersten Nutzung dieser Schnittstelle müssen wir mindestens drei Inhalte ausfüllen:

* `authorization`: Wählen Sie einfach Bearer Token aus der Dropdown-Liste aus.
* `model`: Wählen Sie das GLM-Modell aus, das Sie aufrufen möchten. Die derzeit unterstützten Modelle sind:
  * `glm-5.3`: Neuestes Flaggschiffmodell, unterstützt 1M Kontext und maximal 128K Ausgabe, geeignet für komplexe Schlussfolgerungen, Code- und Agentenaufgaben. Schlussfolgerungen sind immer aktiviert, Sie können `reasoning_effort` auf `low`, `high` oder `max` setzen.
  * `glm-5.2`: Vorgängermodell mit starken Gesamtfähigkeiten.
  * `glm-5.1`: Reifes Flaggschiffmodell, geeignet für allgemeine komplexe Aufgaben.
  * `glm-4.7`: Hervorragende Leistung bei Schlussfolgerungen, Toolaufrufen und Codeaufgaben.
  * `glm-4.6`: Universelles Dialogmodell, das Effektivität und Kosten ausbalanciert.
  * `glm-3-turbo`: Klassisches Dialogmodell, geeignet für allgemeine Textgenerierungsaufgaben.
* `messages`: Array von Eingabewörtern, jede Nachricht enthält `role` und `content`, `role` unterstützt die drei Rollen `user`, `assistant`, `system`.

Häufig verwendete optionale Parameter:

* `max_tokens`: Begrenzung der maximalen Token-Anzahl pro Antwort.
* `temperature`: Zufälligkeit der Generierung, zwischen 0-2, je höher der Wert, desto divergenter.
* `top_p`: Kernsampling-Parameter, der die kumulative Wahrscheinlichkeitsgrenze der Kandidaten-Token steuert.
* `n`: Anzahl der zu generierenden Kandidatenantworten.
* `stream`: Ob die Streaming-Antwort aktiviert werden soll, standardmäßig `false`.
* `stop`: Benutzerdefinierte Stoppsequenz.

Hier ist ein einfaches Beispiel für einen Python-Aufruf:

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

Nach dem Aufruf stellen wir fest, dass das Rückgabeergebnis wie folgt aussieht:

```json theme={null}
{
  "id": "msg_202604262252030313862701a04e33",
  "model": "glm-5.2",
  "object": "chat.completion",
  "created": 1777215124,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hallo! 👋 Wie kann ich Ihnen heute helfen?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 23,
    "total_tokens": 33
  }
}
```

Die wichtigsten Felder der Rückgabeergebnisse sind wie folgt erklärt:

* `id`: Die eindeutige ID der aktuellen Dialogaufgabe.
* `created`: Die Erstellungszeit der aktuellen Dialogaufgabe (Unix-Zeitstempel, in Sekunden).
* `model`: Der tatsächlich aufgerufene Name des GLM-Modells.
* `choices`: Liste der vom Modell generierten Antworten. `choices[i].message.content` ist der spezifische Text der Modellantwort, `finish_reason` kennzeichnet den Grund für das Ende (`stop`, `length`, `tool_calls`, `content_filter` usw.).
* `usage`: Statistiken zur Token-Nutzung dieser Anfrage, einschließlich `prompt_tokens`, `completion_tokens`, `total_tokens`.

## Streaming-Antwort

Diese Schnittstelle unterstützt Streaming-Antworten (Server-Sent Events), was für die Integration in Webseiten sehr nützlich ist, da es ermöglicht, die Ausgabe Wort für Wort anzuzeigen.

Wenn Sie eine Streaming-Antwort zurückgeben möchten, setzen Sie den `stream`-Parameter im Anforderungstext auf `true`.

Python-Beispielaufruf:

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

Die Ausgabe sieht wie folgt aus (Auszug):

```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": "Hallo! Was kann ich"}, "finish_reason": null, "index": 0}], "usage": null}

data: {"id": "msg_2026042622521271f765bbc3734ce1", "object": "chat.completion.chunk", "created": 1777215133, "model": "glm-4.7", "choices": [{"delta": {"content": "dir helfen"}, "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]
```

Es ist zu sehen, dass die Antwort viele `data` enthält, wobei jede `data` einen inkrementellen Abschnitt enthält. `choices[i].delta.content` ist der aktuell hinzugefügte Textabschnitt, den Sie zusammenfügen können, um die vollständige Antwort zu bilden. Wenn der Inhalt von `data` `[DONE]` ist, bedeutet dies, dass die Streaming-Antwort beendet ist. Der letzte Abschnitt mit `usage` fasst den Tokenverbrauch dieser Anfrage zusammen.

JavaScript (Node.js) Beispiel:

```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: "hi" }],
    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));
}
```

Java Beispielcode:

```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", "hi")));
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());
```

Andere Sprachen können ebenfalls angepasst werden, das Prinzip bleibt dasselbe.

## Mehrere Runden im Dialog

Wenn Sie eine Funktion für mehrere Runden im Dialog implementieren möchten, müssen Sie die historischen Dialoge nacheinander in das `messages`-Array einfügen und die abwechselnde Reihenfolge von `user` und `assistant` beibehalten.

Python Beispielaufrufcode:

```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": "Hallo"},
        {"role": "assistant", "content": "Hallo! Wie kann ich Ihnen heute helfen?"},
        {"role": "user", "content": "Was habe ich gerade gesagt?"}
    ]
}

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

Durch das Hochladen mehrerer Fragen können Sie leicht mehrere Runden im Dialog realisieren und erhalten folgende Antwort:

```json theme={null}
{
  "id": "msg_20260426225208b95324e9945a48d3",
  "model": "glm-4.7",
  "object": "chat.completion",
  "created": 1777215128,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Sie haben gesagt: **\"Hallo\"** 😊\n\nLassen Sie mich wissen, ob Sie noch etwas benötigen!"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 37,
    "total_tokens": 85
  }
}
```

Es ist zu sehen, dass die Informationen in `choices` mit der grundlegenden Nutzung übereinstimmen, das Modell gibt basierend auf der vollständigen Dialoghistorie eine Antwort, um mehrere Runden kontextuelle Interaktionen zu unterstützen.

## System-Prompt

Sie können am Anfang von `messages` eine Nachricht mit der Rolle `system` hinzufügen, um die Rolle, den Stil oder das Verhalten des Modells einzuschränken:

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "system", "content": "Sie sind ein erfahrener chinesischer Schreibassistent, bitte antworten Sie in einem prägnanten und professionellen Ton."},
        {"role": "user", "content": "Bitte stellen Sie das GLM-Modell in drei Sätzen vor."}
    ]
}
```

## Funktionsaufruf

Das GLM-Modell unterstützt OpenAI-kompatible Funktionsaufrufe, die über den Parameter `tools` deklarierte Funktionen aufrufen können. Das Modell gibt bei Bedarf in `choices[i].message.tool_calls` strukturierte Informationen zu Funktionsaufrufen zurück.

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "user", "content": "Wie ist das Wetter heute in Peking?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Fragt das Wetter in einer bestimmten Stadt ab",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "Stadtname"}
                    },
                    "required": ["city"]
                }
            }
        }
    ]
}
```

Wenn das Modell beschließt, ein Werkzeug aufzurufen, ändert sich der `finish_reason` in `tool_calls`, und in `message.tool_calls` werden der Funktionsname und die Parameter im JSON-String-Format angegeben. Sie können diese Funktion ausführen und das Ergebnis als Nachricht mit der Rolle `tool` an das Modell zurückgeben, um den vollständigen Funktionsaufrufzyklus abzuschließen.

## Empfehlungen zur Modellauswahl

````
| Modell          | Anwendungsbereich                                 |
| --------------- | ------------------------------------------------- |
| `glm-5.3`      | Neueste Flagship, 1M Kontext, längste 128K Ausgabe, empfohlen für komplexe Schlussfolgerungen, Code- und Agentenaufgaben |
| `glm-5.2`      | Vorgängermodell, geeignet für komplexe Schlussfolgerungen, Code- und Agentenaufgaben                    |
| `glm-5.1`      | Ausgereiftes Flagship, geeignet für komplexe Schlussfolgerungen, lange Dokumentenanalyse                            |
| `glm-4.7`      | Werkzeugaufrufe, Codegenerierung, Agentenorchestrierung und ähnliche Aufgaben                        |
| `glm-4.6`      | Ausgewogene Wahl für allgemeine Gespräche und Inhaltserstellung                               |
| `glm-3-turbo`  | Allgemeine Textgenerierungsaufgaben, kostensensible Szenarien                            |

## Fehlerbehandlung

Bei der API-Nutzung, wenn ein Fehler auftritt, gibt die API den entsprechenden Fehlercode und die Informationen zurück. Zum Beispiel:

- `400 token_mismatched`: Fehlende oder ungültige Anforderungsparameter.
- `400 api_not_implemented`: Verwendung von nicht unterstützten Parametern oder Modellen.
- `401 invalid_token`: Unautorisiert, Bearer-Token fehlt oder ist ungültig.
- `429 too_many_requests`: Frequenzlimit überschritten, bitte später erneut versuchen.
- `500 api_error`: Interner Serverfehler oder vorübergehend nicht verfügbar.

### Fehlerantwortbeispiel

```json
{
  "trace_id": "69ea9bcf-c5da-41a3-be97-c80912a08523",
  "error": {
    "code": "api_error",
    "message": "Der Dienst ist vorübergehend nicht verfügbar, bitte später erneut versuchen."
  }
}
````

Wenn `api_error` zurückgegeben wird und die Nachricht `Der Dienst ist vorübergehend nicht verfügbar, bitte später erneut versuchen.` lautet, bedeutet dies normalerweise, dass der upstream GLM-Dienst vorübergehend nicht verfügbar ist. Es wird empfohlen, mit exponentiellem Backoff erneut zu versuchen oder auf ein anderes verfügbares GLM-Modell umzuschalten (zum Beispiel vorübergehend von `glm-5.1` auf `glm-4.7` oder `glm-4.6` zu wechseln).

## Fazit

Durch dieses Dokument haben Sie gelernt, wie Sie die GLM Chat Completion API zur Nutzung der GLM-Modellreihe von Zhiyu AI aufrufen, einschließlich grundlegender Aufrufe, Streaming-Antworten, mehrerer Dialoge, System-Prompts und Werkzeugaufrufen. Wir hoffen, dass dieses Dokument Ihnen hilft, die API besser zu integrieren und zu nutzen. Bei Fragen wenden Sie sich bitte jederzeit an unser technisches Support-Team.


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