Documentatie Index
Haal de complete documentatie-index op via: https://docs.aihubmix.com/llms.txt
Gebruik dit bestand om alle beschikbare pagina's te ontdekken voordat je verder gaat met verkennen.

Juli 2026 Kimi K3 gids: reasoning_effort max, denkgeschiedenis, dynamisch tool laden, gestructureerde output, automatische caching, gedeeltelijke prefix, en visuele invoer.

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 APIs. Zie ook: Moonshot officiële platformdocumentatie.

De "Geverifieerde" conclusies en voorbeeldantwoorden in elke sectie komen van daadwerkelijke oproepen gedaan op 2026-07-17 via de AIHubMix APIs (Chat Completions / Responses / Messages).

1. Model Specificaties in een Oogopslag

Geverifieerd: beide stop limieten zijn gevalideerd, en het overschrijden van een van beide retourneert 400; de Messages API past dezelfde validatie toe op stop_sequences.

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

# stop met 6 invoeren / een 33-byte invoer -> 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

K3's denken is standaard aan, en reasoning_effort ondersteunt slechts één niveau: "max".

Multi-turn gesprekken moeten de denkgeschiedenis letterlijk teruggeven: volgens de officiële documentatie van Moonshot is K3 getraind met behouden denken, dus in multi-turn gesprekken moet het vorige assistentbericht volledig en ongewijzigd (inclusief de denkinhoud) worden teruggegeven. Ontbrekende denkgeschiedenis leidt tot onbetrouwbare outputkwaliteit. Als je een sessiebeheerframework of een proxylaag gebruikt, bevestig dan dat de denkinhoud ongewijzigd wordt teruggegeven.

Denkinhoud wordt teruggegeven in het `reasoning_content` veld van de respons; in multi-turn gesprekken, geef het vorige assistentbericht (inclusief `reasoning_content`) letterlijk terug.

```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": "Een slak bevindt zich op de bodem van een put van 10 meter. Elke dag klimt hij 3 meter, maar elke nacht glijdt hij 2 meter terug. Hoeveel dagen duurt het om de top te bereiken?"}
    ],
)

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

```text theme={null}
# Multi-turn: geef het vorige assistentbericht letterlijk terug
messages = [
    {"role": "user", "content": "Wat is de hoofdstad van Frankrijk?"},
    {"role": "assistant", "content": "Parijs.", "reasoning_content": "<reasoning_content from the previous response>"},
    {"role": "user", "content": "En de bevolking?"}
]
```

> **Geverifieerd**: de respons retourneert `reasoning_content`; na het letterlijk teruggeven van het vorige assistentbericht (inclusief `reasoning_content`), beantwoorden de volgende beurten normaal.

Denkinhoud wordt teruggegeven als een `reasoning` outputitem; in multi-turn gesprekken, voeg de outputitems van de vorige beurt (`reasoning` + `message`) letterlijk toe aan `input`.

```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="Beantwoord in één woord: hoofdstad van Frankrijk",
)

# Geobserveerde response.output item types: ["reasoning", "message"]; tekst: "Parijs"
# Multi-turn: input = [eerste gebruikersbericht] + response.output + [volgend gebruikersbericht]
# Geobserveerd tweede-beurt antwoord met outputitems die zijn teruggegeven: "Berlijn"
```

Denkinhoud wordt teruggegeven als native `thinking` inhoudsblokken; in multi-turn gesprekken, geef de vorige assistentinhoudsblokken (inclusief de denkblokken) letterlijk terug.

```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": "Beantwoord in één woord: hoofdstad van Frankrijk"}
    ],
)

# Geobserveerde response.content bloktypes: ["thinking", "text"]; tekst: "Parijs"
# Multi-turn: geef response.content letterlijk terug als het assistentbericht
```

3. Samplingparameters zijn Vastgesteld

K3's samplingparameters zijn vastgesteld door de leverancier: temperature 1.0, top_p 0.95, n 1, en presence_penalty / frequency_penalty 0. De officiële aanbeveling is om deze parameters weg te laten uit verzoeken.

Opmerking: de vaste samplingwaarden maken deel uit van de officiële specificatie en kunnen niet worden geverifieerd vanuit respons signalen; volg de officiële aanbeveling en laat deze parameters weg.

4. Tool Aanroepen en Dynamisch Tool Laden

tools ondersteunt tot 128 tools; tool_choice ondersteunt het forceren en uitschakelen van toolaanroepen. K3 ondersteunt ook dynamisch tool laden: nieuwe tools injecteren midden in een gesprek via het tools veld van een systeembericht (een berichtvorm specifiek voor de Chat API).

`tool_choice` ondersteunt `auto` / `none` / `required`; `required` dwingt het model om een tool aan te roepen. Dynamisch tool laden: het tool-injecterende systeembericht bevat geen `content`, de geïnjecteerde tools zijn van toepassing voor volgende beurten, en het bericht moet opnieuw in elk verzoek worden opgenomen.

```text theme={null}
messages = [
    {"role": "system", "content": "Je bent een behulpzame assistent."},
    {"role": "user", "content": "Hallo."},
    {"role": "assistant", "content": "Hoi, hoe kan ik je helpen?"},
    # Injecteer een nieuwe tool midden in het gesprek: alleen het tools-veld, geen inhoud
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Haal de huidige tijd op",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "Hoe laat is het nu?"}
]
```

```text theme={null}
# tool_choice="required" met prompt "Hallo" -> het model wordt gedwongen om de tool aan te roepen
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"New York\"}"}}]
```

> **Geverifieerd**: `tool_choice: "required"` dwingt een toolaanroep zelfs voor niet-gerelateerde prompts; `"none"` onderdrukt toolaanroepen; tools die midden in een gesprek via een systeembericht zonder `content` zijn geïnjecteerd, kunnen normaal worden aangeroepen.

Tooldefinities gebruiken een platte structuur (`name` op het hoogste niveau); het forceren van een aanroep gebruikt ook `tool_choice: "required"`, en aanroepen worden geretourneerd als `function_call` outputitems. Ondersteuning voor dynamisch tool laden is in ontwikkeling; voor nu moeten alle tools in de top-level `tools` parameter worden gedeclareerd.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Hallo",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Haal het weer op voor een stad",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# Geobserveerde output bevat: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"London\"}"}
```

Tools gebruiken het Anthropic-formaat (`input_schema`); forceer een aanroep met `tool_choice: {"type": "any"}` en schakel aanroepen uit met `{"type": "none"}`. ❗ **Kimi K3's officiële Messages (Anthropic-compatibele) eindpunt ondersteunt geen dynamisch tool laden**: bij testen retourneert het injecterende bericht 200, maar de geïnjecteerde tool heeft geen effect (het model kan deze niet aanroepen). Declareer alle tools in de top-level `tools` parameter.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Haal het weer op voor een stad",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Hallo"}],
)

# Geobserveerd: stop_reason "tool_use"; inhoud bevat een tool_use blok dat get_weather aanroept
```

5. Gestructureerde Output

Gestructureerde output zorgt ervoor dat het model inhoud retourneert die strikt voldoet aan een gegeven JSON-schema.

`response_format` ondersteunt `json_schema` met `strict` modus.

```text theme={null}
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Parijs is de hoofdstad van Frankrijk. Extraheer de stadsnaam."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Geobserveerde response inhoud: {"city":"Parijs"}
```

> **Geverifieerd**: de output is geldig JSON dat voldoet aan het schema.

Gestructureerde output wordt gedeclareerd via `text.format`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Parijs is de hoofdstad van Frankrijk. Extraheer de stadsnaam.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Geobserveerde output tekst: {"city":"Parijs"}
```

❗ **Kimi K3's officiële Messages (Anthropic-compatibele) eindpunt ondersteunt geen gestructureerde output**: de velden voor gestructureerde output worden stilzwijgend genegeerd — het verzoek retourneert HTTP 200 met vrije tekst, zonder fout of terugvalmelding, en downstream JSON-parsing zal falen. Wanneer je gestructureerde output nodig hebt, gebruik de Chat Completions of Responses API.

6. Context Caching is Automatisch

K3's context caching is automatisch ingeschakeld, zonder dat parameters vereist zijn. Wanneer een herhaald lange prefix de cache raakt, wordt het aantal hits gerapporteerd in het gebruik (de veldnaam varieert per API). Cacheprijzen staan op de modelpagina.

```text theme={null} # gebruik van de tweede oproep met een identieke lange prefix "prompt_tokens_details": {"cached_tokens": 1536} ```

> **Geverifieerd**: de tweede aanvraag met een identieke lange prefix rapporteert de hit in `usage.prompt_tokens_details.cached_tokens`.

```text theme={null} # gebruik van de tweede Responses-aanroep met identieke lange instructies "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # gebruik van de tweede Messages-aanroep met een identieke lange systeemprompt "cache_read_input_tokens": 1536 ```

7. partial Prefix Voltooiing

Prefix voltooiing zorgt ervoor dat het model blijft genereren vanaf een gegeven prefix, goed geschikt voor codevoltooiing en format-gecontroleerde output.

Geef `"partial": true` op in het laatste assistentbericht.

```text theme={null}
messages = [
    {"role": "user", "content": "Schrijf een haiku over de zee."},
    {"role": "assistant", "content": "Golven vouwen in schuim,", "partial": True},
]

# Prefix: "Golven vouwen in schuim,"  ->  voortzetting geretourneerd door het model
# zout hangt in de lucht—
# maan trekt het tij naar huis.
```

> **Geverifieerd**: generatie gaat verder vanaf de gegeven prefix zonder deze te herhalen.

Geef de prefix op als een assistentbericht aan het einde van de `input` array; geen `partial` parameter is nodig.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Schrijf een haiku over de zee."},
        {"role": "assistant", "content": "Golven vouwen in schuim,"},
    ],
)

# Geobserveerde voortzetting: "zout hangt in de lucht— / maan trekt het tij naar huis."
```

Dezelfde mogelijkheid wordt bereikt met de native assistent prefill van het protocol, zonder `partial` parameter — geef de prefix op als het laatste assistentbericht.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Schrijf een haiku over de zee."},
        {"role": "assistant", "content": "Golven vouwen in schuim,"},
    ],
)

# Geobserveerde voortzetting: "zout wind draagt de schreeuw van de meeuw— / tij trekt ..."
```

8. Visuele Invoer

Afbeeldingen worden doorgegeven als base64; het inhoudsblokformaat varieert per API.

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Wat is de dominante kleur van deze afbeelding? Eén woord."}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,"}}, ], } ]

# Geobserveerde response inhoud: "Rood"  (invoer: een 64x64 solide rode PNG)
```

> **Geverifieerd**: base64 afbeelding invoer werkt, en het model beschrijft de testafbeelding correct.

```text theme={null} input = [ { "role": "user", "content": [ {"type": "input_text", "text": "Wat is de dominante kleur van deze afbeelding? Eén woord."}, {"type": "input_image", "image_url": "data:image/png;base64,"}, ], } ]

# Geobserveerde output tekst: "Rood"
```

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Wat is de dominante kleur van deze afbeelding? Eén woord."}, {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, ], } ]

# Geobserveerde response tekst: "Rood"
```

9. Geverifieerde Referentie: Latentie en Gebruik van een Lange Enkelvoudige Aanroep Taak

K3's denken is vastgesteld op het maximale niveau, dus enkele verzoeken voor complexe taken duren aanzienlijk langer dan bij typische modellen. Gemeten gegevens van een enkele HTML-spel generatie taak (één prompt met een referentieafbeelding, gegenereerd in één keer zonder iteratie): het enkele verzoek duurde 2.541 seconden (ongeveer 42 minuten), met 74.994 voltooiing tokens, waarvan 54.486 (73%) denk tokens waren; de uiteindelijke output was 1.275 regels direct uitvoerbare code, met finish_reason stop.

Aanbevelingen voor de client:

• Stel client time-outs in op minuten of langer, en geef de voorkeur aan streaming voor lange taken;
• Laat voldoende speling in max_completion_tokens — in dit geval verbruikte alleen het denken 54.486 tokens.

10. Capaciteit × API Ondersteuningsmatrix

Elke cel in de onderstaande tabel is geverifieerd op 2026-07-17 door daadwerkelijke oproepen naar de AIHubMix productie APIs; elke cel toont de parameter / veldsyntax voor de bijbehorende API.

FAQ

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

Kan denken worden uitgeschakeld of verlaagd?
Nee. K3's denken is standaard aan, en reasoning_effort ondersteunt alleen het enkele "max" niveau.

Waarom moet reasoning_content in multi-turn gesprekken worden teruggegeven?
K3 is getraind met behouden denken; Moonshot vereist dat het vorige assistentbericht volledig en ongewijzigd wordt teruggegeven. Ontbrekende denkgeschiedenis leidt tot onbetrouwbare outputkwaliteit.

Wat zijn de limieten op de stop parameter?
Maximaal 5 stopsequenties, elk niet langer dan 32 bytes; het overschrijden van een van beide limieten retourneert een 400-fout.

Ondersteunt de Messages API gestructureerde output?
❗ Nee. Kimi K3's officiële Messages (Anthropic-compatibele) eindpunt negeert stilzwijgend gestructureerde outputvelden (terugkerend 200 met vrije tekst en geen fout). Voor gestructureerde output, gebruik response_format op Chat Completions of text.format op Responses.

Waarom duren enkele K3 verzoeken zo lang?
K3's denken is vastgesteld op het maximale niveau, en denk tokens maken een groot aandeel uit bij complexe taken (73% van de voltooiing tokens in het gemeten geval). Stel client time-outs in op minuten of langer en gebruik streaming.

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

Laatste update: 2026-07-17