Qwen3-Max-Thinking : prise en main du plus grand LLM au monde

Qwen3-Max-Thinking est devenu accessible au public en novembre 2025. Lorsque vous activez le mode "thinking", le modèle affiche son raisonnement avant de répondre. Vous voyez ainsi comment il procède sur des problèmes de mathématiques, des casse-têtes logiques et du code complexe. Le modèle comporte plus d’un billion de paramètres et gère jusqu’à 262 000 tokens.

Dans ce tutoriel, vous allez configurer l’accès API, tester le mode thinking sur différents problèmes et créer une application Streamlit qui exécute le même prompt avec Qwen3-Max-Thinking, GPT-5 et Claude Sonnet 4.5. Vous verrez comment chaque modèle aborde le problème et quand le mode thinking apporte un vrai plus. Voici un aperçu de l’application :

Qu’est-ce que Qwen3-Max-Thinking ?

Qwen3 Max Thinking est l’implémentation par Alibaba Cloud du modèle Qwen3-Max, lancée le 5 septembre 2025. Le "thinking" de son nom désigne un mode spécial où le modèle expose son raisonnement pas à pas avant de fournir une réponse.

Les performances du modèle sur des benchmarks de mathématiques et de raisonnement illustrent l’intérêt de cette fonctionnalité. Combinée à l’usage d’outils (comme des interprètes de code pour exécuter des calculs) et à une puissance de calcul accrue à l’inférence, elle lui a permis d’obtenir 100 % sur AIME25, l’American Invitational Mathematics Examination qui évalue des compétences avancées en mathématiques au lycée nécessitant un raisonnement en plusieurs étapes. Il a également atteint 100 % sur HMMT, le Harvard-MIT Math Tournament qui mesure la résolution de problèmes complexes. Ces benchmarks testent une véritable capacité de raisonnement, et non un simple appariement de motifs ou de la mémorisation.

Comment fonctionne le test-time compute

Le test-time compute explique en grande partie ces résultats exceptionnels. Au lieu d’utiliser des ressources de calcul uniquement pendant l’entraînement (quand le modèle apprend), il en utilise aussi pendant l’inférence (quand vous appelez l’API et que le modèle génère une réponse). Couplé à l’usage d’outils, le modèle peut vérifier son raisonnement et contrôler son travail via des ressources externes.

Comparaison de Qwen3-Max-Thinking avec GPT-5 et Claude Sonnet 4.5

Si Qwen3 égale GPT-5 et Claude Sonnet 4.5 sur certains benchmarks comme AIME25, les modèles diffèrent sur d’autres axes. Sur des tâches d’ingénierie logicielle (SWE-bench Verified), Claude mène avec 77,2 %, suivi par GPT-5 à 72,8 % et Qwen3 à 69,6 %. GPT-5 propose la plus grande fenêtre de contexte avec 400 000 tokens, contre 262 000 pour Qwen3 et 200 000 pour Claude.

Côté prix, avantage à Qwen3 avec 1,20 $ / 6,00 $ par million de tokens en entrée/sortie, soit environ la moitié du coût de GPT-5 (1,25 $ / 10,00 $) et 2,5 fois moins cher que Claude (3,00 $ / 15,00 $). Le mode thinking distingue Qwen3 en affichant des étapes de raisonnement explicites.

Le modèle étant encore en préversion et en cours d’entraînement, des résultats de benchmarks complets sur l’ensemble des tâches seront publiés une fois la version finale d’Alibaba disponible.

Mais les benchmarks ne racontent pas toute l’histoire. Pour vraiment prendre le pouls du modèle, nous créerons plus loin une application de comparaison avec GPT-5 et Claude Sonnet 4.5.

Configuration de l’accès API à Qwen3-Max-Thinking

Avant d’utiliser Qwen3 Max Thinking, vous aurez besoin de Python 3.8 ou plus, de pip, et d’une carte bancaire pour vous inscrire sur Alibaba Cloud. Lors de la création du compte, vous bénéficiez d’un quota gratuit, mais vous devrez tout de même renseigner un moyen de paiement.

Inscription à Alibaba Cloud et activation de Model Studio

Rendez-vous sur Alibaba Cloud et créez un compte. Pendant l’inscription, vous choisirez entre deux régions : International (Singapour) ou Chine (Pékin). La plupart des lecteurs hors Chine continentale devraient choisir la région International.

Ce choix est important, car chaque région dispose de son propre endpoint et de sa propre clé API, non interchangeables.

Après l’inscription, accédez à Model Studio dans la console. Vous devrez activer le service avant de pouvoir générer des clés API. Le tutoriel Qwen (Alibaba Cloud) détaille l’intégralité du processus d’ouverture de compte avec captures d’écran et explications.

Créer et sécuriser votre clé API

Une fois Model Studio activé, rendez-vous dans la section API Keys de la console. Générez une nouvelle clé et copiez-la immédiatement. Alibaba Cloud n’affiche la clé qu’une seule fois.

Stockez votre clé dans un fichier .env pour la séparer de votre code, et ajoutez ce fichier à votre .gitignore afin d’éviter de commettre votre clé par inadvertance dans le contrôle de version.

Installer les packages Python et configurer l’environnement

Qwen3 Max Thinking utilise une API compatible OpenAI, vous pouvez donc recourir au SDK Python standard d’OpenAI. Installez-le avec python-dotenv pour la gestion des variables d’environnement :

pip install openai python-dotenvPropulsé par

Créez un fichier .env dans le répertoire de votre projet :

DASHSCOPE_API_KEY=your_key_herePropulsé par

Remplacez your_key_here par votre clé API. Écrivez maintenant un court script de test pour vérifier que tout fonctionne :

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[{"role": "user", "content": "Say hello in one sentence."}]
)

print(completion.choices[0].message.content)Propulsé par

Exécutez ce script. Si vous voyez une erreur sur une clé API invalide, vérifiez que vous avez correctement copié la clé et que vous utilisez le bon base URL pour votre région.

Si le script s’exécute sans erreur, vous devriez obtenir une sortie similaire :

Hello! How can I assist you today?Propulsé par

Comprendre le mode thinking de Qwen3-Max

Vous venez d’effectuer un appel API basique. Activez maintenant le mode thinking pour voir le modèle résoudre les problèmes étape par étape.

Activer le mode thinking avec extra_body

Pour activer le mode thinking, ajoutez enable_thinking: True dans le paramètre extra_body. Voici un exemple avec un prompt bien adapté au raisonnement pas à pas :

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?"}
   ],
   extra_body={"enable_thinking": True}
)

print("Reasoning:", completion.choices[0].message.reasoning_content)
print("\nFinal answer:", completion.choices[0].message.content)Propulsé par

La réponse comporte deux parties. Le champ reasoning_content affiche le raisonnement interne du modèle, où il déroule la résolution étape par étape. Le champ content fournit la réponse finale. Quand le mode thinking est désactivé, reasoning_content renvoie None.

Voici à quoi ressemble la sortie (raisonnement tronqué) :

Reasoning: The problem: "If I have 3 apples and buy 2 more packs of 4 apples each, then give away half, how many do I have left?" Starting with 3 apples. Then buy 2 packs of 4 apples each: that's 2 * 4 = 8 apples. So total after buying is 3 + 8 = 11 apples. Then give away half: half of 11 is 5.5 apples...

Final answer:
1. Start with: 3 apples.
2. Buy 2 packs of 4 apples each → 2 × 4 = 8 apples.
3. Total after buying: 3 + 8 = 11 apples.
4. Give away half: 11/2 = 5.5 apples.

Answer: You have 5½ apples left.Propulsé par

Maîtriser les coûts avec thinking_budget

Comme le raisonnement consomme des tokens supplémentaires, vous pouvez contrôler les coûts avec le paramètre thinking_budget. Ajoutez-le à extra_body aux côtés de enable_thinking :

completion = client.chat.completions.create(
   model="qwen3-max-preview",
   messages=[
       {"role": "user", "content": "Explain why 0.1 + 0.2 doesn't equal 0.3 in Python."}
   ],
   extra_body={
       "enable_thinking": True,
       "thinking_budget": 1000
   }
)Propulsé par

Le paramètre thinking_budget fixe le nombre maximal de tokens que le modèle peut utiliser pour raisonner. Pour des problèmes simples, 500–1000 tokens suffisent. Un raisonnement complexe en plusieurs étapes peut nécessiter 2000–5000 tokens. Si le modèle atteint la limite, il arrête le raisonnement et fournit une réponse finale sur la base des éléments déjà établis.

Vous avez maintenant manipulé le mode thinking de Qwen3. GPT-5 et Claude proposent eux aussi des fonctions de raisonnement, avec une syntaxe et des approches différentes. Pour comparer ces modèles, construisons une application qui teste les trois côte à côte.

Créer une application de chat de comparaison multi-modèles

Vous allez créer une application Streamlit qui envoie le même prompt simultanément à Qwen3 Max Thinking, GPT-5 et Claude Sonnet 4.5. L’application affiche les trois réponses côte à côte pour comparer la façon dont chaque modèle raisonne.

Vous pouvez consulter le code complet du projet dans ce Gist GitHub.

Notez que les sections suivantes proposent un découpage pas à pas de ce script. Si vous souhaitez uniquement les résultats de l’application, passez directement à la section suivante. Cette analyse est à visée pédagogique et vous montre comment structurer des applications à base de LLM avec une interface Streamlit.

Étape 1 : mise en place du projet et dépendances

Installez Streamlit pour l’interface web et le SDK d’Anthropic pour Claude. Vous disposez déjà du SDK OpenAI depuis l’étape d’accès API.

pip install streamlit anthropicPropulsé par

Créez un nouveau fichier nommé model_comparison_chat.py avec les imports et la configuration de l’environnement :

import os
import time
from typing import Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
import streamlit as st
from openai import OpenAI
from anthropic import Anthropic

load_dotenv()Propulsé par

Étape 2 : configurer les connexions API

Vous avez déjà configuré Qwen3 dans la section 3. Ajoutez maintenant les clés API de GPT-5 et Claude à votre fichier .env  :

DASHSCOPE_API_KEY=your_alibaba_cloud_key
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_keyPropulsé par

Pour l’accès à GPT-5 et les tarifs, consultez le guide GPT-5. Pour Claude Sonnet 4.5, voyez la présentation de Claude Sonnet 4.5.

Initialisez les trois clients API :

QWEN_CLIENT = OpenAI(
   api_key=os.getenv("DASHSCOPE_API_KEY"),
   base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
)
GPT_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CLAUDE_CLIENT = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))Propulsé par

Étape 3 : créer des fonctions utilitaires pour chaque modèle

Plutôt que d’écrire une fonction par API, utilisez une fonction unifiée qui gère les trois modèles. Voici le début pour Qwen3 :

def call_model(model_name: str, messages: List[Dict], **kwargs) -> Dict:
   """Call any model with unified interface."""
   try:
       start_time = time.time()

       if model_name == "Qwen3 Max Thinking":
           enable_thinking = kwargs.get("enable_thinking", True)
           extra_body = {"enable_thinking": enable_thinking}

           completion = QWEN_CLIENT.chat.completions.create(
               model="qwen3-max-preview",
               messages=messages,
               extra_body=extra_body
           )
           reasoning_content = getattr(
               completion.choices[0].message,
               'reasoning_content',
               None
           )
           # Extract content and token info, then continue belowPropulsé par

GPT-5 fonctionne différemment : il utilise l’API responses avec des niveaux d’effort de raisonnement configurables (suite de la même fonction) :

       elif model_name == "GPT-5":
           reasoning_effort = kwargs.get("reasoning_effort", "medium")

           response = GPT_CLIENT.responses.create(
               model="gpt-5",
               input=messages,
               reasoning={
                   "effort": reasoning_effort,
                   "summary": "auto"
               }
           )
           # Extract response data, then continue belowPropulsé par

GPT-5 propose quatre niveaux d’effort : minimal, low, medium et high. Plus l’effort est élevé, meilleure est la qualité, mais les réponses sont plus lentes et plus coûteuses.

Claude Sonnet 4.5 adopte une autre approche (suite de la même fonction) :

       else:  # Claude Sonnet 4.5
           enable_thinking = kwargs.get("enable_thinking", True)
           params = {
               "model": "claude-sonnet-4-5",
               "max_tokens": 10000,
               "messages": messages
           }
           if enable_thinking:
               params["thinking"] = {
                   "type": "enabled",
                   "budget_tokens": 5000
               }

           message = CLAUDE_CLIENT.messages.create(**params)
           # Parse thinking blocks from response, then continue belowPropulsé par

Remarque : le mode thinking de Claude fonctionne différemment de celui de Qwen3. Au lieu d’un champ reasoning_content séparé, Claude inclut des blocs de thinking dans le contenu à analyser. C’est une différence clé entre les modèles.

Les trois branches de la fonction convergent pour retourner la même structure (fin de la fonction) :

    return {
               "content": content_text,
               "reasoning_content": thinking_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": input_tokens,
                   "output": output_tokens,
                   "total": total_tokens
               },
               "error": None
           }

   except Exception as e:
       return {
           "content": None,
           "reasoning_content": None,
           "response_time": 0,
           "tokens_used": {"input": 0, "output": 0, "total": 0},
           "error": f"{model_name} Error: {str(e)}"
       }Propulsé par

Ce format de retour standard facilite l’affichage des résultats de n’importe quel modèle avec le même code.

Étape 4 : construire l’interface Streamlit

Maintenant que vous comprenez le fonctionnement des API, créez l’interface web. Commencez par la configuration de base de la page Streamlit :

def main():
   st.set_page_config(
       page_title="Multi-Model Comparison Chat",
       page_icon="🤖",
       layout="wide",
       initial_sidebar_state="expanded"
   )

   st.session_state.setdefault("messages", [])
   st.session_state.setdefault("model_responses", [])Propulsé par

L’état de session conserve l’historique de conversation et les réponses des modèles entre les rafraîchissements de page (lors des interactions).

Ajoutez le titre et les commandes de la barre latérale pour configurer le mode thinking :

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Qwen3 Max Thinking**, **GPT-5**, and **Claude Sonnet 4.5** side-by-side.
   All three models support reasoning modes - see how they approach problems differently.
   """)

   with st.sidebar:
       st.header("⚙️ Settings")

       st.subheader("Thinking Mode")
       qwen_thinking = st.checkbox("Enable Qwen3 Thinking", value=True)
       gpt5_reasoning = st.selectbox(
           "GPT-5 Reasoning Effort",
           options=["minimal", "low", "medium", "high"],
           index=2
       )
       claude_thinking = st.checkbox("Enable Claude Thinking", value=True)Propulsé par

Ajoutez des indicateurs d’état des API :

st.subheader("API Status")
       st.markdown(f"""
       - Qwen3: {"✅" if os.getenv("DASHSCOPE_API_KEY") else "❌"}
       - GPT-5: {"✅" if os.getenv("OPENAI_API_KEY") else "❌"}
       - Claude: {"✅" if os.getenv("ANTHROPIC_API_KEY") else "❌"}
       """)Propulsé par

Cela indique quelles clés API sont configurées. Si vous voyez des croix rouges, vérifiez votre fichier .env.

Étape 5 : implémenter la logique de comparaison

def call_models_parallel(messages: List[Dict], selected_models: List[str], qwen_thinking: bool, gpt5_reasoning: str, claude_thinking: bool) -> Dict[str, Dict]:
   """Call multiple models in parallel."""
   model_kwargs = {
       "Qwen3 Max Thinking": {"enable_thinking": qwen_thinking},
       "GPT-5": {"reasoning_effort": gpt5_reasoning},
       "Claude Sonnet 4.5": {"enable_thinking": claude_thinking}
   }

   with ThreadPoolExecutor(max_workers=3) as executor:
       futures = {
           executor.submit(call_model, m, messages, **model_kwargs[m]): m
           for m in selected_models if m in model_kwargs
       }
       return {futures[f]: f.result() for f in as_completed(futures)}Propulsé par

Plutôt que d’attendre les réponses séquentiellement, l’exécution en parallèle appelle les trois modèles en même temps, ce qui réduit le temps d’attente total.

Intégrez cela à l’interface de chat et affichez les réponses côte à côte :

if prompt := st.chat_input("Ask a question to all models..."):
       st.session_state.messages.append({"role": "user", "content": prompt})

       with st.spinner("🤔 Models are thinking..."):
           responses = call_models_parallel(
               st.session_state.messages,
               ["Qwen3 Max Thinking", "GPT-5", "Claude Sonnet 4.5"],
               qwen_thinking,
               gpt5_reasoning,
               claude_thinking
           )

       cols = st.columns(3)
       for idx, (model_name, response_data) in enumerate(responses.items()):
           with cols[idx]:
               st.markdown(f"### {model_name}")
               if response_data["reasoning_content"]:
                   with st.expander("🧠 Thinking Process", expanded=False):
                       st.markdown(response_data["reasoning_content"])
               st.markdown(response_data["content"])Propulsé par

Trois colonnes sont créées, une par modèle. Le processus de raisonnement est replié par défaut afin de laisser la priorité aux réponses finales.

Étape 6 : tester et affiner

Lancez l’application avec :

streamlit run model_comparison_chat.pyPropulsé par

Commencez par une question de vérification simple, comme « What is 2+2? », pour confirmer que vos connexions API fonctionnent et que l’exécution en parallèle est opérationnelle.

Une fois la base validée, vous pouvez tester les modèles avec des prompts complexes qui mettront en évidence leurs différences d’approche.

Tester l’application avec des prompts complexes

Avec l’application de comparaison en cours d’exécution, mettez-la à l’épreuve avec des problèmes plus difficiles. Essayez ces prompts pour voir comment les modèles s’y prennent.

Les prompts de test

Voici trois prompts qui révèlent clairement le style de raisonnement de chaque modèle.

Test 1 : raisonnement mathématique avancé

Une pizza circulaire est coupée en 8 parts égales. Alice mange 3 parts, puis Bob mange la moitié de ce qui reste. Ensuite, Charlie prend 1 part, et enfin Dana mange 40 % des parts restantes. Combien de parts restent‑il ? Par ailleurs, si la pizza initiale avait un diamètre de 16 pouces, quelle est la surface totale (en pouces carrés) de pizza consommée ?

Test 2 : raisonnement logique en plusieurs étapes

Cinq amis — Amy, Ben, Clara, David et Emma — sont assis en rangée au

cinéma. Les conditions suivantes doivent être respectées :

1. Amy doit être assise à côté de Ben

2. Clara ne peut pas être assise à côté de David

3. Emma doit être assise à une extrémité

4. Ben ne peut être assis à aucune extrémité. Compte tenu de ces contraintes, listez tous les placements possibles de gauche à droite.

Test 3 : génération de code avec contraintes

Écrivez une fonction Python qui trouve la plus longue sous-chaîne palindrome dans une chaîne donnée, avec les exigences suivantes :

1. Complexité temporelle O(n²) ou meilleure

2. Prise en charge correcte des caractères Unicode

3. Retourner la première occurrence s’il y a plusieurs palindromes de même longueur

4. Inclure une docstring détaillée avec des exemples

5. Ajouter des annotations de type

6. Gérer les cas limites (chaîne vide, caractère unique, aucun palindrome).

Expliquez également votre choix d’algorithme

et pourquoi il respecte la contrainte de complexité.

Résultats

Les trois modèles ont réussi chaque problème. Voici leurs performances :

Qwen3 met 10 fois plus de temps que Claude et utilise 3 à 4 fois plus de tokens.

L’approche de Qwen3

Il considère tous les angles. Sur le problème de la pizza, il s’est interrogé sur la pertinence des parts fractionnaires, a envisagé un arrondi aux parts entiières, a validé plusieurs fois les calculs et a étudié des interprétations alternatives avant de se décider.

On le voit en permanence se dire « et si ? » puis « mais peut-être que ». Pour le problème de placement, il a passé en revue : « si Ben est ici, où Amy peut-elle aller ? » pour chaque possibilité.

La solution sur le palindrome s’accompagnait d’une analyse poussée expliquant le choix de l’algorithme face aux alternatives, la prise en charge des cas limites Unicode et une analyse de complexité très détaillée. C’est comme observer quelqu’un penser à voix haute et se relire sans cesse.

L’approche de GPT-5

Structuré et méthodique. Il expose le problème, déroule les étapes dans l’ordre et vérifie les résultats. Moins d’exploration, plus d’exécution.

Sur le puzzle de placement, il a d’abord posé Emma en bout de rangée, puis a rempli les positions en respectant les règles.

Le code du palindrome venait avec une justification claire du choix d’algorithme et une documentation solide. Il suit un plan sans trop de retour en arrière. Il y a assez de détail pour comprendre le raisonnement, sans remise en question permanente.

L’approche de Claude

Rapide et efficace. Il identifie très vite la bonne voie et l’exécute proprement. Pour le placement, il a structuré en cas (Emma en position 1 vs position 5) et a traité chaque scénario. Le code du palindrome était propre et bien documenté, mais plus direct. Il montre son travail sans s’attarder.

Conclusion pratique : choisissez Qwen3 lorsque vous avez besoin de tout le raisonnement détaillé derrière une solution. Ce niveau de transparence aide pour l’apprentissage ou la validation de décisions complexes. Privilégiez Claude quand la vitesse prime et que vous faites confiance à la réponse sans voir chaque étape. Optez pour GPT-5 si vous cherchez un équilibre entre les deux.

Note : ces tests ne reflètent pas l’intégralité des capacités des trois modèles. Vos résultats peuvent varier selon les prompts.

Conclusion

Dans ce tutoriel, je vous ai montré comment configurer Qwen3 Max Thinking, tester son mode thinking sur différents types de problèmes et construire une application de comparaison qui exécute des prompts via Qwen3, GPT-5 et Claude Sonnet 4.5 côte à côte.

L’enseignement clé : chaque modèle a ses points forts selon les scénarios. Qwen3 excelle quand vous avez besoin d’un raisonnement fouillé et d’une compréhension pas à pas. Claude l’emporte en vitesse et exécution propre. GPT-5 offre un bon compromis.

Servez-vous de votre application de comparaison pour tester ces modèles sur vos propres problèmes. À force d’expérimenter, vous saurez rapidement lequel convient le mieux à vos besoins.

Pour aller plus loin avec Qwen3 et le développement multi-modèles, consultez le tutoriel OpenRouter pour gérer plusieurs APIs de modèles, ou apprenez à exécuter localement des modèles Qwen3 plus petits avec Ollama pour un développement hors ligne.