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

> Kimi API guide - Ace Data Cloud

Kimi to seria modeli AI wprowadzona przez Mroczną Stronę Księżyca. Obecnie zalecany `kimi-k3` jest skierowany na długozasięgowe programowanie, agentów, złożone rozumowanie i pracę z wiedzą, i można go wywołać za pomocą zgodnego z OpenAI API Chat Completions.

Dokument ten głównie opisuje proces korzystania z Kimi Chat Completion API, dzięki któremu możemy łatwo korzystać z funkcji rozmowy oficjalnego Kimi.

## 申请流程

Aby korzystać z Kimi 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/5hmkdg.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 otrzymasz darmowy limit, aby móc korzystać z usługi za darmo; gdy limit się wyczerpie, możesz doładować saldo ogólne w [控制台](https://platform.acedata.cloud/console/coin).

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

## 基本使用

Następnie możesz wypełnić odpowiednie treści na interfejsie, jak pokazano na obrazku:

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

Podczas pierwszego korzystania z tego interfejsu musisz wypełnić co najmniej trzy pola: `authorization`, które można bezpośrednio wybrać z rozwijanej listy; `model`, aby wybrać model Kimi, zaleca się użycie `kimi-k3`; `messages` to tablica wiadomości rozmowy, gdzie każda wiadomość zawiera `role` i `content`, przy czym `role` obsługuje `user`, `assistant`, `system` i `tool`.

Możesz również zauważyć, że po prawej stronie generowany jest odpowiedni kod wywołania, który możesz skopiować i uruchomić, lub możesz bezpośrednio kliknąć przycisk „Try”, aby przetestować.

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

Poniżej znajduje się rzeczywista odpowiedź K3 uzyskana przy użyciu `reasoning_effort: max` (pominięto nieużywane pola rozszerzeń):

```json theme={null}
{
  "id": "msg_2D4Btbg1WgvkNE3tCYkR4xGA",
  "object": "chat.completion",
  "created": 1784466588,
  "model": "kimi-k3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Cześć! Jak mogę Ci dzisiaj pomóc?"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 86,
    "completion_tokens": 206,
    "total_tokens": 292
  }
}
```

Zwrócone wyniki zawierają wiele pól, które są opisane poniżej:

* `id`, identyfikator generowanego zadania rozmowy, używany do unikalnej identyfikacji tego zadania rozmowy.
* `model`, wybrany model Kimi z oficjalnej strony.
* `choices`, informacje o odpowiedzi Kimi na zadane pytanie.
* `usage`: statystyki dotyczące tokenów dla tej pary pytań i odpowiedzi.

Wśród nich `choices` zawiera informacje o odpowiedzi Kimi, a wewnątrz `choices` znajdują się konkretne informacje o odpowiedzi Kimi, co można zobaczyć na obrazku.

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

Można zauważyć, że pole `content` w `choices` zawiera konkretne treści odpowiedzi Kimi; K3 może również zwrócić `reasoning_content`, aby wskazać proces rozumowania.

## K3 推理强度

`kimi-k3` zawsze włącza rozumowanie. Najwyższy poziom żądania obsługuje pole `reasoning_effort`, a jedyną obsługiwaną wartością jest `max`; pominięcie tego pola również skutkuje użyciem `max`. `standard`, `high` lub inne ciągi mogą być częściowo akceptowane przez luźniejsze upstream, ale nie gwarantują zmiany zachowania rozumowania, nie polegaj na tym.

```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": "Przejrzyj ten kod i podaj propozycję poprawek"}],
    "reasoning_effort": "max"
  }'
```

Podczas korzystania z OpenAI SDK można bezpośrednio przekazać to pole:

```python theme={null}
response = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Zaprojektuj niezawodną kolejkę zadań"}],
    reasoning_effort="max",
)
```

W przypadku wieloetapowych rozmów i wywołań narzędzi należy przekazać pełną wiadomość asystenta z poprzedniej rundy do `messages`, w tym `reasoning_content` i `tool_calls`.

### 官方参考

* [Thinking Effort](https://platform.kimi.ai/docs/guide/use-thinking-effort)：wyjaśnia, że Kimi K3 zawsze włącza rozumowanie, a jedyną obsługiwaną wartością `reasoning_effort` jest `max`.
* [Model Parameter Reference](https://platform.kimi.ai/docs/api/models-overview)：porównuje parametry rozumowania K3 i K2, okna kontekstowe oraz różnice w wywołaniach narzędzi.
* [Create Chat Completion](https://platform.kimi.ai/docs/api/chat)：oficjalne żądania, odpowiedzi i definicje pól OpenAPI dla Chat Completions Moonshot.

## 流式响应

Ten interfejs obsługuje również odpowiedzi strumieniowe, co jest bardzo przydatne w integracji z witrynami internetowymi, umożliwiając wyświetlanie efektu literowego.

Jeśli chcesz, aby odpowiedź była zwracana strumieniowo, możesz zmienić parametr `stream` w nagłówku żądania na `true`.

Zmiana jak na obrazku, ale kod wywołania musi być odpowiednio zmieniony, aby obsługiwał odpowiedzi strumieniowe.

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

Po zmianie `stream` na `true`, API zwróci odpowiednie dane JSON w wierszach, a na poziomie kodu musimy wprowadzić odpowiednie zmiany, aby uzyskać wyniki w wierszach.

Przykładowy kod wywołania w Pythonie:

```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":"Cześć"}],
    "reasoning_effort": "max",
    "stream": True
}

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

Poniżej przedstawiono fragmenty z rzeczywistej odpowiedzi strumieniowej K3 Max, w tym bloki danych początkowych, rozumowania, treści, zakończenia i użycia:

```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":"The"},"finish_reason":null}],"usage":null}

data: {"id":"msg_er7WZjyv2kD3TG2yzbFPu5ZJ","object":"chat.completion.chunk","created":1784466598,"model":"kimi-k3","choices":[{"index":0,"delta":{"content":"Cześć"},"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]
```

Można zauważyć, że odpowiedź zawiera wiele `data`, a `data` wewnątrz `choices` to najnowsza treść odpowiedzi, zgodna z wcześniej przedstawioną treścią. `choices` to nowa treść odpowiedzi, którą można zintegrować z systemem. Zakończenie strumieniowej odpowiedzi jest określane na podstawie zawartości `data`, a jeśli zawartość to `[DONE]`, oznacza to, że strumieniowa odpowiedź została całkowicie zakończona. Zwracane wyniki `data` mają wiele pól, które są opisane poniżej:

* `id`, identyfikator generowanego zadania rozmowy, używany do unikalnej identyfikacji tego zadania rozmowy.
* `model`, wybrany model z oficjalnej strony Kimi.
* `choices`, informacje o odpowiedziach udzielonych przez Kimi na pytania.

JavaScript jest również obsługiwany, na przykład kod do strumieniowego wywołania w Node.js wygląda następująco:

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

Przykładowy kod w Javie:

```java theme={null}
JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "kimi-k3");
jsonObject.put("messages", [{"role":"user","content":"Cześć"}]);
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())
```

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

## Wieloetapowa rozmowa

Jeśli chcesz zintegrować funkcję wieloetapowej rozmowy, musisz przesłać wiele pytań w polu `messages`, a konkretne przykłady wielu pytań są pokazane na poniższym obrazku:

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

Przykładowy kod wywołania w Pythonie:

```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":"Cześć! Jak mogę Ci dzisiaj pomóc?"},{"role":"user","content":"Jaki jesteś modelem?"}],
    "reasoning_effort": "max"
}

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

Przesyłając wiele pytań, można łatwo zrealizować wieloetapową rozmowę. Poniżej znajduje się rzeczywista odpowiedź K3 Max uzyskana z tego żądania (pomijając nieużywane pola rozszerzeń):

```json theme={null}
{
  "id": "msg_Rqp8nPGBDHWwBlL4VpxuafOp",
  "object": "chat.completion",
  "created": 1784466628,
  "model": "kimi-k3",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Jestem Kimi, asystentem AI opracowanym przez Moonshot AI (月之暗面). Nie mam konkretnego identyfikatora wersji modelu publicznego do podzielenia się stąd."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 134,
    "completion_tokens": 346,
    "total_tokens": 480
  }
}
```

Można zauważyć, że informacje zawarte w `choices` są zgodne z podstawowym użyciem, zawierają konkretne treści odpowiedzi Kimi na wiele rozmów, co pozwala na odpowiadanie na odpowiednie pytania na podstawie wielu treści rozmowy.

## Obsługa błędów

Podczas wywoływania API, jeśli wystąpią błędy, API zwróci odpowiednie kody błędów i informacje. Na przykład:

* `400 token_mismatched`: Zły wniosek, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
* `400 api_not_implemented`: Zły wniosek, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
* `401 invalid_token`: Nieautoryzowany, nieprawidłowy lub brakujący token autoryzacyjny.
* `429 too_many_requests`: Zbyt wiele żądań, przekroczono limit szybkości.
* `500 api_error`: Błąd wewnętrzny serwera, coś poszło nie tak na serwerze.

### Przykład odpowiedzi błędu

```
{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "fetch failed"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}
```

## Wnioski

Dzięki temu dokumentowi zrozumiałeś, jak używać Kimi Chat Completion API do realizacji zwykłych rozmów, strumieniowych odpowiedzi, wieloetapowych rozmów oraz jak kontrolować intensywność rozumowania K3 za pomocą `reasoning_effort`.
