Indeks dokumentacji
Pobierz kompletny indeks dokumentacji pod adresem: https://docs.aihubmix.com/llms.txt
Użyj tego pliku, aby odkryć wszystkie dostępne strony przed dalszym eksplorowaniem.

Lipiec 2026 Przewodnik po Kimi K3: maksymalny wysiłek rozumowania, historia myślenia, dynamiczne ładowanie narzędzi, strukturalne wyjście, automatyczne buforowanie, częściowy prefiks i wejścia wizualne.

Artykuł ten omawia nowe parametry i uwagi dotyczące użytkowania Kimi K3. Na AIHubMix K3 jest dostępny za pośrednictwem API Chat Completions, Responses i Claude-compatible Messages. Zobacz także: oficjalna dokumentacja platformy Moonshot.

Wnioski i przykładowe odpowiedzi w każdej sekcji pochodzą z rzeczywistych wywołań wykonanych 2026-07-17 za pośrednictwem API AIHubMix (Chat Completions / Responses / Messages).

1. Specyfikacje modelu w skrócie

Zweryfikowane: oba limity stop są zweryfikowane, a ich przekroczenie zwraca 400; API Messages stosuje tę samą walidację do stop_sequences.

❗ Kiedy sekwencja zatrzymania jest osiągnięta, API Messages nie stosuje semantyki Anthropic: w testach stop_reason to "end_turn" (zamiast "stop_sequence"), stop_sequence to null, a widoczny tekst przed słowem zatrzymania może być pusty. Klienci, którzy polegają na tych dwóch polach do wykrywania obcięcia, powinni to uwzględnić.

# zatrzymanie z 6 wpisami / wpis 33-bajtowy -> HTTP 400
"Nieprawidłowe żądanie: tablica stop jest zbyt długa. Oczekiwana tablica o maksymalnej długości 5, ale otrzymano tablicę o długości 6"
"Nieprawidłowe żądanie: sekwencja zatrzymania nie może być dłuższa niż 32, ale otrzymano 33"

2. Tryb myślenia: reasoning_effort obsługuje tylko max

Myślenie K3 jest włączone domyślnie, a reasoning_effort obsługuje tylko jeden poziom: "max".

Wieloturnowe rozmowy muszą przekazywać historię myślenia dosłownie: zgodnie z oficjalną dokumentacją Moonshot, K3 jest trenowany z zachowaną myślą, więc w wieloturnowych rozmowach poprzednia wiadomość asystenta musi być przekazywana w całości i bez modyfikacji (w tym treści myślenia). Brakująca historia myślenia prowadzi do niestabilnej jakości wyjścia. Jeśli używasz frameworka do zarządzania sesjami lub warstwy proxy, upewnij się, że treść myślenia jest przekazywana w całości.

Treść myślenia jest zwracana w polu `reasoning_content` odpowiedzi; w wieloturnowych rozmowach poprzednią wiadomość asystenta (w tym `reasoning_content`) należy przekazywać dosłownie.

```text theme={null}
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="max",
    messages=[
        {"role": "user", "content": "Ślimak jest na dnie 10-metrowej studni. Każdego dnia wspina się 3 metry, ale każdej nocy zjeżdża z powrotem 2 metry. Ile dni zajmie mu dotarcie na szczyt?"}
    ],
)

print(completion.choices[0].message.reasoning_content)
print(completion.choices[0].message.content)
```

```text theme={null}
# Wieloturnowe: przekazuj poprzednią wiadomość asystenta dosłownie
messages = [
    {"role": "user", "content": "Jakie jest stolica Francji?"},
    {"role": "assistant", "content": "Paryż.", "reasoning_content": "<reasoning_content z poprzedniej odpowiedzi>"},
    {"role": "user", "content": "A jego populacja?"},
]
```

> **Zweryfikowane**: odpowiedź zwraca `reasoning_content`; po przekazaniu poprzedniej wiadomości asystenta (w tym `reasoning_content`) dosłownie, kolejne tury odpowiadają normalnie.

Treść myślenia jest zwracana jako element wyjściowy `reasoning`; w wieloturnowych rozmowach do `input` należy dosłownie dołączyć elementy wyjściowe poprzedniej tury (`reasoning` + `message`).

```text theme={null}
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key="<AIHUBMIX_API_KEY>",
)

response = client.responses.create(
    model="kimi-k3",
    input="Odpowiedz jednym słowem: stolica Francji",
)

# Obserwowane typy elementów response.output: ["reasoning", "message"]; tekst: "Paryż"
# Wieloturnowe: input = [pierwsza wiadomość użytkownika] + response.output + [następna wiadomość użytkownika]
# Obserwowana odpowiedź drugiej tury z przekazanymi elementami wyjściowymi: "Berlin"
```

Treść myślenia jest zwracana jako natywne bloki treści `thinking`; w wieloturnowych rozmowach poprzednie bloki treści asystenta (w tym bloki myślenia) należy przekazywać dosłownie.

```text theme={null}
from anthropic import Anthropic

client = Anthropic(
    api_key="<AIHUBMIX_API_KEY>",
    base_url="https://aihubmix.com"
)

response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Odpowiedz jednym słowem: stolica Francji"}
    ],
)

# Obserwowane typy bloków response.content: ["thinking", "text"]; tekst: "Paryż"
# Wieloturnowe: przekazuj response.content dosłownie jako wiadomość asystenta
```

3. Parametry próbkowania są stałe

Parametry próbkowania K3 są ustalone przez dostawcę: temperature 1.0, top_p 0.95, n 1 oraz presence_penalty / frequency_penalty 0. Oficjalna rekomendacja to pominięcie tych parametrów w żądaniach.

Uwaga: stałe wartości próbkowania są częścią oficjalnej specyfikacji i nie mogą być weryfikowane na podstawie sygnałów odpowiedzi; stosuj się do oficjalnej rekomendacji i pomiń te parametry.

4. Wywoływanie narzędzi i dynamiczne ładowanie narzędzi

tools obsługuje do 128 narzędzi; tool_choice obsługuje wymuszanie i wyłączanie wywołań narzędzi. K3 obsługuje również dynamiczne ładowanie narzędzi: wstrzykiwanie nowych narzędzi w trakcie rozmowy za pomocą pola tools w wiadomości systemowej (kształt wiadomości specyficzny dla API Chat).

`tool_choice` obsługuje `auto` / `none` / `required`; `required` wymusza na modelu wywołanie narzędzia. Dynamiczne ładowanie narzędzi: wiadomość systemowa wstrzykująca narzędzie nie zawiera `content`, wstrzyknięte narzędzia mają zastosowanie w kolejnych turach, a wiadomość musi być ponownie dołączona w każdym żądaniu.

```text theme={null}
messages = [
    {"role": "system", "content": "Jesteś pomocnym asystentem."},
    {"role": "user", "content": "Cześć."},
    {"role": "assistant", "content": "Cześć, jak mogę Ci pomóc?"},
    # Wstrzyknij nowe narzędzie w trakcie rozmowy: tylko pole tools, bez treści
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Pobierz aktualny czas",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "Która godzina?"}
]
```

```text theme={null}
# tool_choice="required" z podpowiedzią "Cześć" -> model jest zmuszony do wywołania narzędzia
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"Nowy Jork\"}"}}]
```

> **Zweryfikowane**: `tool_choice: "required"` wymusza wywołanie narzędzia nawet dla niezwiązanych podpowiedzi; `"none"` tłumi wywołania narzędzi; narzędzia wstrzykiwane w trakcie rozmowy za pomocą wiadomości systemowej bez `content` mogą być wywoływane normalnie.

Definicje narzędzi używają płaskiej struktury (`name` na najwyższym poziomie); wymuszenie wywołania również używa `tool_choice: "required"`, a wywołania są zwracane jako elementy wyjściowe `function_call`. Wsparcie dla dynamicznego ładowania narzędzi jest w toku; na razie zadeklaruj wszystkie narzędzia w górnym poziomie parametru `tools`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Cześć",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Pobierz prognozę pogody dla miasta",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# Obserwowane wyjście zawiera: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"Londyn\"}"}
```

Narzędzia używają formatu Anthropic (`input_schema`); wymuś wywołanie za pomocą `tool_choice: {"type": "any"}` i wyłącz wywołania za pomocą `{"type": "none"}`. ❗ **Oficjalny punkt końcowy Kimi K3 Messages (kompatybilny z Anthropic) nie obsługuje dynamicznego ładowania narzędzi**: w testach wiadomość wstrzykująca zwraca 200, ale wstrzyknięte narzędzie nie ma wpływu (model nie może go wywołać). Zadeklaruj wszystkie narzędzia w górnym poziomie parametru `tools`.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Pobierz prognozę pogody dla miasta",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Cześć"}],
)

# Obserwowane: stop_reason "tool_use"; treść zawiera blok tool_use wywołujący get_weather
```

5. Strukturalne wyjście

Strukturalne wyjście sprawia, że model zwraca treść, która ściśle odpowiada danemu schematowi JSON.

`response_format` obsługuje `json_schema` w trybie `strict`.

```text theme={null}
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Paryż jest stolicą Francji. Wydobądź nazwę miasta."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Obserwowana treść odpowiedzi: {"city":"Paryż"}
```

> **Zweryfikowane**: wyjście jest poprawnym JSON-em zgodnym ze schematem.

Strukturalne wyjście jest zadeklarowane za pomocą `text.format`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Paryż jest stolicą Francji. Wydobądź nazwę miasta.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Obserwowane wyjście tekstowe: {"city":"Paryż"}
```

❗ **Oficjalny punkt końcowy Kimi K3 Messages (kompatybilny z Anthropic) nie obsługuje strukturalnego wyjścia**: pola strukturalnego wyjścia są cicho ignorowane — żądanie zwraca HTTP 200 z tekstem dowolnym, bez błędu lub powiadomienia o awarii, a późniejsze parsowanie JSON zakończy się niepowodzeniem. Gdy potrzebujesz strukturalnego wyjścia, użyj API Chat Completions lub Responses.

6. Buforowanie kontekstu jest automatyczne

Buforowanie kontekstu K3 jest włączone automatycznie, bez potrzeby podawania parametrów. Gdy powtarzający się długi prefiks trafia do pamięci podręcznej, ilość trafień jest raportowana w użyciu (nazwa pola różni się w zależności od API). Ceny za pamięć podręczną znajdują się na stronie modelu.

```text theme={null} # użycie drugiego wywołania z identycznym długim prefiksem "prompt_tokens_details": {"cached_tokens": 1536} ```

> **Zweryfikowane**: drugie żądanie z identycznym długim prefiksem raportuje trafienie w `usage.prompt_tokens_details.cached_tokens`.

```text theme={null} # użycie drugiego wywołania Responses z identycznymi długimi instrukcjami "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # użycie drugiego wywołania Messages z identycznym długim prefiksem systemowym "cache_read_input_tokens": 1536 ```

7. Uzupełnienie prefiksu partial

Uzupełnienie prefiksu sprawia, że model kontynuuje generowanie z danego prefiksu, co jest dobrze dopasowane do uzupełniania kodu i wyjścia kontrolowanego formatem.

Przekaż `"partial": true` w ostatniej wiadomości asystenta.

```text theme={null}
messages = [
    {"role": "user", "content": "Napisz haiku o morzu."},
    {"role": "assistant", "content": "Fale składają się w pianę,", "partial": True},
]

# Prefiks: "Fale składają się w pianę,"  ->  kontynuacja zwrócona przez model
# sól wisi w powietrzu—
# księżyc przyciąga przypływ do domu.
```

> **Zweryfikowane**: generacja kontynuuje z danego prefiksu bez jego powtarzania.

Przekaż prefiks jako wiadomość asystenta na końcu tablicy `input`; nie jest potrzebny żaden parametr `partial`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Napisz haiku o morzu."},
        {"role": "assistant", "content": "Fale składają się w pianę,"},
    ],
)

# Obserwowana kontynuacja: "sól wisi w powietrzu— / księżyc przyciąga przypływ do domu."
```

Ta sama funkcjonalność jest osiągana za pomocą natywnego wypełnienia asystenta protokołu, bez parametru `partial` — przekaż prefiks jako ostatnią wiadomość asystenta.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Napisz haiku o morzu."},
        {"role": "assistant", "content": "Fale składają się w pianę,"},
    ],
)

# Obserwowana kontynuacja: "sól wisi w powietrzu— / księżyc przyciąga przypływ do domu."
```

8. Wejście wizualne

Obrazy są przekazywane jako base64; format bloku treści różni się w zależności od API.

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Jaki jest dominujący kolor tego obrazu? Jedno słowo."}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,"}}, ], } ]

# Obserwowana treść odpowiedzi: "Czerwony"  (wejście: 64x64 jednolity czerwony PNG)
```

> **Zweryfikowane**: wejście obrazu base64 działa, a model poprawnie opisuje testowy obraz.

```text theme={null} input = [ { "role": "user", "content": [ {"type": "input_text", "text": "Jaki jest dominujący kolor tego obrazu? Jedno słowo."}, {"type": "input_image", "image_url": "data:image/png;base64,"}, ], } ]

# Obserwowana treść wyjściowa: "Czerwony"
```

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Jaki jest dominujący kolor tego obrazu? Jedno słowo."}, {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, ], } ]

# Obserwowana treść odpowiedzi: "Czerwony"
```

9. Zweryfikowane odniesienie: opóźnienie i wykorzystanie długiego zadania jednego wywołania

Myślenie K3 jest ustalone na maksymalnym poziomie, więc pojedyncze żądania dotyczące złożonych zadań zajmują znacznie więcej czasu niż w typowych modelach. Zmierzono dane z zadania generowania gry HTML w jednym pliku (jedno zapytanie z obrazem referencyjnym, wygenerowane w jednym podejściu bez iteracji): pojedyncze żądanie zajęło 2,541 sekund (około 42 minut), z 74,994 tokenami zakończenia, z których 54,486 (73%) to tokeny myślenia; ostateczne wyjście to 1,275 linii kodu gotowego do uruchomienia, z finish_reason stop.

Rekomendacje po stronie klienta:

• Ustaw czasy oczekiwania klienta na minuty lub dłużej i preferuj strumieniowanie dla długich zadań;
• Zostaw wystarczająco dużo miejsca w max_completion_tokens — w tym przypadku myślenie samo w sobie zużyło 54,486 tokenów.

10. Macierz wsparcia API × możliwości

Każda komórka w poniższej tabeli została zweryfikowana 2026-07-17 za pomocą rzeczywistych wywołań do produkcyjnych API AIHubMix; każda komórka pokazuje składnię parametru / pola dla odpowiadającego API.

FAQ

Jakie API obsługuje K3 na AIHubMix?
Chat Completions (/v1/chat/completions), Responses (/v1/responses) i API Messages kompatybilne z Claude (/v1/messages).

Czy myślenie można wyłączyć lub zmniejszyć?
Nie. Myślenie K3 jest włączone domyślnie, a reasoning_effort obsługuje tylko jeden poziom "max".

Dlaczego reasoning_content musi być przekazywane w wieloturnowych rozmowach?
K3 jest trenowany z zachowaną myślą; Moonshot wymaga, aby poprzednia wiadomość asystenta była przekazywana w całości i bez modyfikacji. Brakująca historia myślenia prowadzi do niestabilnej jakości wyjścia.

Jakie są limity parametru stop?
Maksymalnie 5 sekwencji zatrzymania, każda nie dłuższa niż 32 bajty; przekroczenie któregokolwiek z limitów zwraca błąd 400.

Czy API Messages obsługuje strukturalne wyjście?
❗ Nie. Oficjalny punkt końcowy Kimi K3 Messages (kompatybilny z Anthropic) cicho ignoruje pola strukturalnego wyjścia (zwracając 200 z tekstem dowolnym i bez błędu). Dla strukturalnego wyjścia użyj response_format w Chat Completions lub text.format w Responses.

Dlaczego pojedyncze żądania K3 zajmują tak dużo czasu?
Myślenie K3 jest ustalone na maksymalnym poziomie, a tokeny myślenia stanowią dużą część w złożonych zadaniach (73% tokenów zakończenia w zmierzonym przypadku). Ustaw czasy oczekiwania klienta na minuty lub dłużej i używaj strumieniowania.

Aby uzyskać informacje o cenach i statusie w czasie rzeczywistym, zobacz stronę modelu Kimi K3; aby zobaczyć więcej modeli, odwiedź galerię modeli.

Ostatnia aktualizacja: 2026-07-17