Przewodnik po Kimi K3: Nowe parametry i macierz wsparcia API

Artykuł ten dotyczy nowych parametrów i uwag dotyczących 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 "Zweryfikowane" w każdej sekcji pochodzą z rzeczywistych wywołań dokonanych 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 zostanie 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 skrócenia, powinni to uwzględnić.

# zatrzymanie z 6 wpisami / wpis o długości 33 bajtów -> 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 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ść myślenia). Brak historii 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 bez przycinania.
Chat Completions

Treść myślenia jest zwracana w polu reasoning_content odpowiedzi; w wieloturnowych rozmowach, przekazuj poprzednią wiadomość asystenta (w tym 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": "Ślimak jest na dnie 10-metrowej studni. Każdego dnia wspina się na 3 metry, ale każdej nocy zjeżdża z powrotem o 2 metry. Ile dni zajmie mu dotarcie na szczyt?"}
    ],
)

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

# Wieloturnowe: przekazuj poprzednią wiadomość asystenta dosłownie
messages = [
    {"role": "user", "content": "Jakie jest stolica Francji?"},
    {"role": "assistant", "content": "Paryż.", "reasoning_content": "<reasoning_content from the previous response>"},
    {"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.
Odpowiedzi

Treść myślenia jest zwracana jako element wyjściowy reasoning; w wieloturnowych rozmowach, dołącz poprzednie elementy wyjściowe tury (reasoning + message) z powrotem 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="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"

Wiadomości

Treść myślenia jest zwracana jako natywne bloki treści thinking; w wieloturnowych rozmowach, przekazuj poprzednie bloki treści asystenta (w tym bloki myślenia) 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": "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ą ustalane przez dostawcę modelu: temperature 1.0, top_p 0.95, n 1, a presence_penalty / frequency_penalty 0. Oficjalne zalecenie 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; postępuj zgodnie z oficjalnym zaleceniem 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).
Chat Completions

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.

messages = [
    {"role": "system", "content": "Jesteś pomocnym asystentem."},
    {"role": "user", "content": "Cześć."},
    {"role": "assistant", "content": "Cześć, jak mogę ci pomóc?"},
    # Wstrzykiwanie nowego narzędzia 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?"},
]

# tool_choice="required" z zapytaniem "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 zapytań; "none" tłumi wywołania narzędzi; narzędzia wstrzyknięte w trakcie rozmowy za pomocą wiadomości systemowej bez content mogą być wywoływane normalnie.
Odpowiedzi

Definicje narzędzi używają płaskiej struktury (name na najwyższym poziomie); wymuszanie 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.

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

# Obserwowana odpowiedź zawiera: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"Londyn\"}"}

Wiadomości

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 efektu (model nie może go wywołać). Zadeklaruj wszystkie narzędzia w górnym poziomie parametru tools.

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. Ustrukturyzowane wyjście

Ustrukturyzowane wyjście sprawia, że model zwraca treść, która ściśle odpowiada podanemu schematowi JSON.
Chat Completions

response_format obsługuje json_schema w trybie strict.

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

Ustrukturyzowane wyjście jest deklarowane za pomocą text.format.

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"]},
        }
    },
)

# Obserwowana treść wyjścia: {"city":"Paryż"}

Wiadomości

❗ Oficjalny punkt końcowy Kimi K3 Messages (kompatybilny z Anthropic) nie obsługuje ustrukturyzowanego wyjścia: pola ustrukturyzowanego wyjścia są cicho ignorowane: żądanie zwraca HTTP 200 z tekstem swobodnym, bez błędu lub powiadomienia o awarii, a dalsze analizowanie JSON zakończy się niepowodzeniem. Gdy potrzebujesz ustrukturyzowanego 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.
Chat Completions

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

# użycie drugiego wywołania Responses z identycznymi długimi instrukcjami
"input_tokens_details": {"cached_tokens": 1536}

Wiadomości

# użycie drugiego wywołania Messages z identycznym długim zapytaniem systemowym
"cache_read_input_tokens": 1536

7. Ukończenie prefiksu partial

Ukończenie prefiksu sprawia, że model kontynuuje generowanie z danego prefiksu, co jest dobrze dopasowane do ukończenia kodu i wyjścia kontrolowanego formatem.
Chat Completions

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

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

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

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

Wiadomości

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

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 wiatru niesie krzyk mewy— / przypływ ciągnie ..."

8. Wejście wizji

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

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,<BASE64>"}},
        ],
    }
]

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

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

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,<BASE64>"},
        ],
    }
]

# Obserwowana treść wyjścia: "Czerwony"

Wiadomości

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": "<BASE64>"}},
        ],
    }
]

# Obserwowana treść odpowiedzi: "Czerwony"

9. Zweryfikowane odniesienie: Opóźnienie i użycie długiego zadania jednorazowego

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 ukończenia, z których 54,486 (73%) to tokeny myślenia; ostateczne wyjście to 1,275 linii bezpośrednio wykonalnego kodu, 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 dużo zapasu w max_completion_tokens: w tym przypadku myślenie samo w sobie zużyło 54,486 tokenów.

10. Matryca wsparcia API × możliwości

Każda komórka w poniższej tabeli została zweryfikowana 2026-07-17 poprzez rzeczywiste wywołania 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 pojedynczy 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. Brak historii 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 limitu zwraca błąd 400.

Czy API Messages obsługuje ustrukturyzowane wyjście?
❗ Nie. Oficjalny punkt końcowy Kimi K3 Messages (kompatybilny z Anthropic) cicho ignoruje pola ustrukturyzowanego wyjścia (zwracając 200 z tekstem swobodnym i bez błędu). Dla ustrukturyzowanego 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 ukoń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