Skip to main content

Capacidades de código (Qwen-Coder)

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.

Se 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
  • DashScope
  • Python
  • Node.js
  • curl
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

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:
  1. 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.
  2. 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.
  3. 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
  • 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}")
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 实现。你可以运行这个文件查看示例输出。如果需要进一步修改或解释，请告诉我！

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
  • DashScope
  • Python
  • Node.js
  • curl
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)

Interfaz de Completions

La 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
  • Finalización basada en prefijo y sufijo
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.
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)

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:
  1. 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".
  2. 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.