> ## 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 Ansökan och Användning

> GLM API guide - Ace Data Cloud

GLM (General Language Model) är en ny generation av stora språkmodeller som lanserats av Zhipu AI (Zhipu AI / Z.ai), med starka förmågor inom förståelse och generering av både kinesiska och engelska. Den presterar utmärkt inom uppgifter som kinesiska scenarier, kodgenerering, resonemang och flerdialog. De nya modellerna GLM-5.3, GLM-5.2, GLM-4.7 med flera har genomgått omfattande optimeringar för långa sammanhang, verktygsanrop och koduppgifter, och kan tillämpas brett inom intelligenta frågesystem, innehållsskapande, kodassistans, kundtjänstrobotar och andra scenarier.

Detta dokument beskriver huvudsakligen användningsprocessen för GLM Chat Completion API, vilket gör att du enkelt kan anropa GLM-serien av modeller via ett enhetligt OpenAI-kompatibelt gränssnitt.

## Ansökningsprocess

För att använda GLM Chat Completion API, börja med att gå till [Ace Data Cloud-konsolen](https://platform.acedata.cloud/console/applications) för att hämta din API-token, som du ska spara för framtida bruk.

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

Om du inte har loggat in eller registrerat dig, kommer du automatiskt att omdirigeras till inloggningssidan där du blir inbjuden att registrera dig och logga in. När detta är klart kommer du automatiskt att återvända till den aktuella sidan.

**En API-token räcker för att anropa alla tjänster på plattformen, du behöver inte ansöka separat för varje tjänst.** Vid första ansökan får du en gratis kvot för att prova; om kvoten tar slut kan du ladda på allmän balans i [konsolen](https://platform.acedata.cloud/console/coin).

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

## Grundläggande Användning

Begärningsadressen för GLM Chat Completion API är `https://api.acedata.cloud/glm/chat/completions`, och autentisering sker med Bearer Token. Begärningskroppen är kompatibel med OpenAI Chat Completions-protokollet.

Vid första användning av detta gränssnitt behöver vi fylla i minst tre innehåll:

* `authorization`: Välj Bearer Token direkt från rullgardinsmenyn.
* `model`: Välj den GLM-modell som ska anropas, de för närvarande stödda modellerna inkluderar:
  * `glm-5.3`: Den senaste flaggskeppsmodellen, stödjer 1M sammanhang och längst 128K utdata, lämplig för komplexa resonemang, kod och agentuppgifter. Resonemang är alltid aktiverat, och du kan välja `reasoning_effort` som `low`, `high` eller `max`.
  * `glm-5.2`: Den föregående flaggskeppsmodellen, med starka övergripande förmågor.
  * `glm-5.1`: En mogen flaggskeppsmodell, lämplig för allmänna komplexa uppgifter.
  * `glm-4.7`: Presterar utmärkt inom resonemang, verktygsanrop och koduppgifter.
  * `glm-4.6`: En allmän dialogmodell, balanserar effekt och kostnad.
  * `glm-3-turbo`: En klassisk dialogmodell, lämplig för allmänna textgenereringsuppgifter.
* `messages`: En array av meddelanden, där varje meddelande innehåller `role` och `content`, där `role` stöder tre roller: `user`, `assistant`, `system`.

Vanliga valfria parametrar:

* `max_tokens`: Begränsar det maximala antalet tokens för ett enda svar.
* `temperature`: Genererar slumpmässighet, mellan 0-2, ju högre värde desto mer spritt.
* `top_p`: Kärnprovningsparameter, kontrollerar den kumulativa sannolikhetströskeln för kandidattokens.
* `n`: Hur många kandidatsvar som ska genereras åt gången.
* `stream`: Om strömmande svar ska aktiveras, standard är `false`.
* `stop`: Anpassad stoppsekvens.

Här är ett enklaste exempel på Python-anrop:

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

Efter anropet ser vi att returresultatet ser ut som följer:

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

Förklaringar av de viktigaste fälten i returresultatet:

* `id`: Det unika ID:t för denna dialoguppgift.
* `created`: Tiden för skapandet av denna dialoguppgift (Unix-tidsstämpel, sekunder).
* `model`: Namnet på den faktiska anropade GLM-modellen.
* `choices`: Listan över svar som genererats av modellen. `choices[i].message.content` är den specifika texten som modellen svarade med, `finish_reason` anger orsaken till avslutningen (`stop`, `length`, `tool_calls`, `content_filter` etc.).
* `usage`: Statistik över tokenanvändningen för denna begäran, inklusive `prompt_tokens`, `completion_tokens`, `total_tokens`.

## Strömmande Svar

Detta gränssnitt stöder strömmande svar (Server-Sent Events), vilket är mycket användbart för webbgränssnitt och kan ge en effekt av att visa texten ord för ord.

Om du vill ha strömmande svar, ställ in `stream`-parametern i begärningskroppen till `true`.

Exempel på Python-anropskod:

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

Utdataeffekten ser ut som följer (utdrag):

```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": "Hej! Vad kan jag"}, "finish_reason": null, "index": 0}], "usage": null}

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

Du kan se att svaret innehåller många `data`, varje `data` innehåller ett inkrementellt segment. `choices[i].delta.content` är den aktuella chunkens nya textsegment, du kan sammanfoga dessa segment för att bilda ett komplett svar. När `data` innehållet är `[DONE]` betyder det att den strömmande svaret har avslutats. Den sista chunk som har `usage` kommer att sammanfatta token-användningen för denna begäran.

JavaScript (Node.js) exempel:

```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: "hej" }],
    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 exempel kod:

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

Andra språk kan skrivas om på liknande sätt, principen är densamma.

## Flera omgångar av dialog

Om du vill implementera funktionalitet för flera omgångar av dialog, behöver du lägga in historiska dialoger i `messages` arrayen och behålla ordningen av `user` och `assistant` som växlar.

Python exempel anropskod:

```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": "Hej"},
        {"role": "assistant", "content": "Hej! Hur kan jag hjälpa dig idag?"},
        {"role": "user", "content": "Vad sa jag precis?"}
    ]
}

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

Genom att ladda upp flera frågor kan du enkelt uppnå flera omgångar av dialog och få följande svar:

```json theme={null}
{
  "id": "msg_20260426225208b95324e9945a48d3",
  "model": "glm-4.7",
  "object": "chat.completion",
  "created": 1777215128,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Du sa: **\"Hej\"** 😊\n\nLåt mig veta om du behöver något mer!"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 37,
    "total_tokens": 85
  }
}
```

Du kan se att informationen i `choices` är densamma som vid grundläggande användning, modellen ger svar baserat på hela dialoghistoriken, vilket stödjer flera omgångar av kontextuell interaktion.

## Systemprompt (System Prompt)

Du kan lägga till ett meddelande med `role` som `system` i början av `messages` för att begränsa modellens roll, stil eller beteende:

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "system", "content": "Du är en erfaren kinesisk skrivassistent, vänligen svara med en kort och professionell ton."},
        {"role": "user", "content": "Kan du introducera GLM-modellen i tre meningar?"}
    ]
}
```

## Verktygsanrop (Function Calling)

GLM-modellen stöder OpenAI-kompatibla verktygsanrop, du kan deklarera anropbara funktioner genom `tools` parametern, modellen kommer att returnera strukturerad funktionsanropsinformation i `choices[i].message.tool_calls` när det behövs.

```python theme={null}
payload = {
    "model": "glm-4.7",
    "messages": [
        {"role": "user", "content": "Hur är vädret i Beijing idag?"}
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Fråga om vädret i en specifik stad",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {"type": "string", "description": "Stadsnamn"}
                    },
                    "required": ["city"]
                }
            }
        }
    ]
}
```

Om modellen beslutar att anropa verktyget, kommer resultatet att ha `finish_reason` som ändras till `tool_calls`, och i `message.tool_calls` ges funktionsnamnet och JSON-strängformatet av parametrarna. Du kan utföra den funktionen och skicka resultatet som ett meddelande med `role` som `tool` tillbaka till modellen för att slutföra den fullständiga verktygsanropscykeln.

## Rekommendationer för modellval

````
| Modell          | Användningsområde                                   |
| --------------- | -------------------------------------------------- |
| `glm-5.3`      | Senaste flaggskeppet, 1M kontext, längst 128K utdata, rekommenderas för komplexa resonemang, kod och Agent-uppgifter |
| `glm-5.2`      | Föregående generations flaggskepp, lämplig för komplexa resonemang, kod och Agent-uppgifter                    |
| `glm-5.1`      | Mogen flaggskepp, lämplig för komplexa resonemang, långdokumentanalys                            |
| `glm-4.7`      | Verktygsanrop, kodgenerering, Agent-kordination och liknande uppgifter                        |
| `glm-4.6`      | Allmän dialog, en balanserad val för innehållsskapande                               |
| `glm-3-turbo`  | Allmän textgenereringsuppgifter, kostnadskänsliga scenarier                            |

## Felhantering

Vid anrop av API:et, om ett fel uppstår, kommer API:et att returnera motsvarande felkod och information. Till exempel:

- `400 token_mismatched`: Begärningsparametrar saknas eller är ogiltiga.
- `400 api_not_implemented`: Använda parametrar eller modeller som inte stöds.
- `401 invalid_token`: Ej auktoriserad, Bearer Token saknas eller har upphört att gälla.
- `429 too_many_requests`: Utlöst frekvensbegränsning, vänligen försök igen senare.
- `500 api_error`: Intern serverfel eller model service tillfälligt otillgänglig.

### Exempel på felrespons

```json
{
  "trace_id": "69ea9bcf-c5da-41a3-be97-c80912a08523",
  "error": {
    "code": "api_error",
    "message": "Tjänsten är tillfälligt otillgänglig, vänligen försök igen senare."
  }
}
````

När `api_error` returneras och meddelandet är `Tjänsten är tillfälligt otillgänglig, vänligen försök igen senare.`, indikerar det vanligtvis att upstream GLM-tjänsten är tillfälligt otillgänglig, det rekommenderas att använda exponentiell backoff för att försöka igen, eller växla till en annan tillgänglig GLM-modell (till exempel från `glm-5.1` tillfälligt växla till `glm-4.7` eller `glm-4.6`).

## Slutsats

Genom detta dokument har du fått en förståelse för hur man använder GLM Chat Completion API för att anropa Zhiyu AI:s GLM-serie modeller, inklusive grundläggande anrop, strömmande svar, flerdialoger, systempromptar och verktygsanrop. Vi hoppas att detta dokument kan hjälpa dig att bättre integrera och använda detta API. Om du har några frågor, tveka inte att kontakta vårt tekniska supportteam.


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