Corps de la requête modelstring(Obligatoire) Nom du modèle. Modèles pris en charge : Qwen Large Language Model (versions commerciales et open source), Qwen-VL, Qwen-Coder, Qwen-Omni, Qwen-Math, DeepSeek, Kimi, GLM et MiniMax. Pour connaître les noms exacts des modèles et les détails de facturation, consultez la console Model Studio. messagesarray(Obligatoire) Contexte transmis au grand modèle de langage, organisé selon l'ordre conversationnel. Type de message Message systèmeobject(Optional) Message système définissant le rôle, le ton, la tâche ou les contraintes du grand modèle de langage. Il constitue généralement le premier élément du tableau messages.
Ne définissez pas de message système pour QwQ. Les messages système n'ont aucun effet sur QVQ.
Propriétés contentstring(Obligatoire) Instruction système. Elle spécifie le rôle, le comportement, le style de réponse et les contraintes de la tâche du modèle. rolestring(Obligatoire) Rôle associé au message système. La valeur est fixée à system. Message utilisateurobject(Required) Message provenant de l'utilisateur. Il transmet des questions, des instructions ou du contexte au modèle. Propriétés contentstring or array(Obligatoire) Contenu du message. Le type est string si l'entrée est uniquement textuelle. Il est array si l'entrée contient des données multimodales telles que des images, ou si la mise en cache explicite est activée. Propriétés pour les modèles multimodaux ou lorsque la mise en cache explicite est activée typestring(Obligatoire) Valeurs valides :
-
text
Définissez cette valeur à text pour une entrée textuelle.
-
image_url
Utilisez image_url pour une entrée image.
-
input_audio
Choisissez input_audio pour une entrée audio.
-
video
Spécifiez video pour une entrée vidéo sous forme de liste d'images.
-
video_url
Indiquez video_url pour une entrée de fichier vidéo.
Seuls certains modèles Qwen-VL acceptent les fichiers vidéo. Consultez Compréhension vidéo avec Qwen-VL. QVQ et Qwen-Omni acceptent directement les fichiers vidéo.
textstring Texte d'entrée. Ce paramètre est requis lorsque type vaut text. image_urlobject Informations sur l'image d'entrée. Ce paramètre est obligatoire quand type est défini à image_url. input_audioobject Informations sur l'audio d'entrée. Ce paramètre devient nécessaire si type correspond à input_audio. Propriétés data string(Obligatoire) URL ou Data URL encodée en Base64 du fichier audio. Pour transmettre un fichier local, consultez Entrée d'un fichier local encodé en Base64. formatstring(Obligatoire) Format de l'audio d'entrée, par exemple mp3 ou wav. videoarray Informations vidéo d'entrée fournies sous forme de liste d'images. Ce paramètre est requis lorsque type vaut video. Pour plus de détails sur son utilisation, consultez Compréhension vidéo (Qwen-VL, QVQ) ou Compréhension vidéo (Qwen-Omni). Exemple de valeur : [
"https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/xzsgiz/football1.jpg",
"https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/tdescd/football2.jpg",
"https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/zefdja/football3.jpg",
"https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/aedbqh/football4.jpg"
]
video_urlobject Informations sur le fichier vidéo d'entrée. Ce paramètre est obligatoire si type est défini à video_url. Qwen-VL analyse uniquement les informations visuelles des fichiers vidéo, tandis que Qwen-Omni traite à la fois les composantes visuelle et audio. fpsfloat(Facultatif) Nombre d'images à extraire par seconde. Valeurs valides : [0.1, 10]. Valeur par défaut : 2.0.
Pour MiniMax/MiniMax-M3, la plage autorisée est [0.2, 5] et la valeur par défaut est 1.
Description de la fonctionnalité Le paramètre fps remplit deux fonctions :
-
Pour un fichier vidéo, ce paramètre contrôle la fréquence d'extraction : une image est extraite toutes les 1/fps secondes.
S'applique à Qwen-VL et aux modèles QVQ.
-
Il indique au modèle l'intervalle de temps entre les images adjacentes afin de faciliter la compréhension de la progression temporelle de la vidéo. Cela concerne aussi bien les entrées de fichiers vidéo que les listes d'images. Cette fonctionnalité convient particulièrement aux scénarios tels que la localisation temporelle d'événements ou le résumé segmenté de contenu.
Pris en charge par Qwen3.7, Qwen3.6, Qwen3.5, Qwen3-VL, Qwen2.5-VL, Qwen3.5-Omni et QVQ.
Une valeur fps élevée convient aux scènes comportant des mouvements rapides, comme les événements sportifs ou les films d'action. À l'inverse, une valeur fps plus faible est recommandée pour les vidéos longues ou les scènes statiques. Exemples de valeurs
- Entrée pour une liste d'images :
{"video":["https://xx1.jpg",...,"https://xxn.jpg"],"fps":2}
- Entrée de fichier vidéo :
{"video": "https://xx1.mp4", "fps":2}
min_pixelsinteger(Facultatif) Définit le seuil minimal de pixels pour les images ou les trames vidéo d'entrée. Si le nombre de pixels d'une entrée est inférieur à min_pixels, celle-ci est agrandie jusqu'à ce que son total dépasse min_pixels. Ce paramètre s'applique aux modèles Qwen-VL et QVQ. Plage de valeurs
-
Entrée image :
- Qwen3.8, Qwen3.7, Qwen3.6, Qwen3.5 et Qwen3-VL : valeur par défaut et minimum :
65536
- Qwen3.5-Omni : valeur par défaut et minimum :
24576
- Série open source
Qwen2.5-VL et modèles de la série QVQ : valeur par défaut et minimale : 3136
-
Entrée de fichier vidéo ou de liste d'images :
- Qwen3.8, Qwen3.7, Qwen3.6, Qwen3.5, Qwen3.5-Omni, Qwen3-VL (versions commerciales et open source) : valeur par défaut :
65536. Minimum : 4096
- Série open source
Qwen2.5-VL et modèles de la série QVQ : valeur par défaut : 50176. Valeur minimale : 3136
Exemples de valeurs
- Entrée image :
{"type": "image_url","image_url": {"url":"https://xxxx.jpg"},"min_pixels": 65536}
- Entrée de fichier vidéo :
{"type": "video_url","video_url": {"url":"https://xxxx.mp4"},"min_pixels": 65536}
- Entrée de liste d'images :
{"type": "video","video": ["https://xx1.jpg",...,"https://xxn.jpg"],"min_pixels": 65536}
max_pixelsinteger(Facultatif) Spécifie le seuil maximal de pixels pour les images ou les trames vidéo d'entrée. Si le nombre de pixels d'une image ou d'une vidéo se situe dans la plage [min_pixels, max_pixels], le modèle traite l'image originale. S'il dépasse max_pixels, l'image est réduite jusqu'à atteindre un nombre de pixels inférieur ou égal à max_pixels. Ce paramètre concerne les modèles Qwen-VL et QVQ. Exemples de valeurs
- Entrée image :
{"type": "image_url","image_url": {"url":"https://xxxx.jpg"},"max_pixels": 8388608}
- Entrée de fichier vidéo :
{"type": "video_url","video_url": {"url":"https://xxxx.mp4"},"max_pixels": 655360}
- Entrée de liste d'images :
{"type": "video","video": ["https://xx1.jpg",...,"https://xxn.jpg"],"max_pixels": 655360}
total_pixelsinteger(Facultatif) Limite le nombre total de pixels de toutes les trames extraites d'une vidéo, calculé selon la formule (pixels par trame × nombre total de trames). Si ce seuil est dépassé, le système réduit automatiquement les trames vidéo. Il veille également à ce que chaque trame individuelle respecte la plage [min_pixels, max_pixels]. Ce paramètre s'applique aux modèles Qwen-VL et QVQ. Pour les vidéos longues nécessitant l'extraction de nombreuses trames, réduire cette valeur permet de diminuer la consommation de tokens et le temps de traitement, mais cela peut entraîner une perte de détails visuels. Plage de valeurs
Qwen3.8 series, Qwen3.7 series, Qwen3.6 series et Qwen3.5 series : valeur par défaut et maximum : 819200000, soit 800000 tokens d'image, à raison de 1 token pour 32×32 pixels.
Qwen3-VL closed-source series : valeur par défaut et maximum : 134217728, soit 131072 tokens d'image, à raison de 1 token pour 32×32 pixels.
Qwen3.5-Omni : valeur par défaut et minimale : 184549376. Cela correspond à 180224 tokens d'image (1 token d'image pour 32×32 pixels).
- Autres modèles open source
Qwen3-VL : valeur par défaut et minimale : 67108864. Cela correspond à 65536 tokens d'image (1 token d'image pour 32×32 pixels).
- Série open source
Qwen2.5-VL et modèles de la série QVQ : valeur par défaut et minimale : 51380224. Cela correspond à 65536 tokens d'image (1 token d'image pour 28×28 pixels).
Exemples de valeurs
- Entrée de fichier vidéo :
{"type": "video_url","video_url": {"url":"https://xxxx.mp4"},"total_pixels": 134217728}
- Entrée de liste d'images :
{"type": "video","video": ["https://xx1.jpg",...,"https://xxn.jpg"],"total_pixels": 134217728}
cache_controlobject(Facultatif) Active la mise en cache explicite. Pour plus d'informations, consultez Mise en cache explicite. Propriétés type string(Obligatoire) Seule la valeur ephemeral est prise en charge. rolestring(Obligatoire) Rôle associé au message utilisateur. La valeur est fixée à user. Message assistant object(Optional) Réponse générée par le modèle. Elle est généralement réinjectée comme contexte lors d'une conversation multi-tours. Propriétés contentstring(Facultatif) Contenu textuel de la réponse du modèle. Lorsque tool_calls est présent, content peut être vide. Dans le cas contraire, content est obligatoire. rolestring(Obligatoire) Rôle associé au message assistant. La valeur est fixée à assistant. partialboolean(Facultatif) Valeur par défaut : false Indique si le mode partiel doit être activé. Valeurs valides :
- true : Activer.
- false : Désactiver.
Pour obtenir la liste des modèles compatibles, consultez mode partiel. tool_calls array(Facultatif) Informations concernant l'outil et ses paramètres d'entrée que le modèle a décidé d'appeler. Ce champ contient un ou plusieurs objets et provient du champ tool_calls de la réponse précédente du modèle. Propriétés id string(Obligatoire) Identifiant de l'appel d'outil. type string(Obligatoire) Type d'outil. Seul function est actuellement pris en charge. function object(Obligatoire) Outils et paramètres d'entrée Propriétés name string(Obligatoire) Nom de l'outil. arguments string(Obligatoire) Informations des paramètres d'entrée, sous forme de chaîne JSON. index integer(Obligatoire) Indice de cet appel d'outil dans le tableau tool_calls. Message outil object(Optional) Résultat issu de l'appel d'outil. Propriétés contentstring(Obligatoire) Contenu de sortie de la fonction outil. Il doit s'agir d'une chaîne de caractères. Si l'outil renvoie des données structurées, telles que du JSON, celles-ci doivent être sérialisées en chaîne. rolestring(Obligatoire) La valeur est fixée à tool. tool_call_idstring(Obligatoire) Identifiant de l'appel d'outil auquel ce message répond. Vous pouvez l'obtenir via completion.choices[0].message.tool_calls[$index].id. Cet ID permet d'associer le message outil à l'appel correspondant. streamboolean(Facultatif) Valeur par défaut : false Indique si la réponse doit être fournie en mode streaming. Pour plus d'informations, consultez Sortie en streaming. Valeurs valides :
false : Le modèle retourne le contenu complet une fois la génération terminée.
true : Le modèle émet le contenu au fur et à mesure de sa génération. Un fragment de données est renvoyé à chaque nouvelle portion générée. Vous devez assembler ces fragments pour reconstituer la réponse complète.
Nous vous recommandons de définir cette valeur à true afin d'améliorer l'expérience utilisateur et de limiter les risques de délai d'attente. RemarqueSi un appel non-streaming ne se termine pas dans les 300 secondes, le service interrompt la requête et retourne le contenu déjà généré au lieu d'une erreur. Pour les scénarios nécessitant de longues sorties, privilégiez les appels en streaming. Pour plus d'informations, consultez la section sur les délais d'attente dans Vue d'ensemble des modèles de génération de texte. stream_optionsobject(Facultatif) Options de configuration pour la sortie en streaming. Ce paramètre n'est pris en compte que lorsque stream est défini à true. Propriétés include_usageboolean(Facultatif) Valeur par défaut : false Indique si les informations de consommation de tokens doivent figurer dans le dernier fragment de données de la réponse. Valeurs valides :
true : Inclure.
false : Ne pas inclure.
En streaming, les informations de consommation des tokens peuvent uniquement figurer dans le dernier fragment de réponse.
modalitiesarray(Facultatif) Valeur par défaut : ["text"] Modalité des données de sortie. Ce paramètre s'applique exclusivement aux modèles Qwen-Omni. Pour plus d'informations, consultez Non temps réel (Qwen-Omni). Valeurs valides :
["text","audio"] : Génère du texte et de l'audio.
["text"] : Génère uniquement du texte.
audioobject(Facultatif) La voix et le format de l'audio en sortie. Ce paramètre s'applique uniquement aux modèles Qwen-Omni et nécessite que le paramètre modalities soit défini sur ["text","audio"]. Pour plus d'informations, reportez-vous à Non temps réel (Qwen-Omni). Propriétés voicestring (Obligatoire) La voix de l'audio en sortie. Pour plus d'informations, reportez-vous à Non temps réel (Qwen-Omni). formatstring (Obligatoire) Le format de l'audio en sortie. Seul le format wav est pris en charge. temperaturefloat(Facultatif) La température d'échantillonnage, qui contrôle la diversité du texte généré par le modèle. Une température élevée produit un texte plus diversifié, tandis qu'une température basse rend le texte plus déterministe. Plage de valeurs : [0, 2) Les paramètres temperature et top_p permettent tous deux de contrôler la diversité du texte généré. Nous vous recommandons de n'en définir qu'un seul. Pour plus d'informations, reportez-vous à Vue d'ensemble.
Ne modifiez pas la température par défaut des modèles QVQ.
top_pfloat(Facultatif) Le seuil de probabilité pour l'échantillonnage par noyau, qui contrôle la diversité du texte généré par le modèle. Une valeur top_p élevée augmente la diversité du texte. Une valeur top_p faible rend le texte plus déterministe. Plage de valeurs : (0, 1.0] Les paramètres temperature et top_p permettent tous deux de contrôler la diversité du texte généré. Nous vous recommandons de n'en définir qu'un seul. Pour plus d'informations, reportez-vous à Vue d'ensemble.
Ne modifiez pas top_p par défaut pour les modèles QVQ.
top_kinteger(Facultatif) Définit le nombre de tokens candidats parmi lesquels effectuer l'échantillonnage lors de la génération. Une valeur élevée accroît l'aléatoire de la sortie, tandis qu'une valeur faible la rend plus déterministe. Si ce paramètre est défini sur null ou sur une valeur supérieure à 100, la stratégie top_k est désactivée et seule la stratégie top_p s'applique. La valeur doit être un entier supérieur ou égal à 0. Valeurs top_k par défaut Série QVQ : 10 ; Série QwQ : 40 ; Série Qwen3-Omni-Flash : 50 ; Tous les autres modèles : 20. Série GLM (fournie par Alibaba Cloud) : 20 ; Les séries DeepSeek, Kimi et MiniMax ne prennent pas en charge le paramètre top_k.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans l'objet extra_body : extra_body={"top_k":xxx}.
Ne modifiez pas top_k par défaut pour les modèles QVQ.
repetition_penaltyfloat(Facultatif) Pénalité de répétition des séquences consécutives. Augmenter repetition_penalty réduit les répétitions. 1.0 signifie aucune pénalité. La valeur doit être supérieure à 0, sans plage stricte.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans l'objet extra_body : extra_body={"repetition_penalty":xxx}.
Ne modifiez pas repetition_penalty par défaut pour QVQ.
presence_penalty float(Facultatif) Contrôle la répétition du contenu lorsque le modèle génère du texte. Plage de valeurs : [-2.0, 2.0]. Les valeurs positives réduisent les répétitions, tandis que les valeurs négatives les augmentent. Augmentez cette valeur dans les scénarios nécessitant de la diversité, du ludique ou de la créativité, comme la rédaction créative ou le brainstorming. Diminuez-la pour les scénarios privilégiant la cohérence et la précision terminologique, tels que les documents techniques ou les textes formels. Valeurs presence_penalty par défaut Qwen3.8 (sans réflexion), Qwen3.7 (sans réflexion), Qwen3.6 (sans réflexion), Qwen3.5-Omni, Qwen3.5 (sans réflexion), Qwen3 (sans réflexion), série Qwen3-Instruct/1.7b/4b (avec réflexion), série QVQ, qwen-max, série qwen2.5-vl et Qwen3-VL (sans réflexion) : 1.5 ; qwen-plus/qwen-plus-latest/2025-04-28 (avec réflexion), qwen-turbo-2025-04-28 (avec réflexion) : 0.5 ; Tous les autres : 0.0. Série DeepSeek (fournie par Alibaba Cloud) : version distillée deepseek-r1-distill-qwen : 1 ; Série Kimi fournie par Alibaba Cloud : kimi-k2.7-code, kimi-k2.6, kimi-k2.5 : 0.0 ; Série Kimi fournie par Moonshot AI : 0.0 ; Série MiniMax fournie par Alibaba Cloud : MiniMax-M2.5 : 0.0 ; Les autres modèles DeepSeek, Kimi, GLM et MiniMax n'ont pas de valeur par défaut. Fonctionnement Si la valeur du paramètre est positive, le modèle applique une pénalité aux tokens déjà présents dans le texte. Cette pénalité est indépendante du nombre d'apparitions du token. Cela réduit la probabilité de réapparition de ces tokens, diminuant ainsi les répétitions de contenu et augmentant la diversité lexicale. Exemple Prompt : Traduisez cette phrase en chinois : « Ce film est bon. L'intrigue est bonne, le jeu d'acteur est bon, la musique est bonne, et dans l'ensemble, tout le film est simplement bon. C'est vraiment bien, en fait. L'intrigue est tellement bonne, et le jeu d'acteur est tellement bon, et la musique est tellement bonne. » Valeur du paramètre 2.0 : Ce film est excellent. L'intrigue est fantastique, le jeu d'acteur est superbe et la musique est également très belle. Dans l'ensemble, le film entier est tout simplement incroyable. Il est en réalité véritablement exceptionnel. Le scénario est très passionnant, les performances sont excellentes et la bande originale est si émouvante. Valeur du paramètre 0.0 : Ce film est bon. L'intrigue est bonne, le jeu d'acteur est bon et la musique est bonne. Dans l'ensemble, tout le film est très bien. En fait, il est vraiment génial. L'intrigue est très bonne, le jeu d'acteur est aussi très excellent et la musique est tout aussi remarquable. Valeur du paramètre -2.0 : Ce film est bon. L'intrigue est bonne, le jeu d'acteur est bon et la musique est bonne. Dans l'ensemble, tout le film est bon. En fait, il est vraiment bon. L'intrigue est très bonne, le jeu d'acteur est très bon et la musique est très bonne.
Ne modifiez pas presence_penalty par défaut pour QVQ.
response_formatobject (Facultatif) Valeur par défaut : {"type": "text"} Le format de la réponse. Valeurs valides :
{"type": "text"} : Génère une réponse textuelle.
{"type": "json_object"} : Génère une chaîne formatée en JSON standard.
{"type": "json_schema", "json_schema": {...}} : Génère une chaîne JSON qui respecte strictement le JSON Schema spécifié, ce qui permet de contrôler précisément la structure de la sortie et le type des champs.
Pour plus d'informations, consultez Sortie structurée. Les modes json_object et json_schema ne prennent pas en charge les mêmes modèles. Pour plus d'informations, consultez Modèles pris en charge.
Si vous spécifiez {"type": "json_object"}, demandez explicitement une sortie JSON dans le prompt, par exemple « Please output in JSON format ». Sinon, une erreur est renvoyée. Si vous spécifiez {"type": "json_schema", ...}, le prompt n'a pas besoin de contenir le mot-clé JSON.
Propriétés typestring(Obligatoire) Le format du contenu retourné. Valeurs valides :
text : Génère une réponse textuelle.
json_object : Génère une chaîne formatée en JSON standard.
json_schema : Génère une chaîne JSON qui respecte strictement la structure définie par le champ json_schema.
json_schemaobject(Facultatif) Obligatoire lorsque type est défini sur json_schema. Définit la structure JSON que la sortie du modèle doit respecter. Pour plus d'informations, consultez Obtenir une sortie structurée.
Avec la méthode parse du SDK OpenAI, vous pouvez transmettre directement une classe Pydantic Python ou un objet Zod Node.js. Le SDK la convertit automatiquement en JSON Schema : aucune construction manuelle n'est nécessaire.
Propriétés namestring(Obligatoire) Le nom du schéma. schemaobject(Obligatoire) L'objet JSON Schema qui décrit la structure de la sortie. Utilisez properties pour définir la structure des champs, required pour lister les champs obligatoires et additionalProperties pour contrôler si des champs non définis dans le schéma peuvent être retournés. Nous vous recommandons de définir additionalProperties sur false afin que seuls les champs définis soient retournés. Types de données pris en charge : string, number, integer, boolean, object, array et enum. Pour plus d'informations, consultez Guide de configuration. strictboolean(Facultatif) Indique s'il faut respecter strictement la structure définie par schema. Nous vous recommandons de définir ce paramètre sur true. max_tokensinteger(Facultatif, bientôt obsolète)
Ce paramètre sera abandonné. Pour les nouvelles intégrations, utilisez max_completion_tokens.
La signification de ce paramètre varie selon le modèle :
- deepseek-v4-pro, deepseek-v4-pro-0813 et deepseek-v4-flash-0731 : nombre maximal de tokens cumulés de la réponse et du raisonnement. Au-delà, la génération s'arrête et
finish_reason vaut length.
- glm-5.3 :
max_tokens correspond au nombre maximal de tokens cumulés de la réponse du modèle et du raisonnement. Si la sortie dépasse cette valeur, la génération s’arrête prématurément et le finish_reason retourné est length. glm-5.3 ignore le paramètre thinking_budget.
- glm-5.2 : sans le paramètre
thinking_budget, max_tokens limite les tokens cumulés de la réponse et du raisonnement. Au-delà, la génération s'arrête et finish_reason vaut length. Si thinking_budget est fourni, max_tokens limite uniquement les tokens de réponse, et thinking_budget contrôle séparément ceux du raisonnement.
- Autres modèles : nombre maximal de tokens de réponse, hors raisonnement. Au-delà, la génération s'arrête et
finish_reason vaut length.
Pour les modèles GLM, les valeurs par défaut et maximales sont indiquées dans le tableau suivant. Pour les autres modèles, les valeurs par défaut et maximales correspondent toutes deux à la longueur de sortie maximale du modèle. | Fournisseur | Modèle | Valeur par défaut | Valeur maximale |
|---|
| Alibaba Cloud | glm-5.3, glm-5.2, glm-5.2-fast-preview, glm-5.1, glm-5 | 65536 | 131072 | | ZHIPU AI | ZHIPU/GLM-5.3, ZHIPU/GLM-5.2 | 65536 | 131072 |
max_completion_tokensinteger(Facultatif) La longueur maximale de la sortie du modèle, incluant la chaîne de pensée et la réponse du modèle. Si la sortie du modèle dépasse cette valeur, la génération s'arrête prématurément et le finish_reason retourné est length. Pour les modèles GLM, consultez le tableau du paramètre max_tokens pour connaître les valeurs par défaut et maximales. Pour les autres modèles, les valeurs par défaut et maximales correspondent toutes deux à la longueur de sortie maximale du modèle. Différence avec max_tokens : max_completion_tokens limite toujours la sortie complète du modèle (chaîne de pensée + réponse). La portée exacte de max_tokens varie selon le modèle et la configuration de thinking_budget, comme indiqué précédemment. Pour les modèles avec réflexion, nous recommandons d’utiliser max_completion_tokens. Les modèles suivants sont pris en charge :
- Qwen Max : Qwen3.7-Max et modèles ultérieurs
- Qwen Plus : Qwen3.5-Plus et modèles ultérieurs
- Qwen Flash : Qwen3.5-Flash et modèles ultérieurs
- Kimi : kimi-k2.5 et modèles ultérieurs
- GLM : les modèles fournis par Alibaba Cloud et ZHIPU AI répertoriés dans le tableau précédent
- MiniMax : MiniMax-M2.5 et modèles ultérieurs
- DeepSeek : deepseek-v4-pro et modèles ultérieurs
À l’exception des modèles GLM fournis par ZHIPU AI répertoriés dans le tableau précédent, les modèles ci-dessus n’incluent aucun autre modèle fourni directement par des tiers.
Un écart de 10 tokens au maximum peut exister entre la sortie réelle et la valeur max_completion_tokens.
vl_high_resolution_imagesboolean(Facultatif) Valeur par défaut : false Indique s'il faut augmenter la limite de pixels des images d'entrée pour atteindre le nombre de pixels correspondant à 16384 tokens. Pour plus d'informations, reportez-vous à Traitement des images haute résolution.
-
vl_high_resolution_images: true utilise une stratégie de résolution fixe et ignore le paramètre max_pixels. Si la résolution est dépassée, le nombre total de pixels de l'image est réduit proportionnellement pour rester dans cette limite.
Cliquez pour voir les limites de pixels pour chaque modèle Lorsque vl_high_resolution_images est True, les limites de pixels varient selon le modèle :
- Pour les séries Qwen3.8, Qwen3.7, Qwen3.6,
Qwen3.5, ainsi que Qwen3-VL series, la valeur est 16777216. Chaque Token correspond à 32*32 pixels ; le total est calculé comme 16384*32*32.
QVQ series et autres modèles Qwen2.5-VL series : 12845056. 1 token correspond à 28*28 pixels, soit 16384*28*28.
-
Si vl_high_resolution_images est false, la limite de pixels est déterminée par max_pixels. Si le nombre de pixels de l'image d'entrée dépasse max_pixels, l'image est réduite pour rester dans la limite max_pixels. La limite de pixels par défaut pour chaque modèle correspond à la valeur par défaut de max_pixels.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"vl_high_resolution_images":xxx}.
ninteger(Facultatif) Valeur par défaut : 1 Le nombre de réponses à générer. La plage de valeurs est 1-4. Ce paramètre convient aux scénarios nécessitant plusieurs réponses candidates, comme la rédaction créative ou les textes publicitaires.
Pris en charge uniquement par Qwen3 en mode sans réflexion.
Si tools est fourni, définissez n sur 1.
Augmenter n accroît les tokens de sortie, mais pas ceux d'entrée.
enable_thinking boolean (Facultatif) Lorsque vous utilisez un modèle à réflexion mixte, prenant en charge à la fois les modes avec et sans réflexion, ce paramètre indique s'il faut activer le mode réflexion. Cela s'applique aux modèles Qwen3.8, Qwen3.7, Qwen3.6, Qwen3.5, Qwen3, Qwen3.8-Omni-Flash, Qwen3-Omni-Flash et Qwen3-VL, ainsi qu'aux séries DeepSeek-V4-Pro/V4-Flash, aux séries DeepSeek-V3.2/V3.2-exp/V3.1, à Kimi-K2.7-code (modèle avec réflexion uniquement), aux séries Kimi-K2.6/K2.5, et à la série GLM. La série DeepSeek-V4 active la réflexion par défaut. Vous pouvez ajuster l'intensité de l'inférence avec le paramètre reasoning_effort. Valeurs valides :
-
true : Activer
Lorsque le mode est activé, le raisonnement est renvoyé dans reasoning_content.
-
false : Désactiver
Valeurs par défaut pour les différents modèles : Modèles pris en charge
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"enable_thinking": xxx}.
Pour un appel HTTP direct, par exemple avec curl, sans SDK OpenAI, n'utilisez pas extra_body. Placez enable_thinking au niveau supérieur du corps de requête (body), à côté de model et messages, par exemple "enable_thinking": true.
Les modèles MiniMax et MiniMax-M3 de Xiyu Technology utilisent thinking à la place de ce paramètre.
thinking object (Facultatif) Valeur par défaut : {"type":"adaptive"} Contrôle le mode de réflexion des modèles MiniMax/MiniMax-M3 fournis par MiniMax. Valeurs valides pour thinking.type :
adaptive : Automatique (par défaut). Le modèle décide s'il doit réfléchir.
disabled : Désactive la réflexion et répond directement.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"thinking": {"type": "adaptive"}}.
preserve_thinking boolean (Facultatif) Valeur par défaut : false (valeur par défaut pour qwen3.8-max/qwen3.8-flash :true) Indique s'il faut ajouter le reasoning_content des messages de l'assistant dans l'historique de conversation à l'entrée du modèle. Cette option convient aux scénarios où le modèle doit se référer au processus de réflexion historique. Actuellement pris en charge par qwen3.7-max, qwen3.7-max-2026-05-20 et ses snapshots ultérieurs, qwen3.7-plus, qwen3.7-plus-2026-05-26, qwen3.6-plus, qwen3.6-plus-2026-04-02, qwen3.7-flash, qwen3.7-flash-2026-07-15, qwen3.6-flash, qwen3.6-flash-2026-04-16, la série qwen3.8-max (activé par défaut), qwen3.8-flash (activé par défaut), kimi-k2.6 (déployé sur Model Studio), kimi-k2.7-code (déployé sur Model Studio, activé par défaut), kimi/kimi-k2.7-code-highspeed (fourni par Moonshot AI, activé par défaut) et kimi/kimi-k2.7-code (fourni par Moonshot AI, activé par défaut).
Important pour qwen3.8-max/qwen3.8-flash : preserve_thinking vaut true par défaut. Renvoyez tout l'historique reasoning_content dans le champ reasoning_content. Ne concaténez PAS reasoning_content dans content. Cela peut dégrader les performances.
- Si les messages historiques ne contiennent pas de reasoning_content, l'activation de ce paramètre ne provoque pas d'erreur.
- Lorsque cette option est activée, le reasoning_content de la conversation historique est inclus dans le décompte des tokens d'entrée et est facturé.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"preserve_thinking": True}.
thinking_budget integer (Facultatif) Le nombre maximal de tokens pour le processus de réflexion. Cela s'applique aux modèles Qwen3.8, Qwen3.7, Qwen3.6, Qwen3.5, Qwen3-VL, Qwen3, GLM et Kimi. Pour plus d'informations, reportez-vous à Limiter la longueur de la réflexion. La valeur par défaut correspond à la longueur maximale de la chaîne de pensée du modèle. Pour plus d'informations, consultez la liste des modèles.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"thinking_budget": xxx}.
reasoning_effort string (Facultatif) Contrôle l'intensité de l'inférence des modèles. Les valeurs valides et les valeurs par défaut varient selon le modèle. Séries DeepSeek-V4 et GLM (Valeur par défaut : high) Valeurs valides :
high : Inférence à haute intensité
max : Inférence à intensité maximale
low et medium sont mappés sur high, et xhigh est mappé sur max. S'applique à glm-5.2, glm-5.1, glm-5 et deepseek-v4-pro. Modèles ZHIPU/GLM-5.3 et kimi-k3, fournis par Alibaba Cloud : valeur par défaut :max Valeurs valides :
max (par défaut) : raisonnement approfondi
high : raisonnement renforcé
low : raisonnement léger
Ce modèle raisonne toujours. enable_thinking accepte uniquement true. Fournir false fait échouer la requête API. deepseek-v4-flash-0731 et deepseek-v4-pro-0813 : valeur par défaut :high Valeurs valides :
max (par défaut) : Inférence à intensité maximale
high : Inférence standard
low : Inférence à faible intensité
Correspondance des valeurs standard OpenAI : medium et xhigh sont convertis en high. kimi/kimi-k3 (Valeur par défaut : max ; seul max est pris en charge) Valeur valide :
max : Inférence à intensité maximale
Série Qwen3.8 : valeur par défaut :xhigh Valeurs valides :
xhigh (par défaut) : Inférence à intensité maximale
medium : Inférence standard
low : Inférence à faible intensité
Mappage des valeurs standard OpenAI : max est mappé sur xhigh, high est mappé sur xhigh, minimal est mappé sur low, et none est mappé sur enable_thinking=False.
Toute valeur autre que les valeurs autorisées ou leurs correspondances provoque une erreur.
Pour la série qwen3.8, reasoning_effort et thinking_budget ne peuvent pas être définis simultanément. Ils sont toutefois convertibles l'un dans l'autre :
- Lorsque thinking_budget n'est pas défini, les niveaux reasoning_effort sont automatiquement mappés sur thinking_budget :
low correspond à 4096, medium correspond à 16384, et xhigh correspond à 262144.
- Lorsque reasoning_effort n'est pas défini, thinking_budget est automatiquement remappé sur reasoning_effort : 0–4096 correspond à
low, 4097–16384 correspond à medium, et 16385–262144 correspond à xhigh.
- Si aucun des deux n'est défini, le thinking_budget par défaut (131072) et le reasoning_effort par défaut (xhigh) sont utilisés.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"reasoning_effort": "high"}.
tool_stream boolean (Facultatif) Valeur par défaut : false Ce paramètre n'est pris en compte que lorsque stream=true. Il est actuellement compatible uniquement avec les séries Qwen et GLM. Liste de compatibilité pour la série Qwen :
- Série qwen-max : modalité texte des séries qwen3.8-max et qwen3.7-max
- Série qwen-plus : modalité texte des séries qwen3.7-plus et qwen3.6-plus, ainsi que l'omni-modalité de la série qwen3.5-plus
- Série qwen-flash : capacités multimodales intégrales des séries qwen3.8-flash, qwen3.7-flash, qwen3.6-flash et qwen3.5-flash
Référence d'utilisation pour la série Qwen :Le paramètre tool_stream influence uniquement les paramètres d'outils complexes. Pour les paramètres d'outils standards, la sortie en streaming est activée dès que stream=true. Un outil est considéré comme complexe lorsque certains types de paramètres dans sa définition sont array ou object.
tool_stream=false : les paramètres d'outils complexes sont générés en une seule fois. Ce comportement par défaut offre une meilleure précision pour les formats complexes.
tool_stream=true : les paramètres d'outils complexes sont générés en flux continu, ce qui permet d'éviter les risques de timeout liés aux formats complexes.
Liste de compatibilité pour la série GLM : glm-5 et glm-5.1. Référence d'utilisation pour la série GLM :
tool_stream=false : les paramètres d'outils sont générés en une seule fois. Ce comportement par défaut garantit une précision accrue pour les formats complexes.
tool_stream=true : les paramètres d'outils sont générés en flux continu, limitant ainsi les risques de timeout pour les formats complexes.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"tool_stream": true}.
enable_code_interpreter boolean (Facultatif) Valeur par défaut : false Détermine si la fonctionnalité d'interpréteur de code doit être activée. Pour plus d'informations, consultez Interpréteur de code. Valeurs valides :
true : Activer
false : Désactiver
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"enable_code_interpreter": xxx}.
seedinteger(Facultatif) Graine de nombre aléatoire permettant d'assurer la reproductibilité des résultats pour une même entrée et des paramètres identiques. Si vous transmettez la même valeur de seed lors d'un appel et que les autres paramètres restent inchangés, le modèle s'efforce de retourner un résultat identique. Plage de valeurs : [0,2<sup>31</sup>−1]. logprobs boolean (Facultatif) Valeur par défaut : false Indique s'il faut retourner les probabilités logarithmiques des tokens de sortie. Valeurs valides :
-
true
Retourner
-
false
Ne pas retourner
Le raisonnement (reasoning_content) ne renvoie pas de probabilités logarithmiques.
Modèles pris en charge
- Modèles snapshot de la série qwen-plus (hors versions stables)
- Modèles de la série qwen3-vl-plus (y compris les versions stables)
- Modèles open source Qwen3
top_logprobs integer (Facultatif) Valeur par défaut : 0 Définit le nombre de tokens candidats les plus probables à retourner à chaque étape de génération. Plage de valeurs : [0, 5] Ce paramètre n'est effectif que si logprobs est défini sur true. stopstring or array(Facultatif) Permet de définir des mots d'arrêt. La génération s'interrompt immédiatement dès qu'une chaîne ou un token_id spécifié dans stop apparaît dans le texte généré. Transmettez des mots sensibles afin de contrôler la sortie du modèle.
Si stop est un tableau, ses éléments ne peuvent pas mélanger token_id et des chaînes. Par exemple, ["Hello",104307] n'est pas autorisé.
toolsarray(Facultatif) Tableau contenant un ou plusieurs objets outils que le modèle peut appeler via Function Calling. Pour plus d'informations, consultez Function Calling. Si tools est défini et que le modèle juge nécessaire d'appeler un outil, la réponse inclut les informations correspondantes dans tool_calls. Propriétés typestring(Obligatoire) Type d'outil. Seul function est actuellement pris en charge. functionobject(Obligatoire) Propriétés namestring(Obligatoire) Nom de l'outil. Seuls les lettres, chiffres, traits de soulignement (_) et tirets (-) sont autorisés. La longueur maximale est de 64 tokens. descriptionstring(Obligatoire) Description de l'outil, aidant le modèle à déterminer quand et comment l'appeler. parametersobject(Facultatif) Valeur par défaut : {} Description des paramètres de l'outil, devant respecter un schéma JSON Schema valide. Pour plus de détails sur JSON Schema, consultez ce lien. Si le paramètre parameters est vide, l'outil n'accepte aucun paramètre d'entrée (par exemple, un outil de requête horaire).
Pour améliorer la précision des appels d'outils, il est recommandé de fournir parameters.
tool_choice string or object(Facultatif) Valeur par défaut : auto Stratégie de sélection des outils. Configurez ce paramètre pour imposer une méthode d'appel spécifique selon le type de problème, par exemple pour toujours utiliser un outil donné ou désactiver tous les outils. deepseek-v4.1-flash-1017 accepte tool_choice défini sur auto, none, required ou une fonction désignée par son nom.
Valeurs valides :
-
auto
Le grand modèle de langage choisit lui-même la stratégie d'outils.
-
none
Pour empêcher tout appel d'outil, définissez le paramètre tool_choice sur none.
-
{"type": "function", "function": {"name": "the_function_to_call"}}
Pour forcer l'appel d'un outil précis, définissez le paramètre tool_choice sur {"type": "function", "function": {"name": "the_function_to_call"}}, où the_function_to_call correspond au nom de la fonction outil ciblée.
Les modèles en mode de réflexion ne permettent pas de forcer un outil précis.
parallel_tool_calls boolean (Facultatif) Valeur par défaut : false Active ou désactive l'appel parallèle d'outils. Pour plus d'informations, consultez Appel parallèle d'outils. Valeurs valides :
true : Activer
false : Désactiver
enable_search boolean(Facultatif) Valeur par défaut : false Active ou désactive la recherche web. Pour plus d'informations, consultez Recherche web. Valeurs valides :
-
true : Activer.
Si aucune recherche web n'est effectuée après activation, améliorez le prompt ou définissez forced_search dans search_options pour forcer la recherche.
-
false : Désactiver.
Activer la recherche web peut augmenter la consommation de tokens.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"enable_search": True}.
search_optionsobject(Facultatif) Stratégie appliquée à la recherche web. Pour plus d'informations, consultez Recherche web. Propriétés forced_search boolean(Facultatif) Valeur par défaut : false Force l'exécution d'une recherche web. Ce paramètre n'est pris en compte que si enable_search est défini sur true. Valeurs valides :
- true : Activation forcée.
- false : Pas d'activation forcée. Le modèle décide lui-même d'effectuer ou non une recherche web.
search_strategy string(Facultatif) Valeur par défaut : turbo Stratégie de recherche utilisée. Ce paramètre n'est effectif que si enable_search est défini sur true. Valeurs valides :
-
turbo (Par défaut) : offre un compromis entre rapidité de réponse et efficacité de la recherche. Cette stratégie convient à la majorité des cas d'usage.
-
max : adopte une approche de recherche plus exhaustive. Elle sollicite plusieurs moteurs de recherche pour obtenir des résultats détaillés, mais peut entraîner un temps de réponse plus long.
-
agent : permet d'invoquer à plusieurs reprises l'outil de recherche web et le grand modèle de langage afin d'effectuer une récupération d'informations multi-tours et une intégration du contenu.
Cette stratégie s'applique uniquement à qwen3.5-plus, qwen3.5-plus-2026-02-15, qwen3.5-flash, qwen3.5-flash-2026-02-23, qwen3.5-omni-plus, qwen3.5-omni-plus-2026-03-15, qwen3.5-omni-flash et qwen3.5-omni-flash-2026-03-15.
enable_search_extension boolean(Facultatif) Valeur par défaut : false Active la recherche verticale. Ce paramètre n'est pris en compte que si enable_search est défini sur true. Valeurs valides :
true : Activer.
false : Désactiver.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"search_options": xxx}.
clear_thinkingboolean(Facultatif) Valeur par défaut : false Contrôle si le reasoning_content (processus de réflexion) des tours précédents d'une conversation multi-tours est utilisé comme contexte pour le modèle. Ce paramètre est uniquement pris en charge par les modèles de la série GLM : glm-5.2, glm-5.1 et glm-5.
Ce paramètre n'est pas standard dans OpenAI. Avec le SDK Python, placez-le dans extra_body : extra_body={"skill": [...]}.
true : ignore le reasoning_content des tours précédents et utilise uniquement le texte visible, les appels d'outils, les résultats et autres contenus non inférés comme entrée contextuelle. Cela permet de réduire la longueur du contexte et le coût associé.
false (Par défaut) : conserve le reasoning_content des tours précédents et le transmet au modèle avec le contexte. Pour activer la préservation de la réflexion (Preserved Thinking), vous devez transmettre l'historique complet du reasoning_content, sans modification et dans son ordre d'origine au sein des messages. Toute omission, troncation, réécriture ou réorganisation dégrade les performances ou provoque un échec.
| Entrée textePythonimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
# Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
# This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
model="qwen3.8-max",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who are you?"},
],
# extra_body={"enable_thinking": False},
)
print(completion.model_dump_json())
Java// This code uses OpenAI SDK version 2.6.0
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
public class Main {
public static void main(String[] args) {
OpenAIClient client = OpenAIOkHttpClient.builder()
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
// Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
.baseUrl("https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1")
.build();
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.addUserMessage("Who are you?")
.model("qwen3.8-max")
.build();
try {
ChatCompletion chatCompletion = client.chat().completions().create(params);
System.out.println(chatCompletion);
} catch (Exception e) {
System.err.println("Error occurred: " + e.getMessage());
e.printStackTrace();
}
}
}
Node.jsimport OpenAI from "openai";
const openai = new OpenAI(
{
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
apiKey: process.env.DASHSCOPE_API_KEY,
// Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const completion = await openai.chat.completions.create({
model: "qwen3.8-max", // This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "Who are you?" }
],
});
console.log(JSON.stringify(completion))
}
main();
Gopackage main
import (
"context"
"os"
"github.com/openai/openai-go"
"github.com/openai/openai-go/option"
)
func main() {
client := openai.NewClient(
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
option.WithAPIKey(os.Getenv("DASHSCOPE_API_KEY")), // defaults to os.LookupEnv("OPENAI_API_KEY")
// Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
option.WithBaseURL("https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/"),
)
chatCompletion, err := client.Chat.Completions.New(
context.TODO(), openai.ChatCompletionNewParams{
Messages: openai.F(
[]openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Who are you?"),
},
),
Model: openai.F("qwen-plus"),
},
)
if err != nil {
panic(err.Error())
}
println(chatCompletion.Choices[0].Message.Content)
}
C# (HTTP)using System.Net.Http.Headers;
using System.Text;
class Program
{
private static readonly HttpClient httpClient = new HttpClient();
static async Task Main(string[] args)
{
// If the environment variable is not configured, replace the following line with your Model Studio API key: string? apiKey = "sk-xxx";
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
string? apiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY");
if (string.IsNullOrEmpty(apiKey))
{
Console.WriteLine("API Key not set. Make sure the 'DASHSCOPE_API_KEY' environment variable is set.");
return;
}
// Set the request URL and content
// Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
string url = "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions";
// This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
string jsonContent = @"{
""model"": ""qwen-plus"",
""messages"": [
{
""role"": ""system"",
""content"": ""You are a helpful assistant.""
},
{
""role"": ""user"",
""content"": ""Who are you?""
}
]
}";
// Send the request and get the response
string result = await SendPostRequestAsync(url, jsonContent, apiKey);
// Print the result
Console.WriteLine(result);
}
private static async Task<string> SendPostRequestAsync(string url, string jsonContent, string apiKey)
{
using (var content = new StringContent(jsonContent, Encoding.UTF8, "application/json"))
{
// Set request headers
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
// Send the request and get the response
HttpResponseMessage response = await httpClient.PostAsync(url, content);
// Process the response
if (response.IsSuccessStatusCode)
{
return await response.Content.ReadAsStringAsync();
}
else
{
return $"Request failed: {response.StatusCode}";
}
}
}
}
PHP (HTTP)<?php
// Set the request URL
// Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
$url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions';
// If the environment variable is not configured, replace the following line with your Model Studio API key: $apiKey = "sk-xxx";
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
$apiKey = getenv('DASHSCOPE_API_KEY');
// Set request headers
$headers = [
'Authorization: Bearer '.$apiKey,
'Content-Type: application/json'
];
// Set the request body
$data = [
// This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
"model" => "qwen-plus",
"messages" => [
[
"role" => "system",
"content" => "You are a helpful assistant."
],
[
"role" => "user",
"content" => "Who are you?"
]
]
];
// Initialize a cURL session
$ch = curl_init();
// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
// Execute the cURL session
$response = curl_exec($ch);
// Check for errors
if (curl_errno($ch)) {
echo 'Curl error: ' . curl_error($ch);
}
// Close the cURL resource
curl_close($ch);
// Print the response
echo $response;
?>
curl
Remplacez {WorkspaceId} par votre ID d'espace de travail. Les URL varient selon la région. Obtenez une clé API à l'adresse https://www.alibabacloud.com/help/model-studio/get-api-key.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Who are you?"
}
]
}'
Sortie en streaming
Pour l'utilisation, consultez Sortie en streaming.
Pythonimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
model="qwen3.8-max", # This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
messages=[{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Who are you?'}],
stream=True,
stream_options={"include_usage": True}
)
for chunk in completion:
print(chunk.model_dump_json())
Node.jsimport OpenAI from "openai";
const openai = new OpenAI(
{
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const completion = await openai.chat.completions.create({
model: "qwen3.8-max", // This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
messages: [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who are you?"}
],
stream: true,
});
for await (const chunk of completion) {
console.log(JSON.stringify(chunk));
}
}
main();
curl
Remplacez {WorkspaceId} par votre ID d'espace de travail. Les URL varient selon la région. Obtenez une clé API à l'adresse https://www.alibabacloud.com/help/model-studio/get-api-key.
curl --location "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "qwen3.8-max",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Who are you?"
}
],
"stream":true
}'
Entrée image
Pour l'analyse d'images par les grands modèles, consultez Compréhension des images et vidéos.
Pythonimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
model="qwen3-vl-plus", # This example uses qwen3-vl-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/models
messages=[{"role": "user","content": [
{"type": "image_url",
"image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg"}},
{"type": "text", "text": "What is this?"},
]}]
)
print(completion.model_dump_json())
Node.jsimport OpenAI from "openai";
const openai = new OpenAI(
{
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
async function main() {
const response = await openai.chat.completions.create({
model: "qwen3-vl-plus", // This example uses qwen3-vl-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/models
messages: [{role: "user",content: [
{ type: "image_url",image_url: {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg"}},
{ type: "text", text: "What is this?" },
]}]
});
console.log(JSON.stringify(response));
}
main();
curl
Remplacez {WorkspaceId} par votre ID d'espace de travail. Les URL varient selon la région. Obtenez une clé API à l'adresse https://www.alibabacloud.com/help/model-studio/get-api-key.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"model": "qwen3-vl-plus",
"messages": [{
"role": "user",
"content": [
{"type": "image_url","image_url": {"url": "https://dashscope.oss-cn-beijing.aliyuncs.com/images/dog_and_girl.jpeg"}},
{"type": "text","text": "What is this?"}
]}]
}'
Entrée vidéo
L'exemple suivant transmet une liste d'images. Pour les autres usages, dont les fichiers vidéo, consultez Compréhension visuelle.
Pythonimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
# This example uses qwen3-vl-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/models
model="qwen3-vl-plus",
messages=[{
"role": "user",
"content": [
{
"type": "video",
"video": [
"https://img.alicdn.com/imgextra/i3/O1CN01K3SgGo1eqmlUgeE9b_!!6000000003923-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01BjZvwg1Y23CF5qIRB_!!6000000003000-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01Ib0clU27vTgBdbVLQ_!!6000000007859-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i1/O1CN01aygPLW1s3EXCdSN4X_!!6000000005710-0-tps-3840-2160.jpg"]
},
{
"type": "text",
"text": "Describe the specific process in this video"
}]}]
)
print(completion.model_dump_json())
Node.js// Make sure you have specified "type": "module" in package.json
import OpenAI from "openai";
const openai = new OpenAI({
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
});
async function main() {
const response = await openai.chat.completions.create({
// This example uses qwen3-vl-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/models
model: "qwen3-vl-plus",
messages: [{
role: "user",
content: [
{
type: "video",
video: [
"https://img.alicdn.com/imgextra/i3/O1CN01K3SgGo1eqmlUgeE9b_!!6000000003923-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01BjZvwg1Y23CF5qIRB_!!6000000003000-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01Ib0clU27vTgBdbVLQ_!!6000000007859-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i1/O1CN01aygPLW1s3EXCdSN4X_!!6000000005710-0-tps-3840-2160.jpg"
]
},
{
type: "text",
text: "Describe the specific process in this video"
}
]}]
});
console.log(JSON.stringify(response));
}
main();
curl
Remplacez {WorkspaceId} par votre ID d'espace de travail. Les URL varient selon la région. Consultez Obtenir une clé API.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
"model": "qwen3-vl-plus",
"messages": [
{
"role": "user",
"content": [
{
"type": "video",
"video": [
"https://img.alicdn.com/imgextra/i3/O1CN01K3SgGo1eqmlUgeE9b_!!6000000003923-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01BjZvwg1Y23CF5qIRB_!!6000000003000-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i4/O1CN01Ib0clU27vTgBdbVLQ_!!6000000007859-0-tps-3840-2160.jpg",
"https://img.alicdn.com/imgextra/i1/O1CN01aygPLW1s3EXCdSN4X_!!6000000005710-0-tps-3840-2160.jpg"
]
},
{
"type": "text",
"text": "Describe the specific process in this video"
}
]
}
]
}'
Appel d'outils
Pour le code complet d'appel de fonction, consultez Appel de fonction.
Date limite des connaissances du modèleUn grand modèle génère ses réponses à partir de données d'entraînement ayant une date limite. Il ne connaît pas spontanément la date actuelle. À cette question, il peut renvoyer une date antérieure à la fin de son entraînement. Il ne s'agit pas d'un défaut de configuration. Pour obtenir l'heure actuelle exacte :
- Appel de fonction : définissez un outil
get_current_time pour obtenir l'heure réelle. Voir l'exemple ci-dessous.
- Injection dans le prompt système : ajoutez la date actuelle au message système, dynamiquement à chaque appel.
- Recherche web :
enable_search récupère des informations récentes, mais pas directement l'heure actuelle.
Pythonimport os
from openai import OpenAI
client = OpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
tools = [
# Tool 1: Get the current time
{
"type": "function",
"function": {
"name": "get_current_time",
"description": "Useful when you want to know the current time.",
"parameters": {} # Because getting the current time requires no input parameters, parameters is an empty dictionary
}
},
# Tool 2: Get the weather for a specified city
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Useful when you want to query the weather of a specified city.",
"parameters": {
"type": "object",
"properties": {
# A location must be provided to query the weather, so the parameter is set to location
"location": {
"type": "string",
"description": "A city or district, such as Beijing, Hangzhou, or Yuhang District."
}
},
"required": ["location"]
}
}
}
]
messages = [{"role": "user", "content": "What's the weather like in Hangzhou?"}]
completion = client.chat.completions.create(
model="qwen3.8-max", # This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
messages=messages,
tools=tools
)
print(completion.model_dump_json())
Node.jsimport OpenAI from "openai";
const openai = new OpenAI(
{
// If the environment variable is not configured, replace the following line with your Model Studio API key: apiKey: "sk-xxx",
// API keys vary by region. Get API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
}
);
const messages = [{"role": "user", "content": "What's the weather like in Hangzhou?"}];
const tools = [
// Tool 1: Get the current time
{
"type": "function",
"function": {
"name": "get_current_time",
"description": "Useful when you want to know the current time.",
// Because getting the current time requires no input parameters, parameters is empty
"parameters": {}
}
},
// Tool 2: Get the weather for a specified city
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Useful when you want to query the weather of a specified city.",
"parameters": {
"type": "object",
"properties": {
// A location must be provided to query the weather, so the parameter is set to location
"location": {
"type": "string",
"description": "A city or district, such as Beijing, Hangzhou, or Yuhang District."
}
},
"required": ["location"]
}
}
}
];
async function main() {
const response = await openai.chat.completions.create({
model: "qwen3.8-max", // This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
messages: messages,
tools: tools,
});
console.log(JSON.stringify(response));
}
main();
curl
Remplacez {WorkspaceId} par votre ID d'espace de travail. Les URL varient selon la région. Consultez Obtenir une clé API.
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is the weather like in Hangzhou?"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_current_time",
"description": "Useful when you want to know the current time.",
"parameters": {}
}
},
{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Useful when you want to query the weather of a specified city.",
"parameters": {
"type": "object",
"properties": {
"location":{
"type": "string",
"description": "A city or district, such as Beijing, Hangzhou, or Yuhang District."
}
},
"required": ["location"]
}
}
}
]
}'
Invocation asynchroneimport os
import asyncio
from openai import AsyncOpenAI
import platform
client = AsyncOpenAI(
# If the environment variable is not configured, replace the following line with your Model Studio API key: api_key="sk-xxx"
# If you use a model in the China (Beijing) region, you need to use the API KEY for the China (Beijing) region. Get the link: https://modelstudio.console.alibabacloud.com/?tab=model#/api-key
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
async def main():
response = await client.chat.completions.create(
messages=[{"role": "user", "content": "Who are you?"}],
model="qwen3.8-max", # This example uses qwen-plus. You can replace it with another model name as needed. Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
)
print(response.model_dump_json())
if platform.system() == "Windows":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
asyncio.run(main())
|