Kimi K3 praktische gids: nieuwe parameters en API-ondersteuningsmatrix

Dit artikel behandelt de nieuwe parameters en gebruiksnotities voor Kimi K3. Op AIHubMix is K3 beschikbaar via de Chat Completions-, Responses- en Claude-compatibele Messages-API's. Zie ook: officiële documentatie van het Moonshot-platform.

De conclusies "Verified" en de voorbeeldresponsen in elke sectie komen van daadwerkelijke aanroepen die op 2026-07-17 via de AIHubMix-API's (Chat Completions / Responses / Messages) zijn gedaan.

1. Modelspecificaties in het kort

Verified: beide stop-limieten worden gevalideerd; bij overschrijding van een van beide geeft de API een 400-fout terug. De Messages-API past dezelfde validatie toe op stop_sequences.

❗ Wanneer een stopsequentie wordt geraakt, volgt de Messages-API de Anthropic-semantiek niet: in tests is stop_reason "end_turn" (in plaats van "stop_sequence"), is stop_sequence null, en kan de zichtbare tekst vóór het stopwoord leeg zijn. Clients die op deze twee velden vertrouwen om afkapping te detecteren, moeten hiermee rekening houden.

# 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. Denkmodus: reasoning_effort ondersteunt alleen max

Het denken van K3 staat standaard aan, en reasoning_effort ondersteunt slechts één niveau: "max".

Geef de denkgeschiedenis bij meerdere beurten ongewijzigd terug: volgens de officiële documentatie van Moonshot is K3 getraind met behouden denkstappen, dus in gesprekken met meerdere beurten moet het vorige assistentbericht compleet en onveranderd worden teruggegeven (inclusief de denkinhoud). Ontbrekende denkgeschiedenis leidt tot onstabiele outputkwaliteit. Als je een sessiebeheerframework of een proxylaag gebruikt, controleer dan of de denkinhoud ongekapt wordt teruggegeven.
Chat Completions

Denkinhoud wordt teruggegeven in het veld reasoning_content van de respons; geef in gesprekken met meerdere beurten het vorige assistentbericht (inclusief reasoning_content) ongewijzigd terug.

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

Verified: de respons bevat reasoning_content; nadat het vorige assistentbericht (inclusief reasoning_content) ongewijzigd is teruggegeven, antwoordt het model in volgende beurten normaal.
Responses

Denkinhoud wordt teruggegeven als een reasoning-outputitem; voeg in gesprekken met meerdere beurten de outputitems van de vorige beurt (reasoning + message) ongewijzigd toe aan input.

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

Denkinhoud wordt teruggegeven als native thinking-contentblokken; geef in gesprekken met meerdere beurten de contentblokken van het vorige assistentbericht (inclusief de thinking-blokken) ongewijzigd terug.

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. Samplingparameters zijn vast

De samplingparameters van K3 worden door de modelaanbieder vastgelegd: temperature 1.0, top_p 0.95, n 1, en presence_penalty / frequency_penalty 0. De officiële aanbeveling is om deze parameters niet in verzoeken op te nemen.

Let op: de vaste samplingwaarden maken deel uit van de officiële specificatie en kunnen niet worden geverifieerd aan de hand van responssignalen; volg de officiële aanbeveling en laat deze parameters weg.

4. Toolaanroepen en dynamisch laden van tools

tools ondersteunt tot 128 tools; tool_choice ondersteunt het afdwingen en uitschakelen van toolaanroepen. K3 ondersteunt ook dynamisch laden van tools: nieuwe tools tijdens een gesprek injecteren via het veld tools van een systeembericht (een berichtvorm die specifiek is voor de Chat API).
Chat Completions

tool_choice ondersteunt auto / none / required; required dwingt het model om een tool aan te roepen. Dynamisch laden van tools: het systeembericht dat tools injecteert bevat geen content, de geïnjecteerde tools gelden voor volgende beurten, en het bericht moet bij elk verzoek opnieuw worden meegestuurd.

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\"}"}}]

Verified: tool_choice: "required" dwingt een toolaanroep af, ook bij niet-gerelateerde prompts; "none" onderdrukt toolaanroepen; tools die tijdens een gesprek via een systeembericht zonder content zijn geïnjecteerd, kunnen normaal worden aangeroepen.
Responses

Tooldefinities gebruiken een platte structuur (name op het hoogste niveau); het afdwingen van een aanroep gebeurt eveneens met tool_choice: "required", en aanroepen worden teruggegeven als function_call-outputitems. Ondersteuning voor dynamisch laden van tools is in ontwikkeling; declareer voorlopig alle tools in de bovenste parameter 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

Tools gebruiken het Anthropic-formaat (input_schema); een aanroep forceren doe je met tool_choice: {"type": "any"}, en aanroepen uitschakelen met {"type": "none"}. ❗ Het officiële Messages-eindpunt (Anthropic-compatibel) van Kimi K3 ondersteunt geen dynamisch laden van tools: in tests geeft het bericht dat tools injecteert een 200 terug, maar de geïnjecteerde tool heeft geen effect (het model kan hem niet aanroepen). Declareer alle tools in de bovenste parameter 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. Gestructureerde output

Gestructureerde output zorgt ervoor dat het model inhoud teruggeeft die strikt voldoet aan een gegeven JSON Schema.
Chat Completions

response_format ondersteunt json_schema met de strict-modus.

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

Verified: de output is geldige JSON die aan het schema voldoet.
Responses

Gestructureerde output wordt gedeclareerd via 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

❗ Het officiële Messages-eindpunt (Anthropic-compatibel) van Kimi K3 ondersteunt geen gestructureerde output: de velden voor gestructureerde output worden stilzwijgend genegeerd: het verzoek geeft HTTP 200 terug met vrije tekst, zonder foutmelding of meldingsbericht, en de downstream JSON-verwerking zal mislukken. Gebruik de Chat Completions- of Responses-API wanneer je gestructureerde output nodig hebt.

6. Contextcaching is automatisch

De contextcaching van K3 is automatisch ingeschakeld en vereist geen parameters. Wanneer een herhaald lang voorvoegsel uit de cache wordt geladen, wordt het aantal treffers gerapporteerd in usage (de veldnaam verschilt per API). De cacheprijzen staan op de modelpagina.
Chat Completions

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

Verified: het tweede verzoek met een identiek lang voorvoegsel meldt de treffer in 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. partial-voorvoegselaanvulling

Voorvoegselaanvulling laat het model verdergaan met genereren vanaf een gegeven voorvoegsel, wat goed past bij codeaanvulling en outputs met een vaste opmaak.
Chat Completions

Geef "partial": true mee in het laatste assistentbericht.

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.

Verified: het genereren gaat verder vanaf het gegeven voorvoegsel zonder het te herhalen.
Responses

Geef het voorvoegsel als assistentbericht aan het einde van de input-array mee; een partial-parameter is niet nodig.

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

Dezelfde mogelijkheid wordt bereikt met de native assistant-prefill van het protocol, zonder partial-parameter: geef het voorvoegsel mee als laatste assistentbericht.

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. Visuele invoer

Afbeeldingen worden als base64 meegestuurd; het formaat van de contentblokken verschilt per 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)

Verified: base64-afbeeldingsinvoer werkt, en het model beschrijft de testafbeelding correct.
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. Geverifieerde referentie: latentie en gebruik bij een lange taak in één aanroep

Het denken van K3 staat vast op het maximale niveau, dus enkelvoudige verzoeken voor complexe taken duren aanzienlijk langer dan bij gangbare modellen. Gemeten gegevens van een taak waarin één HTML-spelbestand werd gegenereerd (één prompt met een referentieafbeelding, in één keer gegenereerd zonder iteratie): het enkele verzoek duurde 2.541 seconden (ongeveer 42 minuten), met 74.994 completion-tokens, waarvan 54.486 (73%) denk-tokens; de uiteindelijke output was 1.275 regels direct uitvoerbare code, met finish_reason stop.

Aanbevelingen aan de clientzijde:

• Stel clienttimeouts in op minuten of langer, en geef de voorkeur aan streaming voor lange taken;
• Houd ruim marge aan in max_completion_tokens: in dit geval verbruikte het denken alleen al 54.486 tokens.

10. Matrix van mogelijkheden en API-ondersteuning

Elke cel in de onderstaande tabel is op 2026-07-17 geverifieerd via daadwerkelijke aanroepen naar de productie-API's van AIHubMix; elke cel toont de parameter- / veldsyntaxis voor de bijbehorende API.

Veelgestelde vragen

Welke API's ondersteunt K3 op AIHubMix?
Chat Completions (/v1/chat/completions), Responses (/v1/responses) en de Claude-compatibele Messages-API (/v1/messages).

Kan het denken worden uitgeschakeld of verlaagd?
Nee. Het denken van K3 staat standaard aan, en reasoning_effort ondersteunt alleen het enige niveau "max".

Waarom moet reasoning_content worden teruggestuurd in gesprekken met meerdere beurten?
K3 is getraind met behouden redenering (preserved thinking); Moonshot vereist dat het vorige assistentbericht volledig en ongewijzigd wordt teruggestuurd. Ontbrekende redeneergeschiedenis leidt tot onstabiele outputkwaliteit.

Wat zijn de limieten voor de stop-parameter?
Er zijn maximaal 5 stopreeksen toegestaan, elk niet langer dan 32 bytes; het overschrijden van een van beide limieten geeft een 400-fout terug.

Ondersteunt de Messages API gestructureerde output?
❗ Nee. Het officiële Messages-eindpunt (Anthropic-compatibel) van Kimi K3 negeert velden voor gestructureerde output stilzwijgend (het geeft een 200-antwoord met vrije tekst en zonder foutmelding terug). Gebruik voor gestructureerde output response_format op Chat Completions of text.format op Responses.

Waarom duren single K3-verzoeken zo lang?
Het denken van K3 staat vast op het maximale niveau, en denktokens vormen een groot aandeel van de completion-tokens bij complexe taken (73% van de completion-tokens in het gemeten geval). Stel clienttimeouts in op minuten of langer en gebruik streaming.

Voor prijzen en actuele status, zie de modelpagina van Kimi K3; voor meer modellen, bezoek de modelgalerij.

Laatst bijgewerkt: 2026-07-17