Skip to main content

Code capabilities (Qwen-Coder)

Qwen-Coder is a language model designed for code tasks. You can use the API to generate code, complete code, and call tools to interact with external systems.

It is recommended to use the latest general-purpose model instead of the Qwen-Coder model. See Text Generation to select a model that fits your scenario.

Quick Start

API prerequisites: You have obtained and configured an API Key and configured the API Key as an environment variable. If calling via SDK, you need to install the OpenAI or DashScope SDK. The following examples will demonstrate how to callqwen-coder-plus-latestthe Model to write a Python function that finds prime numbers.
  • OpenAI-compatible Chat Completions API
  • DashScope
  • Python
  • Node.js
  • curl
Request Example
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)
Response
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

Core Capabilities

Built-in Tools

To enable the model to interact with the external environment (for example, reading and writing files, calling APIs, and operating databases), you can provide it with a series of tools. The model will decide whether and how to call these tools based on your instructions. For details, seeFunction Calling。 The complete tool calling process includes:
  1. Define tools and send a request：Define the tool list in the request, and present to the model the task that needs to be completed using tools.
  2. Execute tool：Parse the model's returned tool_calls, and call the corresponding tool function you have implemented locally to execute the task.
  3. Return execution result：Wrap the tool's execution result into a specific format and send it back to the model, letting it complete the final task based on the result.
The following example demonstrates how to guide the model to generate code, and use write_file tool to save it to a local file.
  • OpenAI-compatible Chat Completions API
  • DashScope
  • Python
  • Node.js
  • curl
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}")
Response
正在调用工具 [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 实现。你可以运行这个文件查看示例输出。如果需要进一步修改或解释，请告诉我！

Code generation

Qwen-Coder supports two Code Completion methods. Please choose based on your needs:
  • Prefix Continuation (Partial Mode): Applicable to all Qwen-Coder Models and regions, supports prefix completion, simple to implement, recommended for use.
  • Completions interface: Only supports North China 2 (Beijing) qwen-coder-turbo-latest Model. Supports prefix completion and prefix-suffix completion.

Prefix Continuation (Partial Mode)

This feature is used to let the Model automatically complete the remaining part based on the code (prefix) you have written halfway. By adding a message with role set to assistant in the messages list and setting partial: true, you can implement this. The assistant message's content is the code prefix you provide. For details, see Prefix Continuation.
  • OpenAI-compatible
  • DashScope
  • Python
  • Node.js
  • curl
Request Examples
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)
Response
(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)

Completions Interface

The Completions interface is only applicable to models in the China North 2 (Beijing) region and requires using the China North 2 (Beijing) region API Key.
Supported Models: qwen-coder-turbo-latest Completions APIBy prompt using special fim (Fill-in-the-Middle) tags to guide the model to complete.
  • Prefix-based completion
  • Prefix and suffix-based completion
Prompt Template:
<|fim_prefix|>{prefix_content}<|fim_suffix|>
  • <|fim_prefix|> and <|fim_suffix|> are special Tokens, used to guide the model in text completion, no modification needed.
  • {prefix_content}Need to be replaced with the passed-in prefix information, such as function name, Input Parameters, usage instructions, etc.
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)

Production Usage

To optimize the efficiency and reduce the cost of using the Qwen-Coder model, refer to the following recommendations:
  • Enable Stream: Setting stream=True can return intermediate results in real time, reducing timeout risks and improving user experience.
  • Lower the temperature parameter: Code generation tasks usually require determinacy and accuracy in results. It is recommended to lower the temperature parameter to reduce the randomness of generated results.
  • Use a model that supports context caching: In scenarios containing a large number of repeated prefixes (such as code completion and code review), it is recommended to use a model that supportsContext Cache to effectively reduce costs.
  • Control Tool Count: To ensure the efficiency and cost-effectiveness of model calls, it is recommended that the number of tools passed in a single calltools does not exceed 20. Passing a large number of tool descriptions will consume too many input Tokens, which not only increases costs and reduces response speed, but also makes it harder for the model to select the correct tool. For details, see Function Calling.

Billing and Rate Limiting

  • Basic Billing: Based on each request's input Token count and output Token count for billing. Unit prices differ across models; for specific prices, refer to Models。
  • Special Billing Items:
    • Tiered Pricing: The qwen3-coder series models adopt tiered pricing. When SingleAfter the number of input Tokens in a request reaches a specific tier, all input and output Tokens of that request are billed at the unit price of this tier.
    • Context Cache: For models that support context caching, when multiple requests contain large amounts of repeated input (such as code review), the caching mechanism can significantly reduce costs. HitImplicit Cache's input text is billed at 20% of the unit price, hitExplicit Cache's input text is billed at 10% of the unit price. For details, please refer to Context Cache.
    • Built-in Tools (Function Calling): When using the built-in tools feature, you are in tools The tool descriptions defined in the parameters are counted as input content Token total volume and incur costs.
  • Rate Limiting: API calls are subject to dual limits of requests per minute (RPM) and tokens per minute (TPM). For details, see Rate Limiting.
  • Free Quota (Singapore only): The Validity is calculated from the date of activating Bailian or model application Pass, within the 90-day Validity, Qwen-Coder models each provide 1 million Token new user Free Quota.

API Reference

For the Input Parameters and output parameters of the Qwen Code model, see Text Generation.

FAQ

When using development tools like Qwen Code, Claude Code, etc., why are a large number of Tokens consumed?

When calling the Qwen-Coder Model through external development tools to handle problems, the tool may call the API multiple times, thereby consuming a large number of Tokens. For specific methods of monitoring and reducing Token consumption, please refer to Qwen Code and Claude CodeDocs. You can enable the Free Quota Only feature to avoid extra costs after the Free Quota is exhausted. You can also purchase an AI coding plan, adopting a fixed monthly fee and providing monthly request quotas supported for Use in AI tools. For details, please see Coding Plan Overview.

How to view Model Usage?

After Model Calling occursper-minutecan be viewed in Monitoring charts. Log in to the Monitoring page (SingaporeOrBeijing), select in the left navigation barO&M Management > MonitoringEnter the monitoring overview page, set query conditions (for example, select time range, business space, etc.), then in the Models area find the target model and click View Details to view the calling statistics of that model. For details, see Monitoring Docs.
Monitoring data is updated per minute and is for Reference only, not as a billing basis.

How to make the model only output Code without any explanatory text?

You can Refer to the following methods:
  1. Prompt Constraints: Explicitly instruct in the prompt, for example: "Only return code, do not include any explanations, comments, or markdown tags."
  2. SettingsstopSequence: Use stop=["\n# Explanation:", "Note:", "Explanation:", "Note:"] and similar phrases to terminate early when the Model begins generating explanatory text. For details, see Qwen API Reference.
Get Started
Billing
Token Plan
Model Playground
Clients and Developer Tools
Model Inference
Fine-tuning
Evaluation
Statistics and Monitoring
Asset Center
Security and Compliance
Best Practices
Support
Changelog