Dokumentationsindex
Laden Sie den vollständigen Dokumentationsindex herunter unter: https://docs.aihubmix.com/llms.txt
Verwenden Sie diese Datei, um alle verfügbaren Seiten zu entdecken, bevor Sie weiter erkunden.

Juli 2026 Kimi K3 Anleitung: reasoning_effort max, Denkgeschichte, dynamisches Laden von Werkzeugen, strukturierte Ausgabe, automatisches Caching, partielles Präfix und Visionseingaben.

Dieser Artikel behandelt die neuen Parameter und Nutzungshinweise für Kimi K3. Auf AIHubMix ist K3 über die Chat Completions, Responses und Claude-kompatiblen Messages APIs verfügbar. Siehe auch: Offizielle Moonshot-Plattformdokumentation.

Die "Verifizierten" Schlussfolgerungen und Beispielantworten in jedem Abschnitt stammen aus tatsächlichen Aufrufen, die am 2026-07-17 über die AIHubMix APIs (Chat Completions / Responses / Messages) gemacht wurden.

1. Modell-Spezifikationen auf einen Blick

Verifiziert: beide stop Limits sind validiert, und das Überschreiten eines der Limits gibt 400 zurück; die Messages API wendet dieselbe Validierung auf stop_sequences an.

❗ Wenn eine Stoppsequenz erreicht wird, folgt die Messages API nicht den Anthropic-Semantiken: In Tests ist stop_reason "end_turn" (anstatt "stop_sequence"), stop_sequence ist null, und der sichtbare Text vor dem Stoppwort kann leer sein. Clients, die sich auf diese beiden Felder zur Erkennung von Trunkierungen verlassen, sollten dies beachten.

# stop mit 6 Einträgen / ein 33-Byte-Eintrag -> HTTP 400
"Ungültige Anfrage: stop-Array zu lang. Erwartet wurde ein Array mit maximaler Länge 5, aber es wurde stattdessen ein Array mit Länge 6 erhalten"
"Ungültige Anfrage: Stoppsequenz darf nicht länger als 32 sein, aber es wurden 33 erhalten"

2. Denkmodus: reasoning_effort unterstützt nur max

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

Multi-Turn-Gespräche müssen die Denkgeschichte unverändert zurückgeben: Laut der offiziellen Dokumentation von Moonshot wird K3 mit bewahrtem Denken trainiert, sodass in Multi-Turn-Gesprächen die vorherige Assistenznachricht vollständig und unverändert zurückgegeben werden muss (einschließlich des Denkgehalts). Fehlende Denkgeschichte führt zu instabiler Ausgabequalität. Wenn Sie ein Sitzungsmanagement-Framework oder eine Proxy-Schicht verwenden, bestätigen Sie, dass der Denkgehalt unverändert zurückgegeben wird.

Der Denkgehalt wird im Feld `reasoning_content` der Antwort zurückgegeben; in Multi-Turn-Gesprächen muss die vorherige Assistenznachricht (einschließlich `reasoning_content`) unverändert zurückgegeben werden.

```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": "Eine Schnecke ist am Boden eines 10-Meter-Brunnens. Jeden Tag klettert sie 3 Meter hoch, aber jede Nacht rutscht sie 2 Meter zurück. Wie viele Tage braucht sie, um die Spitze zu erreichen?"}
    ],
)

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

```text theme={null}
# Multi-Turn: die vorherige Assistenznachricht unverändert zurückgeben
messages = [
    {"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"},
    {"role": "assistant", "content": "Paris.", "reasoning_content": "<reasoning_content aus der vorherigen Antwort>"},
    {"role": "user", "content": "Und die Bevölkerung?"},
]
```

> **Verifiziert**: die Antwort gibt `reasoning_content` zurück; nach der unveränderten Rückgabe der vorherigen Assistenznachricht (einschließlich `reasoning_content`) antworten nachfolgende Runden normal.

Der Denkgehalt wird als `reasoning` Ausgabepunkt zurückgegeben; in Multi-Turn-Gesprächen fügen Sie die Ausgabepunkte der vorherigen Runde (`reasoning` + `message`) unverändert in `input` ein.

```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="Antworte mit einem Wort: Hauptstadt von Frankreich",
)

# Beobachtete response.output Elementtypen: ["reasoning", "message"]; text: "Paris"
# Multi-Turn: input = [erste Benutzer-Nachricht] + response.output + [nächste Benutzer-Nachricht]
# Beobachtete Antwort der zweiten Runde mit zurückgegebenen Ausgabepunkten: "Berlin"
```

Der Denkgehalt wird als native `thinking` Inhaltsblöcke zurückgegeben; in Multi-Turn-Gesprächen müssen die vorherigen Assistenzinhaltsblöcke (einschließlich der Denkblöcke) unverändert zurückgegeben werden.

```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": "Antworte mit einem Wort: Hauptstadt von Frankreich"}
    ],
)

# Beobachteter response.content Blocktypen: ["thinking", "text"]; text: "Paris"
# Multi-Turn: response.content unverändert als Assistenznachricht zurückgeben
```

3. Sampling-Parameter sind festgelegt

Die Sampling-Parameter von K3 sind vom Anbieter festgelegt: temperature 1.0, top_p 0.95, n 1 und presence_penalty / frequency_penalty 0. Die offizielle Empfehlung ist, diese Parameter aus den Anfragen wegzulassen.

Hinweis: Die festen Sampling-Werte sind Teil der offiziellen Spezifikation und können nicht aus Antwortsignalen verifiziert werden; folgen Sie der offiziellen Empfehlung und lassen Sie diese Parameter weg.

4. Werkzeugaufruf und dynamisches Laden von Werkzeugen

tools unterstützt bis zu 128 Werkzeuge; tool_choice unterstützt das Erzwingen und Deaktivieren von Werkzeugaufrufen. K3 unterstützt auch das dynamische Laden von Werkzeugen: das Injizieren neuer Werkzeuge während des Gesprächs über das tools Feld einer Systemnachricht (eine Nachrichtenform, die spezifisch für die Chat-API ist).

`tool_choice` unterstützt `auto` / `none` / `required`; `required` zwingt das Modell, ein Werkzeug aufzurufen. Dynamisches Laden von Werkzeugen: Die systemnachricht, die das Werkzeug injiziert, enthält keinen `content`, die injizierten Werkzeuge treten für nachfolgende Runden in Kraft, und die Nachricht muss in jeder Anfrage erneut enthalten sein.

```text theme={null}
messages = [
    {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
    {"role": "user", "content": "Hallo."},
    {"role": "assistant", "content": "Hallo, wie kann ich Ihnen helfen?"},
    # Injiziere ein neues Werkzeug während des Gesprächs: nur das tools-Feld, kein Inhalt
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Holen Sie sich die aktuelle Uhrzeit",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "Wie spät ist es jetzt?"},
]
```

```text theme={null}
# tool_choice="required" mit Eingabe "Hallo" -> das Modell wird gezwungen, das Werkzeug aufzurufen
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"New York\"}"}}]
```

> **Verifiziert**: `tool_choice: "required"` zwingt einen Werkzeugaufruf, selbst bei nicht verwandten Eingaben; `"none"` unterdrückt Werkzeugaufrufe; Werkzeuge, die während des Gesprächs über eine Systemnachricht ohne `content` injiziert werden, können normal aufgerufen werden.

Werkzeugdefinitionen verwenden eine flache Struktur (`name` auf der obersten Ebene); das Erzwingen eines Aufrufs erfolgt ebenfalls mit `tool_choice: "required"`, und Aufrufe werden als `function_call` Ausgabepunkte zurückgegeben. Die Unterstützung für dynamisches Laden von Werkzeugen ist in Arbeit; derzeit müssen alle Werkzeuge im obersten `tools` Parameter deklariert werden.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Hallo",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Holen Sie sich das Wetter für eine Stadt",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# Beobachtete Ausgabe enthält: {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"London\"}"}
```

Werkzeuge verwenden das Anthropic-Format (`input_schema`); erzwingen Sie einen Aufruf mit `tool_choice: {"type": "any"}` und deaktivieren Sie Aufrufe mit `{"type": "none"}`. ❗ **Kimi K3's offizielle Messages (Anthropic-kompatible) Endpoint unterstützt kein dynamisches Laden von Werkzeugen**: In Tests gibt die injizierende Nachricht 200 zurück, aber das injizierte Werkzeug hat keine Wirkung (das Modell kann es nicht aufrufen). Deklarieren Sie alle Werkzeuge im obersten `tools` Parameter.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Holen Sie sich das Wetter für eine Stadt",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Hallo"}],
)

# Beobachtet: stop_reason "tool_use"; der Inhalt enthält einen tool_use Block, der get_weather aufruft
```

5. Strukturierte Ausgabe

Strukturierte Ausgaben sorgen dafür, dass das Modell Inhalte zurückgibt, die strikt einem gegebenen JSON-Schema entsprechen.

`response_format` unterstützt `json_schema` im `strict` Modus.

```text theme={null}
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Paris ist die Hauptstadt von Frankreich. Extrahiere den Stadtnamen."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Beobachtete Antwortinhalt: {"city":"Paris"}
```

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

Strukturierte Ausgaben werden über `text.format` deklariert.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Paris ist die Hauptstadt von Frankreich. Extrahiere den Stadtnamen.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Beobachteter Ausgabetext: {"city":"Paris"}
```

❗ **Kimi K3's offizielle Messages (Anthropic-kompatible) Endpoint unterstützt keine strukturierten Ausgaben**: Die Felder für strukturierte Ausgaben werden stillschweigend ignoriert — die Anfrage gibt HTTP 200 mit freiem Text zurück, ohne Fehler oder Rückfallhinweis, und die nachgelagerte JSON-Analyse schlägt fehl. Wenn Sie strukturierte Ausgaben benötigen, verwenden Sie die Chat Completions oder Responses API.

6. Kontext-Caching ist automatisch

Das Kontext-Caching von K3 ist automatisch aktiviert, ohne dass Parameter erforderlich sind. Wenn ein wiederholtes langes Präfix den Cache trifft, wird die Trefferanzahl in der Nutzung gemeldet (der Feldname variiert je nach API). Die Preise für den Cache finden Sie auf der Modellseite.

```text theme={null} # Nutzung des zweiten Aufrufs mit einem identischen langen Präfix "prompt_tokens_details": {"cached_tokens": 1536} ```

> **Verifiziert**: Die zweite Anfrage mit einem identischen langen Präfix meldet den Treffer in `usage.prompt_tokens_details.cached_tokens`.

```text theme={null} # Nutzung des zweiten Responses-Aufrufs mit identischen langen Anweisungen "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # Nutzung des zweiten Messages-Aufrufs mit einem identischen langen Systemprompt "cache_read_input_tokens": 1536 ```

7. partial Präfix-Vervollständigung

Die Präfix-Vervollständigung ermöglicht es dem Modell, die Generierung von einem gegebenen Präfix fortzusetzen, was sich gut für die Codevervollständigung und formatgesteuerte Ausgaben eignet.

Übergeben Sie `"partial": true` in der letzten Assistenznachricht.

```text theme={null}
messages = [
    {"role": "user", "content": "Schreibe ein Haiku über das Meer."},
    {"role": "assistant", "content": "Wellen falten sich zu Schaum,", "partial": True},
]

# Präfix: "Wellen falten sich zu Schaum,"  ->  Fortsetzung, die vom Modell zurückgegeben wird
# Salz hängt in der Luft—
# der Mond zieht die Gezeiten nach Hause.
```

> **Verifiziert**: Die Generierung setzt sich vom gegebenen Präfix fort, ohne es zu wiederholen.

Übergeben Sie das Präfix als Assistenznachricht am Ende des `input` Arrays; kein `partial` Parameter ist erforderlich.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Schreibe ein Haiku über das Meer."},
        {"role": "assistant", "content": "Wellen falten sich zu Schaum,"},
    ],
)

# Beobachtete Fortsetzung: "Salz hängt in der Luft— / der Mond zieht die Gezeiten nach Hause."
```

Die gleiche Fähigkeit wird mit der nativen Assistenzvorbefüllung des Protokolls erreicht, ohne dass ein `partial` Parameter erforderlich ist — übergeben Sie das Präfix als letzte Assistenznachricht.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Schreibe ein Haiku über das Meer."},
        {"role": "assistant", "content": "Wellen falten sich zu Schaum,"},
    ],
)

# Beobachtete Fortsetzung: "Salzwind trägt den Schrei der Möwe— / Gezeiten ziehen ..."
```

8. Visionseingabe

Bilder werden als base64 übergeben; das Format des Inhaltsblocks variiert je nach API.

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Was ist die dominante Farbe dieses Bildes? Ein Wort."}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,"}}, ], } ]

# Beobachteter Antwortinhalt: "Rot"  (Eingabe: ein 64x64 einfarbiger roter PNG)
```

> **Verifiziert**: Die base64-Bild-Eingabe funktioniert, und das Modell beschreibt das Testbild korrekt.

```text theme={null} input = [ { "role": "user", "content": [ {"type": "input_text", "text": "Was ist die dominante Farbe dieses Bildes? Ein Wort."}, {"type": "input_image", "image_url": "data:image/png;base64,"}, ], } ]

# Beobachteter Ausgabetext: "Rot"
```

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Was ist die dominante Farbe dieses Bildes? Ein Wort."}, {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, ], } ]

# Beobachteter Antworttext: "Rot"
```

9. Verifizierte Referenz: Latenz und Nutzung einer langen Einzelaufrufsaufgabe

Das Denken von K3 ist auf das maximale Niveau festgelegt, sodass Einzelanfragen für komplexe Aufgaben deutlich länger dauern als bei typischen Modellen. Gemessene Daten aus einer Einzeldatei-HTML-Spielgenerierungsaufgabe (ein Prompt mit einem Referenzbild, das in einem Durchgang ohne Iteration generiert wurde): Die Einzelanfrage dauerte 2.541 Sekunden (etwa 42 Minuten), mit 74.994 Abschluss-Tokens, von denen 54.486 (73%) Denk-Tokens waren; die endgültige Ausgabe bestand aus 1.275 Zeilen direkt ausführbarem Code, mit finish_reason stop.

Empfehlungen für die Client-Seite:

• Setzen Sie Client-Timeouts auf Minuten oder länger und bevorzugen Sie Streaming für lange Aufgaben;
• Hinterlassen Sie ausreichend Spielraum in max_completion_tokens — in diesem Fall verbrauchte das Denken allein 54.486 Tokens.

10. Fähigkeit × API-Unterstützungsmatrix

Jede Zelle in der folgenden Tabelle wurde am 2026-07-17 durch tatsächliche Aufrufe der AIHubMix Produktions-APIs verifiziert; jede Zelle zeigt die Parameter-/Feldsyntax für die entsprechende 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 reduziert werden?
Nein. Das Denken von K3 ist standardmäßig aktiviert, und reasoning_effort unterstützt nur die einzelne "max" Stufe.

Warum muss reasoning_content in Multi-Turn-Gesprächen zurückgegeben werden?
K3 wird mit bewahrtem Denken trainiert; Moonshot verlangt, dass die vorherige Assistenznachricht vollständig und unverändert zurückgegeben wird. Fehlende Denkgeschichte führt zu instabiler Ausgabequalität.

Was sind die Grenzen des stop Parameters?
Maximal 5 Stoppsequenzen, jede nicht länger als 32 Bytes; das Überschreiten eines der Limits gibt einen 400-Fehler zurück.

Unterstützt die Messages API strukturierte Ausgaben?
❗ Nein. Kimi K3's offizielle Messages (Anthropic-kompatible) Endpoint ignoriert stillschweigend strukturierte Ausgabefelder (gibt 200 mit freiem Text und ohne Fehler zurück). Für strukturierte Ausgaben verwenden Sie response_format bei Chat Completions oder text.format bei Responses.

Warum dauern Einzelanfragen an K3 so lange?
Das Denken von K3 ist auf das maximale Niveau festgelegt, und Denk-Tokens machen einen großen Anteil bei komplexen Aufgaben aus (73% der Abschluss-Tokens im gemessenen Fall). Setzen Sie Client-Timeouts auf Minuten oder länger und verwenden Sie Streaming.

Für Preise und Echtzeitstatus siehe die Kimi K3 Modellseite; für weitere Modelle besuchen Sie die Modellgalerie.

Letzte Aktualisierung: 2026-07-17