Skip to main content

Raisonnement approfondi

Les modèles de raisonnement approfondi analysent la demande avant d'y répondre, ce qui améliore leur précision sur des tâches complexes telles que le raisonnement logique et les mathématiques.

Ces exemples utilisent l'API Chat Completion compatible OpenAI ainsi que l'API DashScope. Pour l'API Responses, consultez Raisonnement approfondi .
Vous pouvez également ouvrir un modèle dans le Centre d'expérience de la console Model Studio, activer la réflexion approfondie et consulter directement le processus de raisonnement.

Utilisation

Model Studio prend en charge le raisonnement approfondi selon deux modes :
  • Mode de raisonnement hybride : utilisez le paramètre enable_thinking pour activer ou désactiver le raisonnement à chaque requête :
    • Définissez-le sur true : le modèle effectue un raisonnement avant de répondre.
    • Définissez-le sur false : le modèle répond directement sans étape de raisonnement.
    • Compatible OpenAI
    • DashScope
    # Import dependencies and create a client...
    completion = client.chat.completions.create(
        model="qwen4-max", # Select a model
        messages=[{"role": "user", "content": "Who are you"}],
        # Since enable_thinking is not a standard OpenAI parameter, pass it in extra_body.
        extra_body={"enable_thinking":True},
        # Enable streaming output.
        stream=True,
        # Configure the stream to include token consumption information in the last data packet.
        stream_options={
            "include_usage": True
        }
    )
    
  • Mode raisonnement uniquement : le modèle effectue systématiquement un raisonnement avant de répondre ; ce comportement ne peut pas être désactivé. Le format de requête est identique à celui du mode hybride, mais aucun paramètre enable_thinking n'est nécessaire.
L'API retourne le raisonnement dans le champ reasoning_content et la réponse dans le champ content. Le raisonnement ajoutant de la latence, tous les exemples utilisent par défaut le streaming (recommandé pour observer le processus en temps réel). Les modèles commerciaux de raisonnement prennent également en charge la sortie non-streaming (synchrone) ; consultez la FAQ ci-dessous pour les détails d'utilisation et les précautions à prendre. Certains modèles (comme les versions open source qwen3.5-122b-a10b et qwen3.5-27b) ne supportent que le streaming ; un appel non-streaming générera alors une erreur.

Modèles pris en charge

  • Qwen4
  • Qwen3.8
  • Qwen3.7
  • Qwen3.6
  • Qwen3.5
  • Qwen3
  • DeepSeek
  • GLM
  • Kimi
  • MiniMax
Série Qwen4 Max (version préliminaire, mode de raisonnement hybride, raisonnement activé par défaut) : qwen4-max, qwen4-max-preview (Token Plan uniquement)
Les noms des modèles, les fenêtres de contexte, les tarifs et les versions snapshot sont disponibles dans la Liste des modèles. Les limites de taux sont décrites dans la rubrique Limitation du débit.

Prise en main

Obtenez une clé API et définissez-la comme variable d'environnement. Si vous utilisez un SDK, installez le SDK OpenAI ou DashScope (le SDK Java DashScope version 2.19.4 ou ultérieure est requis). L'exemple suivant appelle qwen3.8-max en mode raisonnement avec une sortie en streaming.
  • Compatible OpenAI
  • DashScope
  • Python
  • Node.js
  • HTTP

Exemple de code

from openai import OpenAI
import os

# Initialize the OpenAI client.
client = OpenAI(
    # API keys vary by region. To get an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If an environment variable is not configured, provide your Model Studio API key directly: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Configurations vary by region. Modify the base_url based on your region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

messages = [{"role": "user", "content": "Who are you"}]

completion = client.chat.completions.create(
    model="qwen4-max",  # You can replace this with other deep-thinking models as needed.
    messages=messages,
    extra_body={"enable_thinking": True},
    stream=True,
    stream_options={
        "include_usage": True
    },
)

reasoning_content = ""  # Full thinking process
answer_content = ""  # Full response
is_answering = False  # Tracks if the response phase has started
print("\n" + "=" * 20 + "Thinking process" + "=" * 20 + "\n")

for chunk in completion:
    if not chunk.choices:
        print("\nUsage:")
        print(chunk.usage)
        continue

    delta = chunk.choices[0].delta

    # Collect only the reasoning content.
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content

    # When content is received, start responding.
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Réponse

====================Thinking process====================

The user's query "Who are you?" requires an accurate and friendly response. The answer should first establish my identity as Qwen, developed by Tongyi Lab at Alibaba Cloud. It will then outline key capabilities such as question answering, text generation, and logical reasoning. The language must be simple and the tone approachable. To encourage interaction, I will invite the user to ask more questions. Finally, I'll check that all key details are present, including my name (Qwen) and developer, to provide a comprehensive answer.
====================Full response====================

Hello! I am Qwen, a large language model developed by Tongyi Lab at Alibaba Group. I can answer questions, generate text, perform logical reasoning, write code, and more, to provide you with high-quality information and services. You can call me Qwen. How can I help you?

Fonctionnalités principales

Basculer entre les modes avec et sans raisonnement

Le mode de raisonnement améliore la qualité des réponses, mais augmente la latence et le coût. Sur les modèles à raisonnement hybride, activez-le ou désactivez-le pour chaque requête selon la complexité de la demande :
  • Définissez enable_thinking sur false pour les requêtes simples (conversation informelle, questions-réponses directes).
  • Définissez enable_thinking sur true pour les tâches nécessitant un raisonnement complexe (problèmes logiques, génération de code ou calculs mathématiques).
  • Compatible OpenAI
  • DashScope
enable_thinking n'est pas un paramètre standard OpenAI. Dans le SDK Python OpenAI, transmettez-le via extra_body. Dans le SDK Node.js, passez-le en tant que paramètre de premier niveau.
  • Python
  • Node.js
  • HTTP

Exemple de code

from openai import OpenAI
import os

# Initialize the OpenAI client.
client = OpenAI(
    # If the environment variable is not configured, replace the value with your Model Studio API key: api_key="sk-xxx"
    # API keys differ by region. To get an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following URL is for the Chine (Pékin) region. When calling, replace WorkspaceId with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

messages = [{"role": "user", "content": "Who are you?"}]
completion = client.chat.completions.create(
    model="qwen4-max",
    messages=messages,
    # Set enable_thinking in extra_body to enable the reasoning process.
    extra_body={"enable_thinking": True},
    stream=True,
    stream_options={
        "include_usage": True
    },
)

reasoning_content = ""  # Full reasoning process
answer_content = ""  # Full response
is_answering = False  # Indicates if the response phase has started
print("\n" + "=" * 20 + "Reasoning process" + "=" * 20 + "\n")

for chunk in completion:
    if not chunk.choices:
        print("\n" + "=" * 20 + "Token usage" + "=" * 20 + "\n")
        print(chunk.usage)
        continue

    delta = chunk.choices[0].delta

    # Collect only the reasoning content.
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content

    # When content is received, start the response.
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Full response" + "=" * 20 + "\n")
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Réponse

====================Reasoning process====================

The user is asking "Who are you?". I need to determine what they want to know. They might be interacting with me for the first time or want to confirm my identity. I should introduce myself as Qwen, developed by Tongyi Lab. Then, I should explain my capabilities, such as answering questions, creating text, and coding, so the user understands how I can assist them. I should also mention my multilingual support so international users know they can communicate in different languages. Finally, I should maintain a friendly tone and invite them to ask questions to encourage further interaction. The explanation must be clear and simple, avoiding technical jargon. The user likely wants a quick overview of my abilities, so I will focus on my functions and applications. I should also consider if any information is missing, such as mentioning Alibaba Group or more technical details. However, the user probably only needs basic information. I will ensure the response is friendly and professional, and encourages them to continue the conversation.
====================Full response====================

I am Qwen, a large-scale language model developed by Tongyi Lab. I can help you answer questions, create text, code, and express opinions. I support communication in multiple languages. How can I help you?
====================Token usage====================

CompletionUsage(completion_tokens=221, prompt_tokens=10, total_tokens=231, completion_tokens_details=CompletionTokensDetails(accepted_prediction_tokens=None, audio_tokens=None, reasoning_tokens=172, rejected_prediction_tokens=None), prompt_tokens_details=PromptTokensDetails(audio_tokens=None, cached_tokens=0))
Pour les modèles open source à raisonnement hybride Qwen3, ainsi que pour qwen-plus-2025-04-28 et les modèles associés, vous pouvez également contrôler le mode de raisonnement via des suffixes d'invite. Lorsque enable_thinking est défini sur true, ajoutez /no_think à une invite pour désactiver le raisonnement lors de ce tour, ou ajoutez /think pour le réactiver. Le modèle respecte toujours la dernière instruction /think ou /no_think reçue.

Limiter la longueur du raisonnement

Les modèles de réflexion approfondie génèrent parfois un raisonnement long, ce qui augmente la latence et consomme davantage de tokens. Utilisez le paramètre thinking_budget pour définir le nombre maximal de tokens du raisonnement. Une fois cette limite atteinte, le modèle commence immédiatement à générer la réponse. kimi-k3.1-pro et kimi-k3 ne prennent pas en charge ce paramètre ; il ne peut donc pas limiter la longueur de leur réflexion. Pour connaître les modèles pris en charge et leurs valeurs par défaut, consultez les paramètres de Chat Completions et les paramètres DashScope. Les exemples ci-dessous présentent uniquement les paramètres clés. Pour un exemple complet en streaming, consultez Démarrage rapide.
  • Compatible OpenAI
  • DashScope
completion = client.chat.completions.create(
    model="qwen4-max",
    messages=messages,
    # Définit le nombre maximal de tokens du raisonnement
    extra_body={"enable_thinking": True, "thinking_budget": 50},
    stream=True,
)

Transmission du processus de réflexion

kimi-k3.1-pro et kimi-k3 (déployés sur Alibaba Cloud Model Studio) conservent par défaut le reasoning_content historique fourni par le client. Nous recommandons de renvoyer les messages historiques de l'assistant avec leur reasoning_content complet dans les requêtes multi-tours. Par défaut, le modèle ignore le champ reasoning_content présent dans l'historique des messages. Définissez preserve_thinking sur true pour transmettre le raisonnement précédent aux tours suivants. Le contenu de reasoning_content issu des messages antérieurs de l'assistant est alors ajouté à l'entrée du modèle.
Pour connaître les modèles pris en charge et leurs valeurs par défaut, consultez les paramètres de Chat Completions et les paramètres DashScope.
L'activation de ce paramètre ne provoque aucune erreur si les messages de l'historique ne contiennent pas de champ reasoning_content .
Lorsque cette option est activée, le contenu de reasoning_content provenant de l'historique de conversation est comptabilisé dans les tokens d'entrée et la facturation.
  • Compatible OpenAI
  • DashScope
preserve_thinking n'est pas un paramètre standard OpenAI. Lors de l'utilisation du SDK Python, transmettez ce paramètre via extra_body.
  • Python
  • Node.js
  • HTTP

Exemples de code

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Configurations vary by region. Modify this based on your actual region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

# First turn of the conversation
messages = [
    {"role": "user", "content": "I need to choose a message queue for an E-commerce system that handles tens of millions of messages per day. Please provide a recommendation."}
]

first_reasoning = ""
first_content = ""
is_answering = False

completion = client.chat.completions.create(
    model="qwen4-max",
    messages=messages,
    extra_body={"enable_thinking": True},
    stream=True,
    stream_options={"include_usage": True},
)

print("=" * 20 + "First-turn thought process" + "=" * 20)

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        first_reasoning += delta.reasoning_content
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "First-turn response" + "=" * 20)
            is_answering = True
        print(delta.content, end="", flush=True)
        first_content += delta.content

# Second turn: Pass the thought process and ask why the model excluded Kafka
messages = [
    {"role": "user", "content": "I need to choose a message queue for an E-commerce system that handles tens of millions of messages per day. Please provide a recommendation."},
    {
        "role": "assistant",
        "content": first_content,
        "reasoning_content": first_reasoning,
    },
    {"role": "user", "content": "Why did you exclude Kafka in your comparison?"},
]

reasoning_content = ""
answer_content = ""
is_answering = False

# Pass preserve_thinking through extra_body
completion = client.chat.completions.create(
    model="qwen4-max",
    messages=messages,
    extra_body={
        "enable_thinking": True,
        "preserve_thinking": True,
    },
    stream=True,
    stream_options={"include_usage": True},
)

print("\n" + "=" * 20 + "Second-turn thought process" + "=" * 20)

for chunk in completion:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    if hasattr(delta, "reasoning_content") and delta.reasoning_content is not None:
        if not is_answering:
            print(delta.reasoning_content, end="", flush=True)
        reasoning_content += delta.reasoning_content
    if hasattr(delta, "content") and delta.content:
        if not is_answering:
            print("\n" + "=" * 20 + "Second-turn response" + "=" * 20)
            is_answering = True
        print(delta.content, end="", flush=True)
        answer_content += delta.content

Réponse

====================First-turn thought process====================
The user needs a message queue for an E-commerce system with tens of millions of daily messages. I will compare mainstream solutions based on dimensions such as throughput, reliability, delayed messages, and transaction support...

RocketMQ: Validated in Alibaba's E-commerce scenarios, natively supports transactional and delayed messages, and provides strict partition-level ordering...
Kafka: Extremely high throughput, but lacks native support for transactional and delayed messages, requiring custom compensation mechanisms...
RabbitMQ: Low latency, but limited cluster scalability, with a peak TPS in the tens of thousands...
====================First-turn response====================
Considering the core needs of an E-commerce scenario (transactional messages, delayed messages, ordering, and peak handling), I recommend Apache RocketMQ. If your team already has a Kafka ecosystem or requires strong real-time analytics, Kafka is also a viable option.
====================Second-turn thought process====================
The user is asking why Kafka was excluded. Reviewing my historical thought process, I did not exclude Kafka; I gave it a 4-star rating. I will refer to my previous detailed comparison to explain...

In the last turn, I compared the differences between RocketMQ and Kafka regarding transactional messages, delayed messages, and ordering. Kafka's main disadvantage is that it requires additional architectural design to compensate for E-commerce-specific semantics...
====================Second-turn response====================
I did not exclude Kafka. Kafka excels in throughput and ecosystem. The reason RocketMQ received a slightly higher rating is its better out-of-the-box match for core E-commerce workflows. RocketMQ natively supports transactional and delayed messages, while Kafka requires self-implementation through architectural patterns like the Outbox Pattern. If your team already has a Kafka ecosystem, it is fully capable of handling a scenario with tens of millions of messages.

Autres fonctionnalités

Facturation

  • Le contenu de réflexion est facturé par token de sortie.
  • Certains modèles à réflexion hybride appliquent des tarifs différents selon que le mode réflexion est activé ou non.
    Si un modèle en mode réflexion ne produit aucun résultat de raisonnement, la tarification hors réflexion s'applique.

FAQ

La procédure dépend du type de modèle :
  • Pour les modèles à réflexion hybride, tels que qwen-plus et deepseek-v4-pro, définissez enable_thinking sur false.
  • Pour les modèles exclusivement dédiés à la réflexion, comme glm-5.3 et kimi-k2.7-code, il est impossible de désactiver ce mode.
  • kimi-k3.1-pro et kimi-k3 activent la réflexion par défaut. Définissez enable_thinking=false pour la désactiver, mais il est recommandé de la maintenir activée. Pour kimi-k3.1-pro, sa désactivation dégrade considérablement la qualité de la sortie ; il est donc fortement recommandé de la maintenir activée.
Les exemples de cette rubrique utilisent le streaming par défaut (recommandé pour observer le raisonnement en temps réel et éviter une longue attente). Les modèles de réflexion commerciaux (tels que qwen-plus e qwen-flash) prennent également en charge la sortie non-streaming (synchrone), qui retourne l'intégralité du raisonnement et de la réponse en une seule fois.
Lors du passage d'un exemple du mode streaming au mode non-streaming, mettez également à jour le code d'analyse de la réponse : un appel non-streaming retourne un objet de réponse complet ( completion ). Ne l'itérez pas avec for chunk in completion comme dans l'exemple streaming (cela déclenche l'erreur 'tuple' object has no attribute 'choices' ). Lisez plutôt directement completion.choices[0].message.reasoning_content (raisonnement) et completion.choices[0].message.content (réponse). De plus, lorsque stream=False , ne définissez pas le paramètre stream_options .
L'exemple suivant appelle qwen3.8-max en mode réflexion sans streaming, via l'interface compatible OpenAI :
from openai import OpenAI
import os

client = OpenAI(
    # API keys differ by region. Get an API key: https://www.alibabacloud.com/help/en/model-studio/get-api-key
    # If the environment variable is not configured, replace the line below with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The following is the configuration for the Chine (Pékin) region. Replace WorkspaceId with your real workspace ID; configurations differ by region.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
    model="qwen4-max",  # Replace with a thinking model that supports non-streaming output
    messages=[{"role": "user", "content": "Who are you?"}],
    extra_body={"enable_thinking": True},
    stream=False,  # Non-streaming (synchronous) output; do not set stream_options when stream=False
)

# A non-streaming call returns a complete response object. Read message directly; do not iterate.
message = completion.choices[0].message
print("=" * 20 + "Reasoning" + "=" * 20 + "\n")
print(getattr(message, "reasoning_content", "") or "")
print("\n" + "=" * 20 + "Answer" + "=" * 20 + "\n")
print(message.content)
Certains modèles (comme les modèles open source qwen3.5-122b-a10b et qwen3.5-27b) ne prennent en charge que le streaming. Un appel non-streaming retourne l'erreur parameter.enable_thinking only support stream call ; utilisez le streaming pour ces modèles.
Rechargez votre compte dans le centre Dépenses et coûts. Votre compte ne doit présenter aucun impayé pour pouvoir appeler des modèles.
Une fois le quota gratuit épuisé, les appels sont facturés à la minute. Consultez vos dépenses dans Détails de la facture .
Ces modèles acceptent uniquement du texte. Qwen3-VL et QVQ prennent en charge la réflexion approfondie sur les images .
Une heure après l'appel d'un modèle, accédez à la page Monitoring (Singapore ou Beijing). Définissez les critères de requête, tels que la plage horaire et le workspace. Ensuite, dans la zone Models, localisez le modèle cible et cliquez sur Monitor dans la colonne Actions pour consulter ses statistiques d'appel. Pour plus d'informations, reportez-vous au document Monitoring.
Les données sont actualisées toutes les heures. En période de forte activité, un délai de l'ordre d'une heure peut survenir.
image

Référence API

Pour les paramètres d'entrée et de réponse, consultez Text Generation.

Codes d'erreur

En cas d'échec d'un appel, consultez Error codes.