Tous les produits
Search
Centre de documentation

Alibaba Cloud Model Studio:Make your first API call to Qwen

Dernière mise à jour :Sep 07, 2026

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

  1. 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 .

  2. 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é.

  3. 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.

  4. 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.

  1. 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'" >> ~/.bashrc
    

    Vous pouvez également modifier manuellement le fichier ~/.bashrc.

    Edit manually

    Exécutez la commande suivante pour ouvrir le fichier ~/.bashrc.

    nano ~/.bashrc
    

    Ajoutez 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.

  2. Exécutez la commande suivante pour appliquer la modification :

    source ~/.bashrc
    
  3. 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.

  1. Exécutez la commande suivante :

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
    
  2. 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.

  1. Exécutez la commande suivante pour vérifier le type de Shell par défaut.

    echo $SHELL
    
  2. Effectuez l'opération correspondant à votre type de Shell.

    Zsh

    1. 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'" >> ~/.zshrc
      

      Vous pouvez également modifier manuellement le fichier ~/.zshrc.

      Edit manually

      Exécutez la commande suivante pour ouvrir le fichier de configuration.

      nano ~/.zshrc
      

      Ajoutez 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.

    2. Exécutez la commande suivante pour appliquer la modification :

      source ~/.zshrc
      
    3. 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

    1. 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_profile
      

      Vous pouvez également modifier manuellement le fichier ~/.bash_profile.

      Edit manually

      Exécutez la commande suivante pour ouvrir le fichier.

      nano ~/.bash_profile
      

      Ajoutez 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.

    2. Exécutez la commande suivante pour appliquer la modification :

      source ~/.bash_profile
      
    3. 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.

  1. Exécutez la commande suivante :

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
    
  2. 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.
  1. Appuyez sur Win+Q sur votre bureau. Saisissez « Edit the system environment variables » dans la zone de recherche, puis cliquez pour ouvrir la fenêtre System Properties.

  2. Dans la fenêtre System Properties, cliquez sur Environment Variables. Dans la section System Variables, cliquez sur New, saisissez DASHSCOPE_API_KEY comme nom de variable et your actual API Key comme valeur de variable.

    image

  3. Cliquez sur OK dans les trois boîtes de dialogue.

  4. 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%
      

      image

    • Windows PowerShell :

      echo $env:DASHSCOPE_API_KEY
      

      image

CMD

Variable d'environnement permanente

Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.

  1. Exécutez la commande suivante :

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    setx DASHSCOPE_API_KEY "YOUR_DASHSCOPE_API_KEY"
    
  2. Ouvrez une nouvelle session.

  3. Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :

    echo %DASHSCOPE_API_KEY%
    

    image

Variable d'environnement temporaire

Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.

  1. Exécutez la commande suivante :

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    set DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
    
  2. Exécutez la commande suivante dans la session en cours pour vérifier que la variable d'environnement est effective :

    echo %DASHSCOPE_API_KEY%
    

    image

PowerShell

Variable d'environnement permanente

Pour rendre la clé API disponible dans toutes les sessions futures, exportez-la de manière permanente.

  1. 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)
    
  2. Ouvrez une nouvelle session.

  3. Exécutez la commande suivante pour vérifier que la variable d'environnement est effective :

    echo $env:DASHSCOPE_API_KEY
    

    image

Variable d'environnement temporaire

Pour utiliser la clé API uniquement dans la session en cours, exportez-la temporairement.

  1. Exécutez la commande suivante :

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    $env:DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY"
    
  2. 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
    

    image

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

  1. 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.

  2. 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

  1. Vérifiez que vous avez installé Python en suivant Installer Python.

  2. Si Python est installé mais que l'erreur persiste, exécutez which python pip pour vérifier si python et pip existent 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 -V et pip3 --version pour 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.

  1. Créer un environnement virtuel

    Créez un environnement virtuel nommé .venv :

    # If this fails, replace python with python3
    python -m venv .venv
    
  2. Activer l'environnement virtuel

    Sous Windows, activez l'environnement virtuel :

    .venv\Scripts\activate
    

    Sous 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.

  1. Créez un fichier nommé hello_qwen.py.

  2. Copiez ce code dans hello_qwen.py et 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")
    
  3. Exécutez python hello_qwen.py ou python3 hello_qwen.py depuis la ligne de commande.

    Si le message No such file or directory s'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.

  1. Créez un fichier nommé hello_qwen.py.

  2. Copiez ce code dans hello_qwen.py et 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")
    
  3. Exécutez python hello_qwen.py ou python3 hello_qwen.py depuis 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

  1. Créez un fichier nommé hello_qwen.mjs.

  2. 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");
    }
    
  3. Exécutez cette commande pour envoyer une requête API.

    node hello_qwen.mjs
    

    Remarque

    • 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 message Cannot find package 'openai' imported from xxx s'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.
    

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

  1. Ouvrez le fichier pom.xml de votre projet Maven.

  2. 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>
    
  3. Enregistrez le fichier pom.xml.

  4. Exécutez une commande Maven telle que mvn compile ou mvn clean install pour 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

  1. Ouvrez le fichier build.gradle de votre projet Gradle.

  2. 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'
    }
    
  3. Enregistrez le fichier build.gradle.

  4. 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èle
package 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

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 qwen3.8-max. Model Studio prend également en charge d'autres modèles Qwen. Consultez la Liste des modèles pour connaître les modèles pris en charge et leurs références API.

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 model lors des appels API. Pour plus de détails, consultez Appels post-déploiement.