> ## 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.

# Kimi Chat Completion API Ansökan och Användning

> Kimi API guide - Ace Data Cloud

Kimi är en AI-modellserie som lanserats av Månen av Mörka Sidan. Den nuvarande rekommenderade `kimi-k3` är inriktad på långsiktig programmering, agenter, komplexa resonemang och kunskapsarbete, och kan anropas via OpenAI-kompatibel Chat Completions API.

Detta dokument beskriver huvudsakligen användningsflödet för Kimi Chat Completion API, vilket gör att vi enkelt kan använda den officiella Kimi:s samtalsfunktion.

## Ansökningsprocess

För att använda Kimi 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/5hmkdg.jpg)

Om du inte har loggat in eller registrerat dig, kommer du automatiskt att omdirigeras till inloggningssidan som bjuder in dig att registrera dig och logga in, och efter att ha slutfört detta kommer du automatiskt att återvända till den aktuella sidan.

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

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

## Grundläggande Användning

Nu kan du fylla i motsvarande innehåll på gränssnittet, som visas i bilden:

<p>
  <img src="https://cdn.acedata.cloud/ej5ozg.png" width="400" className="m-auto" />
</p>

Vid första användning av detta gränssnitt behöver du fylla i minst tre fält: `authorization` kan väljas direkt från rullgardinsmenyn; `model` används för att välja Kimi-modellen, rekommenderat att använda `kimi-k3`; `messages` är en array av samtalsmeddelanden, där varje meddelande innehåller `role` och `content`, där `role` stöder `user`, `assistant`, `system` och `tool`.

Samtidigt kan du notera att det finns motsvarande anropskod som genereras till höger, du kan kopiera koden för att köra den direkt, eller klicka på "Try" knappen för att testa.

<p>
  <img src="https://cdn.acedata.cloud/six7e3.png" width="400" className="m-auto" />
</p>

Nedan är en verklig K3-respons som erhållits med `reasoning_effort: max` (utökade fält som inte används har utelämnats):

```json theme={null}
{
  "id": "msg_2D4Btbg1WgvkNE3tCYkR4xGA",
  "object": "chat.completion",
  "created": 1784466588,
  "model": "kimi-k3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hej! Hur kan jag hjälpa dig idag?"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 86,
    "completion_tokens": 206,
    "total_tokens": 292
  }
}
```

Det returnerade resultatet har flera fält, som beskrivs nedan:

* `id`, ID för att generera denna samtalsuppgift, används för att unikt identifiera denna samtalsuppgift.
* `model`, den valda Kimi-modellen från hemsidan.
* `choices`, Kimi:s svarsinformation på frågan.
* `usage`: statistik över token för denna fråge- och svarsinteraktion.

Där `choices` innehåller Kimi:s svarsinformation, och `choices` inuti det är den specifika informationen som Kimi svarade med, vilket kan ses i bilden.

<p>
  <img src="https://cdn.acedata.cloud/tv9rul.png" width="400" className="m-auto" />
</p>

Det kan ses att `content`-fältet i `choices` innehåller det specifika innehållet i Kimi:s svar; K3 kan också returnera `reasoning_content`, som används för att representera resonemangsprocessen.

## K3 Resonemang Intensitet

`kimi-k3` har alltid aktiverat resonemang. Den översta nivån av begäran stöder fältet `reasoning_effort`, det nuvarande enda stödda värdet är `max`; om detta fält utelämnas används också `max`. `standard`, `high` eller andra strängar kan delvis accepteras av upstream-lösningar, men det garanterar inte att resonemangsbeteendet ändras, så förlita dig inte på det.

```bash theme={null}
curl https://api.acedata.cloud/kimi/chat/completions \
  -H "Authorization: Bearer $ACEDATACLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [{"role": "user", "content": "Granska denna kod och ge förslag på lösningar"}],
    "reasoning_effort": "max"
  }'
```

Vid användning av OpenAI SDK kan detta fält överföras direkt:

```python theme={null}
response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Designa en pålitlig uppgiftskö"}],
    reasoning_effort="max",
)
```

Vid fleromgångssamtal och verktygsanrop, vänligen skicka tillbaka hela föregående assistentmeddelande till `messages`, inklusive `reasoning_content` och `tool_calls`.

### Officiell Referens

* [Thinking Effort](https://platform.kimi.ai/docs/guide/use-thinking-effort): Förklarar att Kimi K3 alltid har aktiverat resonemang, det nuvarande enda stödda värdet för `reasoning_effort` är `max`.
* [Model Parameter Reference](https://platform.kimi.ai/docs/api/models-overview): Jämför resonansparametrar, kontextfönster och skillnader i verktygsanrop mellan K3 och K2-serien.
* [Create Chat Completion](https://platform.kimi.ai/docs/api/chat): Moonshot officiella Chat Completions begäran, svar och OpenAPI fältdokumentation.

## Strömmande Respons

Detta gränssnitt stöder också strömmande respons, vilket är mycket användbart för webbgränssnitt, eftersom det kan ge en tecken-för-tecken visningseffekt.

Om du vill ha en strömmande respons kan du ändra `stream`-parametern i begärans huvud till `true`.

Ändringen visas i bilden, men anropskoden behöver ha motsvarande ändringar för att stödja strömmande respons.

<p>
  <img src="https://cdn.acedata.cloud/a3nzpw.png" width="400" className="m-auto" />
</p>

När `stream` ändras till `true`, kommer API:t att returnera motsvarande JSON-data rad för rad, och på kodnivå behöver vi göra nödvändiga ändringar för att få rad-för-rad resultat.

Python exempel på anropskod:

```python theme={null}
import requests

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

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

payload = {
    "model": "kimi-k3",
    "messages": [{"role":"user","content":"Hej"}],
    "reasoning_effort": "max",
    "stream": True
}

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

Nedan är ett utdrag från en verklig K3 Max strömmande respons som innehåller start-, resonemangs-, text-, slut- och användningsdatablock:

```json theme={null}
data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[{"index":0,"delta":{"content":"","role":"assistant"},"finish_reason":null}],"usage":null}

data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[{"index":0,"delta":{"reasoning_content":"Den"},"finish_reason":null}],"usage":null}

data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[{"index":0,"delta":{"content":"Hej"},"finish_reason":null}],"usage":null}

data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":null}

data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[],"usage":{"prompt_tokens":172,"completion_tokens":168,"total_tokens":340}}

data: [DONE]
```

Det kan ses att svaret innehåller många `data`, där `data` inuti `choices` är det senaste svaret, vilket överensstämmer med den tidigare beskrivna informationen. `choices` är det nya svaret, och du kan koppla det till ditt system baserat på resultatet. Samtidigt är slutet på den strömmande svaret baserat på innehållet i `data`, om innehållet är `[DONE]`, indikerar det att det strömmande svaret har avslutats helt. De returnerade `data`-resultaten har flera fält, som beskrivs nedan:

* `id`, ID för att generera denna dialoguppgift, används för att unikt identifiera denna dialoguppgift.
* `model`, den valda Kimi-webbplatsmodellen.
* `choices`, Kimi:s svarsinformation på frågeordet.

JavaScript stöds också, till exempel Node.js:s strömmande anropskod ser ut så här:

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

fetch("https://api.acedata.cloud/kimi/chat/completions", options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

Java-exempel på kod:

```java theme={null}
JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "kimi-k3");
jsonObject.put("messages", [{"role":"user","content":"Hej"}]);
jsonObject.put("stream", true);
MediaType mediaType = "application/json; charset=utf-8".toMediaType();
RequestBody body = jsonObject.toString().toRequestBody(mediaType);
Request request = new Request.Builder()
  .url("https://api.acedata.cloud/kimi/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.print(response.body!!.string())
```

Andra språk kan skrivas om på egen hand, principen är densamma.

## Flera rundor av dialog

Om du vill koppla fler rundor av dialogfunktionalitet, behöver du ladda upp flera frågeord i `messages`-fältet, specifika exempel på flera frågeord visas nedan:

<p>
  <img src="https://cdn.acedata.cloud/g85v2a.png" width="400" className="m-auto" />
</p>

Python-exempel på anropskod:

```python theme={null}
import requests

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

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

payload = {
    "model": "kimi-k3",
    "messages": [{"role":"assistant","content":"Hej! Hur kan jag hjälpa dig idag?"},{"role":"user","content":"Vilken modell är du?"}],
    "reasoning_effort": "max"
}

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

Genom att ladda upp flera frågeord kan du enkelt uppnå flera rundor av dialog. Här är det verkliga svaret från K3 Max som erhölls från denna begäran (utelämnar oanvända utvidgningsfält):

```json theme={null}
{
  "id": "msg_Rqp8nPGBDHWwBlL4VpxuafOp",
  "object": "chat.completion",
  "created": 1784466628,
  "model": "kimi-k3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Jag är Kimi, en AI-assistent utvecklad av Moonshot AI (月之暗面). Jag har ingen specifik offentlig modellversionsidentifierare att dela härifrån."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 134,
    "completion_tokens": 346,
    "total_tokens": 480
  }
}
```

Det kan ses att `choices` innehåller information som är i linje med den grundläggande användningen, detta innehåller Kimi:s specifika innehåll för att svara på flera dialoger, så att du kan svara på motsvarande frågor baserat på flera dialoginnehåll.

## Felhantering

När du anropar API:et, om du stöter på fel, kommer API:et att returnera motsvarande felkod och information. Till exempel:

* `400 token_mismatched`: Dålig begäran, möjligtvis på grund av saknade eller ogiltiga parametrar.
* `400 api_not_implemented`: Dålig begäran, möjligtvis på grund av saknade eller ogiltiga parametrar.
* `401 invalid_token`: Obefogad, ogiltig eller saknad auktoriseringstoken.
* `429 too_many_requests`: För många begärningar, du har överskridit hastighetsgränsen.
* `500 api_error`: Internt serverfel, något gick fel på servern.

### Exempel på felrespons

```
{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "hämtning misslyckades"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}
```

## Slutsats

Genom detta dokument har du fått en förståelse för hur du använder Kimi Chat Completion API för att genomföra vanliga dialoger, strömmande svar, flera rundor av dialog, samt hur du kontrollerar K3:s resonemangsstyrka genom `reasoning_effort`.
