> ## Documentation Index > Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt > Use this file to discover all available pages before exploring further. # Kimi K3 Praxis-Guide: Neue Parameter & 3-API-Support-Matrix > Kimi K3 Praxis-Guide (Juli 2026): reasoning_effort max, Thinking-Verlauf, dynamische Tools, Auto-Cache, partial und Vision – AIHubMix Chat/Responses/Messages. Kimi K3 Praxis-Guide: Thinking-Modus, dynamisches Tool-Laden und Kontext-Caching > Dieser Artikel stellt die neuen Parameter und Aufrufhinweise von [Kimi K3](https://aihubmix.com/model/kimi-k3) vor. K3 ist auf AIHubMix über Chat Completions, Responses und die Claude-kompatible Messages-Schnittstelle aufrufbar. Weiterführend: [Offizielle Moonshot-Plattformdokumentation](https://platform.moonshot.ai/docs). > > Alle als "Verifiziert" gekennzeichneten Ergebnisse und Beispielantworten der einzelnen Abschnitte stammen aus realen Aufrufen über die AIHubMix-Schnittstellen (Chat Completions / Responses / Messages) am 2026-07-17. ## 1. Modellspezifikation im Überblick | Merkmal | Wert | | :----------------- | :------------------------------------------------------------------ | | Kontextfenster | 1M Tokens | | Maximale Ausgabe | `max_completion_tokens` Standard 131.072, Maximum 1.048.576 | | Eingabemodalitäten | Text, Bilder (Videoeingabe siehe offizielle Moonshot-Dokumentation) | | Thinking-Modus | Standardmäßig aktiviert, `reasoning_effort` unterstützt nur `"max"` | | Stoppsequenzen | `stop` maximal 5 Einträge, jeweils höchstens 32 Bytes | > **Verifiziert**: Beide Obergrenzen von `stop` werden validiert, bei Überschreitung wird 400 zurückgegeben; `stop_sequences` der Messages-Schnittstelle führt dieselbe Validierung aus. > > ❗ **Die Messages-Schnittstelle folgt beim Treffer einer Stoppsequenz nicht der Anthropic-Semantik**: Verifiziert wurde `stop_reason` als `"end_turn"` (statt `"stop_sequence"`), `stop_sequence` als `null`, und der sichtbare Text vor der Stoppsequenz kann leer sein. Clients, die anhand dieser beiden Felder den Abbruchgrund bestimmen, sollten dies beachten. ```text theme={null} # 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. Thinking-Modus: `reasoning_effort` nur mit Stufe `max` Das Thinking von K3 ist standardmäßig aktiviert, `reasoning_effort` unterstützt ausschließlich die Stufe `"max"`. **In Multi-Turn-Dialogen muss der Thinking-Verlauf unverändert zurückgegeben werden**: Laut offizieller Moonshot-Angabe wurde K3 mit preserved thinking trainiert. In Multi-Turn-Dialogen muss die Assistant-Nachricht der vorherigen Runde **unverändert und vollständig** zurückgegeben werden (einschließlich Thinking-Inhalt); fehlender Thinking-Verlauf führt zu instabiler Ausgabequalität. Bei Verwendung von Session-Management-Frameworks oder Proxy-Schichten stellen Sie sicher, dass der Thinking-Inhalt vor der Rückgabe nicht gekürzt wird. Der Thinking-Inhalt wird im Feld `reasoning_content` der Antwort zurückgegeben; in Multi-Turn-Dialogen wird die Assistant-Nachricht der vorherigen Runde (inkl. `reasoning_content`) unverändert zurückgegeben. ```text theme={null} from openai import OpenAI client = OpenAI( base_url="https://aihubmix.com/v1", 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) ``` ```text theme={null} # 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": ""}, {"role": "user", "content": "And its population?"}, ] ``` > **Verifiziert**: Die Antwort enthält `reasoning_content`; nach unveränderter Rückgabe der Assistant-Nachricht der vorherigen Runde (inkl. `reasoning_content`) antworten die Folgerunden normal. Der Thinking-Inhalt wird als `reasoning`-Output-Item zurückgegeben; in Multi-Turn-Dialogen werden die Output-Items der vorherigen Runde (`reasoning` + `message`) unverändert in `input` eingefügt. ```text theme={null} from openai import OpenAI client = OpenAI( base_url="https://aihubmix.com/v1", 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" ``` Der Thinking-Inhalt wird als nativer `thinking`-Content-Block zurückgegeben; in Multi-Turn-Dialogen werden die Content-Blöcke des Assistants der vorherigen Runde (inkl. Thinking-Block) unverändert zurückgegeben. ```text theme={null} from anthropic import Anthropic client = Anthropic( 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. Sampling-Parameter sind Festwerte Die Sampling-Parameter von K3 sind offiziell festgelegte Werte: `temperature` 1.0, `top_p` 0.95, `n` 1, `presence_penalty` / `frequency_penalty` 0. Offiziell wird empfohlen, diese Parameter nicht im Request zu übergeben. > **Hinweis**: Die festen Sampling-Werte sind offizielle Spezifikation und lassen sich nicht aus Antwortsignalen verifizieren; lassen Sie diese Parameter gemäß offizieller Empfehlung weg. ## 4. Tool-Aufrufe und dynamisches Tool-Laden `tools` unterstützt maximal 128 Tools; `tool_choice` unterstützt erzwungene und deaktivierte Tool-Aufrufe. K3 unterstützt zudem dynamisches Tool-Laden: Mitten im Dialog werden über das `tools`-Feld einer System-Nachricht neue Tools injiziert (eine für die Chat-Schnittstelle spezifische Nachrichtenform). `tool_choice` unterstützt `auto` / `none` / `required`; `required` zwingt das Modell zum Tool-Aufruf. Dynamisches Tool-Laden: Die System-Nachricht zur Tool-Injektion enthält kein `content`, injizierte Tools wirken für die Folgerunden und müssen in jedem Request erneut mitgesendet werden. ```text theme={null} 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?"}, ] ``` ```text theme={null} # 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\"}"}}] ``` > **Verifiziert**: `tool_choice: "required"` erzwingt auch bei themenfremden Fragen einen Tool-Aufruf; `"none"` unterdrückt Tool-Aufrufe; über eine System-Nachricht ohne `content` mitten im Dialog injizierte Tools können normal aufgerufen werden. Tool-Definitionen sind flach strukturiert (`name` auf oberster Ebene), erzwungene Aufrufe verwenden ebenfalls `tool_choice: "required"`, Aufrufe werden als `function_call`-Output-Item zurückgegeben. Dynamisches Tool-Laden ist in Vorbereitung; deklarieren Sie derzeit alle Tools im Top-Level-Parameter `tools`. ```text theme={null} 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\"}"} ``` Tools verwenden das Anthropic-Format (`input_schema`), erzwungener Aufruf ist `tool_choice: {"type": "any"}`, Deaktivierung `{"type": "none"}`. ❗ **Der offizielle Messages-Endpunkt (Anthropic-kompatibel) von Kimi K3 unterstützt kein dynamisches Tool-Laden**: Verifiziert liefert die Injektionsnachricht zwar 200, das injizierte Tool wirkt jedoch nicht (das Modell kann es nicht aufrufen); deklarieren Sie alle Tools im Top-Level-Parameter `tools`. ```text theme={null} 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. Strukturierte Ausgabe Mit strukturierter Ausgabe liefert das Modell Inhalte, die strikt dem vorgegebenen JSON-Schema entsprechen. `response_format` unterstützt `json_schema` und den `strict`-Modus. ```text theme={null} 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"} ``` > **Verifiziert**: Die Ausgabe ist gültiges, schemakonformes JSON. Strukturierte Ausgabe wird über `text.format` deklariert. ```text theme={null} 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"} ``` ❗ **Der offizielle Messages-Endpunkt (Anthropic-kompatibel) von Kimi K3 unterstützt keine strukturierte Ausgabe**: Felder für strukturierte Ausgabe werden stillschweigend ignoriert — der Request liefert HTTP 200 mit Freitext, ohne Fehlermeldung oder Degradierungshinweis; nachgelagertes JSON-Parsing schlägt fehl. Verwenden Sie für strukturierte Ausgabe die Chat-Completions- oder Responses-Schnittstelle. ## 6. Kontext-Caching automatisch aktiviert Das Kontext-Caching von K3 ist automatisch aktiviert und benötigt keine Parameter. Bei Cache-Treffern durch wiederholte lange Präfixe wird die Treffermenge im usage-Objekt gemeldet (der Feldname variiert je nach Schnittstelle). Cache-Preise siehe [Modellseite](https://aihubmix.com/model/kimi-k3). ```text theme={null} # usage of the second call with an identical long prefix "prompt_tokens_details": {"cached_tokens": 1536} ``` > **Verifiziert**: Der zweite Request mit identischem langem Präfix meldet den Treffer in `usage.prompt_tokens_details.cached_tokens`. ```text theme={null} # usage of the second Responses call with identical long instructions "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # usage of the second Messages call with an identical long system prompt "cache_read_input_tokens": 1536 ``` ## 7. Präfix-Fortsetzung mit `partial` Die Präfix-Fortsetzung lässt das Modell ab einem vorgegebenen Präfix weiterschreiben — geeignet für Code-Vervollständigung und formatkontrollierte Ausgaben. Übergeben Sie `"partial": true` in der letzten Assistant-Nachricht. ```text theme={null} 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. ``` > **Verifiziert**: Die Generierung setzt am vorgegebenen Präfix an, ohne das Präfix zu wiederholen. Übergeben Sie das Präfix als Assistant-Nachricht am Ende des `input`-Arrays; ein `partial`-Parameter ist nicht nötig. ```text theme={null} 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." ``` Dieselbe Fähigkeit wird über das protokollnative Assistant-Prefill erreicht, ohne `partial`-Parameter — übergeben Sie das Präfix einfach als letzte Assistant-Nachricht. ```text theme={null} 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. Visuelle Eingabe Bilder werden als Base64 übergeben; die Schreibweise der Content-Blöcke variiert je nach Schnittstelle. ```text theme={null} 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,"}}, ], } ] # Observed response content: "Red" (input: a 64x64 solid red PNG) ``` > **Verifiziert**: Base64-Bildeingabe funktioniert; das Modell beschreibt den Inhalt des Testbilds korrekt. ```text theme={null} 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,"}, ], } ] # Observed output text: "Red" ``` ```text theme={null} 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": ""}}, ], } ] # Observed response text: "Red" ``` ## 9. Praxisreferenz: Dauer und Token-Verbrauch eines langen Einzelaufrufs Das Thinking von K3 ist fest auf die Stufe max eingestellt; einzelne Requests für komplexe Aufgaben dauern deutlich länger als bei regulären Modellen. Messdaten einer Single-File-HTML-Spielgenerierung (ein Prompt mit Referenzbild, eine Generierung, keine Iteration): Der einzelne Request dauerte 2.541 Sekunden (ca. 42 Minuten), 74.994 Completion-Tokens, davon 54.486 (73 %) für das Thinking; das Ergebnis waren 1.275 Zeilen direkt lauffähiger Code in einem Durchgang, `finish_reason` war `stop`. Empfehlungen für die Aufrufseite: * Client-Timeouts im Minutenbereich oder höher ansetzen; bei langen Aufgaben bevorzugt Streaming verwenden; * `max_completion_tokens` mit ausreichend Reserve setzen — in diesem Beispiel verbrauchte allein das Thinking 54.486 Tokens. ## 10. Support-Matrix: Fähigkeiten × Schnittstellen Jede Zelle der folgenden Tabelle wurde am 2026-07-17 durch reale Aufrufe über die AIHubMix-Produktionsschnittstellen verifiziert; die Zellen zeigen die Parameter- bzw. Feldschreibweise der jeweiligen Schnittstelle. | Fähigkeit | Chat Completions | Responses | Messages | | :----------------------------------- | :---------------------------------------------- | :------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | Rückgabe des Thinking-Inhalts | ✅ Feld `reasoning_content` | ✅ `reasoning`-Output-Item | ✅ `thinking`-Content-Block | | Rückgabe des Thinking-Verlaufs | ✅ Assistant-Nachricht unverändert zurückgeben | ✅ Output-Items unverändert zurückgeben | ✅ Content-Blöcke unverändert zurückgeben | | Tool-Aufruf erzwingen / deaktivieren | ✅ `tool_choice: "required"` / `"none"` | ✅ `tool_choice: "required"` | ✅ `{"type": "any"}` / `{"type": "none"}` | | Dynamisches Tool-Laden | ✅ System-Nachricht mit `tools` (ohne `content`) | ➖ In Vorbereitung | ❗ Offizieller Messages-Endpunkt (Anthropic-kompatibel) nicht unterstützt | | Strukturierte Ausgabe | ✅ `response_format` (json\_schema + strict) | ✅ `text.format` (json\_schema) | ❗ Offiziell nicht unterstützt, Felder werden **stillschweigend ignoriert** (200 + Freitext), bitte Chat / Responses verwenden | | Messung automatischer Cache-Treffer | ✅ `usage.prompt_tokens_details.cached_tokens` | ✅ `usage.input_tokens_details.cached_tokens` | ✅ `usage.cache_read_input_tokens` | | Präfix-Fortsetzung | ✅ `"partial": true` | ✅ Assistant-Prefill | ✅ Assistant-Prefill (protokollnativ) | | Visuelle Eingabe | ✅ `image_url` (Base64) | ✅ `input_image` (Base64) | ✅ `image`-Content-Block (Base64) | | Stoppsequenzen | ✅ `stop` (Obergrenzen validiert) | ➖ In Vorbereitung | ❗ `stop_sequences` mit identischer Obergrenzen-Validierung, aber beim Treffer kein `stop_reason: "stop_sequence"` / kein `stop_sequence`-Wert | ## Häufige Fragen (FAQ) **Welche Schnittstellen unterstützt K3 auf AIHubMix?** Chat Completions (`/v1/chat/completions`), Responses (`/v1/responses`) und die Claude-kompatible Messages-Schnittstelle (`/v1/messages`). **Kann das Thinking deaktiviert oder die Thinking-Intensität reduziert werden?** Nein. Das Thinking von K3 ist standardmäßig aktiviert, `reasoning_effort` unterstützt nur die Stufe `"max"`. **Warum muss in Multi-Turn-Dialogen `reasoning_content` zurückgegeben werden?** K3 wurde mit preserved thinking trainiert; offiziell ist die unveränderte, vollständige Rückgabe der Assistant-Nachricht der vorherigen Runde erforderlich. Fehlender Thinking-Verlauf führt zu instabiler Ausgabequalität. **Welche Beschränkungen hat der `stop`-Parameter?** Maximal 5 Stoppsequenzen, jede höchstens 32 Bytes; bei Überschreitung wird ein 400-Fehler zurückgegeben. **Unterstützt die Messages-Schnittstelle strukturierte Ausgabe?** ❗ Nein. Der offizielle Messages-Endpunkt (Anthropic-kompatibel) von Kimi K3 ignoriert Felder für strukturierte Ausgabe stillschweigend (liefert 200 mit Freitext, ohne Fehler). Verwenden Sie für strukturierte Ausgabe `response_format` in Chat Completions oder `text.format` in Responses. **Warum dauert ein einzelner K3-Request so lange?** Das Thinking von K3 ist fest auf die Stufe max eingestellt; bei komplexen Aufgaben ist der Thinking-Token-Anteil hoch (im gemessenen Fall 73 % der Completion-Tokens). Setzen Sie Client-Timeouts im Minutenbereich oder höher und verwenden Sie Streaming. *** Preise und Echtzeitstatus des Modells finden Sie auf der [Kimi-K3-Modellseite](https://aihubmix.com/model/kimi-k3), weitere Modelle im [Modell-Marktplatz](https://aihubmix.com/models). Zuletzt aktualisiert: 2026-07-17