Index de documentation
Récupérez l'index complet de la documentation à : https://docs.aihubmix.com/llms.txt
Utilisez ce fichier pour découvrir toutes les pages disponibles avant d'explorer davantage.

Guide Kimi K3 de juillet 2026 : max d'effort de raisonnement, historique de pensée, chargement dynamique d'outils, sortie structurée, mise en cache automatique, préfixe partiel et entrées visuelles.

Cet article couvre les nouveaux paramètres et notes d'utilisation pour Kimi K3. Sur AIHubMix, K3 est disponible via les API de Chat Completions, Responses et Messages compatibles avec Claude. Voir aussi : documentation officielle de la plateforme Moonshot.

Les conclusions et réponses d'exemple "Vérifiées" dans chaque section proviennent d'appels réels effectués le 2026-07-17 via les API AIHubMix (Chat Completions / Responses / Messages).

1. Spécifications du modèle en un coup d'œil

Vérifié : les deux limites de stop sont validées, et dépasser l'une ou l'autre renvoie 400 ; l'API Messages applique la même validation aux stop_sequences.

❗ Lorsqu'une séquence d'arrêt est atteinte, l'API Messages ne suit pas la sémantique d'Anthropic : lors des tests, stop_reason est "end_turn" (plutôt que "stop_sequence"), stop_sequence est null, et le texte visible avant le mot d'arrêt peut être vide. Les clients qui s'appuient sur ces deux champs pour détecter la troncature doivent en tenir compte.

# arrêt avec 6 entrées / une entrée de 33 octets -> HTTP 400
"Requête invalide : tableau d'arrêt trop long. Un tableau d'une longueur maximale de 5 était attendu, mais un tableau d'une longueur de 6 a été reçu à la place"
"Requête invalide : la séquence d'arrêt ne doit pas dépasser 32, mais a reçu 33 à la place"

2. Mode de réflexion : reasoning_effort ne prend en charge que max

La réflexion de K3 est activée par défaut, et reasoning_effort ne prend en charge qu'un seul niveau : "max".

Les conversations multi-tours doivent renvoyer l'historique de pensée tel quel : selon la documentation officielle de Moonshot, K3 est entraîné avec une pensée préservée, donc dans les conversations multi-tours, le message précédent de l'assistant doit être renvoyé complet et non modifié (y compris le contenu de réflexion). L'absence d'historique de pensée entraîne une qualité de sortie instable. Si vous utilisez un cadre de gestion de session ou une couche proxy, confirmez que le contenu de réflexion est renvoyé sans être tronqué.

Le contenu de réflexion est renvoyé dans le champ `reasoning_content` de la réponse ; dans les conversations multi-tours, renvoyez le message précédent de l'assistant (y compris `reasoning_content`) tel quel.

```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": "Un escargot est au fond d'un puits de 10 mètres. Chaque jour, il grimpe de 3 mètres, mais chaque nuit, il glisse de 2 mètres. Combien de jours lui faut-il pour atteindre le sommet ?"}
    ],
)

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

```text theme={null}
# Multi-tours : renvoyez le message précédent de l'assistant tel quel
messages = [
    {"role": "user", "content": "Quelle est la capitale de la France ?"},
    {"role": "assistant", "content": "Paris.", "reasoning_content": "<reasoning_content de la réponse précédente>"},
    {"role": "user", "content": "Et sa population ?"},
]
```

> **Vérifié** : la réponse renvoie `reasoning_content` ; après avoir renvoyé le message précédent de l'assistant (y compris `reasoning_content`) tel quel, les tours suivants répondent normalement.

Le contenu de réflexion est renvoyé en tant qu'élément de sortie `reasoning` ; dans les conversations multi-tours, ajoutez les éléments de sortie du tour précédent (`reasoning` + `message`) dans `input` tel quel.

```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="Répondez en un mot : capitale de la France",
)

# Types d'éléments de sortie observés : ["reasoning", "message"]; texte : "Paris"
# Multi-tours : input = [premier message utilisateur] + response.output + [prochain message utilisateur]
# Réponse observée au deuxième tour avec éléments de sortie renvoyés : "Berlin"
```

Le contenu de réflexion est renvoyé sous forme de blocs de contenu `thinking` natifs ; dans les conversations multi-tours, renvoyez les blocs de contenu précédents de l'assistant (y compris les blocs de réflexion) tel quel.

```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": "Répondez en un mot : capitale de la France"}
    ],
)

# Types de blocs de réponse observés : ["thinking", "text"]; texte : "Paris"
# Multi-tours : renvoyez response.content tel quel en tant que message de l'assistant
```

3. Les paramètres d'échantillonnage sont fixes

Les paramètres d'échantillonnage de K3 sont fixés par le fournisseur : temperature 1.0, top_p 0.95, n 1, et presence_penalty / frequency_penalty 0. La recommandation officielle est d'omettre ces paramètres des requêtes.

Remarque : les valeurs d'échantillonnage fixes font partie des spécifications officielles et ne peuvent pas être vérifiées à partir des signaux de réponse ; suivez la recommandation officielle et omettez ces paramètres.

4. Appel d'outils et chargement dynamique d'outils

tools prend en charge jusqu'à 128 outils ; tool_choice permet de forcer et de désactiver les appels d'outils. K3 prend également en charge le chargement dynamique d'outils : injection de nouveaux outils en cours de conversation via le champ tools d'un message système (une forme de message spécifique à l'API Chat).

`tool_choice` prend en charge `auto` / `none` / `required` ; `required` force le modèle à appeler un outil. Chargement dynamique d'outils : le message système injectant l'outil ne contient aucun `content`, les outils injectés prennent effet pour les tours suivants, et le message doit être inclus à nouveau dans chaque requête.

```text theme={null}
messages = [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "Bonjour."},
    {"role": "assistant", "content": "Salut, comment puis-je vous aider ?"},
    # Injecter un nouvel outil en cours de conversation : champ tools uniquement, pas de contenu
    {
        "role": "system",
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_time",
                    "description": "Obtenir l'heure actuelle",
                    "parameters": {"type": "object", "properties": {}},
                },
            }
        ],
    },
    {"role": "user", "content": "Quelle heure est-il maintenant ?"},
]
```

```text theme={null}
# tool_choice="required" avec l'invite "Bonjour" -> le modèle est forcé d'appeler l'outil
"finish_reason": "tool_calls",
"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"New York\"}"}}]
```

> **Vérifié** : `tool_choice: "required"` force un appel d'outil même pour des invites non liées ; `"none"` supprime les appels d'outils ; les outils injectés en cours de conversation via un message système sans `content` peuvent être appelés normalement.

Les définitions d'outils utilisent une structure plate (`name` au niveau supérieur) ; forcer un appel utilise également `tool_choice: "required"`, et les appels sont renvoyés en tant qu'éléments de sortie `function_call`. Le support pour le chargement dynamique d'outils est en cours ; pour l'instant, déclarez tous les outils dans le paramètre `tools` de niveau supérieur.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Bonjour",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Obtenir la météo pour une ville",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice="required",
)

# La sortie observée contient : {"type": "function_call", "name": "get_weather", "arguments": "{\"city\":\"London\"}"}
```

Les outils utilisent le format d'Anthropic (`input_schema`) ; forcez un appel avec `tool_choice: {"type": "any"}` et désactivez les appels avec `{"type": "none"}`. ❗ **Le point de terminaison officiel des Messages de Kimi K3 (compatible avec Anthropic) ne prend pas en charge le chargement dynamique d'outils** : lors des tests, le message d'injection renvoie 200, mais l'outil injecté n'a aucun effet (le modèle ne peut pas l'appeler). Déclarez tous les outils dans le paramètre `tools` de niveau supérieur.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    tools=[{
        "name": "get_weather",
        "description": "Obtenir la météo pour une ville",
        "input_schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
    }],
    tool_choice={"type": "any"},
    messages=[{"role": "user", "content": "Bonjour"}],
)

# Observé : stop_reason "tool_use"; le contenu contient un bloc tool_use appelant get_weather
```

5. Sortie structurée

La sortie structurée fait en sorte que le modèle renvoie un contenu qui respecte strictement un schéma JSON donné.

`response_format` prend en charge `json_schema` avec le mode `strict`.

```text theme={null}
completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Paris est la capitale de la France. Extraire le nom de la ville."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "extract",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        },
    },
)

# Contenu de réponse observé : {"city":"Paris"}
```

> **Vérifié** : la sortie est un JSON valide conforme au schéma.

La sortie structurée est déclarée via `text.format`.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input="Paris est la capitale de la France. Extraire le nom de la ville.",
    text={
        "format": {
            "type": "json_schema",
            "name": "extract",
            "strict": True,
            "schema": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
        }
    },
)

# Texte de sortie observé : {"city":"Paris"}
```

❗ **Le point de terminaison officiel des Messages de Kimi K3 (compatible avec Anthropic) ne prend pas en charge la sortie structurée** : les champs de sortie structurée sont silencieusement ignorés — la requête renvoie HTTP 200 avec du texte libre, sans erreur ni avis de repli, et l'analyse JSON en aval échouera. Lorsque vous avez besoin d'une sortie structurée, utilisez l'API Chat Completions ou Responses.

6. La mise en cache de contexte est automatique

La mise en cache de contexte de K3 est activée automatiquement, sans paramètres requis. Lorsqu'un préfixe long répété touche le cache, le montant de l'atteinte est signalé dans l'utilisation (le nom du champ varie selon l'API). Les tarifs de cache sont sur la page du modèle.

```text theme={null} # utilisation du deuxième appel avec un préfixe long identique "prompt_tokens_details": {"cached_tokens": 1536} ```

> **Vérifié** : la deuxième requête avec un préfixe long identique signale l'atteinte dans `usage.prompt_tokens_details.cached_tokens`.

```text theme={null} # utilisation du deuxième appel Responses avec des instructions longues identiques "input_tokens_details": {"cached_tokens": 1536} ``` ```text theme={null} # utilisation du deuxième appel Messages avec un prompt système long identique "cache_read_input_tokens": 1536 ```

7. Complétion de préfixe partial

La complétion de préfixe permet au modèle de continuer à générer à partir d'un préfixe donné, bien adaptée à la complétion de code et à la sortie contrôlée par format.

Passez `"partial": true` dans le dernier message de l'assistant.

```text theme={null}
messages = [
    {"role": "user", "content": "Écrivez un haïku sur la mer."},
    {"role": "assistant", "content": "Les vagues se plient en mousse,", "partial": True},
]

# Préfixe : "Les vagues se plient en mousse,"  ->  continuation renvoyée par le modèle
# le sel flotte dans l'air—
# la lune tire la marée chez elle.
```

> **Vérifié** : la génération continue à partir du préfixe donné sans le répéter.

Passez le préfixe en tant que message de l'assistant à la fin du tableau `input` ; aucun paramètre `partial` n'est nécessaire.

```text theme={null}
response = client.responses.create(
    model="kimi-k3",
    input=[
        {"role": "user", "content": "Écrivez un haïku sur la mer."},
        {"role": "assistant", "content": "Les vagues se plient en mousse,"},
    ],
)

# Continuation observée : "le sel flotte dans l'air— / la lune tire la marée chez elle."
```

La même capacité est réalisée avec le pré-remplissage natif de l'assistant du protocole, sans paramètre `partial` — passez le préfixe en tant que dernier message de l'assistant.

```text theme={null}
response = client.messages.create(
    model="kimi-k3",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Écrivez un haïku sur la mer."},
        {"role": "assistant", "content": "Les vagues se plient en mousse,"},
    ],
)

# Continuation observée : "le vent salé porte le cri des mouettes— / la marée tire ..."
```

8. Entrée visuelle

Les images sont transmises sous forme de base64 ; le format de bloc de contenu varie selon l'API.

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Quelle est la couleur dominante de cette image ? Un mot."}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,"}}, ], } ]

# Contenu de réponse observé : "Rouge"  (entrée : un PNG rouge solide de 64x64)
```

> **Vérifié** : l'entrée d'image base64 fonctionne, et le modèle décrit correctement l'image test.

```text theme={null} input = [ { "role": "user", "content": [ {"type": "input_text", "text": "Quelle est la couleur dominante de cette image ? Un mot."}, {"type": "input_image", "image_url": "data:image/png;base64,"}, ], } ]

# Texte de sortie observé : "Rouge"
```

```text theme={null} messages = [ { "role": "user", "content": [ {"type": "text", "text": "Quelle est la couleur dominante de cette image ? Un mot."}, {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": ""}}, ], } ]

# Texte de réponse observé : "Rouge"
```

9. Référence vérifiée : latence et utilisation d'une tâche longue en un seul appel

La réflexion de K3 est fixée au niveau max, donc les demandes uniques pour des tâches complexes prennent beaucoup plus de temps que sur des modèles typiques. Données mesurées d'une tâche de génération de jeu HTML en un seul fichier (une invite avec une image de référence, générée en une seule fois sans itération) : la demande unique a pris 2 541 secondes (environ 42 minutes), avec 74 994 tokens de complétion, dont 54 486 (73 %) étaient des tokens de réflexion ; la sortie finale était de 1 275 lignes de code directement exécutable, avec finish_reason stop.

Recommandations côté client :

• Définissez les délais d'attente du client à plusieurs minutes ou plus, et préférez le streaming pour les longues tâches ;
• Laissez une marge suffisante dans max_completion_tokens — dans ce cas, la réflexion seule a consommé 54 486 tokens.

10. Matrice de support API × capacité

Chaque cellule du tableau ci-dessous a été vérifiée le 2026-07-17 via des appels réels aux API de production AIHubMix ; chaque cellule montre la syntaxe des paramètres / champs pour l'API correspondante.

FAQ

Quelles API K3 prend-elle en charge sur AIHubMix ?
Chat Completions (/v1/chat/completions), Responses (/v1/responses), et l'API Messages compatible avec Claude (/v1/messages).

La réflexion peut-elle être désactivée ou réduite ?
Non. La réflexion de K3 est activée par défaut, et reasoning_effort ne prend en charge que le niveau unique "max".

Pourquoi reasoning_content doit-il être renvoyé dans les conversations multi-tours ?
K3 est entraîné avec une pensée préservée ; Moonshot exige que le message précédent de l'assistant soit renvoyé complet et non modifié. L'absence d'historique de pensée entraîne une qualité de sortie instable.

Quelles sont les limites sur le paramètre stop ?
Au maximum 5 séquences d'arrêt, chacune ne dépassant pas 32 octets ; dépasser l'une ou l'autre limite renvoie une erreur 400.

L'API Messages prend-elle en charge la sortie structurée ?
❗ Non. Le point de terminaison officiel des Messages de Kimi K3 (compatible avec Anthropic) ignore silencieusement les champs de sortie structurée (renvoyant 200 avec du texte libre et sans erreur). Pour une sortie structurée, utilisez response_format sur Chat Completions ou text.format sur Responses.

Pourquoi les demandes uniques de K3 prennent-elles autant de temps ?
La réflexion de K3 est fixée au niveau max, et les tokens de réflexion représentent une grande part des tâches complexes (73 % des tokens de complétion dans le cas mesuré). Définissez les délais d'attente du client à plusieurs minutes ou plus et utilisez le streaming.

Pour les prix et l'état en temps réel, consultez la page du modèle Kimi K3 ; pour plus de modèles, visitez la galerie de modèles.

Dernière mise à jour : 2026-07-17