Skip to main content
Modelos especializados

Capacidades de código (Qwen-Coder)

O Qwen-Coder é um modelo de linguagem projetado para tarefas de código. Você pode usar a API para gerar código, completar código e chamar ferramentas para interagir com sistemas externos.

Recomendamos o uso dos modelos de uso geral mais recentes em vez dos modelos Qwen-Coder. Para obter mais informações, consulte Geração de texto para selecionar um modelo adequado ao seu cenário.

Primeiros passos

Antes de começar, obtenha uma chave de API e configure-a como uma variável de ambiente. Se você utilizar um kit de desenvolvimento de software (SDK), será necessário instalar o SDK da OpenAI ou do DashScope. O exemplo a seguir mostra como chamar o modelo qwen3-coder-next para escrever uma função em Python que encontra números primos.
  • API Chat Completions compatível com OpenAI
  • DashScope
  • Python
  • Node.js
  • curl
Exemplo de solicitação
import os
from openai import OpenAI

client = OpenAI(
    # API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="qwen3-coder-next",
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'Write a Python function named find_prime_numbers that takes an integer n as a parameter and returns a list of all prime numbers less than n. Do not output non-code content or Markdown code blocks.'}],
)
print(completion.choices[0].message.content)
Resposta
def find_prime_numbers(n):
    if n <= 2:
        return []

    primes = []
    for num in range(2, n):
        is_prime = True
        for i in range(2, int(num ** 0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(num)

    return primes

Capacidades principais

Chamada de ferramentas

Forneça ao modelo um conjunto de ferramentas para interagir com ambientes externos, como leitura e escrita de arquivos, chamada de APIs ou operação de bancos de dados. O modelo decide se e como chamar essas ferramentas com base nas suas instruções. Para obter mais informações, consulte Function Calling. O fluxo completo de chamada de ferramentas inclui:
  1. Definir ferramentas e iniciar uma solicitação: Defina uma lista de ferramentas na solicitação e instrua o modelo a concluir uma tarefa que exija essas ferramentas.
  2. Executar as ferramentas: Analise os tool_calls retornados pelo modelo e chame as funções de ferramenta correspondentes implementadas localmente para executar a tarefa.
  3. Retornar os resultados da execução: Empacote os resultados da execução da ferramenta em um formato específico e envie-os de volta ao modelo. O modelo utiliza esses resultados para concluir a tarefa final.
O exemplo a seguir mostra como orientar o modelo a gerar código e usar a ferramenta write_file para salvá-lo em um arquivo local.
  • API Chat Completions compatível com OpenAI
  • DashScope
  • Python
  • Node.js
  • curl
import os
import json
from openai import OpenAI

client = OpenAI(
    # API keys vary by region. To get an API key, visit: https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Writes content to a specified file. Creates the file if it does not exist.",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The relative or absolute path of the object file."
                    },
                    "content": {
                        "type": "string",
                        "description": "The string content to write to the file."
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# Implement the tool function
def write_file(path: str, content: str) -> str:
    """Writes content to a file."""
    try:
        # Ensure the directory exists
        os.makedirs(os.path.dirname(path),
                    exist_ok=True) if os.path.dirname(path) else None
        with open(path, 'w', encoding='utf-8') as f:
            f.write(content)
        return f"Success: The file '{path}' has been written."
    except Exception as e:
        return f"Error: An exception occurred while writing the file - {str(e)}"

messages = [{"role": "user", "content": "Write a Python quicksort algorithm and name the file quick_sort.py."}]

completion = client.chat.completions.create(
    model="qwen3-coder-next",
    messages=messages,
    tools=tools
)

assistant_output = completion.choices[0].message
if assistant_output.content is None:
    assistant_output.content = ""
messages.append(assistant_output)

# If no tool call is needed, print the content directly
if assistant_output.tool_calls is None:
    print(f"No tool call needed. Direct response: {assistant_output.content}")
else:
    # Enter the tool calling loop
    while assistant_output.tool_calls is not None:
        for tool_call in assistant_output.tool_calls:
            tool_call_id = tool_call.id
            func_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            print(f"Calling tool [{func_name}] with arguments: {arguments}")
            # Execute the tool
            tool_result = write_file(**arguments)
            # Construct the tool return message
            tool_message = {
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": tool_result,
            }
            print(f"Tool returned: {tool_message['content']}")
            messages.append(tool_message)
        # Call the model again to get a summarized natural language response
        response = client.chat.completions.create(
            model="qwen3-coder-next",
            messages=messages,
            tools=tools
        )
        assistant_output = response.choices[0].message
        if assistant_output.content is None:
            assistant_output.content = ""
        messages.append(assistant_output)
    print(f"Final model response: {assistant_output.content}")
Resposta
Calling tool [write_file] with arguments: {'content': 'def quick_sort(arr):\\n    if len(arr) <= 1:\\n        return arr\\n    pivot = arr[len(arr) // 2]\\n    left = [x for x in arr if x < pivot]\\n    middle = [x for x in arr if x == pivot]\\n    right = [x for x in arr if x > pivot]\\n    return quick_sort(left) + middle + quick_sort(right)\\n\\nif __name__ == \\"__main__\\":\\n    example_list = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\"Original list:\\", example_list)\\n    sorted_list = quick_sort(example_list)\\n    print(\\"Sorted list:\\", sorted_list)', 'path': 'quick_sort.py'}
Tool returned: Success: The file 'quick_sort.py' has been written.
Final model response: I have created a file named `quick_sort.py` for you, which contains the Python implementation of the quicksort algorithm. You can run this file to see the example output. Let me know if you need any further modifications or explanations!

Conclusão de código

O Qwen-Coder oferece suporte a dois métodos de conclusão de código. Selecione um com base nas suas necessidades:
  • Modo parcial: Adequado para todos os modelos e regiões do Qwen-Coder. Oferece suporte à conclusão de prefixo e é simples de implementar. Recomendamos este método.
  • API Completions: Disponível apenas para os modelos da série qwen2.5-coder na região China (Pequim). Suporta tanto a conclusão de prefixo quanto a conclusão fill-in-the-middle.

Modo Parcial

Esse recurso permite que o modelo complete automaticamente o restante do seu código com base em um prefixo fornecido. Para usar esse recurso, adicione uma mensagem com role definido como assistant e partial: true à lista messages. O content da mensagem assistant corresponde ao prefixo de código que você fornece. Para obter mais informações, consulte Modo parcial.
  • Compatível com OpenAI
  • DashScope
  • Python
  • Node.js
  • curl
Solicitação
import os
from openai import OpenAI

client = OpenAI(
    # If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="qwen3-coder-next",
    messages=[{
        "role": "user",
        "content": "Help me write a Python script to generate prime numbers up to 100. Do not output non-code content or Markdown code blocks."
    },
    {
        "role": "assistant",
        "content": "def generate_prime_number",
        "partial": True
    }]
    )
print(completion.choices[0].message.content)
Resposta
(n):
    primes = []
    for i in range(2, n+1):
        is_prime = True
        for j in range(2, int(i**0.5)+1):
            if i % j == 0:
                is_prime = False
                break
        if is_prime:
            primes.append(i)
    return primes

prime_numbers = generate_prime_number(100)
print(prime_numbers)

API Completions

A API Completions está disponível apenas para modelos na região China (Pequim) e requer uma chave de API da região China (Pequim).
Modelos suportados: qwen-coder-turbo A API Completions usa tags especiais fim (Fill-in-the-Middle) no prompt para orientar a conclusão do modelo.
  • Conclusão baseada em prefixo
  • Conclusão baseada em prefixo e sufixo
Modelo de prompt:
<|fim_prefix|>{prefix_content}<|fim_suffix|>
  • <|fim_prefix|> e <|fim_middle|> são tokens especiais que orientam o modelo a completar o texto. Não os modifique.
  • Substitua {prefix_content} pelas informações do seu prefixo, como nome da função, parâmetros de entrada e instruções de uso.
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
    api_key=os.getenv("DASHSCOPE_API_KEY")
)

completion = client.completions.create(
  model="qwen-coder-turbo",
  prompt="<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>",
)

print(completion.choices[0].text)

import OpenAI from "openai";

const client = new OpenAI(
    {
        // If the environment variable is not configured, replace the following line with your Alibaba Cloud Model Studio API key: apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const completion = await client.completions.create({
        model: "qwen-coder-turbo",
        prompt: "<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>",
    });
    console.log(completion.choices[0].text)
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-coder-turbo",
    "prompt": "<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>"
}'

Entrada em produção

Para otimizar a eficiência e reduzir o custo de uso dos modelos Qwen-Coder, considere as seguintes sugestões:
  • Ative asaída em streaming: Defina stream=True para receber resultados intermediários em tempo real. Isso reduz o risco de tempos limite e melhora a experiência do usuário.
  • Reduza a temperatura: Tarefas de geração de código geralmente exigem resultados determinísticos e precisos. Diminuir o parâmetro temperature reduz a aleatoriedade da saída gerada.
  • Utilize um modelo com suporte a cache de contexto: Em cenários com muitos prefixos repetitivos, como conclusão e revisão de código, usar um modelo que ofereça suporte ao cache de contexto pode reduzir efetivamente a sobrecarga.
  • Controle a quantidade de ferramentas: Para garantir chamadas de modelo eficientes e econômicas, passe no máximo 20 ferramentas no parâmetro tools por chamada. Passar muitas descrições de ferramentas consome tokens de entrada em excesso, o que aumenta custos, reduz a velocidade de resposta e dificulta a seleção da ferramenta correta pelo modelo. Para obter mais informações, consulte Function Calling.

Faturamento e limitação de taxa

  • Faturamento básico: A cobrança é feita com base no número de tokens de entrada e tokens de saída de cada solicitação. O preço unitário varia dependendo do modelo. Para preços específicos, consulte a Lista de modelos.
  • Itens especiais de faturamento:
    • Faturamento escalonado: Os modelos da série qwen3-coder utilizam um método de faturamento escalonado. Quando o número de tokens de entrada em uma única solicitação atinge um nível específico, todos os tokens de entrada e saída dessa solicitação são cobrados conforme a taxa desse nível.
    • Cache de contexto: Para modelos compatíveis com cache de contexto, o mecanismo de cache pode reduzir significativamente os custos de solicitações com grandes quantidades de entrada repetitiva, como em revisões de código. O texto de entrada que atinge o cache implícito é cobrado a 20% da taxa padrão. O texto de entrada que atinge o cache explícito é cobrado a 10% da taxa padrão. Para obter mais informações, consulte Cache de contexto.
    • Chamada de ferramentas (Function Calling): Ao usar o recurso de chamada de ferramentas, as descrições definidas no parâmetro tools são incluídas na contagem total de tokens e geram cobranças.
  • Limitação de taxa: As chamadas de API estão sujeitas a limites duplos de solicitações por minuto (RPM) e tokens por minuto (TPM). Para obter mais informações, consulte Limitação de taxa.
  • Cota gratuita(apenas região Singapura): Após ativar o Model Studio ou ter sua solicitação de modelo aprovada, cada modelo Qwen-Coder inclui uma cota gratuita de 1 milhão de tokens para novos usuários válida por 90 dias.

Referência da API

Para obter mais informações sobre os parâmetros de entrada e saída dos modelos Qwen-Coder, consulte Geração de texto.

Perguntas frequentes

Por que ferramentas de desenvolvimento como Qwen Code e Claude Code consomem muitos tokens?

Ao usar uma ferramenta de desenvolvimento externa para chamar um modelo Qwen-Coder, a ferramenta pode fazer várias chamadas de API, o que consome muitos tokens. Para métodos específicos de monitoramento e redução do consumo de tokens, consulte os documentos do Qwen Code e do Claude Code. Você pode ativar o recurso parar-quando-cota-esgotada para evitar cobranças extras após o esgotamento da sua cota gratuita. Você também pode adquirir um plano de codificação com IA. Esse plano oferece uma taxa mensal fixa por uma cota mensal de solicitações que pode ser usada em ferramentas de IA. Para obter mais informações, consulte o documento Visão geral do Plano de Codificação.

Como visualizo o uso do modelo?

Uma hora após chamar um modelo, acesse a página Monitoramento (Singapura ou Pequim). Defina as condições de consulta, como intervalo de tempo e workspace. Em seguida, na área Models, localize o modelo desejado e clique em Monitor na coluna Actions para visualizar as estatísticas de chamadas do modelo. Para obter mais informações, consulte o documento Monitoramento.
Os dados são atualizados de hora em hora. Durante períodos de pico, pode haver uma latência de até uma hora.
image

Como faço para o modelo gerar apenas código, sem texto explicativo?

Você pode utilizar os seguintes métodos:
  1. Restrições no prompt: Forneça instruções claras no prompt, por exemplo: "Retorne apenas o código. Não inclua explicações, comentários ou tags Markdown."
  2. Defina uma sequência de parada: Use frases como stop=["\n# Explanation:", "Note:"] para encerrar a geração antes que o modelo comece a produzir texto explicativo. Para obter mais informações, consulte a Referência da API Qwen.
Começar
Faturamento
Plano de Tokens
Playground de Modelos
Clientes e Ferramentas de Desenvolvedor
Inferência do Modelo
Ajuste fino
Implantação
Avaliação
Compressão de Modelos
Estatísticas e Monitoramento
Segurança e Conformidade
Melhores Práticas
Suporte
Registro de alterações
Capacidades de código (Qwen-Coder) - Alibaba Cloud Model Studio