Przewodnik praktyczny Kimi K3: nowe parametry i macierz wsparcia API

W tym artykule omówiono nowe parametry i wskazówki dotyczące użycia Kimi K3. W AIHubMix model K3 jest dostępny przez Chat Completions, Responses oraz API Messages zgodne z Claude. Zobacz także: oficjalną dokumentację platformy Moonshot.

Wnioski „Verified” oraz przykładowe odpowiedzi w każdej sekcji pochodzą z rzeczywistych wywołań wykonanych 2026-07-17 przez API AIHubMix (Chat Completions / Responses / Messages).

1. Specyfikacja modelu w skrócie

Zweryfikowano: oba limity stop są sprawdzane, a przekroczenie któregokolwiek zwraca 400; API Messages stosuje tę samą walidację do stop_sequences.

❗ Po trafieniu sekwencji zatrzymującej API Messages nie postępuje zgodnie z semantyką Anthropic: w testach stop_reason ma wartość "end_turn" (zamiast "stop_sequence"), stop_sequence ma wartość null, a widoczny tekst przed słowem zatrzymującym może być pusty. Klienci, którzy polegają na tych dwóch polach do wykrywania obcięcia, powinni to uwzględnić.

# stop with 6 entries / a 33-byte entry -> HTTP 400
"Invalid request: stop array too long. Expected an array with maximum length 5, but got an array with length 6 instead"
"Invalid request: stop sequence must not be longer than 32, but got 33 instead"

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

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

Historię myślenia w rozmowach wieloturowych należy przekazywać dosłownie: zgodnie z oficjalną dokumentacją Moonshot, K3 jest trenowany z zachowanym myśleniem, więc w rozmowach wieloturowych poprzednią wiadomość asystenta trzeba przekazywać w całości i bez zmian (łącznie z treścią myślenia). Brak historii myślenia prowadzi do niestabilnej jakości odpowiedzi. Jeśli używasz frameworka do zarządzania sesją lub warstwy proxy, upewnij się, że treść myślenia jest przekazywana bez skracania.
Chat Completions

Treść myślenia zwracana jest w polu reasoning_content odpowiedzi; w rozmowach wieloturowych przekaż poprzednią wiadomość asystenta (łącznie z reasoning_content) dosłownie.

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": "A snail is at the bottom of a 10-meter well. Each day it climbs 3 meters, but each night it slides back 2 meters. How many days does it take to reach the top?"}
    ],
)

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

# Multi-turn: pass the previous assistant message back verbatim
messages = [
    {"role": "user", "content": "What is the capital of France?"},
    {"role": "assistant", "content": "Paris.", "reasoning_content": "<reasoning_content from the previous response>"},
    {"role": "user", "content": "And its population?"},
]

Zweryfikowano: odpowiedź zwraca reasoning_content; po przekazaniu poprzedniej wiadomości asystenta (łącznie z reasoning_content) bez zmian kolejne tury odpowiadają poprawnie.
Responses

Treść myślenia zwracana jest jako element wyjścia reasoning; w rozmowach wieloturowych dołącz elementy wyjścia z poprzedniej tury (reasoning + message) do input dosłownie.

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="Answer in one word: capital of France",
)

# Observed response.output item types: ["reasoning", "message"]; text: "Paris"
# Multi-turn: input = [first user message] + response.output + [next user message]
# Observed second-turn answer with output items passed back: "Berlin"

Messages

Treść myślenia zwracana jest jako natywne bloki treści thinking; w rozmowach wieloturowych przekaż poprzednie bloki treści asystenta (łącznie z blokami thinking) dosłownie.

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": "Answer in one word: capital of France"}
    ],
)

# Observed response.content block types: ["thinking", "text"]; text: "Paris"
# Multi-turn: pass response.content back verbatim as the assistant message

3. Parametry próbkowania są stałe

Parametry próbkowania K3 są ustalone przez dostawcę modelu: temperature 1.0, top_p 0.95, n 1, a presence_penalty / frequency_penalty 0. Oficjalne zalecenie to pomijanie tych parametrów w żądaniach.

Uwaga: stałe wartości próbkowania są częścią oficjalnej specyfikacji i nie da się ich zweryfikować na podstawie sygnałów odpowiedzi; stosuj się do oficjalnego zalecenia 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 też dynamiczne ładowanie narzędzi: wstrzykiwanie nowych narzędzi w trakcie rozmowy przez pole tools wiadomości systemowej (kształt wiadomości specyficzny dla API Chat).
Chat Completions

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

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello."},
    {"role": "assistant", "content": "Hi, how can I help you?"},
    # Inject a new tool mid-conversation: tools field only, no content
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Get the current time",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "What time is it now?"},
]

# tool_choice="required" with prompt "Hello" -> the model is forced to call the tool
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"New York\"}"}}]

Zweryfikowano: tool_choice: "required" wymusza wywołanie narzędzia nawet przy niezwiązanych z tym promptach; "none" blokuje wywołania narzędzi; narzędzia wstrzyknięte w trakcie rozmowy przez wiadomość systemową bez content mogą być normalnie wywoływane.
Responses

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 zwracane są jako elementy wyjścia function_call. Obsługa dynamicznego ładowania narzędzi jest w przygotowaniu; na razie deklaruj wszystkie narzędzia w parametrze najwyższego poziomu tools.

response = client.responses.create(
    model="kimi-k3",
    input="Hello",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Get weather for a city",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# Observed output contains: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"London\"}"}

Messages

Narzędzia używają formatu Anthropic (input_schema); wymuś wywołanie przez tool_choice: {"type": "any"}, a wyłącz wywołania przez {"type": "none"}. ❗ Oficjalny endpoint Messages (zgodny z Anthropic) dla Kimi K3 nie obsługuje dynamicznego ładowania narzędzi: w testach wiadomość wstrzykująca zwraca 200, ale wstrzyknięte narzędzie nie działa (model nie może go wywołać). Deklaruj wszystkie narzędzia w parametrze najwyższego poziomu tools.

response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Get weather for a city",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Hello"}],
)

# Observed: stop_reason "tool_use"; content contains a tool_use block calling get_weather

5. Wyjście strukturalne

Wyjście strukturalne sprawia, że model zwraca treść ściśle zgodną z podanym JSON Schema.
Chat Completions

response_format obsługuje json_schema z trybem strict.

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Paris is the capital of France. Extract the city name."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Observed response content: {"city":"Paris"}

Zweryfikowano: wyjście jest poprawnym JSON-em zgodnym ze schematem.
Responses

Wyjście strukturalne deklaruje się przez text.format.

response = client.responses.create(
    model="kimi-k3",
    input="Paris is the capital of France. Extract the city name.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Observed output text: {"city":"Paris"}

Messages

❗ Oficjalny endpoint Messages (zgodny z Anthropic) dla Kimi K3 nie obsługuje wyjścia strukturalnego: pola structured output są po cichu ignorowane. Żądanie zwraca HTTP 200 z tekstem swobodnym, bez błędu ani informacji o zastępczym zachowaniu, a dalsze parsowanie JSON się nie powiedzie. Gdy potrzebujesz wyjścia strukturalnego, użyj API Chat Completions lub Responses.

6. Cache'owanie kontekstu jest automatyczne

Cache'owanie kontekstu K3 jest włączone automatycznie, bez wymaganych parametrów. Gdy powtarzający się długi prefiks trafia w cache, liczba trafień jest raportowana w usage (nazwa pola zależy od API). Ceny cache są na stronie modelu.
Chat Completions

# usage of the second call with an identical long prefix
"prompt_tokens_details": {"cached_tokens": 1536}

Zweryfikowano: drugie żądanie z identycznym długim prefiksem raportuje trafienie w usage.prompt_tokens_details.cached_tokens.
Responses

# usage of the second Responses call with identical long instructions
"input_tokens_details": {"cached_tokens": 1536}

Messages

# usage of the second Messages call with an identical long system prompt
"cache_read_input_tokens": 1536

7. Dopełnianie prefiksu za pomocą partial

Dopełnianie prefiksu sprawia, że model kontynuuje generowanie od podanego prefiksu, co dobrze sprawdza się przy uzupełnianiu kodu i wyjściu o kontrolowanym formacie.
Chat Completions

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

messages = [
    {"role": "user", "content": "Write a haiku about the sea."},
    {"role": "assistant", "content": "Waves fold into foam,", "partial": True},
]

# Prefix: "Waves fold into foam,"  ->  continuation returned by the model
# salt hangs in the air—
# moon pulls the tide home.

Zweryfikowano: generowanie kontynuuje od podanego prefiksu bez jego powtarzania.
Responses

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

response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Write a haiku about the sea."},
        {"role": "assistant", "content": "Waves fold into foam,"},
    ],
)

# Observed continuation: "salt hangs in the air— / moon pulls the tide home."

Messages

Tę samą funkcję osiąga się natywnym dla protokołu assistant prefill, bez parametru partial: przekaż prefiks jako ostatnią wiadomość asystenta.

response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Write a haiku about the sea."},
        {"role": "assistant", "content": "Waves fold into foam,"},
    ],
)

# Observed continuation: "salt wind carries the gull's cry— / tide pulls ..."

8. Wejście wizualne

Obrazy przekazuje się jako base64; format bloku treści zależy od API.
Chat Completions

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the dominant color of this image? One word."},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,<BASE64>"}},
        ],
    }
]

# Observed response content: "Red"  (input: a 64x64 solid red PNG)

Zweryfikowano: wejście obrazu w base64 działa, a model poprawnie opisuje obraz testowy.
Responses

input = [
    {
        "role": "user",
        "content": [
            {"type": "input_text", "text": "What is the dominant color of this image? One word."},
            {"type": "input_image", "image_url": "data:image/png;base64,<BASE64>"},
        ],
    }
]

# Observed output text: "Red"

Messages

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "What is the dominant color of this image? One word."},
            {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": "<BASE64>"}},
        ],
    }
]

# Observed response text: "Red"

9. Zweryfikowane dane referencyjne: opóźnienie i zużycie przy długim zadaniu w jednym wywołaniu

Myślenie K3 jest ustawione na stałe na poziomie max, dlatego pojedyncze żądania złożonych zadań trwają znacznie dłużej niż w typowych modelach. Dane pomiarowe z zadania wygenerowania jednoplikowej gry HTML (jeden prompt z obrazem referencyjnym, wygenerowanie w jednym przebiegu bez iteracji): pojedyncze żądanie trwało 2,541 sekund (około 42 minut), z 74,994 tokenami completion, z czego 54,486 (73%) to tokeny myślenia; końcowe wyjście to 1,275 wierszy bezpośrednio uruchamialnego kodu, z finish_reason równym stop.

Zalecenia po stronie klienta:

• Ustaw timeouty klienta na minuty lub więcej i preferuj streaming przy długich zadaniach;
• Zostaw duży zapas w max_completion_tokens: w tym przypadku samo myślenie zużyło 54,486 tokenów.

10. Macierz wsparcia: możliwości × API

Każda komórka poniższej tabeli została zweryfikowana 2026-07-17 przez rzeczywiste wywołania produkcyjnych API AIHubMix; każda komórka pokazuje składnię parametru / pola dla danego API.

FAQ

Które API obsługuje K3 w AIHubMix?
Chat Completions (/v1/chat/completions), Responses (/v1/responses) oraz zgodne z Claude API Messages (/v1/messages).

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

Dlaczego reasoning_content trzeba przekazywać z powrotem w rozmowach wieloturowych?
K3 jest trenowany z zachowanym myśleniem (preserved thinking); Moonshot wymaga, aby poprzednia wiadomość asystenta była przekazana w całości i bez modyfikacji. Brak historii myślenia prowadzi do niestabilnej jakości odpowiedzi.

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

Czy Messages API obsługuje structured output?
❗ Nie. Oficjalny endpoint Messages (zgodny z Anthropic) Kimi K3 po cichu ignoruje pola structured output (zwraca 200 z tekstem swobodnym i bez błędu). Do structured output użyj response_format w Chat Completions lub text.format w Responses.

Dlaczego pojedyncze żądania K3 trwają tak długo?
Myślenie K3 jest ustawione na maksymalnym poziomie, a tokeny myślenia stanowią dużą część w złożonych zadaniach (73% tokenów completion w zmierzonym przypadku). Ustaw timeouty klienta na minuty lub dłużej i użyj streamingu.

Cenniki i aktualny status w czasie rzeczywistym znajdziesz na stronie modelu Kimi K3; więcej modeli znajdziesz w galerii modeli.

Ostatnia aktualizacja: 2026-07-17