GLM Chat Completion API 申请及使用

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 控制台, aby uzyskać swój token API, który należy zachować na przyszłość.

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.

📘 Pełna dokumentacja: GLM Chat Completion API →

基本使用

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:

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:

{
  "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:

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

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

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:

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:

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ź:

{
  "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:

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.

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
&#123;
  "trace_id": "69ea9bcf-c5da-41a3-be97-c80912a08523",
  "error": &#123;
    "code": "api_error",
    "message": "Usługa jest tymczasowo niedostępna, spróbuj ponownie później."
  &#125;
&#125;

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.

Getting Started

Czat AI

Obraz AI

Wideo AI

Audio AI

Sieć i dane

CAPTCHA

Tożsamość

Coding

Więcej przewodników

GLM Chat Completion API 申请及使用

申请流程

基本使用

流式响应

Wiele rund rozmowy

System Prompt

Wywołanie funkcji

Rekomendacje dotyczące wyboru modelu

Wnioski

​申请流程

​基本使用

​流式响应

​Wiele rund rozmowy

​System Prompt

​Wywołanie funkcji

​Rekomendacje dotyczące wyboru modelu

​Wnioski

申请流程

基本使用

流式响应

Wiele rund rozmowy

System Prompt

Wywołanie funkcji

Rekomendacje dotyczące wyboru modelu

Wnioski