Skip to main content

Kimi

Cette rubrique explique comment appeler le service d'inférence du modèle Kimi déployé sur Alibaba Cloud Model Studio.

Régions prises en charge : Chine (Pékin), Singapour, Japon (Tokyo), Chine (Hong Kong), Allemagne (Francfort) et États-Unis (Virginie). Essai du modèle : Vous pouvez tester le modèle Kimi dans le centre d'essai des modèles. kimi-k3.1-pro prend en charge OpenAI Chat Completions, OpenAI Responses, Anthropic Messages et l'API native DashScope. Les points de terminaison du service sont spécifiques à chaque région. Configurez l'URL de base appropriée pour votre région.
  • OpenAI compatible
  • DashScope
  • Anthropic-compatible
Les valeurs régionales de base_url ci-dessous s'appliquent également aux appels OpenAI Responses ; pour les requêtes HTTP, ajoutez /responses au base_url, par exemple POST {base_url}/responses.
  • US (Virginia)
  • Germany (Frankfurt)
  • Singapore
  • Japan (Tokyo)
  • China (Beijing)
  • China (Hong Kong)
Le paramètre base_url pour les appels SDK est : https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/compatible-mode/v1URL de la requête HTTP : POST https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions
Remplacez {WorkspaceId} par votre ID d'espace de travail réel. Prérequis : vous devez obtenir une clé API et la définir comme variable d'environnement. Si vous utilisez le SDK, vous devez l'installer.

Premiers pas

Les exemples suivants utilisent uniquement des entrées textuelles. Pour des exemples multimodaux, consultez la section Appel multimodal.
  • Compatible OpenAI
  • DashScope
  • Compatible Anthropic
  • Python
  • Node.js
  • HTTP
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Who are you?"}],
    stream=True,
    extra_body={"enable_thinking": True},  # Enable thinking mode to get reasoning_content
)

reasoning_content = ""  # Complete thinking process
answer_content = ""     # Complete response
is_answering = False    # Tracks if the main response has started.

print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")

for chunk in completion:
    if chunk.choices:
        delta = chunk.choices[0].delta
        # Store content from the thinking process.
        if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
            if not is_answering:
                print(delta.reasoning_content, end="", flush=True)
            reasoning_content += delta.reasoning_content
        # Start printing the main response once its content arrives.
        if hasattr(delta, "content") and delta.content:
            if not is_answering:
                print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
                is_answering = True
            print(delta.content, end="", flush=True)
            answer_content += delta.content

Réponse

====================Thinking Process====================

The user asks "Who are you?", which is a direct question about my identity. I need to answer truthfully based on my actual identity.

I am Kimi, an AI assistant developed by Moonshot AI. I should introduce myself clearly and concisely, including:
1. My identity: AI assistant
2. My developer: Moonshot AI
3. My name: Kimi
4. My core capabilities: long-text processing, intelligent conversation, file processing, search, etc.

I should maintain a friendly and professional tone, avoiding overly technical terms for clarity. I should also emphasize that I am an AI without personal consciousness, emotions, or experiences to prevent misunderstandings.

Response structure:
- Directly state my identity
- Mention my developer
- Briefly introduce core capabilities
- Keep it clear and concise
====================Complete Response====================

I am Kimi, an AI assistant developed by Moonshot AI. I am based on a Mixture-of-Experts (MoE) architecture and have capabilities such as ultra-long context understanding, intelligent conversation, file processing, code generation, and complex task reasoning. How can I help you?

Appels multimodaux

Les modèles kimi-k3.1-pro, kimi-k3, kimi-k2.7-code, kimi-k2.6 et kimi-k2.5 prennent en charge les entrées multimodales et les sorties de texte. kimi-k3.1-pro et kimi-k3 prennent uniquement en charge les entrées de texte et d'image, et non les entrées vidéo ; kimi-k2.7-code, kimi-k2.6 et kimi-k2.5 peuvent traiter simultanément du texte, des images ou des vidéos. Utilisez le paramètre enable_thinking pour activer le mode de raisonnement. Les exemples suivants illustrent l'utilisation de cette fonctionnalité.

Activer ou désactiver le mode de raisonnement

kimi-k2.6 et kimi-k2.5 sont des modèles à raisonnement hybride. Ils peuvent répondre après une phase de réflexion ou fournir une réponse directe. Le paramètre enable_thinking permet de contrôler l'activation du mode de raisonnement :
  • true : active le mode de raisonnement
  • false (par défaut) : désactive le mode de raisonnement
Le modèle kimi-k2.7-code fonctionne exclusivement en mode de raisonnement : ce mode est toujours activé (la valeur par défaut de enable_thinking est true et ne peut pas être désactivée), et la valeur par défaut de preserve_thinking est true. kimi-k3.1-pro et kimi-k3 activent la réflexion par défaut (enable_thinking=true). Vous pouvez définir ce paramètre sur false pour désactiver la réflexion, mais il est recommandé de la maintenir activée. Pour kimi-k3.1-pro, sa désactivation dégrade considérablement la qualité de la sortie ; il est donc fortement recommandé de la maintenir activée. Les deux modèles conservent par défaut le reasoning_content historique fourni par le client. Nous recommandons de renvoyer le reasoning_content complet des messages historiques de l'assistant dans les requêtes multi-tours. kimi-k2.6 prend en charge la transmission du processus de raisonnement dans les conversations multi-tours via le paramètre preserve_thinking . Pour plus d'informations, consultez la rubrique Transmettre le processus de raisonnement. Les exemples ci-dessous montrent comment utiliser une URL d'image avec le mode de raisonnement activé. L'exemple principal traite l'entrée d'une seule image, tandis que le code commenté illustre l'entrée de plusieurs images.
  • OpenAI compatible
  • DashScope
Python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

# Single-image input example (thinking mode enabled)
completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What scene is depicted in the image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"
                    }
                }
            ]
        }
    ],
    extra_body={"enable_thinking":True}  # Enable thinking mode
)

# Print the thinking process
if hasattr(completion.choices[0].message, 'reasoning_content') and completion.choices[0].message.reasoning_content:
    print("\n" + "=" * 20 + "Thinking Process" + "=" * 20 + "\n")
    print(completion.choices[0].message.reasoning_content)

# Print the complete response
print("\n" + "=" * 20 + "Complete Response" + "=" * 20 + "\n")
print(completion.choices[0].message.content)

# Multi-image input example (thinking mode enabled, uncomment to use)
# completion = client.chat.completions.create(
#     model="kimi-k2.6",
#     messages=[
#         {
#             "role": "user",
#             "content": [
#                 {"type": "text", "text": "What do these images depict?"},
#                 {
#                     "type": "image_url",
#                     "image_url": {"url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241022/emyrja/dog_and_girl.jpeg"}
#                 },
#                 {
#                     "type": "image_url",
#                     "image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/tiger.png"}
#                 }
#             ]
#         }
#     ],
#     extra_body={"enable_thinking":True}
# )
#
# # Print the thinking process and complete response
# if hasattr(completion.choices[0].message, 'reasoning_content') and completion.choices[0].message.reasoning_content:
#     print("\nThinking Process:\n" + completion.choices[0].message.reasoning_content)
# print("\nComplete Response:\n" + completion.choices[0].message.content)

Compréhension vidéo

kimi-k3.1-pro et kimi-k3 ne prennent pas en charge les entrées vidéo (ils acceptent uniquement les entrées de texte et d'image) ; les exemples de compréhension vidéo de cette section ne s'appliquent donc à aucun de ces deux modèles.
  • Fichier vidéo
  • Liste d'images
Les modèles kimi-k2.7-code, kimi-k2.6 et kimi-k2.5 analysent les vidéos en extrayant une séquence d'images. Vous pouvez contrôler la stratégie d'extraction des images à l'aide des paramètres suivants :
  • fps : contrôle la fréquence d'extraction des images. L'intervalle entre les images extraites est de 1/fps secondes. La valeur doit se situer dans la plage [0.1, 10]. La valeur par défaut est 2.0.
    • Pour les scènes à mouvement rapide : définissez une valeur fps plus élevée pour capturer davantage de détails.
    • Pour les vidéos statiques ou longues : définissez une valeur fps plus faible pour améliorer l'efficacité du traitement.
  • max_frames : spécifie le nombre maximal d'images à extraire d'une vidéo. La valeur par défaut et maximale est 2000. Si le nombre d'images calculé à partir de la valeur fps dépasse cette limite, le système extrait automatiquement les images de manière uniforme pour respecter la limite max_frames. Ce paramètre est disponible uniquement lorsque vous utilisez le SDK DashScope.
  • OpenAI compatible
  • DashScope
Lors de la transmission d'un fichier vidéo au modèle à l'aide du SDK OpenAI ou d'une requête HTTP, définissez le paramètre "type" dans le message utilisateur sur "video_url" .
Python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                # When passing a video file directly, set the "type" parameter to "video_url".
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4"
                    },
                    "fps": 2
                },
                {
                    "type": "text",
                    "text": "What is the content of this video?"
                }
            ]
        }
    ]
)

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

Transmettre un fichier local

Les exemples suivants illustrent la transmission d'un fichier local. L'API compatible OpenAI prend uniquement en charge l'encodage Base64, tandis que DashScope accepte à la fois l'encodage Base64 et les chemins de fichiers.
  • Compatible OpenAI
  • DashScope
Pour transmettre un fichier local via un encodage Base64, construisez une URL de données. Pour plus d'informations, reportez-vous à la section Construire une URL de données.
Python
from openai import OpenAI
import os
import base64

# Encoding function: Converts a local file to a Base64-encoded string.
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Replace "xxx/eagle.png" with the absolute path to your local image.
base64_image = encode_image("xxx/eagle.png")

client = OpenAI(
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    # China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{base64_image}"},
                },
                {"type": "text", "text": "What scene is depicted in the image?"},
            ],
        }
    ],
)
print(completion.choices[0].message.content)

# The following examples show how to pass a local video file and a local image list.

# [Local video file] Encode the local video as a Data URL and pass it to the video_url parameter:
#   def encode_video_to_data_url(video_path):
#       with open(video_path, "rb") as f:
#           return "data:video/mp4;base64," + base64.b64encode(f.read()).decode("utf-8")

#   video_data_url = encode_video_to_data_url("xxx/local.mp4")
#   content = [{"type": "video_url", "video_url": {"url": video_data_url}, "fps": 2}, {"type": "text", "text": "What is the content of this video?"}]

# [Local image list] Encode multiple local images with Base64 and pass them as a list to the video parameter:
#   image_data_urls = [f"data:image/jpeg;base64,{encode_image(p)}" for p in ["xxx/f1.jpg", "xxx/f2.jpg", "xxx/f3.jpg", "xxx/f4.jpg"]]
#   content = [{"type": "video", "video": image_data_urls, "fps": 2}, {"type": "text", "text": "Describe the sequence of events in this video."}]

Limitations des fichiers

  • Limitations des images
  • Limitations des vidéos
  • Résolution de l'image :
    • Taille minimale : la largeur et la hauteur doivent chacune dépasser 10 pixels.
    • Ratio d'aspect : le rapport entre le côté le plus long et le côté le plus court ne doit pas dépasser 200:1.
    • Résolution maximale : la résolution maximale recommandée est de 8K(7680x4320). Des résolutions supérieures peuvent entraîner des délais d'expiration des appels API en raison de la taille importante des fichiers ou de la lenteur des transferts réseau.
  • Formats d'image pris en charge
    • Les formats suivants sont pris en charge pour les résolutions inférieures à 4K (3840x2160) :

      Format d'image

      Extension de fichier

      Type MIME

      BMP

      .bmp

      image/bmp

      JPEG

      .jpe, .jpeg, .jpg

      image/jpeg

      PNG

      .png

      image/png

      TIFF

      .tif, .tiff

      image/tiff

      WEBP

      .webp

      image/webp

      HEIC

      .heic

      image/heic

    • Pour les résolutions comprises entre 4K(3840x2160) et 8K(7680x4320), seuls les formats JPEG, JPG et PNG sont pris en charge.
  • Taille de l'image :
    • Lorsque vous fournissez une image via une URL publique ou un chemin local, sa taille ne doit pas dépasser 10 Mo.
    • Lors de l'utilisation de l'encodage Base64, la chaîne encodée ne doit pas dépasser 10 Mo.
    Pour compresser un fichier, consultez la rubrique Comment compresser une image ou une vidéo pour respecter la limite de taille .
  • Nombre d'images prises en charge : Lorsque vous fournissez plusieurs images, le nombre total de jetons pour toutes les images et le texte ne doit pas dépasser la limite d'entrée maximale du modèle.

Autres fonctionnalités

Modèle

Conversation multi-tours

Réflexion approfondie

Appel de fonction

Sortie structurée

Recherche Web

Complétion par préfixe

Cache de contexte

kimi-k3.1-pro

Pris en charge

Pris en charge

Pris en charge

Pris en charge (JSON Mode)

Pris en charge

Non pris en charge

Pris en charge (cache implicite)

kimi-k3

Pris en charge

Pris en charge

Pris en charge

Pris en charge

Pris en charge (API Responses)

Pris en charge

Pris en charge

kimi-k2.7-code

Pris en charge

Pris en charge

Pris en charge

Non pris en charge

Non pris en charge

Non pris en charge

Pris en charge

kimi-k2.6

Pris en charge

Pris en charge

Pris en charge

Non pris en charge

Non pris en charge

Non pris en charge

Pris en charge

kimi-k2.5

Pris en charge

Pris en charge

Pris en charge

Non pris en charge

Non pris en charge

Non pris en charge

Pris en charge

Outils chargés dynamiquement

Lorsqu'une application doit monter un grand nombre d'outils, l'inclusion de toutes les déclarations d'outils dans le champ tools de premier niveau de la requête entraîne une inflation des définitions d'outils. Chaque requête doit transporter la description et le schéma de paramètres de tous les outils, ce qui augmente considérablement la consommation de jetons. De plus, plus le nombre d'outils candidats est élevé, plus le risque que le modèle sélectionne le mauvais outil et construise des arguments d'appel incorrects est important. Les outils chargés dynamiquement vous permettent d'injecter des outils à la demande au cours d'une conversation : montez d'abord quelques outils principaux, puis insérez dynamiquement les outils spécifiques nécessaires lorsque la conversation l'exige directement dans le champ messages. Cette approche réduit la consommation de jetons et améliore la précision de la sélection des outils.
kimi-k3.1-pro et kimi-k3 prennent en charge les outils chargés dynamiquement. Toute tentative d'utilisation sur d'autres modèles (tels que kimi-k2.6) renvoie une erreur tokenization failed.Le format et les exemples de cette section relatifs à l'injection d'outils dans messages via le champ tools d'un message system (system.tools) s'appliquent à l'API OpenAI Chat Completions.

Injecter des déclarations d'outils dans les messages

Insérez un message avec le champ role défini sur system dans le tableau messages, et déclarez les outils à charger via le champ tools de ce message. Le format est identique à celui du champ tools de premier niveau de la requête, et vous devez fournir les informations complètes de l'outil (name, description, parameters).
  • Un message system contenant un champ tools possède le même statut qu'un message ordinaire : les outils deviennent visibles pour le modèle à partir de la position où ce message apparaît dans la liste messages.
  • Les outils chargés dynamiquement coexistent avec les outils globaux déclarés dans le champ tools de premier niveau de la requête ; le modèle peut voir simultanément ces deux types d'outils.
  • Une déclaration d'outil injectée dynamiquement doit être une définition d'outil complète ; vous ne pouvez pas transmettre uniquement le nom de l'outil ni faire référence à un outil déclaré globalement.
  • Un message system contenant un champ tools ne doit pas comporter de champ content ; dans le cas contraire, la requête échoue avec une erreur 400. Avec le SDK OpenAI, vous pouvez transmettre directement le champ tools dans messages.
Python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following is the URL for the China (Beijing) region. Replace {WorkspaceId} with your Bailian workspace ID; URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Please calculate 23 * 47 for me."},
        # Dynamically load a tool: insert a system message carrying a tools field into the conversation
        {
            "role": "system",
            "tools": [
                {
                    "type": "function",
                    "function": {
                        "name": "Calculator",
                        "description": "Calculator; evaluates a single arithmetic expression only",
                        "parameters": {
                            "type": "object",
                            "properties": {
                                "expr": {
                                    "type": "string",
                                    "description": "Arithmetic expression supporting basic operations, exponentiation, logarithms, and trigonometric functions, in JavaScript syntax",
                                }
                            },
                            "required": ["expr"],
                        },
                    },
                }
            ],
        },
    ],
)

print(completion.choices[0].message.tool_calls)

Chargement à la demande combiné à un outil de recherche

Il n'existe pas d'API dédiée à la recherche d'outils. Lorsque les outils sont nombreux, vous pouvez combiner un outil de recherche personnalisé avec les outils chargés dynamiquement afin de charger les outils à la demande :
  1. Au début de la session, déclarez dans le champ tools de premier niveau uniquement un outil search_tools implémenté par le backend de votre application (il renvoie les noms et les résumés des outils correspondant à un mot-clé), ainsi que quelques outils principaux susceptibles d'être utilisés à chaque tour.
  2. Déclarez les mots-clés recherchables (tels qu'un catalogue d'outils ou des étiquettes de domaine) dans l'invite système afin d'inciter le modèle à appeler d'abord search_tools lorsqu'il a besoin d'un outil. La définition de tool_choice: "required" dans la première requête garantit au moins un appel d'outil, mais ne garantit pas que search_tools soit appelé en premier. Si la recherche préalable est obligatoire, définissez explicitement tool_choice: {"type": "function", "function": {"name": "search_tools"}}, puis rétablissez tool_choice sur "auto" après la recherche. La modification de tool_choice n'invalide pas le cache de préfixe.
  3. En fonction des résultats renvoyés par search_tools, l'application insère dynamiquement dans messages les déclarations complètes des outils correspondants, au moyen d'un message system contenant tools.
  4. Le modèle peut ensuite appeler directement ces outils nouvellement chargés lors de la génération suivante.
Ainsi, quel que soit le nombre total d'outils, seules quelques déclarations d'outils sont effectivement présentes dans chaque requête, ce qui permet de maîtriser la fenêtre de contexte et la difficulté de sélection pour le modèle.

Remarques

  • Les déclarations d'outils dynamiques s'appliquent requête par requête et ne sont pas mémorisées par le serveur. Il appartient à l'intégrateur de décider s'il continue à les transmettre dans la requête suivante : s'il continue, les outils restent disponibles (ce qui favorise également l'utilisation du cache de préfixe) ; s'il cesse, la déclaration expire. Si l'outil n'est déclaré nulle part ailleurs, le modèle ne peut plus l'appeler, et le cache de préfixe situé après le point de modification peut ne pas être atteint.
  • L'ajout d'une déclaration d'outil dynamique à la fin de messages n'affecte pas le cache du préfixe existant ; la suppression ou la modification de déclarations d'outils antérieures peut affecter les correspondances du cache après le point de modification. La déclaration d'outils globaux dans le champ tools de premier niveau de la requête n'affecte pas non plus les correspondances du cache.
  • Un message system contenant tools consomme également de la longueur de contexte ; n'injectez donc que les outils réellement nécessaires à la conversation en cours.
  • Les déclarations d'outils dynamiques utilisent exactement le même format que les déclarations tools globales ; les intégrateurs n'ont donc pas besoin de maintenir deux schémas.

Paramètres par défaut

Modèle

enable_thinking

temperature

top_p

presence_penalty

fps

max_frames

kimi-k3.1-pro

true (peut être désactivé ; il est fortement recommandé de le maintenir activé)

1.0

0.95

0.0

-

-

kimi-k3

true (peut être désactivé ; il est recommandé de le maintenir activé)

1.0

0.95

0.0

-

-

kimi-k2.7-code

true (mode réflexion uniquement)

1.0

0.95

0.0

2

2000

kimi-k2.6

false

mode réflexion : 1.0

mode sans réflexion : 0.6

Les deux modes : 0.95

Les deux modes : 0.0

2

2000

kimi-k2.5

false

mode réflexion : 1.0

mode sans réflexion : 0.6

Les deux modes : 0.95

Les deux modes : 0.0

2

2000

Un tiret (-) indique que le paramètre ne s'applique pas. Les paramètres d'échantillonnage de kimi-k3.1-pro sont fixés à temperature=1.0, top_p=0.95 et presence_penalty=0.0. La transmission d'une valeur autre que la valeur par défaut pour l'un de ces paramètres renvoie une erreur. Les niveaux d'effort de raisonnement suivants s'appliquent uniquement à kimi-k3.1-pro, max étant la valeur par défaut :
  • max (par défaut) : raisonnement approfondi
  • high : raisonnement renforcé
  • medium : raisonnement modéré
  • low : raisonnement léger
L'emplacement du paramètre d'effort de raisonnement varie selon le protocole :
  • OpenAI Chat Completions : utilisez le champ reasoning_effort de premier niveau. Avec le SDK OpenAI pour Python, transmettez directement reasoning_effort="max".
  • DashScope : utilisez le paramètre SDK reasoning_effort ou parameters.reasoning_effort dans les requêtes HTTP.
  • OpenAI Responses : utilisez reasoning.effort.
  • Anthropic Messages : utilisez output_config.effort.

Modèles et facturation

La série Kimi regroupe des grands modèles de langage développés par Moonshot AI.
  • kimi-k3.1-pro : Prend en charge les entrées de texte et d'image, les sorties de texte et le chargement dynamique d'outils. Les entrées vidéo, Batch et le fine-tuning ne sont pas pris en charge.
  • kimi-k3 : un modèle phare de Kimi. Il raisonne et utilise la réflexion préservée par défaut. Il prend en charge les entrées textuelles et imagées (les entrées vidéo ne sont pas prises en charge), les tâches de conversation et d'agent, ainsi que le chargement dynamique d'outils.
  • kimi-k2.7-code : un modèle Kimi destiné au codage. Il suit plus fiablement les instructions dans des contextes longs et obtient des taux de réussite plus élevés sur les tâches de programmation. Il prend en charge les entrées textuelles, imagées et vidéo, le mode réflexion, ainsi que les tâches de conversation et d'agent.
  • kimi-k2.6 : un modèle de la série Kimi offrant des performances améliorées en matière de codage sur le long terme, de suivi des instructions et d'auto-correction. Il prend en charge les entrées textuelles, imagées et vidéo, les modes avec et sans réflexion, ainsi que les tâches de conversation et d'agent.
  • kimi-k2.5 : il atteint des performances de pointe (SOTA) sur les benchmarks open source pour les tâches d'agent, la génération de code, la compréhension visuelle et d'autres tâches d'intelligence générale. Il prend en charge les entrées imagées, vidéo et textuelles, les modes avec et sans réflexion, ainsi que les tâches de conversation et d'agent.
kimi-k3.1-pro et kimi-k3 ne prennent pas en charge le paramètre thinking_budget. Vous ne pouvez pas utiliser ce paramètre pour limiter la longueur de la réflexion.
Pour les tarifs, consultez facturation des appels de modèle .
Pour les détails sur les tarifs et la fenêtre de contexte, consultez la console Model Studio. La facturation est basée sur le nombre de jetons d'entrée et de sortie.
En mode réflexion, la chaîne de pensée compte comme des jetons de sortie.

Codes d'erreur

Si un appel de modèle échoue et renvoie un message d'erreur, consultez Codes d'erreur.