Qwen3-Next: una guida con progetto demo

Il team di Qwen ha recentemente lanciato il modello Qwen3-Next-80B-A3B, che unisce ragionamento avanzato, gestione di contesti ultra-lunghi ed eccezionale velocità d'inferenza grazie a un'architettura ibrida Mixture-of-Experts (MoE).

In questa guida, mi concentrerò su come Qwen3-Next-80B-A3B si comporta in compiti pratici e reali rispetto ai precedenti modelli Qwen, come Qwen3-30B-A3B. Invece di benchmark astratti, eseguiremo test pratici affiancati, inclusi ragionamento, codice e prompt su documenti ultra-lunghi, così potrai vedere i compromessi in termini di velocità, qualità dell'output e utilizzo della memoria GPU.

Passo dopo passo, ti mostrerò come:

• Accedere e interagire sia con Qwen3-Next-80B-A3B che con Qwen3-30B-A3B tramite l'API OpenRouter, senza necessità di setup
• Creare un'app Streamlit per il confronto immediato, affiancato, delle risposte dei modelli, della latenza e dell'uso delle risorse
• Eseguire esperimenti di retrieval su contesti ultra-lunghi (100K+ token) per testare i veri limiti dei modelli
• Analizzare metriche di performance reali come latenza, token/sec e utilizzo della VRAM.

Alla fine, la tua app apparirà così:

Che cos'è Qwen3-Next?

Qwen3-Next è un modello Mixture-of-Experts (MoE) da 80B parametri. In pratica, attiva solo 3B parametri per token, risultando fino a dieci volte più economico da addestrare e dieci volte più veloce da eseguire rispetto ai vecchi modelli densi (come Qwen3-32B), eguagliandoli o superandoli in qualità.

Alcuni progressi chiave di questo modello includono:

• Architettura ibrida: Qwen3-Next usa un mix 75:25 di Gated DeltaNet (per un'attenzione lineare veloce) e Gated Attention (per richiamo profondo), combinando i punti di forza di entrambi i metodi.
• MoE ultra-sparso: impiega 512 esperti ma ne attiva solo 10+1 per inferenza, riducendo il calcolo di oltre il 90% rispetto agli LLM densi
• Predizione multi-token: questo modello supporta lo speculative decoding per enormi guadagni di velocità, soprattutto in streaming o chat.
• Contesto estremamente lungo: elabora fino a 256K token nativamente (1M+ con scaling YaRN) con cali minimi di performance, ed è ideale per libri lunghi, codebase, ecc.

Fonte: Qwen

Il modello Qwen 3 Next è disponibile in due varianti:

• Qwen3-Next-80B-A3B-Instruct: questo modello è progettato per chat generica, coding e open QA.
• Qwen3-Next-80B-A3B-Thinking: questa variante si presta a ragionamento avanzato, chain-of-thought e flussi di lavoro di ricerca.

Demo: Q&A e ragionamento con Qwen3-Next via OpenRouter API

In questa sezione, ti mostrerò come usare il modello Qwen3-Next tramite l'API OpenRouter per costruire un assistente interattivo di Q&A e ragionamento.

Ecco come funziona:

• Inserisci una domanda nella casella di testo o trascina e rilascia un PDF lungo.
• Seleziona la dimensione Max token e il nome del modello dal menu a tendina
• Interroga istantaneamente due modelli affiancati per un confronto diretto dell'output.
• Visualizza metriche dettagliate per ogni esecuzione, tra cui tempo di risposta (latenza), token al secondo e lunghezza dell'output, per comprendere performance ed efficienza in scenari pratici.

Passo 1: Prerequisiti

Prima di eseguire questa demo, assicuriamoci di avere tutti i prerequisiti.

Passo 1.1: Import 

Per prima cosa, assicurati di avere installato i seguenti import:

pip install streamlit requests pypdfOfferto da

Questo comando installa tutte le dipendenze di base necessarie per costruire l'app, ovvero Streamlit per la UI, requests per effettuare chiamate API e pypdf per l'estrazione dai documenti PDF.

Passo 1.2: Configurazione della chiave API OpenRouter 

Il modello Qwen3-Next è disponibile anche tramite l'API ufficiale Qwen (AlibabaCloud), HuggingFace e come versione quantizzata tramite Ollama. Per questo tutorial ho utilizzato OpenRouter, che consente di accedere a più modelli con un'unica chiave API. Ecco come impostare la tua chiave API per il modello Qwen3-next-80b-a3b-instruct:

• Crea un account su https://openrouter.ai/
• Vai alla scheda Models e cerca i modelli “Qwen3-next-80b-a3b-instruct” e “Qwen3-30B-A3B”. Puoi scegliere tra le varianti Thinking e Instruct in base all'applicazione. In questo tutorial confronto le due varianti Instruct.

• Scorri in basso e clicca su Create API Key. Compila il nome della chiave e il limite di credito (opzionale), quindi clicca su Create. Salva questa chiave API per usi futuri. 

• Poi vai alla scheda Credits e aggiungi i dati della carta o bancari. Puoi pagare anche con Amazon Pay o crypto. Per questa demo, ho aggiunto circa 8$, che sono bastati.

Ora imposta la tua chiave API come variabile d'ambiente prima di eseguire l'app:

export OPENROUTER_API_KEY=your_api_keyOfferto da

Passo 2: Configurazione dei modelli

Iniziamo configurando i modelli che vogliamo confrontare. Ogni modello è definito con un identificatore (usato per le chiamate API), il numero totale di parametri e i parametri attivi.

import streamlit as st
import requests
import time
import PyPDF2
MODEL_CONFIG = {
    "Qwen3-Next-80B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-instruct",
        "params_billion": 80,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-30b-a3b-instruct-2507",
        "params_billion": 30,
        "active_params_billion": 3
    },
    "Qwen3-30B-A3B": {
        "id": "qwen/qwen3-next-80b-a3b-thinking",
        "params_billion": 30,
        "active_params_billion": 3
    },
}Offerto da

Partiamo importando le librerie necessarie per costruire la web app Streamlit, tra cui streamlit per la UI, requests per le chiamate API, time per la misurazione dei tempi e PyPDF2 per l'estrazione di testo dai PDF.

Quindi definiamo il dizionario MODEL_CONFIG che copre i modelli disponibili per il confronto, incluse le loro ID univoche (per le chiamate API) e i conteggi dei parametri, così da poter estendere facilmente diversi modelli Qwen3 in tutta l'app.

Passo 3: Funzioni di supporto

Successivamente, definiamo alcune funzioni di supporto per il backend. Includono funzioni per stimare i requisiti di memoria, effettuare chiamate API in tempo reale a OpenRouter ed estrarre testo dai PDF caricati.

def estimate_vram(params_billion, fp16=True, active_params_billion=None):
    if active_params_billion and active_params_billion != params_billion:
        total_params = params_billion * 1e9
        active_params = active_params_billion * 1e9
        size_bytes = 2 if fp16 else 4
        storage_vram = total_params * size_bytes / 1e9
        moe_overhead = active_params * 0.5 / 1e9  
        system_overhead = storage_vram * 0.2  
        total_vram = storage_vram + moe_overhead + system_overhead
    else:
        size_bytes = 2 if fp16 else 4
        num_params = params_billion * 1e9
        base_vram = num_params * size_bytes / 1e9
        total_vram = base_vram * 1.3 
    return round(total_vram, 1)
def query_openrouter(model_id, prompt, max_tokens=2048):
    api_key = "sk-or-v1-xxxxxxxxxxxxxxxxxxxxx" # Add your API Key here
    url = "https://openrouter.ai/api/v1/chat/completions"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "model": model_id,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens
    }
    try:
        start = time.time()
        response = requests.post(url, headers=headers, json=data, timeout=180)
        elapsed = time.time() - start
        response.raise_for_status()
        j = response.json()
        output = j["choices"][0]["message"]["content"].strip()
        usage = j.get("usage", {})
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        tokens_per_sec = (completion_tokens or 0) / elapsed if elapsed > 0 else 0
        return {
            "output": output,
            "latency": elapsed,
            "output_tokens": completion_tokens,
            "tokens_per_sec": tokens_per_sec,
            "prompt_tokens": prompt_tokens
        }
    except Exception as e:
        return {"error": str(e)}
def extract_pdf_text(uploaded_pdf):
    text = ""
    try:
        reader = PyPDF2.PdfReader(uploaded_pdf)
        for page in reader.pages:
            text += page.extract_text() or ""
        return text[:120000]  
    except Exception as e:
        return f"[PDF extract error: {str(e)}]"Offerto da

Vediamo come ogni funzione si inserisce nella pipeline:

• estimate_vram(): stima la VRAM GPU necessaria per eseguire un modello, considerando se è un modello denso o MoE (Mixture-of-Experts). Per i modelli MoE, considera sia i parametri totali che quelli attivi e aggiunge overhead per routing e utilizzo di sistema.
• query_openrouter(): invia i prompt al modello LLM scelto ospitato su OpenRouter e recupera la risposta. Misura la latenza totale (tempo end-to-end della chiamata API), estrae metriche utili come il numero di token elaborati e calcola il tasso di generazione token-al-secondo. 

Nota che la latenza riportata qui include tutti i ritardi di rete, accodamento e lato server, non solo la pura velocità di inferenza del modello. Riflette quindi la reattività end-to-end nel mondo reale, che può variare a seconda del carico dell'API e delle condizioni di rete.

• extract_pdf_text(): consente agli utenti di caricare e analizzare PDF come contesto di input per i modelli. Analizza il documento PDF usando PyPDF2 ed estrae il testo grezzo, fino a un limite sicuro per documenti molto lunghi. Se l'analisi fallisce, restituisce un messaggio di errore.

Queste funzioni di supporto garantiscono uso efficiente della memoria, inferenza affidabile via API ed estrazione fluida del contesto, offrendo un'esperienza utente senza intoppi.

Passo 4: Applicazione Streamlit

Con tutti i componenti principali pronti, possiamo costruire la nostra applicazione Streamlit.

Passo 4.1: CSS personalizzato

Il primo passo nella costruzione del flusso utente è il design visivo e il layout. Qui configuriamo la pagina Streamlit e iniettiamo CSS personalizzato per un aspetto strutturato.

st.set_page_config(page_title="Qwen3-Next QA & Reasoning", layout="wide", page_icon=" ")
st.markdown("""
<style>
    .main-header {
        text-align: center;
        
        
    }
    .metric-card {
        background-
        
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        
    }
    .output-box {
        background-
        border: 2px solid #e1e5e9;
        border-radius: 0.5rem;
        
        
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .model-header {
        background: linear-gradient(90deg, #1f77b4, #ff7f0e);
        color: white;
        
        border-radius: 0.5rem;
        
        text-align: center;
        font-weight: bold;
    }
</style>
""", unsafe_allow_html=True)
st.markdown('<h1 class="main-header"> QA and Reasoning With Qwen3-Next</h1>', unsafe_allow_html=True)
st.markdown("""
<div style="text-align: center; ">
    <p style="">
        Compare two Qwen3 models side-by-side with real-time performance metrics
    </p>
</div>
""", unsafe_allow_html=True)Offerto da

Usiamo sia le opzioni di configurazione di Streamlit sia parametri di stile CSS personalizzati. La chiamata st.set_page_config imposta il titolo della pagina e un layout ampio per l'output affiancato. Il CSS personalizzato è iniettato tramite st.markdown per stilizzare i principali elementi UI.

La classe .main-header centra e colora il titolo, .metric-card e .output-box migliorano la visualizzazione di metriche e output, e .model-header separa visivamente le risposte dei modelli con un gradiente. Il blocco finale st.markdown rende un'intestazione e una breve descrizione dell'app.

Passo 4.2: Sezione di input

Abbiamo progettato la sezione di input offrendo due opzioni intuitive: caricare un PDF lungo come contesto oppure digitare direttamente una domanda personalizzata.

st.markdown("### Input")
with st.container():
    col_upload, col_text = st.columns([2, 3])
    with col_upload:
        uploaded_pdf = st.file_uploader(
            "Upload PDF for context", 
            type=["pdf"],
            help="Upload a PDF document to provide context for your question"
        )
    with col_text:
        user_question = st.text_area(
            "Ask a question:", 
            height=100, 
            max_chars=12000,
            placeholder="Enter your question here...",
            help="Ask any question or provide a topic to analyze"
        )Offerto da

Questa sezione di input mostra due colonne affiancate: la prima offre un caricatore di file PDF per aggiungere documenti di contesto, mentre la seconda mette a disposizione un'area di testo per inserire domande o argomenti. L'interfaccia consente di caricare un PDF, digitare una domanda o usare entrambi come input per il confronto a valle dei modelli.

Passo 4.3: Selezione del modello

La sezione di selezione del modello offre il pieno controllo su quali modelli Qwen confrontare, oltre alla lunghezza massima delle risposte. Una volta impostato il contesto del documento, è facile selezionare due modelli da un menu a tendina, insieme alla lunghezza massima desiderata della risposta (in token), così da sperimentare con output brevi e lunghi.

context = ""
if uploaded_pdf:
    with st.spinner(" Extracting PDF text..."):
        context = extract_pdf_text(uploaded_pdf)
    st.success(f" PDF loaded: {len(context)//1000}K characters extracted.")
st.markdown("### Model Selection")
model_names = list(MODEL_CONFIG.keys())
col1, col2, col3 = st.columns([2, 2, 1])
with col1:
    model1 = st.selectbox(
        "Model A", 
        model_names, 
        index=0,
        help="Select the first model to compare"
    )
with col2:
    model2 = st.selectbox(
        "Model B", 
        model_names, 
        index=1 if len(model_names) > 1 else 0,
        help="Select the second model to compare"
    )
with col3:
    max_tokens = st.selectbox(
        "Max Tokens",
        [512, 1024, 2048, 4096],
        index=2,  
        help="Maximum length of response (higher = longer responses). Use 2048+ for reasoning questions."
    )Offerto da

Il codice sopra prima estrae testo da un PDF caricato usando una funzione di supporto. Quindi mostra tre menu a tendina: due per selezionare i modelli Qwen (o qualsiasi modello previsto dall'applicazione) da confrontare e uno per specificare il limite massimo di token per le risposte.

Nota: il limite di token controlla la lunghezza massima dell'output. Per compiti complessi o di ragionamento multi-step, impostare un limite più alto assicura che il modello possa generare una risposta completa.

Passo 4.4: Invio

Questo passaggio implementa la logica principale di confronto dei modelli. Quando l'utente clicca "Submit & Compare Models", l'app convalida l'input, costruisce un prompt sensibile al contesto e avvia interrogazioni affiancate ai modelli selezionati

st.markdown("---")
col_btn1, col_btn2, col_btn3 = st.columns([1, 2, 1])
with col_btn2:
    if st.button("Submit & Compare Models", type="primary", use_container_width=True):
        if not user_question and not uploaded_pdf:
            st.warning(" Please enter a question or upload a PDF.")
        else:
            if context:
                base_prompt = f"DOCUMENT:\n{context}\n\nQUESTION: {user_question or 'Summarize the above document.'}"
            else:
                base_prompt = user_question
            prompt = f"""Please provide a detailed and thorough response. Think step by step and explain your reasoning clearly.
{base_prompt}
Please provide a comprehensive answer with clear reasoning and examples where appropriate."""           
            st.markdown("### Results")
            col_left, col_right = st.columns(2)
            models_to_process = [(model1, col_left, "Model A"), (model2, col_right, "Model B")]          
            for model_key, col, model_label in models_to_process:
                with col:
                    st.markdown(f'<div class="model-header">{model_label}: {model_key}</div>', unsafe_allow_html=True)                   
                    progress_bar = st.progress(0)
                    status_text = st.empty()                    
                    try:
                        progress_bar.progress(25)
                        status_text.text("Initializing model...")
                        model_info = MODEL_CONFIG[model_key]
                        vram_estimate = estimate_vram(
                            model_info["params_billion"], 
                            active_params_billion=model_info["active_params_billion"]
                        )
                        progress_bar.progress(50)
                        status_text.text("Querying model...")
                        result = query_openrouter(model_info["id"], prompt, max_tokens=max_tokens)                        
                        progress_bar.progress(100)
                        status_text.text("Complete!")
                        if "error" in result:
                            st.error(f"Error: {result['error']}")
                        else:
                            st.markdown(f'''
                            <div class="metric-card">
                                <strong>Performance Metrics</strong><br>
                                <strong>Latency:</strong> {result['latency']:.2f}s<br>
                                <strong>Speed:</strong> {result['tokens_per_sec']:.2f} tokens/sec<br>
                                <strong>Output tokens:</strong> {result['output_tokens']}<br>
                                <strong>Prompt tokens:</strong> {result['prompt_tokens']}<br>
                                <strong>Est. VRAM:</strong> {vram_estimate} GB
                            </div>
                            ''', unsafe_allow_html=True)
                            st.markdown("** Response:**")
                            st.markdown(f'''
                            <div class="output-box">
                                {result["output"] if result["output"] else "<em>No output received</em>"}
                            </div>
                            ''', unsafe_allow_html=True)                
                    except Exception as e:
                        st.error(f" Unexpected error: {str(e)}")                    
                    finally:
                        progress_bar.empty()
                        status_text.empty()            
            st.markdown("---")            Offerto da

Il gestore della sottomissione organizza il workflow di benchmarking come segue: 

• Quando l'utente clicca "Submit & Compare Models", l'app verifica che sia presente una domanda o un PDF e avvisa in caso contrario.
• Costruisce quindi un prompt dal contesto del documento e dalla domanda dell'utente, aggiungendo istruzioni per risposte dettagliate e passo passo.
• L'area dei risultati è divisa in due colonne per un confronto diretto, affiancato, degli output dei modelli.
• Per ciascun modello, mostra una barra di avanzamento, stima l'uso di VRAM, interroga l'API OpenRouter e aggiorna i messaggi di stato mentre il modello elabora la richiesta.
• Al termine, l'app visualizza latenza, token al secondo, conteggi di token e VRAM usata come metriche di performance in card dedicate.

Testare Qwen3-Next

Per testare le performance reali di Qwen3-Next, ho provato alcuni esperimenti.

Test 1: Q&A con contesto lungo

Per valutare le prestazioni su contesti lunghi di Qwen3-Next, ho eseguito diversi esperimenti pratici usando l'eBook del Progetto Gutenberg “Guerra e pace”, uno dei romanzi più lunghi e complessi mai scritti.

Di seguito tre casi di test che mostrano come i modelli gestiscono contesti ultra-lunghi, evitano allucinazioni e forniscono riassunti di alta qualità.

Tracciamento dei personaggi 

Per prima cosa ho chiesto a entrambi i modelli di identificare tutti i personaggi principali che compaiono sia nel primo che nell'ultimo capitolo del romanzo e di descrivere brevemente come cambiano i loro ruoli nel corso della storia.

Prompt: “Elenca tutti i personaggi principali che compaiono sia nel primo che nell'ultimo capitolo del romanzo. Descrivi brevemente come cambiano i loro ruoli nel tempo.”

Questa domanda richiede al modello di elaborare l'intero testo e tracciare accuratamente gli archi dei personaggi. Pur essendo entrambi molto reattivi, la risposta di Qwen3 Next è stata più pulita e meglio adattata a ciascun capitolo del libro.

Test di allucinazione

Successivamente, ho voluto verificare se i modelli sapessero distinguere contenuti reali dalla disinformazione. Ho fornito a entrambi i modelli una frase che non compare in Guerra e pace, ma che è famosa in un altro romanzo di Tolstoj.

Prompt: “Il romanzo contiene la frase ‘Tutte le famiglie felici si somigliano; ogni famiglia infelice è infelice a modo suo’? Se sì, dove compare nel testo?”

Questa frase proviene in realtà da Anna Karenina, non da Guerra e pace. Un modello ideale dovrebbe rispondere "No", dimostrando forte accuratezza fattuale e bassa allucinazione. In modo notevole, Qwen3-Next ha fornito la risposta corretta mentre il modello Qwen3 30B ha risposto con una frase errata.

Sintesi

Infine, ho testato le capacità di sintesi chiedendo a entrambi i modelli di riassumere il romanzo in 300 parole.

Prompt: “Riassumi il romanzo ‘Guerra e pace’ in 300 parole, concentrandoti sul percorso personale di Pierre Bezukhov.”

Sebbene la valutazione di un riassunto sia in parte soggettiva, ho trovato l'output di Qwen3-Next più strutturato, coerente e informativo. Il riassunto non solo era conciso, ma coglieva con chiarezza l'evoluzione del personaggio di Pierre.

Esempio 2: Ragionamento multistep e logica

Per testare le capacità di ragionamento avanzato di entrambi i modelli, li ho messi alla prova con rompicapi logici complessi e multistep—compiti che richiedono non solo memoria, ma deduzione passo passo ed esclusione accurata.

Rompicapo di disposizione dei posti

Per prima cosa ho proposto ai modelli un indovinello sulla disposizione dei posti:

Prompt: “Al ricevimento di nozze ci sono cinque invitati, Colin, Emily, Kate, Fred e Irene, che non sanno dove sedersi a tavola. Chiedono alla madre della sposa, che risponde: "Per quel che ricordo, Colin non è accanto a Kate, Emily non è accanto a Fred o Kate. Né Kate né Emily sono accanto a Irene. E Fred dovrebbe sedersi alla sinistra di Irene." Guardandoli dal lato opposto del tavolo, riesci a sistemare correttamente gli invitati da sinistra a destra?

Spiega il tuo ragionamento passo dopo passo.”

Questo rompicapo richiedeva l'analisi di vari vincoli e la deduzione dell'unico ordine di seduta possibile:

• Soluzione corretta: Emily, Colin, Irene, Fred, Kate
• Output Qwen3-Next: Kate, Fred, Irene, Colin, Emily (quasi corretto, ma invertito)
• Output Qwen3-30B: impossibile trovare una risposta valida

Sebbene nessun modello abbia fornito l'esatta sequenza corretta, Qwen3-Next ci è andato molto vicino, invertendo soltanto l'ordine, mentre il modello 30B non è riuscito a trovare una soluzione. Questo mostra che Qwen3-Next è capace di deduzione multistep, sebbene alcuni casi limite restino impegnativi.

Eliminazione deduttiva 

Poi ho testato i modelli con un rompicapo di deduzione ispirato al classico “Zebra puzzle”.

Prompt: “Quattro persone (Lisa, Mike, Nora e Omar) hanno comprato ciascuna un frutto diverso (mela, banana, ciliegia, dattero) e hanno guidato un'auto diversa (Ford, Honda, Kia, Mazda).

• Lisa non ha comprato la banana.
• Il guidatore della Ford ha comprato la ciliegia.
• Mike ha guidato una Honda.
• Nora ha comprato la mela e non ha guidato una Mazda.
• Il guidatore della Kia ha comprato il dattero.
• Omar non ha guidato una Ford.

Chi ha comprato quale frutto e ha guidato quale auto? Mostra il tuo procedimento.”

Questo problema è intenzionalmente irrisolvibile con i vincoli forniti, ma ecco cosa hanno restituito i modelli:

• Output Qwen3-Next: ha identificato correttamente che non esiste un'assegnazione valida.
• Output Qwen3-30B: è rimasto bloccato in un loop logico e non è riuscito a concludere nel numero di token disponibile.

Questo esempio dimostra la capacità di Qwen3-Next di ragionare in modo deduttivo e riconoscere quando non è possibile trovare una soluzione.

Conclusione

Questo tutorial mostra come usare Qwen3-Next-80B-A3B per compiti di Q&A e ragionamento, confrontandolo con Qwen3-30B-A3B in un'app Streamlit affiancata. I risultati evidenziano i punti di forza di Qwen3-Next nella gestione di documenti ultra-lunghi, nell'offrire un'inferenza rapida e nel mantenere la qualità dell'output, anche su problemi di ragionamento complessi.