Todos os produtos
Search
Central de documentação

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

Última atualização: Jul 10, 2026

O Alibaba Cloud Model Studio suporta 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

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

    Se encontrar problemas, consulte Registrar uma conta Alibaba Cloud .
  2. 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.

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

  4. Obtenha o ID do seu 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.

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

Variável de ambiente permanente

Para tornar a chave de API disponível em todas as sessões futuras, exporte-a permanentemente.

  1. Execute o comando a seguir para adicionar a variável de ambiente ao arquivo ~/.bashrc:

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

    Você também pode editar o arquivo ~/.bashrc manualmente.

    Editar manualmente

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

    nano ~/.bashrc

    Adicione o conteúdo a seguir ao arquivo.

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

    No editor nano, pressione Ctrl+X e depois Y. Pressione Enter para salvar e fechar o arquivo.

  2. Execute o comando a seguir para aplicar a alteração:

    source ~/.bashrc
  3. Abra uma nova sessão e execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

    echo $DASHSCOPE_API_KEY

Variável de ambiente temporária

Para usar a chave de API apenas na sessão atual, exporte-a temporariamente.

  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
  2. Execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

    echo $DASHSCOPE_API_KEY

macOS

Variável de ambiente permanente

Para tornar a chave de API disponível em todas as sessões futuras, exporte-a permanentemente.

  1. Execute o comando a seguir para verificar o tipo de Shell padrão.

    echo $SHELL
  2. Realize a operação a seguir com base no seu tipo de Shell.

    Zsh

    1. Execute o comando a seguir para adicionar a variável de ambiente ao arquivo ~/.zshrc.

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

      Você também pode editar o arquivo ~/.zshrc manualmente.

      Editar manualmente

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

      nano ~/.zshrc

      Adicione o conteúdo a seguir ao arquivo.

      # Replace YOUR_DASHSCOPE_API_KEY with your API key.
      export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

      No editor nano, pressione Ctrl+X e depois Y. Pressione Enter para salvar e fechar o arquivo.

    2. Execute o comando a seguir para aplicar a alteração:

      source ~/.zshrc
    3. Abra uma nova sessão e execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

      echo $DASHSCOPE_API_KEY

    Bash

    1. Execute o comando a seguir para adicionar a variável de ambiente ao arquivo ~/.bash_profile.

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

      Você também pode editar o arquivo ~/.bash_profile manualmente.

      Editar manualmente

      Execute o comando a seguir para abrir o arquivo.

      nano ~/.bash_profile

      Adicione o conteúdo a seguir ao arquivo.

      # Replace YOUR_DASHSCOPE_API_KEY with your API key.
      export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

      No editor nano, pressione Ctrl+X e depois Y. Pressione Enter para salvar e fechar o arquivo.

    2. Execute o comando a seguir para aplicar a alteração:

      source ~/.bash_profile
    3. Abra uma nova sessão e execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

      echo $DASHSCOPE_API_KEY

Variável de ambiente temporária

Para usar a chave de API apenas na sessão atual, exporte-a temporariamente.

Os comandos a seguir funcionam apenas para Zsh e Bash.
  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
  2. Execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

    echo $DASHSCOPE_API_KEY

Windows

No Windows, exporte variáveis de ambiente usando Propriedades do Sistema, Linha de Comando ou PowerShell.

System Properties

Nota
  • A variável de ambiente configurada dessa forma é efetiva permanentemente.

  • Modificar variáveis de ambiente do sistema requer permissões administrativas.

  • Após configurar a variável de ambiente, programas já em execução não serão afetados. Reinicie IDEs e janelas de comando, ou abra uma nova linha de comando, para carregar a nova variável.

  1. Pressione Win+Q na área de trabalho. Insira "Edit the system environment variables" na caixa de pesquisa e clique para abrir a janela System Properties.

  2. Na janela System Properties, clique em Environment Variables. Na seção System Variables, clique em New, insira DASHSCOPE_API_KEY como nome da variável e your actual API Key como valor da variável.

    image

  3. Clique em OK nas três caixas de diálogo.

  4. Abra o CMD ou Windows PowerShell e execute o comando a seguir para verificar se a variável de ambiente entrou em vigor.

    • CMD:

      echo %DASHSCOPE_API_KEY%

      image

    • Windows PowerShell:

      echo $env:DASHSCOPE_API_KEY

      image

CMD

Variável de ambiente permanente

Para tornar a chave de API disponível em todas as sessões futuras, exporte-a permanentemente.

  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    setx DASHSCOPE_API_KEY "YOUR_DASHSCOPE_API_KEY"
  2. Crie uma nova sessão.

  3. Execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

    echo %DASHSCOPE_API_KEY%

    image

Variável de ambiente temporária

Para usar a chave de API apenas na sessão atual, exporte-a temporariamente.

  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    set DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
  2. Execute o comando a seguir na sessão atual para verificar se a variável de ambiente entrou em vigor:

    echo %DASHSCOPE_API_KEY%

    image

PowerShell

Variável de ambiente permanente

Para tornar a chave de API disponível em todas as sessões futuras, exporte-a permanentemente.

  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    [Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "YOUR_DASHSCOPE_API_KEY", [EnvironmentVariableTarget]::User)
  2. Crie uma sessão.

  3. Execute o comando a seguir para verificar se a variável de ambiente entrou em vigor:

    echo $env:DASHSCOPE_API_KEY

    image

Variável de ambiente temporária

Para usar a chave de API apenas na sessão atual, exporte-a temporariamente.

  1. Execute o comando a seguir:

    # Replace YOUR_DASHSCOPE_API_KEY with your API key.
    $env:DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY"
  2. Execute o comando a seguir na sessão atual para verificar se a variável de ambiente entrou em vigor:

    echo $env:DASHSCOPE_API_KEY

    image

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

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

É necessário Python 3.8 ou superior. Para instruções de instalação, consulte Instalar o Python.

python -V
pip --version

Por exemplo, no Prompt de Comando do Windows:

image

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

  1. Confirme que você instalou o Python seguindo Instalar o Python e adicionou python.exe à variável de ambiente PATH.image

  2. Se o Python e o PATH estiverem configurados corretamente, mas o erro persistir, feche o terminal atual e abra um novo.

Linux e macOS

  1. Confirme que você instalou o Python seguindo Instalar o Python.

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

  1. Crie um ambiente virtual

    Crie um ambiente virtual chamado .venv:

    # If this fails, replace python with python3
    python -m venv .venv
  2. Ative o ambiente virtual

    No Windows, ative o ambiente virtual:

    .venv\Scripts\activate

    No macOS ou Linux, execute:

    source .venv/bin/activate

Instale o OpenAI Python SDK ou DashScope Python SDK

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

Instale o OpenAI Python SDK

Instale ou atualize o OpenAI Python SDK:

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

image

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

Instale o DashScope Python SDK

Instale ou atualize o DashScope Python SDK:

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

image

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

Etapa 2: Chame a API

OpenAI Python SDK

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

  1. Crie um arquivo chamado hello_qwen.py.

  2. 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="qwen-plus",  
            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. 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.

DashScope Python SDK

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

  1. Crie um arquivo chamado hello_qwen.py.

  2. Copie este código para hello_qwen.py e salve-o.

    import os
    from dashscope import Generation
    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': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'Who are you?'}
    ]
    response = Generation.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="qwen-plus",   
        messages=messages,
        result_format="message"
    )
    
    if response.status_code == 200:
        print(response.output.choices[0].message.content)
    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. Execute python hello_qwen.py ou python3 hello_qwen.py na linha de comando.

    Nota

    Execute o comando deste exemplo 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.

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:

image

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
Nota

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

image

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

  1. Crie um arquivo chamado hello_qwen.mjs.

  2. 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: "qwen-plus",  
            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. Execute este comando para enviar uma solicitação de API.

    node hello_qwen.mjs
    Nota
    • 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:

image

Java 8 ou superior é necessário para o DashScope Java SDK. 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

  1. Abra o arquivo pom.xml do seu projeto Maven.

  2. 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>
  3. Salve o arquivo pom.xml.

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

image

Gradle

  1. Abra o arquivo build.gradle do seu projeto Gradle.

  2. 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'
    }
  3. Salve o arquivo build.gradle.

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

image

Etapa 2: Chame a API

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

import java.util.Arrays;
import java.lang.System;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
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 GenerationResult 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.
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.")
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("Who are you?")
                .build();
        GenerationParam param = GenerationParam.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("qwen-plus")
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } 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 Lista de modelos.

Nota

Se 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 ID real do seu workspace. As URLs variam por 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\": \"qwen-plus\",
    \"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": "qwen-plus",
    "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": "qwen-plus",
    "id": "chatcmpl-39799876-eda8-9527-9e14-2214d641cf9a"
}

DashScope HTTP

A URL neste exemplo usa a região Singapore, substitua {WorkspaceId} pelo ID real do seu workspace. As URLs variam por região.

  • Se você usar a região US (Virginia), substitua a URL por https://dashscope-us.aliyuncs.com/api/v1/services/aigc/text-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/text-generation/generation. Substitua {WorkspaceId} pelo ID do seu 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/text-generation/generation" ^
-H "Authorization: Bearer %DASHSCOPE_API_KEY%" ^
-H "Content-Type: application/json" ^
-d "{
  \"model\": \"qwen-plus\",
  \"input\": {
    \"messages\": [
      {
        \"role\": \"system\",
        \"content\": \"You are a helpful assistant.\"
      },
      {
        \"role\": \"user\",
        \"content\": \"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/text-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "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": "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: "qwen-plus",
		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" => "qwen-plus",
    "messages" => [
        [
            "role" => "system",
            "content" => "You are a helpful assistant."
        ],
        [
            "role" => "user",
            "content" => "Who are you?"
        ]
    ]
];
// Initialize a cURL session
$ch = curl_init();
// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
// Execute the cURL session
$response = curl_exec($ch);
// Check for errors
if (curl_errno($ch)) {
    echo 'Curl error: ' . curl_error($ch);
}
// Close the cURL resource
curl_close($ch);
// 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"": ""qwen-plus"",
            ""messages"": [
                {
                    ""role"": ""system"",
                    ""content"": ""You are a helpful assistant.""
                },
                {
                    ""role"": ""user"", 
                    ""content"": ""Who are you?""
                }
            ]
        }";

        // Send the request and get the response
        string result = await SendPostRequestAsync(url, jsonContent, apiKey);

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

Perguntas frequentes

Como corrijo o erro Model.AccessDenied apó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 Qwen-Plus). Para etapas detalhadas, consulte Configurar permissões de chamada de modelo.

Próximas etapas

Explore mais modelos

O código de exemplo usa qwen-plus. O Model Studio também suporta outros modelos Qwen. Consulte a Lista de modelos para ver os 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 saída em streaming, saída estruturada e chamada de função, consulte a Visão geral do modelo de geração de texto.

Experimente modelos no navegador

Se quiser interagir com modelos por meio de uma caixa de diálogo, como no Qwen Chat, acesse o Playground .