Alibaba Cloud Model Studio permet d'appeler des modèles via des interfaces compatibles OpenAI et le SDK DashScope.
Pour appeler l'API Qwen :
- Obtenez une clé API
- Configurez votre environnement de développement local
- Appelez l'API Qwen
Configuration du compte
-
Créez un compte : Si vous ne possédez pas encore de compte Alibaba Cloud, créez-en un.
En cas de problème, consultez Inscription d'un compte Alibaba Cloud .
-
Activez Model Studio : Utilisez votre compte Alibaba Cloud pour accéder à Alibaba Cloud Model Studio. Lisez et acceptez les Conditions d'utilisation pour activer le service. Si aucune boîte de dialogue relative aux Conditions d'utilisation n'apparaît, le service est déjà activé.
-
Obtenez une clé API : Accédez à la page API Key et cliquez sur Create API key. Utilisez ensuite cette clé API pour appeler les modèles.
-
Obtenez votre ID d'espace de travail : Lors de l'appel de modèles dans la région Chine (Pékin), Singapour, Japon (Tokyo), Allemagne (Francfort) ou Chine (Hong Kong), vous devez inclure l'ID d'espace de travail (WorkspaceId) dans l'URL de base. Vous pouvez le trouver sur la page Workspace Management.
Définir votre clé API comme variable d'environnement
Stockez votre clé API dans une variable d'environnement afin d'éviter le codage en dur des identifiants et de réduire les risques de sécurité.
Steps
Linux
Variable d'environnement permanente
Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.
-
Exécutez la commande suivante pour ajouter la variable d'environnement au fichier
~/.bashrc:# Replace YOUR_DASHSCOPE_API_KEY with your API key. echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bashrcVous pouvez également modifier manuellement le fichier
~/.bashrc.Edit manually
Exécutez la commande suivante pour ouvrir le fichier
~/.bashrc.nano ~/.bashrcAjoutez le contenu suivant au fichier.
# Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"Dans l'éditeur nano, appuyez sur Ctrl+X puis sur Y. Appuyez sur Entrée pour enregistrer et fermer le fichier.
-
Exécutez la commande suivante pour appliquer la modification :
source ~/.bashrc -
Ouvrez une nouvelle session et exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $DASHSCOPE_API_KEY
Variable d'environnement temporaire
Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY" -
Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $DASHSCOPE_API_KEY
macOS
Variable d'environnement permanente
Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.
-
Exécutez la commande suivante pour vérifier le type de Shell par défaut.
echo $SHELL -
Effectuez l'opération correspondant à votre type de Shell.
Zsh
-
Exécutez la commande suivante pour ajouter la variable d'environnement au fichier
~/.zshrc.# Replace YOUR_DASHSCOPE_API_KEY with your API key. echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.zshrcVous pouvez également modifier manuellement le fichier
~/.zshrc.Edit manually
Exécutez la commande suivante pour ouvrir le fichier de configuration.
nano ~/.zshrcAjoutez le contenu suivant au fichier.
# Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"Dans l'éditeur nano, appuyez sur Ctrl+X puis sur Y. Appuyez sur Entrée pour enregistrer et fermer le fichier.
-
Exécutez la commande suivante pour appliquer la modification :
source ~/.zshrc -
Ouvrez une nouvelle session et exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $DASHSCOPE_API_KEY
Bash
-
Exécutez la commande suivante pour ajouter la variable d'environnement au fichier
~/.bash_profile.# Replace YOUR_DASHSCOPE_API_KEY with your API key. echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bash_profileVous pouvez également modifier manuellement le fichier
~/.bash_profile.Edit manually
Exécutez la commande suivante pour ouvrir le fichier.
nano ~/.bash_profileAjoutez le contenu suivant au fichier.
# Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"Dans l'éditeur nano, appuyez sur Ctrl+X puis sur Y. Appuyez sur Entrée pour enregistrer et fermer le fichier.
-
Exécutez la commande suivante pour appliquer la modification :
source ~/.bash_profile -
Ouvrez une nouvelle session et exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $DASHSCOPE_API_KEY
-
Variable d'environnement temporaire
Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.
Les commandes suivantes fonctionnent uniquement pour Zsh et Bash.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY" -
Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $DASHSCOPE_API_KEY
Windows
Sous Windows, vous pouvez exporter des variables d'environnement via les Propriétés système, la ligne de commande ou PowerShell.
System Properties
Remarque
- La variable d'environnement configurée de cette manière reste active en permanence.
- La modification d'une variable d'environnement système nécessite des permissions d'administrateur.
- Une fois la variable d'environnement configurée, elle n'affecte pas les programmes déjà en cours d'exécution. Redémarrez vos IDE et fenêtres de commande, ou ouvrez une nouvelle ligne de commande, pour charger la nouvelle variable.
-
Appuyez sur
Win+Qsur votre bureau. Saisissez « Edit the system environment variables » dans la zone de recherche, puis cliquez pour ouvrir la fenêtre System Properties. -
Dans la fenêtre System Properties, cliquez sur Environment Variables. Dans la section System Variables, cliquez sur New, saisissez
DASHSCOPE_API_KEYcomme nom de variable etyour actual API Keycomme valeur de variable.
-
Cliquez sur OK dans les trois boîtes de dialogue.
-
Ouvrez CMD ou Windows PowerShell et exécutez la commande suivante pour vérifier que la variable d'environnement est effective.
-
CMD :
echo %DASHSCOPE_API_KEY%
-
Windows PowerShell :
echo $env:DASHSCOPE_API_KEY
-
CMD
Variable d'environnement permanente
Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. setx DASHSCOPE_API_KEY "YOUR_DASHSCOPE_API_KEY" -
Ouvrez une nouvelle session.
-
Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo %DASHSCOPE_API_KEY%
Variable d'environnement temporaire
Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. set DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY" -
Exécutez la commande suivante dans la session en cours pour vérifier que la variable d'environnement est effective :
echo %DASHSCOPE_API_KEY%
PowerShell
Variable d'environnement permanente
Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. [Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "YOUR_DASHSCOPE_API_KEY", [EnvironmentVariableTarget]::User) -
Ouvrez une nouvelle session.
-
Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :
echo $env:DASHSCOPE_API_KEY
Variable d'environnement temporaire
Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.
-
Exécutez la commande suivante :
# Replace YOUR_DASHSCOPE_API_KEY with your API key. $env:DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY" -
Exécutez la commande suivante dans la session en cours pour vérifier que la variable d'environnement est effective :
echo $env:DASHSCOPE_API_KEY
Choisir un langage de développement
Sélectionnez un langage ou un outil pour appeler les API de modèles.
Python
Étape 1 : Configurer Python
Check your Python version
Exécutez cette commande pour vérifier si Python et pip sont installés :
Python 3,8 ou version ultérieure est requis. Pour les instructions d'installation, consultez Installer Python.
python -V
pip --version
Par exemple, sous Windows Command Prompt :
C:\Users\Administrator>python -V
Python 3.13.2
C:\Users\Administrator>pip --version
pip 24.3.1 from C:\Users\Administrator\AppData\Local\Programs\Python\Python313\Lib\site-packages\pip (python 3.13)
FAQ
Q : Les commandes python -V et pip --version renvoient des erreurs :
'python' is not recognized as an internal or external command, operable program or batch file.'pip' is not recognized as an internal or external command, operable program or batch file.-bash: python: command not found-bash: pip: command not found
Essayez les solutions suivantes :
Windows
-
Vérifiez que vous avez installé Python en suivant Installer Python et que vous avez ajouté python.exe à la variable d'environnement PATH.
Lors de l'installation de Python 3.13.2, sélectionnez Add python.exe to PATH en bas de l'installateur pour ajouter Python aux variables d'environnement système, puis cliquez sur Install Now pour terminer l'installation.
-
Si Python et PATH sont correctement configurés mais que l'erreur persiste, fermez votre terminal actuel et ouvrez-en un nouveau.
Linux et macOS
-
Vérifiez que vous avez installé Python en suivant Installer Python.
-
Si Python est installé mais que l'erreur persiste, exécutez
which python pippour vérifier sipythonetpipexistent dans votre système.-
Si ce résultat apparaît, fermez la fenêtre de terminal actuelle, ouvrez-en une nouvelle et réessayez.
/usr/bin/python /usr/bin/pip -
Si ce résultat est renvoyé, exécutez à nouveau la requête
which python3 pip3./usr/bin/which: no python in (/root/.local/bin:/root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin) /usr/bin/which: no pip in (/root/.local/bin:/root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin)Si le résultat renvoyé correspond à celui affiché, utilisez
python3 -Vetpip3 --versionpour vérifier la version./usr/bin/python3 /usr/bin/pip3
-
Set up a virtual environment (optional)
Si Python est déjà installé, créez un environnement virtuel pour installer le SDK OpenAI Python ou le SDK DashScope Python afin d'éviter les conflits de dépendances.
-
Créer un environnement virtuel
Créez un environnement virtuel nommé .venv :
# If this fails, replace python with python3 python -m venv .venv -
Activer l'environnement virtuel
Sous Windows, activez l'environnement virtuel :
.venv\Scripts\activateSous macOS ou Linux, exécutez :
source .venv/bin/activate
Install the OpenAI Python SDK or DashScope Python SDK
Vous pouvez appeler des modèles sur Model Studio à l'aide du SDK OpenAI Python ou du SDK DashScope Python.
Installer le SDK OpenAI Python
Installez ou mettez à jour le SDK OpenAI Python :
# If this fails, replace pip with pip3
pip install -U openai
Recherchez le message Successfully installed ... openai-x.x.x pour confirmer l'installation.
Installer le SDK DashScope Python
Installez ou mettez à jour le SDK DashScope Python :
# If this fails, replace pip with pip3
pip install -U dashscope
Recherchez le message Successfully installed ... dashscope-x.x.x pour confirmer l'installation.
Étape 2 : Appeler l'API
SDK OpenAI Python
Une fois Python et le SDK OpenAI Python installés, envoyez votre première requête API.
-
Créez un fichier nommé
hello_qwen.py. -
Copiez ce code dans
hello_qwen.pyet enregistrez-le.import os from openai import OpenAI try: client = OpenAI( # If the environment variable is not configured, replace with: api_key="sk-xxx" api_key=os.getenv("DASHSCOPE_API_KEY"), # The following URL is for the Singapore region. When calling, 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( model="qwen3.8-max", messages=[ {'role': 'system', 'content': 'You are a helpful assistant.'}, {'role': 'user', 'content': 'Who are you?'} ] ) print(completion.choices[0].message.content) except Exception as e: print(f"Error message: {e}") print("See: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code") -
Exécutez
python hello_qwen.pyoupython3 hello_qwen.pydepuis la ligne de commande.Si le message
No such file or directorys'affiche, spécifiez le chemin complet vers le fichier.Le résultat est le suivant :
I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.
SDK DashScope Python
Une fois Python et le SDK DashScope Python installés, envoyez votre première requête API.
-
Créez un fichier nommé
hello_qwen.py. -
Copiez ce code dans
hello_qwen.pyet enregistrez-le.import os from dashscope import MultiModalConversation import dashscope # The following URL is for the Singapore region. When calling, replace {WorkspaceId} with your actual workspace ID. URLs vary by region. dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1' messages = [ {'role': 'system', 'content': [{'text': 'You are a helpful assistant.'}]}, {'role': 'user', 'content': [{'text': 'Who are you?'}]} ] response = MultiModalConversation.call( # Singapore, US (Virginia), and China (Beijing) API keys are not interchangeable. Get your API key: https://www.alibabacloud.com/help/model-studio/get-api-key # If the environment variable is not configured, replace with: api_key = "sk-xxx" api_key=os.getenv("DASHSCOPE_API_KEY"), model="qwen3.8-max", messages=messages ) if response.status_code == 200: print(response.output.choices[0].message.content[0]["text"]) else: print(f"HTTP status code: {response.status_code}") print(f"Error code: {response.code}") print(f"Error message: {response.message}") print("See: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code") -
Exécutez
python hello_qwen.pyoupython3 hello_qwen.pydepuis la ligne de commande.RemarqueLa commande de cet exemple doit être exécutée depuis le répertoire contenant le fichier Python. Pour l'exécuter depuis un autre emplacement, spécifiez le chemin complet.
Le résultat est le suivant :
I am a large-scale language model from Alibaba Cloud. My name is Qwen.
Node.js
Étape 1 : Configurer votre environnement Node.js
Check your Node.js installation
Vérifiez si Node.js et npm sont installés :
node -v
npm -v
Par exemple, sous Windows Command Prompt :
C:\Users\Administrator>node -v
v22.14.0
C:\Users\Administrator>npm -v
10.9.2
Cette commande affiche votre version actuelle de Node.js. Si Node.js n'est pas installé, téléchargez-le depuis le site officiel de Node.js.
Install the model calling SDK
Exécutez cette commande dans votre terminal :
npm install --save openai
# Or
yarn add openai
RemarqueEn cas d'échec de l'installation, configurez un miroir de registre :
npm config set registry https://registry.npmmirror.com/
Après avoir configuré le miroir, relancez la commande d'installation du SDK.
Recherchez le message added xx package in xxs pour confirmer l'installation. Vérifiez la version avec : npm list openai.
Étape 2 : Appeler l'API du modèle
-
Créez un fichier nommé
hello_qwen.mjs. -
Copiez ce code dans le fichier.
import OpenAI from "openai"; try { const openai = new OpenAI( { // If the environment variable is not configured, replace with: apiKey: "sk-xxx" apiKey: process.env.DASHSCOPE_API_KEY, // The following URL is for the Singapore region. When calling, replace {WorkspaceId} with your actual workspace ID. URLs vary by region. baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1" } ); const completion = await openai.chat.completions.create({ model: "qwen3.8-max", messages: [ { role: "system", content: "You are a helpful assistant." }, { role: "user", content: "Who are you?" } ], }); console.log(completion.choices[0].message.content); } catch (error) { console.log(`Error message: ${error}`); console.log("See: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code"); } -
Exécutez cette commande pour envoyer une requête API.
node hello_qwen.mjsRemarque
- Exécutez cette commande depuis le répertoire contenant
hello_qwen.mjs. Pour l'exécuter depuis n'importe quel emplacement, spécifiez le chemin complet vers le fichier. - Assurez-vous que le SDK est installé dans le même répertoire que
hello_qwen.mjs. S'ils se trouvent dans des répertoires différents, le messageCannot find package 'openai' imported from xxxs'affichera.
Après une exécution réussie, le résultat est le suivant :
I am a language model from Alibaba Cloud. My name is Qwen. - Exécutez cette commande depuis le répertoire contenant
Java
Étape 1 : Configurer votre environnement Java
Check your Java version
Exécutez cette commande dans votre terminal :
java -version
# (Optional) If you use Maven to manage and build Java projects, ensure Maven is installed
mvn --version
Par exemple, sous Windows Command Prompt :
C:\Users\Administrator>java --version
java 23.0.2 2025-01-21
Java(TM) SE Runtime Environment (build 23.0.2+7-58)
Java HotSpot(TM) 64-Bit Server VM (build 23.0.2+7-58, mixed mode, sharing)
C:\Users\Administrator>mvn --version
Apache Maven 3.9.9 (8e8579a9e76f7d015ee5ec7bfcdc97d260186937)
Maven home: C:\Program Files\apache-maven-3.9.9
Java version: 23.0.2
Java 8 ou version ultérieure est requis pour le SDK DashScope Java. Par exemple, openjdk version "16.0.1" 2021-04-20 correspond à Java 16. Si Java n'est pas installé ou si la version est inférieure à Java 8, téléchargez-le et installez-le depuis Téléchargements Java.
Install the model calling SDK
Installez le SDK DashScope Java. Pour la dernière version, consultez SDK DashScope Java. Ajoutez cette dépendance en remplaçant the-latest-version par le numéro de la dernière version.
XML
-
Ouvrez le fichier
pom.xmlde votre projet Maven. -
Ajoutez cette dépendance à la balise
<dependencies>:<dependency> <groupId>com.alibaba</groupId> <artifactId>dashscope-sdk-java</artifactId> <!-- Replace 'the-latest-version' with the latest version number: https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java --> <version>the-latest-version</version> </dependency> -
Enregistrez le fichier
pom.xml. -
Exécutez une commande Maven telle que
mvn compileoumvn clean installpour mettre à jour les dépendances. Maven téléchargera automatiquement le SDK DashScope Java et l'ajoutera à votre projet.
Par exemple, dans IntelliJ IDEA sous Windows :
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dashscope-sdk-java</artifactId>
<!-- Replace 'the-latest-version' with the latest version number: https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java -->
<version>2.18.2</version>
</dependency>
</dependencies>
</project>
~\Desktop\test_project
mvn compile
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< org.example:test_project >----------------------
[INFO] Building test_project 1.0-SNAPSHOT
[INFO] from pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- resources:3.3.1:resources (default-resources) @ test_project ---
[INFO] skip non existing resourceDirectory C:\Users\Administrator\Desktop\test_project\src\main\resources
[INFO]
[INFO] --- compiler:3.13.0:compile (default-compile) @ test_project ---
[INFO] Nothing to compile - all classes are up to date.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.627 s
[INFO] Finished at: 2025-02-17T13:15:30+08:00
[INFO] ------------------------------------------------------------------------
Gradle
-
Ouvrez le fichier
build.gradlede votre projet Gradle. -
Ajoutez cette dépendance au bloc
dependencies:dependencies { // Replace 'the-latest-version' with the latest version number: https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java implementation group: 'com.alibaba', name: 'dashscope-sdk-java', version: 'the-latest-version' } -
Enregistrez le fichier
build.gradle. -
Dans votre terminal, accédez au répertoire racine de votre projet et exécutez cette commande Gradle pour mettre à jour les dépendances. Elle téléchargera automatiquement le SDK DashScope Java et l'ajoutera à votre projet.
./gradlew build --refresh-dependencies
Par exemple, dans IntelliJ IDEA sous Windows :
Exemple complet de fichier build.gradle :
group = 'org.example'
version = '1.0-SNAPSHOT'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.apache.groovy:groovy:4.0.14'
testImplementation platform('org.junit:junit-bom:5.10.0')
testImplementation 'org.junit.jupiter:junit-jupiter'
implementation group: 'com.alibaba', name: 'dashscope-sdk-java', version: '2.18.2'
}
test {
useJUnitPlatform()
}
Après l'exécution de la commande de build, le terminal affiche :
~/Desktop/test_project
./gradlew build --refresh-dependencies
Welcome to Gradle 8.10!
Here are the highlights of this release:
- Support for Java 23
- Faster configuration cache
- Better configuration cache reports
For more details see https://docs.gradle.org/8.10/release-notes.html
BUILD SUCCESSFUL in 7m 51s
2 actionable tasks: 2 executed
Étape 2 : Appeler l'API
Exécutez ce code pour appeler l'API du modèle.
import java.util.Arrays;
import java.util.Collections;
import java.lang.System;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversation;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationParam;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationResult;
import com.alibaba.dashscope.common.MultiModalMessage;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.protocol.Protocol;
public class Main {
public static MultiModalConversationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
// The following URL is for the Singapore region. When calling, replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
MultiModalConversation conv = new MultiModalConversation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
MultiModalMessage systemMsg = MultiModalMessage.builder()
.role(Role.SYSTEM.getValue())
.content(Arrays.asList(Collections.singletonMap("text", "You are a helpful assistant.")))
.build();
MultiModalMessage userMsg = MultiModalMessage.builder()
.role(Role.USER.getValue())
.content(Arrays.asList(Collections.singletonMap("text", "Who are you?")))
.build();
MultiModalConversationParam param = MultiModalConversationParam.builder()
// Singapore, US (Virginia), and China (Beijing) API keys are not interchangeable. Get your API key: https://www.alibabacloud.com/help/model-studio/get-api-key
// If the environment variable is not configured, replace with: .apiKey("sk-xxx")
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
// Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
.model("qwen3.8-max")
.messages(Arrays.asList(systemMsg, userMsg))
.build();
return conv.call(param);
}
public static void main(String[] args) {
try {
MultiModalConversationResult result = callWithMessage();
System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent().get(0).get("text"));
} catch (ApiException | NoApiKeyException | InputRequiredException e) {
System.err.println("Error message: "+e.getMessage());
System.out.println("See: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code");
}
System.exit(0);
}
}
Le résultat est le suivant :
I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.
curl
Appelez des modèles sur Model Studio à l'aide des endpoints HTTP compatibles OpenAI ou DashScope. Pour les modèles pris en charge, consultez la Liste des modèles.
RemarqueSi DASHSCOPE_API_KEY n'est pas défini, remplacez -H "Authorization: Bearer $DASHSCOPE_API_KEY" par -H "Authorization: Bearer sk-xxx".
HTTP compatible OpenAI
L'URL de cet exemple utilise la région Singapour ; remplacez {WorkspaceId} par votre ID d'espace de travail réel. Les URL varient selon la région. Si vous utilisez la région Chine (Pékin), remplacez l'URL par https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions.
Envoyez la requête API :
Windows
Exécutez cette commande dans l'Invite de commandes :
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?\"
}
]
}"
Linux and macOS
Exécutez cette commande dans le Terminal :
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?"
}
]
}'
Après l'envoi de la requête API, vous recevez cette réponse :
{
"choices": [
{
"message": {
"role": "assistant",
"content": "I am a large-scale language model from Alibaba Cloud. My name is Qwen."
},
"finish_reason": "stop",
"index": 0,
"logprobs": null
}
],
"object": "chat.completion",
"usage": {
"prompt_tokens": 22,
"completion_tokens": 16,
"total_tokens": 38
},
"created": 1728353155,
"system_fingerprint": null,
"model": "qwen3.8-max",
"id": "chatcmpl-39799876-eda8-9527-9e14-2214d641cf9a"
}
DashScope HTTP
L'URL de cet exemple utilise la région Singapour ; remplacez {WorkspaceId} par votre ID d'espace de travail réel. Les URL varient selon la région.
- Si vous utilisez la région États-Unis (Virginie), remplacez l'URL par
https://dashscope-us.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation. - Si vous utilisez la région Chine (Pékin), remplacez l'URL par
https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation. Remplacez {WorkspaceId} par votre ID d'espace de travail.
Envoyez la requête API :
Windows
Exécutez cette commande dans l'Invite de commandes :
curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation" ^
-H "Authorization: Bearer %DASHSCOPE_API_KEY%" ^
-H "Content-Type: application/json" ^
-d "{
\"model\": \"qwen3.8-max\",
\"input\": {
\"messages\": [
{
\"role\": \"system\",
\"content\": [{\"text\": \"You are a helpful assistant.\"}]
},
{
\"role\": \"user\",
\"content\": [{\"text\": \"Who are you?\"}]
}
]
},
\"parameters\": {
\"result_format\": \"message\"
}
}"
Linux and macOS
Exécutez cette commande dans le Terminal :
curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.8-max",
"input":{
"messages":[
{
"role": "system",
"content": [{"text": "You are a helpful assistant."}]
},
{
"role": "user",
"content": [{"text": "Who are you?"}]
}
]
},
"parameters": {
"result_format":"message"
}
}'
Après l'envoi de la requête API, vous recevez cette réponse :
{
"output": {
"choices": [
{
"finish_reason": "stop",
"message": {
"role": "assistant",
"content": [{"text": "I am a large-scale language model from Alibaba Cloud. My name is Qwen."}]
}
}
]
},
"usage": {
"total_tokens": 38,
"output_tokens": 16,
"input_tokens": 22
},
"request_id": "87f776d7-3c82-9d39-b238-d1ad38c9b6a9"
}
Autres langages
Appeler l'API du modèlepackage main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"os"
)
type Message struct {
Role string `json:"role"`
Content string `json:"content"`
}
type RequestBody struct {
Model string `json:"model"`
Messages []Message `json:"messages"`
}
func main() {
// Create an HTTP client
client := &http.Client{}
// Build the request body
requestBody := RequestBody{
// Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
Model: "qwen3.8-max",
Messages: []Message{
{
Role: "system",
Content: "You are a helpful assistant.",
},
{
Role: "user",
Content: "Who are you?",
},
},
}
jsonData, err := json.Marshal(requestBody)
if err != nil {
log.Fatal(err)
}
// The following URL is for the Singapore region. When calling, replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
req, err := http.NewRequest("POST", "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/chat/completions", bytes.NewBuffer(jsonData))
if err != nil {
log.Fatal(err)
}
// Set request headers
// Singapore, US (Virginia), and China (Beijing) API keys are not interchangeable. Get your API key: https://www.alibabacloud.com/help/model-studio/get-api-key
// If the environment variable is not configured, replace with: apiKey := "sk-xxx"
apiKey := os.Getenv("DASHSCOPE_API_KEY")
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
// Send the request
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
// Read the response body
bodyText, err := io.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
// Print the response
fmt.Printf("%s\n", bodyText)
}
<?php
// The following URL is for the Singapore region. When calling, 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';
// Singapore, US (Virginia), and China (Beijing) API keys are not interchangeable. Get your API key: https://www.alibabacloud.com/help/model-studio/get-api-key
// If the environment variable is not configured, replace with: $apiKey = "sk-xxx"
$apiKey = getenv('DASHSCOPE_API_KEY');
// Set request headers
$headers = [
'Authorization: Bearer '.$apiKey,
'Content-Type: application/json'
];
// Set request body
$data = [
"model" => "qwen3.8-max",
"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);
// Output the response
echo $response;
?>
using System.Net.Http.Headers;
using System.Text;
class Program
{
private static readonly HttpClient httpClient = new HttpClient();
static async Task Main(string[] args)
{
// Singapore, US (Virginia), and China (Beijing) API keys are not interchangeable. Get your API key: https://www.alibabacloud.com/help/model-studio/get-api-key
// If the environment variable is not configured, replace with: string? apiKey = "sk-xxx"
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;
}
// The following URL is for the Singapore region. When calling, 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";
// Model list: https://www.alibabacloud.com/help/model-studio/getting-started/models
string jsonContent = @"{
""model"": ""qwen3.8-max"",
""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);
// Output 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);
// Handle the response
if (response.IsSuccessStatusCode)
{
return await response.Content.ReadAsStringAsync();
}
else
{
return $"Request failed: {response.StatusCode}";
}
}
}
}
Référence de l'API
- Pour les paramètres d'entrée et de sortie, consultez la Référence de l'API Qwen.
- Pour les autres modèles, consultez la Liste des modèles.
FAQ
Comment corriger l'erreurModel.AccessDeniedaprès l'appel de l'API du modèle ?
R : Cette erreur survient lorsque vous utilisez une clé API provenant d'un sous-espace de travail. Un sous-espace de travail ne peut pas accéder aux applications ou aux modèles de l'espace de travail par défaut. Pour utiliser une clé API de sous-espace de travail, l'administrateur du compte racine doit accorder l'autorisation de modèle pour le sous-espace de travail correspondant (par exemple, cette rubrique utilise le modèle Qwen-Plus). Pour les étapes détaillées, consultez Configurer les permissions d'appel de modèle.
Étapes suivantes
Explorer d'autres modèles | Le code d'exemple utilise |
Découvrir les fonctionnalités avancées | Le code d'exemple couvre uniquement les questions-réponses de base. Pour en savoir plus sur l'API Qwen, notamment la sortie en streaming, la sortie structurée et l'appel de fonctions, consultez la Présentation du modèle de génération de texte. |
Essayer les modèles dans le navigateur | Si vous souhaitez interagir avec les modèles via une boîte de dialogue, comme sur Qwen Chat, accédez au Playground. |
Appeler un modèle entraîné personnalisé | Si vous avez déployé un modèle entraîné personnalisé sur Model Studio, utilisez le code du modèle (et non l'ID du modèle) figurant sur la page de déploiement du modèle comme paramètre |