Capacidades del modelo Qwen-Coder - Alibaba Cloud Model Studio - Centro de documentación de Alibaba Cloud

Qwen-Coder es un modelo de lenguaje diseñado para tareas de código. Puede usar la API para generar código, completar código y llamar a herramientas para interactuar con sistemas externos.

NotaSe recomienda utilizar el modelo de propósito general más reciente en lugar del modelo Qwen-Coder. Consulte Generación de texto para seleccionar un modelo que se adapte a su escenario.

Inicio rápido

Requisitos previos de la API: Debe haber obtenido y configurado una clave de API y configurado la clave de API como variable de entorno. Si realiza llamadas mediante SDK, necesita instalar el SDK de OpenAI o DashScope.

Los siguientes ejemplos demostrarán cómo llamar al modelo qwen-coder-plus-latest para escribir una función de Python que encuentre números primos.

API Chat Completions compatible con OpenAI

Python

Ejemplo de solicitud

import os
from openai import OpenAI

client = OpenAI(
    # 各地域的API Key不同。获取API Key：https://www.alibabacloud.com/help/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 请将{WorkspaceId}替换为业务空间ID
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="qwen-coder-plus-latest",
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': '请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。'}],
)
print(completion.choices[0].message.content)

Respuesta

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

Node.js

Ejemplo de solicitud

import OpenAI from "openai";

const client = new OpenAI(
    {
        // 各地域的API Key不同。获取API Key：https://www.alibabacloud.com/help/model-studio/get-api-key
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 以下为新加坡地域URL，调用时请将WorkspaceId替换为真实的业务空间ID，各地域的URL不同。
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen-coder-plus-latest",
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。" }
        ],
    });
    console.log(completion.choices[0].message.content);
}

main();

Respuesta

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

curl

Ejemplo de solicitud

La URL difiere según la región.

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-coder-plus-latest",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
        }
    ]
}'

Respuesta

{
    "model": "qwen-coder-plus-latest",
    "id": "chatcmpl-3123d5cb-01b8-9a90-98cc-5bffbb369xxx",
    "choices": [
        {
            "message": {
                "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\n    for num in range(2, n):\n        is_prime = True\n        for i in range(2, int(num ** 0.5) + 1):\n            if num % i == 0:\n                is_prime = False\n                break\n        if is_prime:\n            primes.append(num)\n    \n    return primes",
                "role": "assistant"
            },
            "index": 0,
            "finish_reason": "stop"
        }
    ],
    "created": 1770108104,
    "object": "chat.completion",
    "usage": {
        "total_tokens": 155,
        "completion_tokens": 89,
        "prompt_tokens": 66
    }
}

DashScope

Python

Ejemplo de solicitud

import dashscope
import os

# 请将{WorkspaceId}替换为业务空间ID
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": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
    }
]

response = dashscope.Generation.call(
    # 各地域的API Key不同。获取API Key：https://www.alibabacloud.com/help/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key = "sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen-coder-plus-latest",
    messages=messages,
    result_format="message"
)

if response.status_code == 200:
    print(response.output.choices[0].message.content)
else:
    print(f"HTTP返回码：{response.status_code}")
    print(f"错误码：{response.code}")
    print(f"错误信息：{response.message}")

Respuesta

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

Java

Ejemplos de solicitudes

import java.util.Arrays;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
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 NoApiKeyException, ApiException, InputRequiredException {
        String apiKey = System.getenv("DASHSCOPE_API_KEY");
        // 请将{WorkspaceId}替换为业务空间ID
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
        Message sysMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.").build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。").build();
        GenerationParam param = GenerationParam.builder()
                .apiKey(apiKey)
                .model("qwen-coder-plus-latest")
                .messages(Arrays.asList(sysMsg, 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("请求异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Respuesta

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

curl

Ejemplos de solicitudes

La URL varía según la región.

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-coder-plus-latest",
    "input":{
        "messages":[
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "请编写一个Python函数 find_prime_numbers，该函数接受一个整数 n 作为参数，并返回一个包含所有小于 n 的质数（素数）的列表。不要输出非代码的内容和Markdown的代码块。"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

Respuesta

{
    "output": {
        "choices": [
            {
                "message": {
                    "content": "def find_prime_numbers(n):\n    if n <= 2:\n        return []\n    \n    primes = []\n    for num in range(2, n):\n        is_prime = True\n        for i in range(2, int(num ** 0.5) + 1):\n            if num % i == 0:\n                is_prime = False\n                break\n        if is_prime:\n            primes.append(num)\n    \n    return primes",
                    "role": "assistant"
                },
                "finish_reason": "stop"
            }
        ]
    },
    "usage": {
        "total_tokens": 155,
        "input_tokens": 66,
        "output_tokens": 89
    },
    "request_id": "dd78b1cf-8029-46bb-9bea-b794ded7bxxx"
}

Capacidades principales

Herramientas integradas

Para permitir que el modelo interactúe con el entorno externo (por ejemplo, leer y escribir archivos, llamar a API y operar bases de datos), puede proporcionarle una serie de herramientas. El modelo decidirá si llamar a estas herramientas y cómo hacerlo basándose en sus instrucciones. Para más detalles, consulte Function Calling.

El proceso completo de llamada a herramientas incluye:

Definir herramientas y enviar una solicitud: Defina la lista de herramientas en la solicitud y presente al modelo la tarea que debe completarse utilizando herramientas.
Ejecutar herramienta: Analice los tool_calls devueltos por el modelo y llame a la función de herramienta correspondiente que haya implementado localmente para ejecutar la tarea.
Devolver resultado de ejecución: Envuelva el resultado de ejecución de la herramienta en un formato específico y envíelo de vuelta al modelo para que complete la tarea final basándose en dicho resultado.

El siguiente ejemplo demuestra cómo guiar al modelo para generar código y usar la herramienta write_file para guardarlo en un archivo local.

API Chat Completions compatible con OpenAI

Python

import os
import json
from openai import OpenAI

client = OpenAI(
    # 各地域的API Key不同。获取API Key：https://www.alibabacloud.com/help/model-studio/get-api-key
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 请将{WorkspaceId}替换为业务空间ID
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# 工具函数实现
def write_file(path: str, content: str) -> str:
    """写入文件内容"""
    try:
        # 确保目录存在
        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"成功: 文件 '{path}' 已写入"
    except Exception as e:
        return f"错误: 写入文件时发生异常 - {str(e)}"

messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}]

completion = client.chat.completions.create(
    model="qwen-coder-plus-latest",
    messages=messages,
    tools=tools
)

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

# 如果不需要调用工具，直接输出内容
if assistant_output.tool_calls is None:
    print(f"无需调用工具，直接回复：{assistant_output.content}")
else:
    # 进入工具调用循环（限制最大迭代次数，避免无限循环导致成本或超时问题）
    max_rounds = 10
    current_round = 0
    while assistant_output.tool_calls is not None and current_round < max_rounds:
        current_round += 1
        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"正在调用工具 [{func_name}]，参数：{arguments}")
            # 执行工具
            tool_result = write_file(**arguments)
            # 构造工具返回信息
            tool_message = {
                "role": "tool",
                "tool_call_id": tool_call_id,
                "content": tool_result,
            }
            print(f"工具返回：{tool_message['content']}")
            messages.append(tool_message)
        # 再次调用模型，获取总结后的自然语言回复
        response = client.chat.completions.create(
            model="qwen-coder-plus-latest",
            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"模型最终回复：{assistant_output.content}")

Respuesta

正在调用工具 [write_file]，参数：{'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'}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：好的，已经为你创建了名为 `quick_sort.py` 的文件，其中包含了快速排序的 Python 实现。你可以运行这个文件查看示例输出。如果需要进一步修改或解释，请告诉我！

Node.js

import OpenAI from "openai";
import fs from "fs/promises";
import path from "path";

const client = new OpenAI({
    // 各地域的API Key不同。获取API Key：https://www.alibabacloud.com/help/model-studio/get-api-key
    // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
    apiKey: process.env.DASHSCOPE_API_KEY,
    // 请将{WorkspaceId}替换为业务空间ID
    baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
});

const tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
];

// 工具函数实现
async function write_file(filePath, content) {
    try {
        // 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
        // const dir = path.dirname(filePath);
        // if (dir) {
        //     await fs.mkdir(dir, { recursive: true });
        // }
        // await fs.writeFile(filePath, content, "utf-8");
        return `成功: 文件 '${filePath}' 已写入`;
    } catch (error) {
        return `错误: 写入文件时发生异常 - ${error.message}`;
    }
}

const messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}];

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen-coder-plus-latest",
        messages: messages,
        tools: tools
    });

    let assistant_output = completion.choices[0].message;
    // 确保 content 不是 null
    if (!assistant_output.content) assistant_output.content = "";
    messages.push(assistant_output);

    // 如果不需要调用工具，直接输出内容
    if (!assistant_output.tool_calls) {
        console.log(`无需调用工具，直接回复：${assistant_output.content}`);
    } else {
        // 进入工具调用循环（限制最大迭代次数，避免无限循环导致成本或超时问题）
        const maxRounds = 10;
        let currentRound = 0;
        while (assistant_output.tool_calls && currentRound < maxRounds) {
            currentRound++;
            for (const tool_call of assistant_output.tool_calls) {
                const tool_call_id = tool_call.id;
                const func_name = tool_call.function.name;
                const args = JSON.parse(tool_call.function.arguments);
                console.log(`正在调用工具 [${func_name}]，参数：`, args);
                // 执行工具
                const tool_result = await write_file(args.path, args.content);
                // 构造工具返回信息
                const tool_message = {
                    "role": "tool",
                    "tool_call_id": tool_call_id,
                    "content": tool_result
                };
                console.log(`工具返回：${tool_message.content}`);
                messages.push(tool_message);
            }
            // 再次调用模型，获取总结后的自然语言回复
            const response = await client.chat.completions.create({
                model: "qwen-coder-plus-latest",
                messages: messages,
                tools: tools
            });
            assistant_output = response.choices[0].message;
            if (!assistant_output.content) assistant_output.content = "";
            messages.push(assistant_output);
        }
        console.log(`模型最终回复：${assistant_output.content}`);
    }
}

main();

Respuesta

正在调用工具 [write_file]，参数： {
  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'
}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功创建 `quick_sort.py` 文件，其中包含快速排序的 Python 实现。你可以运行该文件以查看示例列表的排序结果。如果需要进一步修改或解释，请告诉我！

curl

Este ejemplo demuestra el primer paso del proceso de llamada a herramientas: enviar una solicitud y obtener la intención de llamada a herramientas del modelo.

Las URL varían según la región.

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-coder-plus-latest",
    "messages": [
        {
            "role": "user",
            "content": "写一个python代码，快速排序，命名为quick_sort.py"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "将内容写入指定文件，若文件不存在则创建。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "目标文件的相对或绝对路径"
                        },
                        "content": {
                            "type": "string",
                            "description": "写入文件的字符串内容"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
}'

Respuesta

{
    "choices": [
        {
            "message": {
                "content": "",
                "role": "assistant",
                "tool_calls": [
                    {
                        "index": 0,
                        "id": "call_0ca7505bb6e44471a40511e5",
                        "type": "function",
                        "function": {
                            "name": "write_file",
                            "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\"}"
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 494,
        "completion_tokens": 193,
        "total_tokens": 687,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "created": 1761620025,
    "system_fingerprint": null,
    "model": "qwen-coder-plus-latest",
    "id": "chatcmpl-20e96159-beea-451f-b3a4-d13b218112b5"
}

DashScope

Python

import os
import json
import dashscope

# 请将{WorkspaceId}替换为业务空间ID
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

tools = [
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "将内容写入指定文件，若文件不存在则创建。",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目标文件的相对或绝对路径"
                    },
                    "content": {
                        "type": "string",
                        "description": "写入文件的字符串内容"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]

# 工具函数实现
def write_file(path: str, content: str) -> str:
    """写入文件内容"""
    try:
        # 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
        # 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"成功: 文件 '{path}' 已写入"
    except Exception as e:
        return f"错误: 写入文件时发生异常 - {str(e)}"

messages = [{"role": "user", "content": "写一个python代码，快速排序，命名为quick_sort.py"}]

response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen-coder-plus-latest',
    messages=messages,
    tools=tools,
    result_format='message'
)

if response.status_code == 200:
    assistant_output = response.output.choices[0].message
    messages.append(assistant_output)

    # 如果不需要调用工具，直接输出内容
    if "tool_calls" not in assistant_output or not assistant_output["tool_calls"]:
        print(f"无需调用工具，直接回复：{assistant_output['content']}")
    else:
        # 进入工具调用循环（限制最大迭代次数，避免无限循环导致成本或超时问题）
        max_rounds = 10
        current_round = 0
        while "tool_calls" in assistant_output and assistant_output["tool_calls"] and current_round < max_rounds:
            current_round += 1
            for tool_call in assistant_output["tool_calls"]:
                func_name = tool_call["function"]["name"]
                arguments = json.loads(tool_call["function"]["arguments"])
                tool_call_id = tool_call.get("id")
                print(f"正在调用工具 [{func_name}]，参数：{arguments}")
                # 执行工具
                tool_result = write_file(**arguments)
                # 构造工具返回信息
                tool_message = {
                    "role": "tool",
                    "content": tool_result,
                    "tool_call_id": tool_call_id
                }
                print(f"工具返回：{tool_message['content']}")
                messages.append(tool_message)
            # 再次调用模型，获取总结后的自然语言回复
            response = dashscope.Generation.call(
                api_key=os.getenv('DASHSCOPE_API_KEY'),
                model='qwen-coder-plus-latest',
                messages=messages,
                tools=tools,
                result_format='message'
            )
            if response.status_code == 200:
                print(f"模型最终回复：{response.output.choices[0].message.content}")
                assistant_output = response.output.choices[0].message
                messages.append(assistant_output)
            else:
                print(f"总结回复时执行错误：{response}")
                break
else:
    print(f"执行错误：{response}")

Respuesta

正在调用工具 [write_file]，参数：{'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'}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功创建 `quick_sort.py` 文件，其中包含快速排序的 Python 实现。你可以运行该文件以查看示例列表的排序结果。如果需要进一步修改或解释，请告诉我！

Java

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.protocol.Protocol;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.tools.FunctionDefinition;
import com.alibaba.dashscope.tools.ToolCallBase;
import com.alibaba.dashscope.tools.ToolCallFunction;
import com.alibaba.dashscope.tools.ToolFunction;
import com.alibaba.dashscope.utils.JsonUtils;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    /**
     * 写入文件内容
     * @param arguments 模型传入的、包含工具所需参数的JSON字符串。
     * @return 工具执行后的结果字符串。
     */
    public static String writeFile(String arguments) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode argsNode = objectMapper.readTree(arguments);
            String path = argsNode.get("path").asText();
            String content = argsNode.get("content").asText();

            // 为安全起见，文件写入功能已默认禁用，如需使用请取消注释并确保路径安全
            // File file = new File(path);
            // File parentDir = file.getParentFile();
            // if (parentDir != null && !parentDir.exists()) {
            //     parentDir.mkdirs();
            // }
            // Files.write(Paths.get(path), content.getBytes(StandardCharsets.UTF_8));
            return "成功: 文件 '" + path + "' 已写入";
        } catch (Exception e) {
            return "错误: 写入文件时发生异常 - " + e.getMessage();
        }
    }

    public static void main(String[] args) {
        try {
            // 定义工具参数模式
            String writePropertyParams =
                    "{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"目标文件的相对或绝对路径\"},\"content\":{\"type\":\"string\",\"description\":\"写入文件的字符串内容\"}},\"required\":[\"path\",\"content\"]}";

            FunctionDefinition writeFileFunction = FunctionDefinition.builder()
                    .name("write_file")
                    .description("将内容写入指定文件，若文件不存在则创建。")
                    .parameters(JsonUtils.parseString(writePropertyParams).getAsJsonObject())
                    .build();

            // 请将{WorkspaceId}替换为业务空间ID
            Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");

            String userInput = "写一个python代码，快速排序，命名为quick_sort.py";
            List<Message> messages = new ArrayList<>();
            messages.add(Message.builder().role(Role.USER.getValue()).content(userInput).build());

            // 首次调用模型
            GenerationParam param = GenerationParam.builder()
                    .model("qwen-coder-plus-latest")
                    .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                    .messages(messages)
                    .tools(Arrays.asList(ToolFunction.builder().function(writeFileFunction).build()))
                    .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                    .build();

            GenerationResult result = gen.call(param);
            Message assistantOutput = result.getOutput().getChoices().get(0).getMessage();
            messages.add(assistantOutput);

            // 如果不需要调用工具，直接输出内容
            if (assistantOutput.getToolCalls() == null || assistantOutput.getToolCalls().isEmpty()) {
                System.out.println("无需调用工具，直接回复：" + assistantOutput.getContent());
            } else {
                // 进入工具调用循环
                while (assistantOutput.getToolCalls() != null && !assistantOutput.getToolCalls().isEmpty()) {
                    for (ToolCallBase toolCall : assistantOutput.getToolCalls()) {
                        ToolCallFunction functionCall = (ToolCallFunction) toolCall;
                        String funcName = functionCall.getFunction().getName();
                        String arguments = functionCall.getFunction().getArguments();
                        System.out.println("正在调用工具 [" + funcName + "]，参数：" + arguments);

                        // 执行工具
                        String toolResult = writeFile(arguments);

                        // 构造工具返回信息
                        Message toolMessage = Message.builder()
                                .role("tool")
                                .toolCallId(toolCall.getId())
                                .content(toolResult)
                                .build();
                        System.out.println("工具返回：" + toolMessage.getContent());
                        messages.add(toolMessage);
                    }

                    // 再次调用模型，获取总结后的自然语言回复
                    param.setMessages(messages);
                    result = gen.call(param);
                    assistantOutput = result.getOutput().getChoices().get(0).getMessage();
                    messages.add(assistantOutput);
                }
                System.out.println("模型最终回复：" + assistantOutput.getContent());
            }

        } catch (NoApiKeyException | InputRequiredException e) {
            System.err.println("错误: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Respuesta

正在调用工具 [write_file]，参数：{"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_array = [3, 6, 8, 10, 1, 2, 1]\\n    print(\\\"Original array:\\\", example_array)\\n    sorted_array = quick_sort(example_array)\\n    print(\\\"Sorted array:\\\", sorted_array)", "path": "quick_sort.py"}
工具返回：成功: 文件 'quick_sort.py' 已写入
模型最终回复：已成功为您创建了快速排序的Python代码文件 `quick_sort.py`。该文件包含一个 `quick_sort` 函数和一个示例用法，您可以在终端或编辑器中运行它来测试快速排序功能。

curl

Este ejemplo demuestra el primer paso del proceso de llamada a herramientas: enviar una solicitud y obtener la intención de llamada a herramientas del modelo.

Las URL varían según la región.

curl --location "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen-coder-plus-latest",
    "input": {
        "messages": [{
            "role": "user",
            "content": "写一个python代码，快速排序，命名为quick_sort.py"
        }]
    },
    "parameters": {
        "result_format": "message",
        "tools": [
        {
            "type": "function",
            "function": {
                "name": "write_file",
                "description": "将内容写入指定文件，若文件不存在则创建。",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "path": {
                            "type": "string",
                            "description": "目标文件的相对或绝对路径"
                        },
                        "content": {
                            "type": "string",
                            "description": "写入文件的字符串内容"
                        }
                    },
                    "required": ["path", "content"]
                }
            }
        }
    ]
    }
}'

Respuesta

{
    "output": {
        "choices": [
            {
                "finish_reason": "tool_calls",
                "message": {
                    "role": "assistant",
                    "tool_calls": [
                        {
                            "function": {
                                "name": "write_file",
                                "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\"}"
                            },
                            "index": 0,
                            "id": "call_645b149bbd274e8bb3789aae",
                            "type": "function"
                        }
                    ],
                    "content": ""
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 684,
        "output_tokens": 193,
        "input_tokens": 491,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "request_id": "d2386acd-fce3-9d0f-8015-c5f3a8bf9f5c"
}

Generación de código

Qwen-Coder admite dos métodos de Completado de Código. Elija según sus necesidades:

Continuación de prefijo (modo parcial): Aplicable a todos los modelos Qwen-Coder y regiones, admite la finalización de prefijos, es fácil de implementar y se recomienda su uso.
Interfaz Completions: Solo admite el modelo `qwen-coder-turbo-latest` de China Norte 2 (Beijing) qwen-coder-turbo-latest. Admite la finalización de prefijos y la finalización de prefijo-sufijo.

Continuación de prefijo (Modo parcial)

Esta función se utiliza para permitir que el Modelo complete automáticamente la parte restante basándose en el código (prefijo) que ha escrito a medias.

Puede implementar esto agregando un mensaje con role establecido en assistant en la lista messages y configurando partial: true. El content del mensaje assistant es el prefijo de código que usted proporciona. Para más detalles, consulte Continuación de prefijo.

Compatible con OpenAI

Python

Ejemplos de solicitudes

import os
from openai import OpenAI

client = OpenAI(
    # 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 请将{WorkspaceId}替换为业务空间ID
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)
completion = client.chat.completions.create(
    model="qwen-coder-plus-latest",
    messages=[{
        "role": "user",
        "content": "请帮我写一个python代码生成100以内的素数。不要输出非代码的内容和Markdown的代码块。"
    },
    {
        "role": "assistant",
        "content": "def generate_prime_number",
        "partial": True
    }]
    )
print(completion.choices[0].message.content)

Respuesta

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

Node.js

Ejemplos de solicitudes

import OpenAI from "openai";

const client = new OpenAI(
    {
        // 若没有配置环境变量，请用百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 请将{WorkspaceId}替换为业务空间ID
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
    }
);

async function main() {
    const completion = await client.chat.completions.create({
        model: "qwen-coder-plus-latest",
        messages: [
            { role: "user", content: "请帮我写一个python代码生成100以内的素数。不要输出非代码的内容和Markdown的代码块。" },
            { role: "assistant", content: "def generate_prime_number", partial: true}
        ],
    });
    console.log(completion.choices[0].message.content);
}

main();

Respuesta

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

curl

Ejemplos de solicitudes

Las URL varían según la región.

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-coder-plus-latest",
    "messages": [{
        "role": "user",
        "content": "请帮我写一个python代码生成100以内的素数。不要输出非代码的内容和Markdown的代码块。"
    },
    {
        "role": "assistant",
        "content": "def generate_prime_number",
        "partial": true
    }]
}'

Respuesta

{
    "choices": [
        {
            "message": {
                "content": "(n):\n    primes = []\n    for num in range(2, n + 1):\n        is_prime = True\n        for i in range(2, int(num ** 0.5) + 1):\n            if num % i == 0:\n                is_prime = False\n                break\n        if is_prime:\n            primes.append(num)\n    return primes\n\nprime_numbers = generate_prime_number(100)\nprint(prime_numbers)",
                "role": "assistant"
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 38,
        "completion_tokens": 93,
        "total_tokens": 131,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "created": 1761634556,
    "system_fingerprint": null,
    "model": "qwen-coder-plus-latest",
    "id": "chatcmpl-c108050a-bb6d-4423-9d36-f64aa6a32976"
}

DashScope

Python

Ejemplos de solicitudes

from http import HTTPStatus
import dashscope
import os

# 请将{WorkspaceId}替换为业务空间ID
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

messages = [{
    "role": "user",
    "content": "请帮我写一个python代码生成100以内的素数，不要输出非代码的内容和Markdown的代码块。"
},
{
    "role": "assistant",
    "content": "def generate_prime_number",
    "partial": True
}]
response = dashscope.Generation.call(
    # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen-coder-plus-latest',
    messages=messages,
    result_format='message',
)
if response.status_code == HTTPStatus.OK:
    print(response.output.choices[0].message.content)
else:
    print(f"HTTP返回码：{response.status_code}")
    print(f"错误码：{response.code}")
    print(f"错误信息：{response.message}")

Respuesta

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

curl

Ejemplos de solicitudes

Las URL varían según la región.

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-coder-plus-latest",
    "input":{
        "messages":[{
            "role": "user",
            "content": "请帮我写一个python代码生成100以内的素数，不要输出非代码的内容和Markdown的代码块。"
        },
        {
            "role": "assistant",
            "content": "def generate_prime_number",
            "partial": true
        }]
    },
    "parameters": {
        "result_format": "message"
    }
}'

Respuesta

{
    "output": {
        "choices": [
            {
                "message": {
                    "content": "(n):\n    prime_list = []\n    for i in range(2, n+1):\n        is_prime = True\n        for j in range(2, int(i**0.5)+1):\n            if i % j == 0:\n                is_prime = False\n                break\n        if is_prime:\n            prime_list.append(i)\n    return prime_list\n\nprime_numbers = generate_prime_number(100)\nprint(prime_numbers)",
                    "role": "assistant"
                },
                "finish_reason": "stop"
            }
        ]
    },
    "usage": {
        "total_tokens": 131,
        "output_tokens": 92,
        "input_tokens": 39,
        "prompt_tokens_details": {
            "cached_tokens": 0
        }
    },
    "request_id": "9917f629-e819-4519-af44-b0e677e94b2c"
}

Interfaz de Completions

ImportanteLa interfaz Completions solo es aplicable a modelos en la región China North 2 (Beijing) y requiere el uso de la China North 2 (Beijing) de la región API Key.

Modelos admitidos:

qwen-coder-turbo-latest

API de CompletionsMediante prompt usando etiquetas especiales fim (Fill-in-the-Middle) para guiar al modelo a completar.

Finalización basada en prefijo

Plantilla de prompt:

<|fim_prefix|>{prefix_content}<|fim_suffix|>

<|fim_prefix|> y <|fim_suffix|> son tokens especiales, utilizados para guiar al modelo en la completación de texto; no es necesario modificarlos.
{prefix_content}Debe reemplazarse con la información de prefijo pasada, como el nombre de la función, parámetros de entrada, instrucciones de uso, etc.

python

import os
from openai import OpenAI

client = OpenAI(
    # 请将{WorkspaceId}替换为业务空间ID
    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-latest",
  prompt="<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>",
)

print(completion.choices[0].text)

javascript

import OpenAI from "openai";

const client = new OpenAI(
    {
        // 若没有配置环境变量，请用阿里云百炼API Key将下行替换为：apiKey: "sk-xxx",
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 请将{WorkspaceId}替换为业务空间ID
        baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
    }
);

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

main();

bash

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-latest",
    "prompt": "<|fim_prefix|>def quick_sort(arr):<|fim_suffix|>"
}'

Finalización basada en prefijo y sufijo

Plantilla de prompt:

<|fim_prefix|>{prefix_content}<|fim_suffix|>{suffix_content}<|fim_middle|>

<|fim_prefix|>, <|fim_suffix|> y <|fim_middle|> son tokens especiales utilizados para guiar al modelo en la completación de texto; no es necesario modificarlos.
{prefix_content} debe reemplazarse con la información de prefijo pasada, como el nombre de la función, parámetros de entrada, instrucciones de uso, etc.
{suffix_content} debe reemplazarse con la información de sufijo pasada, como los parámetros de retorno de la función, etc.

python

import os
from openai import OpenAI

client = OpenAI(
    # 请将{WorkspaceId}替换为业务空间ID
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
    api_key=os.getenv("DASHSCOPE_API_KEY")
)

prefix_content = """def reverse_words_with_special_chars(s):
'''
反转字符串中的每个单词（保留非字母字符的位置），并保持单词顺序。
    示例:
    reverse_words_with_special_chars("Hello, world!") -> "olleH, dlrow!"
    参数:
        s (str): 输入字符串（可能包含标点符号）
    返回:
        str: 处理后的字符串，单词反转但非字母字符位置不变
'''
"""

suffix_content = "return result"

completion = client.completions.create(
  model="qwen-coder-turbo-latest",
  prompt=f"<|fim_prefix|>{prefix_content}<|fim_suffix|>{suffix_content}<|fim_middle|>",
)

print(completion.choices[0].text)

javascript

import OpenAI from 'openai';

const client = new OpenAI({
  // 请将{WorkspaceId}替换为业务空间ID
  baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
  apiKey: process.env.DASHSCOPE_API_KEY
});

const prefixContent = `def reverse_words_with_special_chars(s):
'''
反转字符串中的每个单词（保留非字母字符的位置），并保持单词顺序。
    示例:
    reverse_words_with_special_chars("Hello, world!") -> "olleH, dlrow!"
    参数:
        s (str): 输入字符串（可能包含标点符号）
    返回:
        str: 处理后的字符串，单词反转但非字母字符位置不变
'''
`;

const suffixContent = "return result";

async function main() {
  const completion = await client.completions.create({
    model: "qwen-coder-turbo-latest",
    prompt: `<|fim_prefix|>${prefixContent}<|fim_suffix|>${suffixContent}<|fim_middle|>`
  });

  console.log(completion.choices[0].text);
}

main();

bash

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-latest",
    "prompt": "<|fim_prefix|>def reverse_words_with_special_chars(s):\n\"\"\"\n反转字符串中的每个单词（保留非字母字符的位置），并保持单词顺序。\n    示例:\n    reverse_words_with_special_chars(\"Hello, world!\") -> \"olleH, dlrow!\"\n    参数:\n        s (str): 输入字符串（可能包含标点符号）\n    返回:\n        str: 处理后的字符串，单词反转但非字母字符位置不变\n\"\"\"\n<|fim_suffix|>return result<|fim_middle|>"
}'

Uso en producción

Para optimizar la eficiencia y reducir el costo de uso del modelo Qwen-Coder, consulte las siguientes recomendaciones:

Habilitar Stream: Configurar stream=True permite devolver resultados intermedios en tiempo real, reduciendo los riesgos de tiempo de espera y mejorando la experiencia del usuario.
Reducir el parámetro temperature: Las tareas de generación de código generalmente requieren determinismo y precisión en los resultados. Se recomienda reducir el parámetro temperature para disminuir la aleatoriedad de los resultados generados.
Usar un modelo compatible con caché de contexto: En escenarios que contienen una gran cantidad de prefijos repetidos (como finalización de código y revisión de código), se recomienda usar un modelo compatible con la caché de contexto para reducir eficazmente los costos.
Controlar el recuento de herramientas: Para garantizar la eficiencia y rentabilidad de las llamadas al modelo, se recomienda que el número de herramientas pasadas en una sola llamada en tools no exceda 20. Pasar una gran cantidad de descripciones de herramientas consumirá demasiados tokens de entrada, lo que no solo aumenta los costos y reduce la velocidad de respuesta, sino que también dificulta que el modelo seleccione la herramienta correcta. Para más detalles, consulte Function Calling.

Facturación y limitación de tasa

Facturación básica: Se factura según el recuento de Token de entrada y el recuento de Token de salida de cada solicitud. Los precios unitarios varían según el modelo; para precios específicos, consulte Modelos.
Conceptos de facturación especiales:
- Precios escalonados: Los modelos de la serie qwen3-coder adoptan precios escalonados. Cuando el número de tokens de entrada en una solicitud individual alcanza un nivel específico, todos los tokens de entrada y salida de esa solicitud se facturan al precio unitario de dicho nivel.
- Caché de contexto: Para modelos que admiten caché de contexto, cuando múltiples solicitudes contienen grandes cantidades de entradas repetidas (como revisiones de código), el mecanismo de caché puede reducir significativamente los costos. El texto de entrada que acierta en la caché implícita se factura al 20% del precio unitario, y el texto de entrada que acierta en la caché explícita se factura al 10% del precio unitario. Para más detalles, consulte Caché de contexto.
- Herramientas integradas (Function Calling): Al utilizar la función de herramientas integradas, las descripciones de herramientas definidas en los parámetros tools se cuentan como volumen total de contenido de entrada Token e incurren en costos.
Límites de tasa: Las llamadas a la API están sujetas a límites duales de solicitudes por minuto (RPM) y tokens por minuto (TPM). Para más detalles, consulte Límites de tasa.
Cuota gratuita (solo Singapur): La validez se calcula a partir de la fecha de activación de Bailian o del pase de aplicación del modelo; dentro de la validez de 90 días, los modelos Qwen-Coder proporcionan cada uno una cuota gratuita para nuevos usuarios de 1 millones de tokens.

Referencia de la API

Para los parámetros de entrada y salida del modelo Qwen Code, consulte Generación de texto.

FAQ

Al utilizar herramientas de desarrollo como Qwen Code, Claude Code, etc., ¿por qué se consume una gran cantidad de tokens?

Al llamar al modelo Qwen-Coder a través de herramientas de desarrollo externas para resolver problemas, la herramienta puede invocar la API varias veces, consumiendo así una gran cantidad de tokens. Para métodos específicos sobre cómo monitorear y reducir el consumo de tokens, consulte la documentación de Qwen Code y Claude Code. Puede habilitar la función Solo cuota gratuita para evitar costos adicionales una vez agotada la cuota gratuita.

También puede adquirir un plan de codificación con IA, que adopta una tarifa mensual fija y proporciona cuotas de solicitudes mensuales compatibles para su uso en herramientas de IA. Para más detalles, consulte Resumen del plan de codificación.

¿Cómo ver el uso del modelo?

Una vez que ocurre la llamada al modelo, los datos por minuto se pueden ver en los gráficos de monitoreo. Inicie sesión en la página de Monitoreo (Singapore o Beijing), seleccione en la barra de navegación izquierda O&M Management > Monitoring para ingresar a la página de resumen de monitoreo, establezca las condiciones de consulta (por ejemplo, seleccione rango de tiempo, espacio de trabajo, etc.), luego en el área de Modelos busque el modelo objetivo y haga clic en View Details para ver las estadísticas de llamadas de ese modelo. Para más detalles, consulte la documentación de Monitoreo.

Los datos de monitoreo se actualizan cada minuto y son solo de referencia, no constituyen una base de facturación.

¿Cómo hacer que el modelo solo genere código sin ningún texto explicativo?

Puede consultar los siguientes métodos:

Restricciones de prompt: Indique explícitamente en el prompt, por ejemplo: "Devuelve solo código, no incluyas ninguna explicación, comentario ni etiqueta de markdown".
Configurarstopsecuencia: Use stop=["\n# Explanation:", "Note:", "Explanation:", "Note:"] y frases similares para terminar anticipadamente cuando el modelo comience a generar texto explicativo. Para más detalles, consulte la referencia de la API de Qwen.