Skip to main content

Code Interpreter

Activez l'interpréteur Python intégré lors de l'appel à un modèle. Le modèle écrit et exécute du code Python dans un environnement isolé (sandbox) pour résoudre des problèmes complexes tels que les calculs mathématiques et l'analyse de données.

Utilisation

L'interpréteur de code prend en charge trois méthodes d'invocation. Les paramètres diffèrent selon la méthode choisie :
  • OpenAI-compatible - Responses API
  • OpenAI-compatible - Chat Completions API
  • DashScope
Pour activer l'interpréteur de code, ajoutez l'outil code_interpreter au paramètre tools.
Pour obtenir les meilleurs résultats, activez simultanément les outils code_interpreter , web_search et web_extractor .
# Import dependencies and create the client...
response = client.responses.create(
    model="qwen4-max",
    input="What is 123 to the power of 21?",
    tools=[
        {"type": "code_interpreter"},
        {"type": "web_search"},
        {"type": "web_extractor"},
    ],
    extra_body={
        "enable_thinking": True
    }
)

print(response.output_text)
Une fois l'interpréteur de code activé, le modèle traite les requêtes selon les étapes suivantes :
  1. Réflexion : le modèle analyse la demande de l'utilisateur et génère des idées ainsi que les étapes nécessaires pour résoudre le problème.
  2. Exécution du code : le modèle génère et exécute du code Python.
  3. Intégration des résultats : le modèle reçoit le résultat de l'exécution du code et planifie les prochaines étapes.
  4. Réponse : le modèle génère une réponse en langage naturel.
Les étapes 2 et 3 peuvent s'exécuter en boucle plusieurs fois.
Les champs renvoyés varient selon les API :
  • Responses API : le contenu de réflexion est renvoyé dans un objet avec type="reasoning" dans la sortie. L'exécution du code est renvoyée avec type="code_interpreter_call". La réponse est renvoyée avec type="message".
  • Chat Completions API / DashScope : le contenu de réflexion est renvoyé dans le champ reasoning_content. La réponse est renvoyée dans le champ content. DashScope permet également de renvoyer le contenu du code dans le champ tool_info.

Portée

deepseek-v4.1-flash-1017 prend en charge l'outil intégré code_interpreter dans l'API Responses dans les six régions et les périmètres de déploiement correspondants indiqués sur la page du modèle. kimi-k3.1-pro (déployé sur Alibaba Cloud Model Studio) prend en charge l'outil intégré code_interpreter dans l'API Responses à Pékin, Singapour, aux États-Unis (Virginie), en Allemagne (Francfort), au Japon (Tokyo) et en Chine (Hong Kong).

Modèles recommandés

  • Responses API
  • Chat Completions API / DashScope
Qwen-Max : qwen4-max , séries Qwen3,8-Max, Qwen3,7-MaxQwen-Plus : séries Qwen3,7-Plus, Qwen3,6-Plus, Qwen3,5-PlusDeepSeek : deepseek-v4-flash-0731, deepseek-v4-proGLM : glm-5,2Série open source Qwen3,8

Autres modèles

Ces modèles prennent également en charge l'interpréteur de code, mais leurs performances peuvent être inférieures. Ils sont pris en charge uniquement via l'API Responses.
  • Qwen-Flash : séries Qwen3,7-Flash, Qwen3,6-Flash, Qwen3,5-Flash
  • Série open source Qwen3,6 (à l'exception de qwen3,6-27b)
  • Série open source Qwen3,5

Prise en main

Ces exemples illustrent la résolution de problèmes mathématiques par l'interpréteur de code.
  • OpenAI-compatible - Responses API
  • OpenAI-compatible - Chat Completions API
  • DashScope
Pour obtenir les meilleurs résultats, activez simultanément les outils code_interpreter , web_search et web_extractor .
python
import os
from openai import OpenAI

client = OpenAI(
    # If the environment variable is not configured, replace the next line with: api_key="sk-xxx", using your Model Studio API key.
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following URL is for the Chine (Pékin) region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
)

response = client.responses.create(
    model="qwen4-max",
    input="12 to the power of 3",
    tools=[
        {
            "type": "code_interpreter"
        },
        {
            "type": "web_search"
        },
        {
            "type": "web_extractor"
        }
    ],
    extra_body = {
        "enable_thinking": True
    }
)
# Uncomment the following line to view the intermediate process output
# print(response.output)
print("="*20+"Response Content"+"="*20)
print(response.output_text)
print("="*20+"Token Consumption and Tool Calls"+"="*20)
print(response.usage)
Exemple de réponse
====================Response Content====================
12 to the power of 3 is **1728**.

Calculation process:
12³ = 12 × 12 × 12 = 144 × 12 = 1728
====================Token Consumption and Tool Calls====================
ResponseUsage(input_tokens=1160, input_tokens_details=InputTokensDetails(cached_tokens=0), output_tokens=195, output_tokens_details=OutputTokensDetails(reasoning_tokens=105), total_tokens=1355, x_tools={'code_interpreter': {'count': 1}})

Analyse des réponses

  • OpenAI-compatible - Responses API
  • DashScope
L'exemple suivant utilisant le SDK Python OpenAI montre comment analyser une réponse en continu.
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following URL is for the Chine (Pékin) region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
)

response = client.responses.create(
    model="qwen4-max",
    input="12 to the power of 3",
    tools=[
        {"type": "code_interpreter"}
    ],
    extra_body={
        "enable_thinking": True
    },
    stream=True
)

def print_section(title):
    print(f"\n{'=' * 20}{title}{'=' * 20}")

current_section = None
final_response = None

for event in response:
    # Incremental output of the thinking process
    if event.type == "response.reasoning_summary_text.delta":
        if current_section != "reasoning":
            print_section("Thinking Process")
            current_section = "reasoning"
        print(event.delta, end="", flush=True)

    # Code Interpreter call completed
    elif event.type == "response.output_item.done" and hasattr(event.item, "code"):
        print_section("Code Execution")
        print(f"Code:\n{event.item.code}")
        if event.item.outputs:
            print(f"Result: {event.item.outputs[0].logs}")
        current_section = "code"

    # Incremental output of the final response
    elif event.type == "response.output_text.delta":
        if current_section != "answer":
            print_section("Complete Response")
            current_section = "answer"
        print(event.delta, end="", flush=True)

    # Response completed, save the final result to get usage
    elif event.type == "response.completed":
        final_response = event.response

# Output token consumption and number of tool calls
if final_response and final_response.usage:
    print_section("Token Consumption and Tool Calls")
    usage = final_response.usage
    print(f"Input Tokens: {usage.input_tokens}")
    print(f"Output Tokens: {usage.output_tokens}")
    print(f"Thinking Tokens: {usage.output_tokens_details.reasoning_tokens}")
    # Si le modèle n'invoque pas réellement l'interpréteur de code (par exemple, les questions simples auxquelles il répond directement), la réponse ne contient pas de champ x_tools
    if hasattr(usage, 'x_tools'):
        print(f"Code Interpreter calls: {usage.x_tools.get('code_interpreter', {}).get('count', 0)}")
    else:
        print("Code Interpreter calls: 0")

Notes

  • Code Interpreter et Appel de fonction s'excluent mutuellement.
    L'activation simultanée des deux options dans une même requête génère une erreur.
  • Lorsque Code Interpreter est activé, une seule requête peut déclencher plusieurs inférences du modèle. Le champ usage résume la consommation totale de jetons pour tous les appels effectués dans cette requête.

Facturation

Code Interpreter est gratuit pour une durée limitée, mais il augmente la consommation de jetons.