Kimi K3 Praxisleitfaden: Neue Parameter und API-Unterstützungsmatrix

Dieser Artikel behandelt die neuen Parameter und Hinweise zur Nutzung von Kimi K3. Auf AIHubMix ist K3 über die Chat-Completions-, Responses- und Claude-kompatible Messages-API verfügbar. Siehe auch: offizielle Moonshot-Plattformdokumentation.

Die „Verifiziert“-Ergebnisse und Beispielantworten in jedem Abschnitt stammen aus tatsächlichen Aufrufen, die am 17.07.2026 über die AIHubMix-APIs (Chat Completions / Responses / Messages) durchgeführt wurden.

1. Modellspezifikationen auf einen Blick

Verifiziert: Beide stop-Grenzwerte werden geprüft; bei Überschreitung wird 400 zurückgegeben. Die Messages-API wendet dieselbe Prüfung auf stop_sequences an.

❗ Wenn eine Stop-Sequenz erreicht wird, folgt die Messages-API nicht der Anthropic-Semantik: In Tests ist stop_reason gleich "end_turn" (statt "stop_sequence"), stop_sequence ist null, und der sichtbare Text vor dem Stop-Wort kann leer sein. Clients, die sich zur Erkennung von Abschneidungen auf diese beiden Felder verlassen, sollten dies berücksichtigen.

# 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 unterstützt nur max

Das Denken von K3 ist standardmäßig aktiviert, und reasoning_effort unterstützt nur eine einzige Stufe: "max".

Der Denkverlauf muss bei mehrstufigen Gesprächen unverändert zurückgegeben werden: Laut der offiziellen Dokumentation von Moonshot ist K3 mit erhaltenem Denken (preserved thinking) trainiert. Daher muss in mehrstufigen Gesprächen die vorherige Assistentennachricht vollständig und unverändert (einschließlich des Denkinhalts) zurückgesendet werden. Fehlender Denkverlauf führt zu instabiler Ausgabequalität. Wenn Sie ein Sitzungsverwaltungs-Framework oder eine Proxy-Schicht verwenden, prüfen Sie, dass der Denkinhalt ungekürzt zurückgegeben wird.
Chat Completions

Denkinhalte werden im Feld reasoning_content der Antwort zurückgegeben; bei mehrstufigen Gesprächen die vorherige Assistentennachricht (einschließlich reasoning_content) unverändert zurückgeben.

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

Verifiziert: Die Antwort enthält reasoning_content; nachdem die vorherige Assistentennachricht (einschließlich reasoning_content) unverändert zurückgesendet wurde, werden nachfolgende Runden normal beantwortet.
Responses

Denkinhalte werden als reasoning-Ausgabeelement zurückgegeben; bei mehrstufigen Gesprächen werden die Ausgabeelemente der vorherigen Runde (reasoning + message) unverändert an input angehängt.

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

Denkinhalte werden als native thinking-Inhaltsblöcke zurückgegeben; bei mehrstufigen Gesprächen die vorherigen Assistenten-Inhaltsblöcke (einschließlich der thinking-Blöcke) unverändert zurückgeben.

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. Sampling-Parameter sind festgelegt

Die Sampling-Parameter von K3 sind vom Modellanbieter festgelegt: temperature 1.0, top_p 0.95, n 1 sowie presence_penalty / frequency_penalty 0. Die offizielle Empfehlung lautet, diese Parameter in Anfragen wegzulassen.

Hinweis: Die festen Sampling-Werte sind Teil der offiziellen Spezifikation und lassen sich anhand der Antwortsignale nicht verifizieren. Folgen Sie der offiziellen Empfehlung und lassen Sie diese Parameter weg.

4. Tool-Aufrufe und dynamisches Laden von Tools

tools unterstützt bis zu 128 Tools; tool_choice unterstützt das Erzwingen und Deaktivieren von Tool-Aufrufen. K3 unterstützt zudem das dynamische Laden von Tools: Neue Tools können mitten im Gespräch über das Feld tools einer Systemnachricht eingefügt werden (ein für die Chat-API spezifisches Nachrichtenformat).
Chat Completions

tool_choice unterstützt auto / none / required; required zwingt das Modell, ein Tool aufzurufen. Dynamisches Laden von Tools: Die Systemnachricht, die Tools einfügt, enthält kein content, die eingefügten Tools gelten für die folgenden Runden, und die Nachricht muss bei jeder Anfrage erneut enthalten sein.

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

Verifiziert: tool_choice: "required" erzwingt einen Tool-Aufruf auch bei themenfremden Prompts; "none" unterdrückt Tool-Aufrufe; per Systemnachricht ohne content mitten im Gespräch eingefügte Tools können normal aufgerufen werden.
Responses

Tool-Definitionen verwenden eine flache Struktur (name auf oberster Ebene). Das Erzwingen eines Aufrufs erfolgt ebenfalls über tool_choice: "required", und Aufrufe werden als function_call-Ausgabeelemente zurückgegeben. Die Unterstützung für dynamisches Laden von Tools ist in Arbeit; derzeit alle Tools im obersten Parameter tools deklarieren.

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 verwenden das Anthropic-Format (input_schema); einen Aufruf erzwingen Sie mit tool_choice: {"type": "any"}, Aufrufe deaktivieren Sie mit {"type": "none"}. ❗ Der offizielle Messages-Endpunkt (Anthropic-kompatibel) von Kimi K3 unterstützt das dynamische Laden von Tools nicht: In Tests liefert die einfügende Nachricht 200, doch das eingefügte Tool hat keine Wirkung (das Modell kann es nicht aufrufen). Alle Tools im obersten Parameter tools deklarieren.

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

Strukturierte Ausgabe bewirkt, dass das Modell Inhalte zurückgibt, die strikt einem vorgegebenen JSON-Schema entsprechen.
Chat Completions

response_format unterstützt json_schema mit dem 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"}

Verifiziert: Die Ausgabe ist gültiges JSON, das dem Schema entspricht.
Responses

Strukturierte Ausgabe wird über text.format deklariert.

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

❗ Der offizielle Messages-Endpunkt (Anthropic-kompatibel) von Kimi K3 unterstützt keine strukturierte Ausgabe: Die Felder für strukturierte Ausgabe werden stillschweigend ignoriert. Die Anfrage liefert HTTP 200 mit Freitext, ohne Fehlermeldung oder Hinweis, und nachgelagertes JSON-Parsing schlägt fehl. Wenn Sie strukturierte Ausgabe benötigen, verwenden Sie die Chat-Completions- oder Responses-API.

6. Kontext-Caching ist automatisch

Das Kontext-Caching von K3 ist automatisch aktiviert und benötigt keine Parameter. Wenn ein wiederholtes langes Präfix den Cache trifft, wird die Trefferanzahl in usage gemeldet (der Feldname variiert je nach API). Die Cache-Preise finden Sie auf der Modellseite.
Chat Completions

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

Verifiziert: Die zweite Anfrage mit identischem langem Präfix meldet den 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-Präfix-Vervollständigung

Die Präfix-Vervollständigung lässt das Modell ab einem vorgegebenen Präfix weitergenerieren; sie eignet sich gut für Code-Vervollständigung und formatgesteuerte Ausgabe.
Chat Completions

Übergeben Sie "partial": true in der letzten Assistentennachricht.

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 ab dem vorgegebenen Präfix fort, ohne es zu wiederholen.
Responses

Übergeben Sie das Präfix als Assistentennachricht am Ende des input-Arrays; ein partial-Parameter ist nicht nötig.

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

Dieselbe Funktion wird mit dem nativen Assistant-Prefill des Protokolls erreicht, ohne partial-Parameter: Übergeben Sie das Präfix als letzte Assistentennachricht.

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

Bilder werden als Base64 übergeben; das Format der Inhaltsblöcke variiert je nach 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)

Verifiziert: Die Base64-Bildeingabe funktioniert, und das Modell beschreibt das Testbild korrekt.
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. Verifizierte Referenz: Latenz und Nutzung einer langen Einzelaufgabe

Das Denken von K3 ist fest auf die Stufe max eingestellt, weshalb Einzelanfragen für komplexe Aufgaben deutlich länger dauern als bei üblichen Modellen. Messdaten aus der Erzeugung eines HTML-Spiels in einer einzigen Datei (ein Prompt mit einem Referenzbild, in einem Durchgang ohne Iteration erzeugt): Die einzelne Anfrage dauerte 2,541 Sekunden (etwa 42 Minuten), mit 74,994 Completion-Token, davon 54,486 (73%) Denk-Token. Die finale Ausgabe umfasste 1,275 Zeilen direkt lauffähigen Code, mit finish_reason stop.

Empfehlungen auf Client-Seite:

• Stellen Sie Client-Timeouts auf Minuten oder mehr ein und bevorzugen Sie bei langen Aufgaben Streaming;
• Lassen Sie in max_completion_tokens ausreichend Reserve: In diesem Fall verbrauchte allein das Denken 54,486 Token.

10. Matrix aus Fähigkeiten und API-Unterstützung

Jede Zelle der folgenden Tabelle wurde am 17.07.2026 durch tatsächliche Aufrufe der AIHubMix-Produktions-APIs verifiziert; jede Zelle zeigt die Parameter- / Feldsyntax für die jeweilige API.

FAQ

Welche APIs unterstützt K3 auf AIHubMix?
Chat Completions (/v1/chat/completions), Responses (/v1/responses) und die Claude-kompatible Messages-API (/v1/messages).

Kann das Denken deaktiviert oder heruntergeregelt werden?
Nein. Das Denken von K3 ist standardmäßig aktiviert, und reasoning_effort unterstützt nur die einzige Stufe "max".

Warum muss reasoning_content in Mehrfachkonversationen zurückgegeben werden?
K3 wird mit erhaltenem Denkprozess (preserved thinking) trainiert; Moonshot verlangt, dass die vorherige Assistenten-Nachricht vollständig und unverändert zurückgegeben wird. Fehlt der Denkverlauf, leidet die Ausgabequalität und wird instabil.

Welche Grenzen gelten für den Parameter stop?
Es sind höchstens 5 Stop-Sequenzen erlaubt, jede mit maximal 32 Bytes; wird eine der beiden Grenzen überschritten, gibt die API einen 400-Fehler zurück.

Unterstützt die Messages API strukturierte Ausgaben?
❗ Nein. Der offizielle Messages-Endpunkt von Kimi K3 (Anthropic-kompatibel) ignoriert strukturierte Ausgabefelder stillschweigend (er liefert 200 mit freiem Text und ohne Fehlermeldung). Für strukturierte Ausgaben verwenden Sie response_format bei Chat Completions oder text.format bei Responses.

Warum dauern einzelne K3-Anfragen so lange?
Das Denken von K3 ist auf die maximale Stufe festgelegt, und bei komplexen Aufgaben machen die Denk-Tokens einen großen Anteil aus (im gemessenen Fall 73% der Completion-Tokens). Setzen Sie Client-Timeouts auf Minuten oder mehr und verwenden Sie Streaming.

Preise und den aktuellen Status finden Sie auf der Modellseite von Kimi K3; weitere Modelle finden Sie in der Modellgalerie.

Zuletzt aktualisiert: 2026-07-17