API Chat Completions : fonctionnement et utilisation

Découvrez le fonctionnement de l’API Chat Completions, apprenez à l’intégrer avec Python, comprenez les principaux paramètres, le streaming et l’appel d’outils, et voyez comment des fournisseurs compatibles avec OpenAI tels que Kimi API peuvent favoriser le développement flexible d’applications d’IA.

9 min de lectureMis à jour : 2026-11-14

Essayer Kimi API

Fonctionnement des requêtes et réponses de l’API Chat Completions

Que vous créiez un chatbot d’IA ou ajoutiez des fonctionnalités conversationnelles à une application, il est important de comprendre comment l’IA gère les conversations. L’API Chat Completions permet cela en reliant les applications à des modèles d’IA afin de générer des réponses pertinentes et naturelles. Grâce à des fonctionnalités telles que l’intégration Python, le streaming et l’appel d’outils, les développeurs peuvent créer des applications plus interactives. Découvrons son fonctionnement, son utilisation et comment des fournisseurs tels que Kimi API favorisent un développement flexible de l’IA.

Qu’est-ce que l’API Chat Completions ?

L’API Chat Completions est une interface qui permet aux applications d’envoyer une séquence de messages à un modèle d’IA et de recevoir une réponse de l’assistant, pour des conversations à un ou plusieurs tours. Par exemple, vous pouvez utiliser Kimi K3.1 Pro pour répondre à une question sur les décorateurs Python, puis poser une question de suivi :

Première requête : envoyez le message utilisateur « What is a Python decorator? ». Kimi renvoie un message de l’assistant expliquant ce concept.
Deuxième requête : pour poursuivre la conversation, envoyez le message utilisateur précédent, le message complet de l’assistant de Kimi et un nouveau message utilisateur : « Can you give me an example? »

Le tableau messages contient le contexte nécessaire à chaque requête. Trois choix de conception majeurs expliquent l’adoption généralisée de cette interface :

Historique géré par l’application : les applications gèrent l’historique de la conversation et incluent le contexte pertinent dans chaque requête, ce qui permet aux développeurs de contrôler ce que le modèle voit.
Rôles de message courants : les rôles les plus utilisés sont system (instructions), user (entrée), assistant (sortie du modèle, renvoyée pour le contexte sur plusieurs tours) et tool (résultats d'appels de fonction). Ensemble, ils permettent d'exprimer des instructions, des dialogues et des interactions avec des outils.
Fonctionnalités flexibles : selon la prise en charge du modèle, l'interface peut gérer le streaming, les appels d'outils, les entrées visuelles et les sorties structurées. Kimi K3.1 Pro prend en charge ces fonctionnalités.

Utiliser l'API Chat Completions avec Kimi

Les exemples suivants utilisent Kimi K3.1 Pro et le SDK Python OpenAI pour montrer comment configurer le client, envoyer des requêtes, traiter les réponses et mettre en œuvre les appels d'outils :

Démarrage rapide : appeler Kimi avec le SDK Python OpenAI

Installez le SDK Python OpenAI :

pip install --upgrade openai

Définissez votre clé Kimi API comme variable d'environnement :

export MOONSHOT_API_KEY="sk-your-kimi-key"

Vous n'avez pas besoin d'une clé API OpenAI. Le SDK Python OpenAI sert de bibliothèque cliente, tandis que votre clé Kimi API et l'URL de base authentifient et acheminent les requêtes vers Kimi.

Initialisez le client et envoyez votre première requête :

import os from openai import OpenAI client = OpenAI( api_key=os.environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1", ) resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ {"role": "user", "content": "Explain REST in one paragraph."} ], ) print(resp.choices[0].message.content)

Cet exemple utilise le point de terminaison API international de Kimi. Pour la configuration officielle et les détails du modèle, consultez le guide de démarrage rapide de Kimi K3.1 Pro.

Paramètres clés

Ces paramètres couvrent les principales options disponibles lors de l'appel à Kimi K3.1 Pro via l'API Chat Completions :

Paramètre	Rôle
`model`	Indique l’ID du modèle, par exemple `kimi-k3.1-pro`.
`messages`	Fournit les messages de la conversation, y compris les entrées précédentes de l’utilisateur et les réponses de l’assistant. Prend en charge le texte et le contenu multimodal.
`reasoning_effort`	Contrôle la profondeur du raisonnement. Accepte `low`, `high` ou `max` (valeur par défaut).
`max_completion_tokens`	Définit le budget maximal de génération, incluant les tokens de raisonnement et ceux de la réponse finale. Les tokens d’entrée sont comptés séparément, mais le total des tokens d’entrée et générés doit tenir dans la fenêtre de contexte du modèle.
`stream`	Définissez cette valeur sur `true` pour recevoir la réponse progressivement au lieu d’attendre la sortie complète.
`tools`	Définit les fonctions dont le modèle peut demander l’exécution à l’application.
`response_format`	Contrôle le formatage de la sortie. Prend en charge `json_object` pour le mode JSON et `json_schema` pour une sortie structurée contrainte par un schéma.

Remarque : Kimi K3.1 Pro utilise des paramètres d'échantillonnage fixes. N'ajoutez pas temperature ni top_p aux requêtes. Consultez la référence de l'API Chat Completions pour connaître le détail des paramètres et les valeurs prises en charge.

Lire la réponse

Après une requête réussie, vous pouvez accéder aux principaux champs de la réponse via l'objet de complétion renvoyé :

choices[0].message – Contient la réponse de l'assistant, y compris content ou tool_calls lorsque le modèle demande une fonction.
choices[0].finish_reason – Indique pourquoi la génération s'est arrêtée, par exemple stop, length ou tool_calls.
usage – Fournit des informations sur l'utilisation des token, notamment les nombres de token d'entrée, de sortie et mis en cache lorsqu'ils sont disponibles.

Pour une réponse textuelle simple, lisez choices[0].message.content. Si le modèle renvoie tool_calls, votre application doit exécuter les fonctions demandées et envoyer leurs résultats dans une requête de suivi

Exemple de streaming

Définissez stream=True pour recevoir la réponse de Kimi sous forme de fragments incrémentiels. L'exemple suivant réutilise le client configuré ci-dessus et affiche la réponse finale à mesure de son arrivée :

stream = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ {"role": "user", "content": "Write a haiku about autumn."} ], stream=True, ) for chunk in stream: if not chunk.choices: continue delta = chunk.choices[0].delta if delta.content: print(delta.content, end="", flush=True)

Kimi K3.1 Pro renvoie le contenu de raisonnement séparément de la réponse finale. Cet exemple n'affiche que delta.content ; il montre donc la réponse finale sans traiter le champ distinct reasoning_content.

Appel d'outils en bref

L'appel d'outils permet à Kimi de demander des fonctions externes lorsqu'une tâche nécessite des informations ou des actions allant au-delà de la réponse du modèle. Par exemple, si un utilisateur demande « Dois-je prendre un parapluie à Tokyo aujourd'hui ? », Kimi peut demander une fonction get_weather pour obtenir les prévisions.

Le processus se déroule en trois étapes :

Déclarer la fonction : définissez get_weather et les arguments attendus sous le paramètre tools.
Exécuter l'outil : Kimi renvoie une entrée tool_calls avec le nom de la fonction et les arguments. Votre application exécute la fonction correspondante et récupère les données météo.
Renvoyer le résultat : ajoutez à la conversation le message complet de l'assistant de Kimi et le résultat de l'outil (avec le tool_call_id correspondant), puis appelez de nouveau Kimi pour générer une réponse destinée à l'utilisateur.

L'exemple suivant réutilise le client configuré ci-dessus. Avant de l'exécuter, assurez-vous d'avoir implémenté une fonction get_weather(city) qui renvoie des données météo sérialisables en JSON. La fonction est exécutée par votre application, et non par Kimi.

import json tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Get the weather forecast for a city.", "parameters": { "type": "object", "properties": { "city": {"type": "string"} }, "required": ["city"] } } } ] messages = [ {"role": "user", "content": "Should I bring an umbrella in Tokyo today?"} ] # Ask Kimi whether it needs to call a tool resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=messages, tools=tools, ) assistant_message = resp.choices[0].message # Preserve the complete assistant message, including tool_calls messages.append(assistant_message) # Execute the requested function in your application for tool_call in assistant_message.tool_calls or []: if tool_call.function.name == "get_weather": args = json.loads(tool_call.function.arguments) # Call your own weather service or API weather_result = get_weather(city=args["city"]) messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(weather_result) }) # Let Kimi interpret the tool result and answer the user final_resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=messages, tools=tools, ) print(final_resp.choices[0].message.content)

Ici, get_weather() représente une fonction implémentée par votre application, et non une fonction exécutée directement par Kimi. Kimi décide quand la demander et fournit les arguments ; votre application effectue l'opération réelle et renvoie le résultat.

En production, mettez en œuvre une boucle qui traite chaque appel d'outil, ajoute les résultats correspondants à la conversation et renvoie les messages mis à jour à Kimi. Répétez ce cycle jusqu'à ce que le modèle renvoie une réponse finale sans demander d'outils supplémentaires.

Pourquoi la compatibilité « OpenAI » compte lors du choix d'un fournisseur

De nombreux fournisseurs prennent en charge le format OpenAI Chat Completions, ce qui permet aux développeurs de réutiliser des SDK et des structures de requêtes familiers. Le changement implique généralement de mettre à jour l'URL de base, la clé API et l'ID du modèle, puis de vérifier les paramètres pris en charge et le traitement des réponses. Lors de la comparaison des fournisseurs, tenez compte des facteurs suivants :

Fidélité de la compatibilité : vérifiez que le streaming, l'appel d'outils, les sorties structurées et le reporting de usage fonctionnent comme votre application l'attend. La compatibilité avec un même format API ne garantit pas une prise en charge identique des fonctionnalités ni le même comportement des réponses selon les fournisseurs.
Qualité du modèle pour votre charge de travail : votre combinaison de langues et vos types de tâches comptent davantage que les benchmarks génériques.
Fenêtre de contexte : les modèles à contexte long peuvent simplifier certains flux de travail documentaires en traitant davantage de contenu source dans une seule requête.
Mécanismes tarifaires : la mise en cache et les remises sur les lots l'emportent souvent sur les tarifs par token mis en avant.
Étendue de l'écosystème : des points de terminaison compatibles supplémentaires, tels que Responses et Anthropic Messages, peuvent offrir davantage d'options d'intégration et de flexibilité à mesure que votre application évolue.

Kimi API : un fournisseur OpenAI-compatible qui se distingue

Kimi API, développé par Moonshot AI, mérite d'être envisagé si vous recherchez un fournisseur OpenAI-compatible, notamment pour les applications en chinois, le traitement de documents longs et les agents de programmation. Il associe des modes d'intégration API familiers aux capacités de contexte long et de raisonnement de Kimi.

Compatible sans modification

Si votre application utilise déjà le SDK Python d’OpenAI, vous pouvez intégrer Kimi sans réécrire l’ensemble de votre flux de requêtes. Il suffit de mettre à jour la configuration de l’API, notamment base_url, api_key et l’identifiant du modèle, tout en conservant l’interface familière Chat Completions.

Par exemple, le code suivant lit un rapport local depuis report.txt, envoie son contenu à Kimi K3.1 Pro pour le résumer et diffuse la réponse générée en continu :

from pathlib import Path report_text = Path("report.txt").read_text(encoding="utf-8") resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ { "role": "user", "content": f"Summarize the following report:\n\n{report_text}" } ], stream=True, ) for chunk in resp: if not chunk.choices: continue content = chunk.choices[0].delta.content if content: print(content, end="", flush=True)

Ici, client réutilise le client Kimi initialisé précédemment avec votre clé API lue depuis une variable d’environnement. Choisissez l’URL de base selon votre région : https://api.moonshot.ai/v1 pour la plateforme internationale ou https://api.moonshot.cn/v1 pour les utilisateurs accédant à l’API depuis la Chine continentale.

Cette approche vous permet de conserver votre flux de travail OpenAI SDK existant tout en utilisant les modèles Kimi pour des tâches telles que le résumé de documents et d’autres applications reposant sur l’API.

Ce qui distingue Kimi

Un modèle phare avec une fenêtre de contexte de 1M token : Kimi K3.1 Pro prend en charge une fenêtre de contexte allant jusqu’à 1M token et la compréhension visuelle native. Les développeurs peuvent travailler sur de vastes bases de code, des documents de la longueur d’un livre et des images dans un même flux de travail, ce qui le rend adapté au raisonnement complexe, au codage et aux applications multimodales.
Optimisation flexible des coûts : Kimi API prend en charge la mise en cache automatique du contexte pour les préfixes de requêtes répétés, ainsi que l’inférence via Batch API pour les tâches à grande échelle ne nécessitant pas de réponses en temps réel. La facturation du cache et les tarifs Batch dépendent du modèle et des règles tarifaires applicables. Consultez les tarifs officiels de Kimi API pour connaître les tarifs actuels et les détails de facturation.
Compatibilité entre les écosystèmes d’API : Kimi propose des endpoints Chat Completions et Responses API compatibles avec OpenAI, ainsi qu’un endpoint compatible avec Anthropic Messages. Les développeurs peuvent intégrer Kimi K3.1 Pro à leurs flux de travail existants à l’aide de SDK et de formats d’API connus, en apportant les ajustements nécessaires selon l’endpoint et les fonctionnalités prises en charge.

Conclusion

Démarrer avec l’API Chat Completions est simple : configurez vos identifiants API, envoyez une requête et lisez la réponse générée dans choices[0].message.content. Une fois votre premier appel API opérationnel, vous pouvez étendre votre intégration selon les besoins de votre application en ajoutant des conversations à plusieurs tours, des réponses diffusées en continu ou l’appel d’outils. Prêt à développer avec Kimi ? Obtenez votre clé Kimi API et commencez à effectuer des requêtes API.

Essayer Kimi API

FAQ

Non. L’API Chat Completions n’est pas réservée aux modèles OpenAI. D’autres fournisseurs d’IA, dont Kimi, proposent des API qui suivent le format Chat Completions compatible avec OpenAI. Les développeurs peuvent ainsi réutiliser des SDK et des structures de requêtes qu’ils connaissent avec les modèles pris en charge par différents fournisseurs, même si la prise en charge des fonctionnalités peut varier.

Les deux API permettent aux applications d’interagir avec des modèles d’IA, mais leurs structures de requêtes et de réponses diffèrent. Chat Completions utilise un tableau messages et renvoie les réponses dans un tableau choices. L’API Responses adopte une structure d’entrée et de sortie plus flexible, prenant en charge différents types de contenu et les interactions avec des outils. La gestion de l’état de la conversation varie selon le fournisseur. Avec l’API Responses de Kimi, les applications doivent inclure l’historique de conversation pertinent dans chaque requête plutôt que de s’appuyer sur l’enchaînement d’ID de réponses.

Si votre application utilise le SDK OpenAI, vous pouvez généralement passer à Kimi en mettant à jour trois valeurs de configuration : base_url avec le point de terminaison de l’API Kimi, api_key avec votre clé Kimi API et model avec l’ID d’un modèle Kimi pris en charge. Testez ensuite votre intégration afin de vérifier que les paramètres et fonctionnalités dont dépend votre application, tels que le streaming et l’appel d’outils, sont pris en charge.