> ## 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 申请及使用

> GLM API guide - Ace Data Cloud

GLM（General Language Model）to nowa generacja modeli językowych wprowadzonych przez Zhipu AI (Zhipu AI / Z.ai), która posiada silne zdolności rozumienia i generowania w języku chińskim i angielskim, osiągając doskonałe wyniki w zadaniach związanych z chińskim kontekstem, generowaniem kodu, wnioskowaniem i wieloma rundami dialogów. Nowe modele, takie jak GLM-5.3, GLM-5.2, GLM-4.7, zostały znacznie zoptymalizowane w zakresie długiego kontekstu, wywoływania narzędzi i zadań związanych z kodem, co pozwala na szerokie zastosowanie w inteligentnych systemach odpowiedzi, tworzeniu treści, wsparciu kodu, chatbotach itp.

Dokument ten głównie opisuje proces korzystania z GLM Chat Completion API, dzięki któremu można łatwo wywoływać modele serii GLM za pomocą jednolitego interfejsu zgodnego z OpenAI.

## 申请流程

Aby korzystać z GLM Chat Completion API, najpierw przejdź do [Ace Data Cloud 控制台](https://platform.acedata.cloud/console/applications), aby uzyskać swój token API, który należy zachować na przyszłość.

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

Jeśli nie jesteś zalogowany lub zarejestrowany, automatycznie zostaniesz przekierowany na stronę logowania, aby zarejestrować się i zalogować, a po zakończeniu zostaniesz automatycznie przekierowany z powrotem na bieżącą stronę.

**Jeden token API wystarczy do wywołania wszystkich usług platformy, nie ma potrzeby składania osobnych wniosków dla każdej usługi.** Przy pierwszym wniosku przyznawana jest darmowa kwota, aby można było skorzystać z doświadczenia; w przypadku niewystarczającej kwoty można doładować saldo ogólne w [kontrolerze](https://platform.acedata.cloud/console/coin).

> 📘 Pełna dokumentacja: [GLM Chat Completion API →](https://platform.acedata.cloud/documents/glm-chat-completions)

## 基本使用

Adres żądania GLM Chat Completion API to `https://api.acedata.cloud/glm/chat/completions`, używając autoryzacji Bearer Token, ciało żądania jest zgodne z protokołem OpenAI Chat Completions.

Podczas pierwszego użycia tego interfejsu musimy wypełnić co najmniej trzy elementy:

* `authorization`: wystarczy wybrać Bearer Token z rozwijanej listy.
* `model`: wybierz model GLM, który chcesz wywołać, obecnie obsługiwane modele to:
  * `glm-5.3`: najnowszy flagowy model, obsługujący 1M kontekstu i maksymalnie 128K wyjścia, odpowiedni do złożonego wnioskowania, zadań związanych z kodem i Agentów. Wnioskowanie jest zawsze włączone, można wybrać `reasoning_effort` jako `low`, `high` lub `max`.
  * `glm-5.2`: poprzedni flagowy model, o silnych zdolnościach ogólnych.
  * `glm-5.1`: dojrzały flagowy model, odpowiedni do ogólnych złożonych zadań.
  * `glm-4.7`: doskonałe wyniki w wnioskowaniu, wywoływaniu narzędzi i zadaniach związanych z kodem.
  * `glm-4.6`: ogólny model dialogowy, zrównoważony pod względem efektów i kosztów.
  * `glm-3-turbo`: klasyczny model dialogowy, odpowiedni do ogólnych zadań generowania tekstu.
* `messages`: tablica promptów, każda wiadomość zawiera `role` i `content`, `role` obsługuje trzy role: `user`, `assistant`, `system`.

Często używane opcjonalne parametry:

* `max_tokens`: ogranicza maksymalną liczbę tokenów w pojedynczej odpowiedzi.
* `temperature`: losowość generacji, w zakresie od 0 do 2, im wyższa wartość, tym bardziej rozproszone wyniki.
* `top_p`: parametr próbkowania jądra, kontrolujący próg skumulowanej prawdopodobieństwa dla kandydatów tokenów.
* `n`: ile kandydatów odpowiedzi generować jednocześnie.
* `stream`: czy włączyć odpowiedzi strumieniowe, domyślnie `false`.
* `stop`: niestandardowa sekwencja zatrzymania.

Poniżej znajduje się najprostszy przykład wywołania w Pythonie:

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

Po wywołaniu zauważamy, że zwrócony wynik wygląda następująco:

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

Opis głównych pól zwróconego wyniku jest następujący:

* `id`: unikalny identyfikator zadania dialogowego.
* `created`: czas utworzenia zadania dialogowego (znacznik czasu Unix, sekundy).
* `model`: nazwa rzeczywiście wywołanego modelu GLM.
* `choices`: lista odpowiedzi wygenerowanych przez model. `choices[i].message.content` to konkretny tekst odpowiedzi modelu, `finish_reason` oznacza powód zakończenia (np. `stop`, `length`, `tool_calls`, `content_filter` itp.).
* `usage`: statystyki użycia tokenów w tym żądaniu, zawierające `prompt_tokens`, `completion_tokens`, `total_tokens`.

## 流式响应

Ten interfejs obsługuje odpowiedzi strumieniowe (Server-Sent Events), co jest bardzo przydatne w integracji z stronami internetowymi, umożliwiając wyświetlanie efektu literowego.

Aby uzyskać odpowiedź strumieniową, wystarczy ustawić parametr `stream` w ciele żądania na `true`.

Przykładowy kod wywołania w Pythonie:

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

Efekt wyjściowy wygląda następująco (fragment):

```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": "Cześć! Jak mogę"}, "finish_reason": null, "index": 0}], "usage": null}

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

Można zauważyć, że odpowiedź zawiera wiele `data`, z których każda zawiera fragment inkrementalny. `choices[i].delta.content` to aktualnie dodany fragment tekstu, który można połączyć, aby utworzyć pełną odpowiedź. Gdy zawartość `data` to `[DONE]`, oznacza to zakończenie odpowiedzi strumieniowej. Ostatni fragment z `usage` podsumowuje zużycie tokenów w tej prośbie.

Przykład w 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: "cześć" }],
    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));
}
```

Przykład kodu w Javie:

```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", "cześć")));
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());
```

Inne języki można dostosować samodzielnie, zasada jest taka sama.

## Wiele rund rozmowy

Jeśli chcesz zrealizować funkcję wielu rund rozmowy, musisz umieścić historię rozmowy w tablicy `messages`, zachowując naprzemienny porządek `user` i `assistant`.

Przykład wywołania w Pythonie:

```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": "Cześć"},
        {"role": "assistant", "content": "Cześć! Jak mogę ci dzisiaj pomóc?"},
        {"role": "user", "content": "Co powiedziałem przed chwilą?"}
    ]
}

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

Przesyłając wiele pytań, można łatwo zrealizować wiele rund rozmowy, uzyskując następującą odpowiedź:

```json theme={null}
{
  "id": "msg_20260426225208b95324e9945a48d3",
  "model": "glm-4.7",
  "object": "chat.completion",
  "created": 1777215128,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Powiedziałeś: **\"Cześć\"** 😊\n\nDaj znać, jeśli potrzebujesz czegoś więcej!"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 37,
    "total_tokens": 85
  }
}
```

Można zauważyć, że informacje zawarte w `choices` są zgodne z podstawowym użyciem, model na podstawie pełnej historii rozmowy udziela odpowiedzi, co wspiera interakcję w kontekście wielu rund.

## System Prompt

Można dodać wiadomość z `role` jako `system` na początku `messages`, aby ograniczyć rolę, styl lub zachowanie modelu:

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "system", "content": "Jesteś doświadczonym asystentem pisania w języku chińskim, proszę odpowiadaj w zwięzłym i profesjonalnym tonie."},
        {"role": "user", "content": "Proszę w trzech zdaniach przedstawić model GLM."}
    ]
}
```

## Wywołanie funkcji

Model GLM obsługuje wywołania funkcji zgodne z OpenAI, można zadeklarować wywoływalne funkcje za pomocą parametru `tools`, model w razie potrzeby zwróci zorganizowane informacje o wywołaniu funkcji w `choices[i].message.tool_calls`.

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "user", "content": "Jakie jest dzisiaj pogoda w Pekinie?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Sprawdź pogodę w określonym mieście",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "Nazwa miasta"}
                    },
                    "required": ["city"]
                }
            }
        }
    ]
}
```

Jeśli model zdecyduje się na wywołanie narzędzia, w zwróconym wyniku `finish_reason` zmieni się na `tool_calls`, a w `message.tool_calls` podane zostaną nazwa funkcji i parametry w formie JSON. Możesz wykonać tę funkcję i zwrócić wynik jako wiadomość z `role` jako `tool` do modelu, aby zakończyć pełną pętlę wywołania narzędzia.

## Rekomendacje dotyczące wyboru modelu

````
| Model           | Zastosowanie                                      |
| -------------- | -------------------------------------------- |
| `glm-5.3`     | Najnowszy flagowiec, 1M kontekst, maksymalnie 128K wyjścia, zalecany do złożonego wnioskowania, zadań związanych z kodem i Agentami |
| `glm-5.2`     | Poprzednia generacja flagowca, odpowiednia do złożonego wnioskowania, zadań związanych z kodem i Agentami                    |
| `glm-5.1`     | Dojrzały flagowiec, odpowiedni do złożonego wnioskowania, analizy długich dokumentów                            |
| `glm-4.7`     | Wywołania narzędzi, generowanie kodu, orkiestracja Agentów i inne zadania                        |
| `glm-4.6`     | Uniwersalny wybór do dialogów i tworzenia treści                               |
| `glm-3-turbo` | Ogólne zadania generowania tekstu, wrażliwe na koszty                            |

## Obsługa błędów

Podczas wywoływania API, jeśli wystąpi błąd, API zwróci odpowiedni kod błędu i informacje. Na przykład:

- `400 token_mismatched`: Brakujące lub nieprawidłowe parametry żądania.
- `400 api_not_implemented`: Użyto nieobsługiwanych parametrów lub modeli.
- `401 invalid_token`: Brak autoryzacji, brak lub nieważny token Bearer.
- `429 too_many_requests`: Przekroczono limit częstotliwości, spróbuj ponownie później.
- `500 api_error`: Błąd wewnętrzny serwera lub tymczasowa niedostępność usługi.

### Przykład odpowiedzi błędu

```json
{
  "trace_id": "69ea9bcf-c5da-41a3-be97-c80912a08523",
  "error": {
    "code": "api_error",
    "message": "Usługa jest tymczasowo niedostępna, spróbuj ponownie później."
  }
}
````

Gdy zwróci `api_error` i wiadomość brzmi `Usługa jest tymczasowo niedostępna, spróbuj ponownie później.`, zazwyczaj oznacza to, że usługa GLM jest tymczasowo niedostępna, zaleca się zastosowanie strategii z wykładniczym opóźnieniem lub przełączenie na inny dostępny model GLM (na przykład tymczasowe przełączenie z `glm-5.1` na `glm-4.7` lub `glm-4.6`).

## Wnioski

Dzięki temu dokumentowi zrozumieliście, jak korzystać z API GLM Chat Completion do wywoływania modeli serii GLM od Zhipu AI, w tym podstawowe wywołania, odpowiedzi strumieniowe, wieloetapowe dialogi, systemowe podpowiedzi i wywołania narzędzi. Mamy nadzieję, że ten dokument pomoże Wam lepiej zintegrować i korzystać z tego API. W razie jakichkolwiek pytań, prosimy o kontakt z naszym zespołem wsparcia technicznego.


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