Make your first API call to Qwen - Alibaba Cloud Model Studio: Central de Documentação do Alibaba Cloud

O Alibaba Cloud Model Studio oferece suporte a chamadas de API para modelos por meio de interfaces compatíveis com OpenAI e do DashScope SDK.

Para chamar a API do Qwen:

Obtenha uma chave de API
Configure seu ambiente de desenvolvimento local
Chame a API do Qwen

Configuração da conta

Crie uma conta: Se você ainda não possui uma conta Alibaba Cloud, crie uma.

Se encontrar problemas, consulte Register an Alibaba Cloud account .
Ative o Model Studio: Use sua conta Alibaba Cloud para acessar o Alibaba Cloud Model Studio. Leia e aceite os Termos de Serviço para ativar o service. Se nenhuma caixa de diálogo dos Termos de Serviço aparecer, o service já está ativado.
Obtenha uma chave de API: Acesse a página API Key e clique em Create API key. Em seguida, use a chave de API para chamar os modelos.

Não é necessário selecionar um modelo ao criar uma chave de API. Especifique o modelo a ser chamado por meio do parâmetro model no corpo da solicitação, por exemplo, model="qwen-plus". Para modelos suportados, consulte Model list. Para limitar os modelos que uma chave de API pode chamar, selecione a permissão Custom ao criar a chave e ative a opção Model access scope. Assim, a chave poderá chamar apenas os modelos selecionados.
Obtenha seu ID de workspace: Ao chamar modelos na região China (Beijing), Singapore, Japan (Tokyo), Germany (Frankfurt) ou China (Hong Kong), inclua o ID do workspace (WorkspaceId) na Base URL. Encontre-o na página Workspace Management. Para modelos na região US (Virginia), domínios específicos de workspace não são suportados. Não inclua o ID do workspace (WorkspaceId) na Base URL — use {WorkspaceId}.us-east-1.maas.aliyuncs.com diretamente como domínio do endpoint.

Defina sua chave de API como variável de ambiente

Armazene sua chave de API em uma variável de ambiente para evitar codificar credenciais diretamente no código e reduzir riscos de segurança.

Etapas

Linux

Permanente

Para tornar a chave de API disponível em todas as novas sessões do usuário atual, defina-a como uma variável de ambiente permanente.

Execute o comando a seguir para adicionar a configuração da variável de ambiente ao arquivo ~/.bashrc.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bashrc

Alternativamente, edite manualmente o arquivo ~/.bashrc.

Modificação manual

Execute o comando a seguir para abrir o arquivo ~/.bashrc.

nano ~/.bashrc Adicione o conteúdo a seguir ao arquivo de configuração.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

No editor nano, pressione Ctrl+X, depois Y e, em seguida, Enter para salvar e fechar o arquivo. 2. Execute o comando a seguir para aplicar as alterações.

source ~/.bashrc 3. Abra uma nova janela de terminal e execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $DASHSCOPE_API_KEY

Temporária

Para usar a variável de ambiente apenas na sessão atual, defina-a como uma variável de ambiente temporária.

Execute o comando a seguir.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

Execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $DASHSCOPE_API_KEY

macOS

Permanente

Para tornar a chave de API disponível em todas as novas sessões do usuário atual, defina-a como uma variável de ambiente permanente.

Execute o comando a seguir no terminal para verificar o tipo de shell padrão.

echo $SHELL
Prossiga conforme o tipo de shell padrão.
Zsh
1. Execute o comando a seguir para adicionar a configuração da variável de ambiente ao arquivo ~/.zshrc.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.zshrc

Alternativamente, edite manualmente o arquivo ~/.zshrc.

Modificação manual

Execute o comando a seguir para abrir o arquivo de configuração do shell.

nano ~/.zshrc Adicione o conteúdo a seguir ao arquivo de configuração.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

No editor nano, pressione Ctrl+X, depois Y e, em seguida, Enter para salvar e fechar o arquivo. 2. Execute o comando a seguir para aplicar as alterações.

source ~/.zshrc 3. Abra uma nova janela de terminal e execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $DASHSCOPE_API_KEY

Bash

Execute o comando a seguir para adicionar a configuração da variável de ambiente ao arquivo ~/.bash_profile.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bash_profile

Alternativamente, edite manualmente o arquivo ~/.bash_profile.

Modificação manual

Execute o comando a seguir para abrir o arquivo de configuração do shell.

nano ~/.bash_profile Adicione o conteúdo a seguir ao arquivo de configuração.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

No editor nano, pressione Ctrl+X, depois Y e, em seguida, Enter para salvar e fechar o arquivo. 2. Execute o comando a seguir para aplicar as alterações.

source ~/.bash_profile 3. Abra uma nova janela de terminal e execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $DASHSCOPE_API_KEY

Temporária

Para usar a variável de ambiente apenas na sessão atual, defina-a como uma variável de ambiente temporária.

O comando a seguir aplica-se tanto ao Zsh quanto ao Bash.

Execute o comando a seguir.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

Execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $DASHSCOPE_API_KEY

Windows

No Windows, configure uma variável de ambiente usando as Propriedades do Sistema, o Prompt de Comando ou o Windows PowerShell.

Propriedades do Sistema

As variáveis de ambiente configuradas dessa forma são permanentes.
São necessárias permissões de administrador para modificar variáveis de ambiente do sistema.
Alterações nas variáveis de ambiente não afetam aplicativos em execução, incluindo janelas do Prompt de Comando e IDEs. Reinicie esses aplicativos ou abra uma nova sessão de linha de comando para aplicar as alterações.

Na área de trabalho do Windows, pressione Win+Q, pesquise por Edit the system environment variables na caixa de pesquisa e clique em no resultado para abrir a janela System Properties.
Na janela System Properties, clique em Environment Variable e, na seção System variables, clique em Create. Em Variable Name, insira DASHSCOPE_API_KEY e, em Variable value, insira sua DashScope API Key.
Clique em OK nas três janelas abertas para salvar as alterações e fechá-las.
Abra uma nova janela do Prompt de Comando ou do Windows PowerShell e execute o comando apropriado para verificar se a variável de ambiente foi definida.
- No Prompt de Comando:
  
  echo %DASHSCOPE_API_KEY%

Microsoft Windows [Version 10.0.19045.5371]
(c) Microsoft Corporation. All rights reserved.
C:\Windows\system32>echo %DASHSCOPE_API_KEY%
sk-ee166797fe40xxx
C:\Windows\system32>

No Windows PowerShell:

echo $env:DASHSCOPE_API_KEY

Windows PowerShell
Copyright (C) Microsoft Corporation. All rights reserved.
Try the new cross-platform PowerShell https://aka.ms/pscore6
PS C:\Windows\system32> echo $env:DASHSCOPE_API_KEY
sk-ee166797fe40xxx
PS C:\Windows\system32>

Prompt de Comando

Permanente

Para tornar a variável de ambiente da chave de API disponível em todas as novas sessões do usuário atual, siga estas etapas.

Execute o comando a seguir no Prompt de Comando.

REM Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
setx DASHSCOPE_API_KEY "YOUR_DASHSCOPE_API_KEY"

Abra uma nova janela do Prompt de Comando para que a alteração tenha efeito.
Na nova janela do Prompt de Comando, execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo %DASHSCOPE_API_KEY%

Temporária

Para usar a variável de ambiente apenas na sessão atual, execute o comando a seguir no Prompt de Comando.

REM Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
set DASHSCOPE_API_KEY=YOUR_DASHSCOPE_API_KEY

Execute o comando a seguir na mesma sessão para verificar se a variável de ambiente foi definida.

echo %DASHSCOPE_API_KEY%

Windows PowerShell

Permanente

Para tornar a variável de ambiente da chave de API disponível em todas as novas sessões do usuário atual, siga estas etapas.

Execute o comando a seguir no Windows PowerShell.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
[Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "YOUR_DASHSCOPE_API_KEY", [EnvironmentVariableTarget]::User)

Abra uma nova janela do Windows PowerShell para que a alteração tenha efeito.
Na nova janela do Windows PowerShell, execute o comando a seguir para verificar se a variável de ambiente foi definida.

echo $env:DASHSCOPE_API_KEY

Temporária

Para usar a variável de ambiente apenas na sessão atual, execute o comando a seguir no PowerShell.

# Replace YOUR_DASHSCOPE_API_KEY with your Model Studio API key
$env:DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY"

Execute o comando a seguir na mesma sessão para verificar se a variável de ambiente foi definida.

echo $env:DASHSCOPE_API_KEY

Escolha uma linguagem de desenvolvimento

Selecione uma linguagem ou ferramenta para chamar as APIs de modelo.

Python

Etapa 1: Configure o Python

Verifique sua versão do Python

É necessário Python 3,9 ou superior. Para instruções de instalação, consulte Install Python.

Execute este comando para verificar se o Python e o pip estão instalados:

python -V
pip --version

Por exemplo, no Prompt de Comando do Windows:

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)

Perguntas frequentes

P: Os comandos python -V e pip --version retornam erros:

'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

Tente estas soluções:

Windows

Confirme se você instalou o Python seguindo a Install Python e adicionou python.exe à variável de ambiente PATH.

Ao instalar o Python 3.13.2, selecione Add python.exe to PATH na parte inferior do instalador para adicionar o Python às variáveis de ambiente do sistema e, em seguida, clique em Install Now para concluir a instalação.
Se o Python e o PATH estiverem configurados corretamente, mas o erro persistir, feche o terminal atual e abra um novo.

Linux e macOS

Confirme se você instalou o Python seguindo a Install Python.
Se o Python estiver instalado, mas o erro persistir, execute which python pip para verificar se python e pip existem no seu sistema.
- Se este resultado aparecer, feche a janela de terminal atual, abra uma nova e tente novamente.

/usr/bin/python
/usr/bin/pip

Se este resultado for retornado, execute a consulta which python3 pip3 novamente.

/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)

Se o resultado mostrado for retornado, use python3 -V e pip3 --version para verificar a versão.

/usr/bin/python3
/usr/bin/pip3

Configure um ambiente virtual (opcional)

Se o Python já estiver instalado, crie um ambiente virtual para instalar o OpenAI Python SDK ou o DashScope Python SDK e evitar conflitos de dependências.

Crie um ambiente virtual
Crie um ambiente virtual chamado .venv:

# If this fails, replace python with python3
python -m venv .venv

Ative o ambiente virtual
No Windows, ative o ambiente virtual:

.venv\Scripts\activate

No macOS ou Linux, execute:

source .venv/bin/activate

Instale o DashScope Python SDK ou o OpenAI Python SDK

Chame modelos no Model Studio usando o DashScope Python SDK (recomendado) ou o OpenAI Python SDK.

Instalar o DashScope Python SDK

Instale ou atualize o DashScope Python SDK:

# If this fails, replace pip with pip3
pip install -U dashscope

Procure por Successfully installed ... dashscope-x.x.x para confirmar a instalação.

Instalar o OpenAI Python SDK

Instale ou atualize o OpenAI Python SDK:

# If this fails, replace pip with pip3
pip install -U openai

Procure por Successfully installed ... openai-x.x.x para confirmar a instalação.

Etapa 2: Chame a API

DashScope Python SDK

Com o Python e o DashScope Python SDK instalados, envie sua primeira solicitação de API.

Crie um arquivo chamado hello_qwen.py.
Copie este código para hello_qwen.py e salve-o.

import os
import dashscope
from dashscope.v2 import DashScopeError

# A configuração abaixo refere-se à região Singapura. O valor de region varia conforme a região. Ao chamar, substitua {WorkspaceId} pelo ID real do seu workspace.
client = dashscope.Client(
    # As API Keys de Singapura, EUA (Virgínia) e China (Pequim) não são intercambiáveis. Obtenha sua API Key: https://www.alibabacloud.com/help/model-studio/get-api-key
    # Se a variável de ambiente não estiver configurada, substitua por: api_key = "sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
)
messages = [
    {'role': 'system', 'content': [{'text': 'You are a helpful assistant.'}]},
    {'role': 'user', 'content': [{'text': 'Who are you?'}]}
]
try:
    response = client.multimodal.chat.create(
        model="qwen3.8-max",   # Lista de modelos: https://www.alibabacloud.com/help/model-studio/models
        messages=messages,
    )
    print(response.output_text)
except DashScopeError as e:
    print(f"Código de status HTTP: {e.status_code}")
    print(f"Código de erro: {e.code}")
    print(f"Mensagem de erro: {e.message}")
    print("Consulte a documentação: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code")

Execute python hello_qwen.py ou python3 hello_qwen.py na linha de comando.

ObservaçãoO comando neste exemplo deve ser executado a partir do diretório que contém o arquivo Python. Para executá-lo de outro local, especifique o caminho completo.

A saída é:

I am a large-scale language model from Alibaba Cloud. My name is Qwen.

OpenAI Python SDK

Com o Python e o OpenAI Python SDK instalados, envie sua primeira solicitação de API.

Crie um arquivo chamado hello_qwen.py.
Copie este código para hello_qwen.py e salve-o.

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")

Para a região US (Virginia), o domínio do endpoint é {WorkspaceId}.us-east-1.maas.aliyuncs.com e a Base URL não contém o prefixo de ID de workspace (WorkspaceId) — um formato diferente de China (Beijing), Singapore e outras regiões.

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 base URL is for the US (Virginia) region, which does not use a workspace-specific domain. Do not include a WorkspaceId.
        base_url="https://{WorkspaceId}.us-east-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")

Execute python hello_qwen.py ou python3 hello_qwen.py na linha de comando.

Se você vir No such file or directory , especifique o caminho completo para o arquivo.

A saída é:

I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.

Node.js

Etapa 1: Configure seu ambiente Node.js

Verifique sua instalação do Node.js

Verifique se o Node.js e o npm estão instalados:

node -v
npm -v

Por exemplo, no Prompt de Comando do Windows:

C:\Users\Administrator>node -v
v22.14.0

C:\Users\Administrator>npm -v
10.9.2

Isso exibe sua versão atual do Node.js. Se o Node.js não estiver instalado, baixe-o no site oficial do Node.js.

Instale o SDK de chamada de modelo

Execute este comando no seu terminal:

npm install --save openai
# Or
yarn add openai

ObservaçãoSe a instalação falhar, configure um espelho de registro:

npm config set registry https://registry.npmmirror.com/

Após configurar o espelho, execute novamente o comando de instalação do SDK.

Procure por added xx package in xxs para confirmar a instalação. Verifique a versão: npm list openai.

Etapa 2: Chame a API do modelo

Crie um arquivo chamado hello_qwen.mjs.
Copie este código para o arquivo.

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");
}

Execute este comando para enviar uma solicitação de API.

node hello_qwen.mjs

Observação

Execute este comando a partir do diretório que contém hello_qwen.mjs. Para executá-lo de qualquer local, especifique o caminho completo para o arquivo.
Certifique-se de que o SDK esteja instalado no mesmo diretório que hello_qwen.mjs. Se estiverem em diretórios diferentes, você verá Cannot find package 'openai' imported from xxx.

Após a execução bem-sucedida, a saída é:

I am a language model from Alibaba Cloud. My name is Qwen.

Java

Etapa 1: Configure seu ambiente Java

Verifique sua versão do Java

Execute este comando no seu terminal:

java -version
# (Optional) If you use Maven to manage and build Java projects, ensure Maven is installed
mvn --version

Por exemplo, no Prompt de Comando do Windows:

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

O DashScope Java SDK requer Java 8 ou superior. Por exemplo, openjdk version "16.0.1" 2021-04-20 significa Java 16. Se o Java não estiver instalado ou a versão for inferior ao Java 8, baixe e instale-o em Downloads do Java.

Instale o SDK de chamada de modelo

Instale o DashScope Java SDK. Para a versão mais recente, consulte DashScope Java SDK. Adicione esta dependência, substituindo the-latest-version pelo número da versão mais recente.

XML

Abra o arquivo pom.xml do seu projeto Maven.
Adicione esta dependência à tag <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>

Salve o arquivo pom.xml.
Execute um comando Maven como mvn compile ou mvn clean install para atualizar as dependências. O Maven baixará e adicionará automaticamente o DashScope Java SDK ao seu projeto.

Por exemplo, no IntelliJ IDEA no 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

Abra o arquivo build.gradle do seu projeto Gradle.
Adicione esta dependência ao bloco 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'
}

Salve o arquivo build.gradle.
No seu terminal, navegue até o diretório raiz do projeto e execute este comando Gradle para atualizar as dependências. Ele baixará e adicionará automaticamente o DashScope Java SDK ao seu projeto.

./gradlew build --refresh-dependencies

Por exemplo, no IntelliJ IDEA no Windows:

Exemplo completo do arquivo 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()
}

Após executar o comando de build, a saída do terminal é:

~/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

Etapa 2: Chame a API

Execute este código para chamar a API do modelo.

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);
    }
}

A saída é:

I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.

curl

Chame modelos no Model Studio usando endpoints HTTP compatíveis com OpenAI ou DashScope. Para modelos suportados, consulte Model list.

ObservaçãoSe DASHSCOPE_API_KEY não estiver definido, substitua -H "Authorization: Bearer $DASHSCOPE_API_KEY" por -H "Authorization: Bearer sk-xxx".

HTTP compatível com OpenAI

A URL neste exemplo usa a região Singapore; substitua {WorkspaceId} pelo seu ID de workspace real. As URLs variam conforme a região. Se você usar a região China (Beijing), substitua a URL por https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions.

Envie a solicitação de API:

Windows

Execute este comando no Prompt de Comando:

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 e macOS

Execute este comando no 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?"
        }
    ]
}'

Após enviar a solicitação de API, você recebe esta resposta:

{
    "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

A URL neste exemplo usa a região Singapore; substitua {WorkspaceId} pelo seu ID de workspace real. As URLs variam conforme a região.

Se você usar a região US (Virginia), substitua a URL por https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation.
Se você usar a região China (Beijing), substitua a URL por https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation. Substitua {WorkspaceId} pelo seu ID de workspace.

Envie a solicitação de API:

Windows

Execute este comando no Prompt de Comando:

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 e macOS

Execute este comando no 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"
    }
}'

Após enviar a solicitação de API, você recebe esta resposta:

{
    "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"
}

Outras linguagens

Chame a API do modelo

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

<?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;
?>

csharp

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}";
            }
        }
    }
}

Referência da API

Para os parâmetros de entrada e saída, consulte Qwen API reference.
Para outros modelos, consulte Model list.

Perguntas frequentes

Como corrijo o erroModel.AccessDeniedapós chamar a API do modelo?

R: Este erro ocorre porque você está usando uma chave de API de um sub-workspace. Um sub-workspace não pode acessar aplicativos ou modelos no workspace padrão. Para usar uma chave de API de sub-workspace, o administrador da conta raiz deve conceder autorização de modelo para o sub-workspace correspondente (por exemplo, este tópico usa o modelo qwen3.8-max). Para etapas detalhadas, consulte Configure model calling permissions.

Próximas etapas

Explore mais modelos	O código de exemplo usa `qwen3.8-max`. O Model Studio também suporta outros modelos Qwen. Consulte a Model list para modelos suportados e suas referências de API.
Aprenda recursos avançados	O código de exemplo cobre apenas perguntas e respostas básicas. Para saber mais sobre a API do Qwen, como streaming output, structured output e function calling, consulte a Text generation model overview.
Experimente modelos no navegador	Se quiser interagir com modelos por meio de uma caixa de diálogo, como no Qwen Chat, acesse o Playground.
Chame um modelo treinado personalizado	Se você implantou um modelo treinado personalizado no Model Studio, use o código do modelo (não o ID do modelo) da página de implantação do modelo como parâmetro `model` ao fazer chamadas de API. Para detalhes, consulte Post-deployment calls.