Qwen3-Max-Thinking: prova pratica con il più grande LLM al mondo

Qwen3-Max-Thinking è diventato pubblico a novembre 2025. Quando attivi la modalità thinking, il modello mostra il suo ragionamento prima di rispondere. Puoi vedere come lavora su problemi di matematica, rompicapi logici e codice complesso. Il modello ha oltre 1 trilione di parametri e gestisce fino a 262k token.

In questo tutorial, configurerai l’accesso API, testerai la modalità thinking su diversi problemi e costruirai un’app Streamlit che esegue lo stesso prompt con Qwen3-Max-Thinking, GPT-5 e Claude Sonnet 4.5. Vedrai come ogni modello affronta il problema e quando la modalità thinking aiuta. Ecco un’anteprima dell’app:

Che cos’è Qwen3-Max-Thinking?

Qwen3 Max Thinking è l’implementazione su Alibaba Cloud del modello Qwen3-Max, lanciato il 5 settembre 2025. Il "thinking" nel nome si riferisce a una modalità speciale in cui il modello espone il suo processo di ragionamento passo dopo passo prima di fornire una risposta.

Le prestazioni del modello sui benchmark di matematica e ragionamento mostrano cosa offre questa funzione. Se combinata con l’uso di strumenti (come interpreti di codice per eseguire calcoli) e con test-time compute scalato, ha ottenuto il 100% su AIME25, l’American Invitational Mathematics Examination che verifica la matematica avanzata delle scuole superiori con ragionamenti multi-step. Ha raggiunto il 100% anche su HMMT, l’Harvard-MIT Math Tournament che misura la risoluzione di problemi complessi. Questi benchmark testano la reale capacità di ragionamento, non il semplice pattern matching o la memorizzazione.

Come funziona il test-time compute

Il test-time compute è il modo in cui il modello raggiunge prestazioni eccezionali nei benchmark. Invece di usare risorse computazionali solo durante l’addestramento (quando il modello impara), le usa anche in inferenza (quando fai una chiamata API e il modello genera una risposta). In combinazione con l’uso di strumenti, il modello può verificare il suo ragionamento e controllare il lavoro rispetto a risorse esterne.

Come si confronta Qwen3-Max-Thinking con GPT-5 e Claude Sonnet 4.5

Sebbene Qwen3 sia alla pari con GPT-5 e Claude Sonnet 4.5 su alcuni benchmark come AIME25, i modelli differiscono in altre aree. Nei compiti di ingegneria del software misurati da SWE-bench Verified, guida Claude al 77,2%, seguito da GPT-5 al 72,8% e Qwen3 al 69,6%. GPT-5 offre la finestra di contesto più ampia con 400k token, rispetto ai 262k di Qwen3 e ai 200k di Claude.

Il vantaggio di prezzo va a Qwen3 con $1,20/$6,00 per milione di token in input/output, circa la metà del costo di GPT-5 ($1,25/$10,00) e 2,5 volte più economico di Claude ($3,00/$15,00). La modalità thinking distingue Qwen3 mostrando passaggi di ragionamento espliciti.

Poiché il modello è ancora in anteprima e in addestramento, risultati di benchmark completi su tutti i compiti saranno disponibili quando Alibaba rilascerà la versione finale.

Tuttavia, i benchmark non raccontano tutto. Per capire come si comporta davvero il modello, più avanti creeremo un’app di confronto per paragonarlo a GPT-5 e Claude Sonnet 4.5.

Configurare l’accesso API a Qwen3-Max-Thinking

Prima di usare Qwen3 Max Thinking, ti serviranno Python 3.8 o superiore, pip e una carta di credito per registrarti su Alibaba Cloud. Quando crei un account, otterrai un limite di utilizzo gratuito, ma dovrai comunque fornire i dati di pagamento.

Registrati su Alibaba Cloud e attiva Model Studio

Vai su Alibaba Cloud e crea un account. Durante la registrazione, sceglierai tra due regioni: International (Singapore) o China (Beijing). La maggior parte dei lettori fuori dalla Cina continentale dovrebbe scegliere la regione International.

Questa scelta è importante perché ogni regione ha il proprio endpoint e la propria chiave API non intercambiabili.

Dopo la registrazione, vai su Model Studio nella console. Dovrai attivare il servizio prima di poter generare le chiavi API. Il tutorial su Qwen (Alibaba Cloud) spiega l’intera procedura di configurazione dell’account, con screenshot e spiegazioni dettagliate.

Crea e proteggi la tua chiave API

Una volta attivato Model Studio, vai alla sezione API Keys nella console. Genera una nuova chiave e copiala subito. Alibaba Cloud mostra la chiave una sola volta.

Archivia la chiave in un file .env per tenerla separata dal codice e aggiungi questo file a .gitignore per evitare di fare commit della chiave API nel controllo versione per errore.

Installa i pacchetti Python e configura l’ambiente

Qwen3 Max Thinking usa un’API compatibile con OpenAI, quindi puoi usare il classico SDK Python di OpenAI. Installalo insieme a python-dotenv per la gestione delle variabili d’ambiente:

pip install openai python-dotenvOfferto da

Crea un file .env nella directory del progetto:

DASHSCOPE_API_KEY=your_key_hereOfferto da

Sostituisci your_key_here con la tua chiave API. Ora scrivi uno script di test veloce per verificare che tutto funzioni:

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)Offerto da

Esegui questo script. Se vedi un errore relativo a chiavi API non valide, ricontrolla di aver copiato correttamente la chiave e di usare il base URL corretto per la tua regione.

Se lo script gira senza errori, dovresti ottenere un output simile al seguente:

Hello! How can I assist you today?Offerto da

Capire la modalità Thinking di Qwen3-Max

Hai appena fatto una chiamata API di base. Ora attiva la modalità thinking per vedere il modello lavorare sui problemi passo dopo passo.

Abilita la modalità thinking con extra_body

Per attivare la modalità thinking, aggiungi enable_thinking: True all’interno del parametro extra_body. Ecco un esempio con un prompt che si presta bene al ragionamento passo passo:

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)Offerto da

La risposta ha due parti. Il campo reasoning_content mostra il processo di pensiero interno del modello, in cui affronta il problema passo dopo passo. Il campo content ti dà la risposta finale. Quando la modalità thinking è disattivata, reasoning_content restituisce None.

Ecco come appare l’output (ragionamento troncato):

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.Offerto da

Controlla i costi con thinking_budget

Poiché il ragionamento usa token aggiuntivi, puoi controllare i costi con il parametro thinking_budget. Aggiungilo a extra_body insieme a 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
   }
)Offerto da

Il parametro thinking_budget imposta il numero massimo di token che il modello può usare per il ragionamento. Per problemi semplici, 500-1000 token vanno bene. Un ragionamento multi-step complesso può richiedere 2000-5000 token. Se il modello raggiunge il limite di budget, interrompe il processo di ragionamento e fornisce una risposta finale basata su quanto elaborato fino a quel momento.

Ora hai provato la modalità thinking di Qwen3. Anche GPT-5 e Claude hanno funzioni di reasoning con sintassi e approcci diversi. Per vedere come si confrontano, costruiamo un’app che testi tutti e tre fianco a fianco.

Creare un’app di chat per il confronto multi-modello

Costruirai un’app Streamlit che invia lo stesso prompt a Qwen3 Max Thinking, GPT-5 e Claude Sonnet 4.5 contemporaneamente. L’app mostra le tre risposte affiancate così puoi confrontare come ciascun modello ragiona sui problemi.

Puoi vedere il codice completo del progetto in questo Gist su GitHub. 

Nota che le sezioni seguenti offrono un’analisi dettagliata di quello script, quindi se ti interessano solo i risultati dell’app, passa direttamente alla sezione successiva. La scomposizione dello script è a scopo didattico e ti mostra come strutturare applicazioni simili basate su LLM con un’interfaccia Streamlit. 

Passo 1: setup del progetto e dipendenze

Installa Streamlit per l’interfaccia web e l’SDK di Anthropic per Claude. Hai già l’SDK di OpenAI dalla sezione di setup dell’API.

pip install streamlit anthropicOfferto da

Crea un nuovo file chiamato model_comparison_chat.py con gli import e la configurazione dell’ambiente:

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()Offerto da

Passo 2: configura le connessioni API

Hai già configurato Qwen3 nella Sezione 3. Ora aggiungi le chiavi API di GPT-5 e Claude al tuo file .env:

DASHSCOPE_API_KEY=your_alibaba_cloud_key
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_keyOfferto da

Per accesso e prezzi di GPT-5, vedi la guida a GPT-5. Per Claude Sonnet 4.5, consulta la panoramica di Claude Sonnet 4.5.

Inizializza tutti e tre i client 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"))Offerto da

Passo 3: crea funzioni helper per ciascun modello

Invece di scrivere funzioni separate per ogni API, usa un’unica funzione che gestisce tutti e tre i modelli. Ecco l’inizio della funzione per 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 belowOfferto da

GPT-5 funziona in modo diverso, usando le responses API con livelli di impegno nel reasoning configurabili (continuazione della stessa funzione):

       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 belowOfferto da

GPT-5 ha quattro livelli di impegno nel reasoning: minimal, low, medium e high. Un impegno più alto significa qualità migliore ma risposte più lente e costi maggiori.

Claude Sonnet 4.5 adotta un altro approccio (sempre nella stessa funzione):

       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 belowOfferto da

Nota: la modalità thinking di Claude funziona diversamente da Qwen3. Invece di un reasoning_content separato, Claude include thinking blocks nel contenuto della risposta che devi estrarre. Questa è una differenza chiave nel confronto tra i modelli.

Tutti e tre i rami della funzione convergono per restituire la stessa struttura (fine della funzione):

    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)}"
       }Offerto da

Questo formato di ritorno standardizzato rende semplice visualizzare le risposte di qualsiasi modello con lo stesso codice.

Passo 4: costruisci l’interfaccia Streamlit

Ora che hai capito come funziona l’API di ciascun modello, crea l’interfaccia web. Parti dalla configurazione base della pagina 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", [])Offerto da

Lo stato di sessione traccia la cronologia della conversazione e le risposte dei modelli tra un rerun e l’altro (quando Streamlit aggiorna la pagina dopo le interazioni).

Aggiungi il titolo e i controlli della sidebar per configurare la modalità 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)Offerto da

Aggiungi indicatori di stato delle 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 "❌"}
       """)Offerto da

Questo mostra quali chiavi API sono configurate. Se vedi delle X rosse, controlla il file .env.

Passo 5: implementa la logica di confronto

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)}Offerto da

Invece di aspettare che ogni modello risponda in sequenza, l’esecuzione in parallelo li chiama tutti e tre insieme, riducendo il tempo totale di attesa.

Integralo nell’interfaccia della chat e mostra le risposte affiancate:

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"])Offerto da

Questo crea tre colonne, una per ciascun modello. Il processo di thinking rimane compresso di default, così gli utenti possono concentrarsi sulle risposte finali.

Passo 6: test e rifinitura

Esegui l’app con:

streamlit run model_comparison_chat.pyOfferto da

Inizia con una domanda di controllo semplice come “Quanto fa 2+2?” per confermare che le connessioni API funzionano e che l’esecuzione in parallelo è operativa.

Una volta confermata la funzionalità di base, sei pronto a testare i modelli con prompt complessi che evidenziano i loro diversi approcci al reasoning.

Testare l’app con prompt complessi

Con l’app di confronto in esecuzione, provala con problemi più difficili. Esegui questi prompt nella tua app per vedere come i diversi modelli li affrontano.

I prompt di test

Ecco tre prompt che mostrano pattern chiari su come pensa ciascun modello.

Test 1: ragionamento matematico avanzato

Una pizza circolare è tagliata in 8 fette uguali. Alice mangia 3 fette, poi Bob mangia metà di quelle rimaste. Poi Charlie prende 1 fetta e infine Dana mangia il 40% delle fette rimanenti. Quante fette restano? Inoltre, se la pizza originale aveva un diametro di 16 pollici, qual è l’area totale (in pollici quadrati) della pizza che è stata consumata?

Test 2: ragionamento logico multi-step

Cinque amici - Amy, Ben, Clara, David ed Emma - sono seduti in fila al

cinema. Devono essere soddisfatte le seguenti condizioni:

1. Amy deve sedere accanto a Ben

2. Clara non può sedere accanto a David

3. Emma deve sedere a una delle estremità

4. Ben non può sedere a nessuna delle estremità. Dati questi vincoli, elenca tutte le possibili disposizioni dei posti da sinistra a destra.

Test 3: generazione di codice con vincoli

Scrivi una funzione Python che trovi la sottostringa palindroma più lunga in una stringa data, ma con questi requisiti specifici:

1. La complessità temporale deve essere O(n²) o migliore

2. Deve gestire correttamente i caratteri Unicode

3. Deve restituire la prima occorrenza se ci sono più palindromi della stessa lunghezza

4. Includi una docstring dettagliata con esempi

5. Aggiungi type hints

6. Gestisci i casi limite (stringa vuota, singolo carattere, nessun palindromo).

Spiega anche la scelta dell’algoritmo

e perché soddisfa il requisito di complessità.

Risultati

Tutti e tre i modelli hanno risolto correttamente ogni problema. Ecco come si sono comportati:

Qwen3 impiega 10 volte più tempo di Claude e usa 3–4 volte più token.

L’approccio di Qwen3

Considera tutto. Sul problema della pizza, si è chiesto se le frazioni di fetta avessero senso, ha valutato se arrotondare ai numeri interi, ha validato i calcoli più volte ed esaminato interpretazioni alternative prima di fissare una risposta. 

Lo vedi pensare “e se” e “ma forse” in tutto il processo. Per il problema dei posti, ha lavorato su “se Ben siede qui, dove può andare Amy” per ogni possibilità. 

La soluzione al palindromo è arrivata con un’analisi approfondita del perché ha scelto quell’algoritmo rispetto alle alternative, di come gestisce i casi limite Unicode e con una scomposizione accurata della complessità. È come guardare qualcuno pensare ad alta voce e ricontrollare continuamente il proprio lavoro.

L’approccio di GPT-5

È strutturato e metodico. Ha esposto ogni problema, ha seguito i passaggi in ordine e ha verificato i risultati. Meno esplorazione, più esecuzione. 

Nel rompicapo dei posti, ha messo prima Emma a un’estremità, poi ha riempito le posizioni rispettando le regole. 

Il codice per il palindromo è arrivato con un ragionamento chiaro sulla scelta dell’algoritmo e una documentazione solida. Segue un piano senza molti ripensamenti. Hai dettagli sufficienti per capire il thinking, ma non si mette continuamente in discussione.

L’approccio di Claude 

Si muove veloce. Individua rapidamente il percorso di soluzione ed esegue in modo pulito. Per il problema dei posti, ha organizzato per casi (Emma in posizione 1 vs posizione 5) e ha lavorato su ciascuno. Il codice per il palindromo era pulito e ben documentato, ma è andato dritto al punto. Mostra il lavoro ma senza indugiare. Vedi il thinking, ma è conciso.

La lezione pratica: usa Qwen3 quando hai bisogno di vedere ogni considerazione alla base di una soluzione. Il thinking dettagliato aiuta quando stai imparando dal modello o stai validando decisioni complesse. Usa Claude quando la velocità conta e ti fidi che arrivi alla risposta senza mostrarti ogni passaggio. Usa GPT-5 quando vuoi qualcosa tra questi estremi.

Nota: questi test non possono catturare pienamente le capacità dei tre modelli. I tuoi risultati possono variare con prompt diversi.

Conclusione

In questo tutorial, ti ho mostrato come configurare Qwen3 Max Thinking, testare la sua modalità thinking con diversi tipi di problemi e costruire un’app di confronto che esegue i prompt con Qwen3, GPT-5 e Claude Sonnet 4.5 fianco a fianco. 

L’idea chiave è che ogni modello ha punti di forza in scenari diversi. Qwen3 eccelle quando ti serve un ragionamento dettagliato e vuoi capire ogni passaggio. Claude vince per velocità ed esecuzione pulita. GPT-5 bilancia i due approcci.

Usa la tua app di confronto per testare questi modelli con i tuoi problemi. Sperimentando con compiti diversi, svilupperai un’intuizione su quale modello funziona meglio per le tue esigenze.

Per approfondire Qwen3 e lo sviluppo multi-modello, dai un’occhiata al tutorial su OpenRouter per gestire più API di modelli, oppure scopri come eseguire localmente modelli Qwen3 più piccoli con Ollama per lo sviluppo offline.