Qwen3-Next: Um guia com projeto de demonstração

A equipe da Qwen lançou recentemente o modelo Qwen3-Next-80B-A3B , que combina raciocínio avançado, processamento de contexto ultralongo e velocidade de inferência excepcional usando uma arquitetura híbrida Mixture-of-Experts (MoE).

Neste guia, vou focar no desempenho do Qwen3-Next-80B-A3B em tarefas práticas do mundo real, comparando com modelos Qwen anteriores, como o Qwen3-30B-A3B. Em vez de benchmarks abstratos, vamos fazer testes práticos e comparativos, incluindo raciocínio, código e prompts de documentos ultra longos, para que você possa ver as vantagens e desvantagens em termos de velocidade, qualidade de saída e uso da memória da GPU.

Passo a passo, vou te mostrar como:

• Acesse e interaja com o Qwen3-Next-80B-A3B e o Qwen3-30B-A3B através da API OpenRouter, sem precisar de nenhuma configuração.
• Crie um aplicativo Streamlit para comparar instantaneamente as respostas do modelo, a latência e o uso de recursos lado a lado.
• Faça experimentos de recuperação de contexto superlongos (mais de 100 mil tokens) para testar os limites reais dos modelos.
• Analise métricas de desempenho do mundo real, como latência, tokens/segundo e uso de VRAM.

No final, seu aplicativo vai ficar assim:

O que é o Qwen3-Next?

Qwen3-Next é um modelo de 80 bilhões de parâmetros de mistura de especialistas (MoE). Na prática, ele só ativa 3B parâmetros por token, o que faz com que seja até dez vezes mais barato treinar e dez vezes mais rápido de rodar do que os modelos densos mais antigos (como o Qwen3-32B), sem deixar a desejar na qualidade.

Algumas das principais melhorias nesse modelo são:

• Arquitetura híbrida: O Qwen3-Next usa uma mistura 75:25 de Gated DeltaNet (para atenção linear rápida) e Gated Attention (para recordação profunda), juntando os pontos fortes dos dois métodos.
• e MoE ultra-esparso: Emprega 512 especialistas, mas ativa apenas 10+1 por inferência, reduzindo a computação em mais de 90% em comparação com LLMs densos.
• Previsão multitoken: Esse modelo dá suporte à decodificação especulativa para grandes ganhos de velocidade, especialmente em streaming ou chat.
• de contexto extremamente longo: Ele processa até 256K tokens nativamente (mais de 1 milhão com escalonamento YaRN) com uma queda mínima de desempenho e é ideal para livros longos, bases de código, etc.

Fonte: Qwen

O Qwen 3 Next Model está disponível em duas versões:

• Qwen3-Next-80B-A3B-Instruct: Esse modelo foi feito pra conversas gerais, programação e perguntas e respostas abertas.
• Qwen3-Next-80B-A3B-Thinking: Embora esse modelo possa ser usado para raciocínio avançado, cadeia de pensamento e fluxos de trabalho de pesquisa.

Demonstração: Perguntas e respostas e raciocínio com Qwen3-Next com API OpenRouter

Nesta seção, vou mostrar como usar o modelo Qwen3-Next através do OpenRouter para criar um assistente interativo de perguntas e respostas e raciocínio.

Funciona assim:

• Digite uma pergunta na caixa de texto ou arraste e solte um documento PDF grande.
• Selecione o tamanho máximo do token e o nome do modelo no menu suspenso
• Consulte instantaneamente dois modelos lado a lado para comparar diretamente os resultados.
• Veja métricas detalhadas para cada execução, incluindo tempo de resposta (latência), tokens por segundo e comprimento da saída para entender o desempenho e a eficiência em cenários práticos.

Passo 1: Pré-requisitos

Antes de rodar essa demonstração, vamos ver se temos tudo o que precisa.

Passo 1.1: Importações 

Primeiro, certifique-se de que você tem as seguintes importações instaladas:

pip install streamlit requests pypdf

Esse comando instala todas as dependências principais necessárias para compilar o aplicativo, ou seja, Streamlit para a interface do usuário, requests para fazer chamadas de API e pypdf para lidar com a extração de documentos PDF.

Passo 1.2: Configurando a chave API do OpenRouter 

O modelo Qwen3-Next também está disponível através da API oficial do Qwen (AlibabaCloud), HuggingFacee como uma versão quantizada através do Ollama. Pra esse tutorial, usei o OpenRouter, que permite acessar vários modelos com uma única chave API. Veja como configurar sua chave API para o modelo Qwen3-next-80b-a3b-instruct:

• Crie uma conta em https://openrouter.ai/
• Vá até a aba Modelos e procure pelos modelos “Qwen3-next-80b-a3b-instruct” e “Qwen3-30B-A3B”. Você pode escolher entre as variantes Thinking e Instruct com base na sua aplicação. Neste tutorial, vou comparar as duas versões do modelo Instruct.

• Role para baixo e clique em “ ” (Criar chave API). Preencha o nome da chave e o limite de crédito (opcional) e clique em Criar. Guarde essa chave API para usar depois. 

• Depois, vá até a abaCréditos e coloque os dados do seu cartão ou conta bancária. Você também pode pagar pelo Amazon Pay ou com criptomoedas. Pra essa demonstração, eu coloquei uns US$ 8, o que foi suficiente.

Agora, defina sua chave API como uma variável de ambiente antes de executar o aplicativo:

export OPENROUTER_API_KEY=your_api_key

Passo 2: Configurando o modelo

Começamos configurando os modelos que queremos comparar. Cada modelo é definido com um identificador (usado para chamadas de API), contagem total de parâmetros e contagem de parâmetros ativos.

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
    },
}

Começamos importando as bibliotecas necessárias para construir o aplicativo web Streamlit, incluindo bibliotecas como streamlit para UI, requests para chamadas de API, time para temporização e PyPDF2 para extração de texto em PDF.

Depois, a gente define o dicionário MODEL_CONFIG, que abrange os modelos disponíveis para comparação, incluindo seus IDs exclusivos (para chamadas de API) e contagens de parâmetros, facilitando a extensão de diferentes modelos Qwen3 em todo o aplicativo.

Passo 3: Funções auxiliares

Depois, vamos definir várias funções auxiliares para o backend. Isso inclui funções para estimar os requisitos de memória, fazer chamadas de API em tempo real para o OpenRouter e extrair texto de PDFs enviados.

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)}]"

Vamos entender como cada função se encaixa no pipeline:

• estimate_vram() função: Essa função estima a VRAM da GPU necessária para executar um modelo, levando em consideração se é um modelo denso ou MoE (Mixture-of-Experts). Para modelos MoE, ele considera os parâmetros totais e ativos e adiciona uma sobrecarga para roteamento e uso do sistema.
• query_openrouter() função: Essa função é responsável por mandar comandos para um modelo LLM escolhido que tá hospedado no OpenRouter e pegar a resposta. Ele mede a latência total (tempo de chamada da API de ponta a ponta), pega métricas úteis, como o número de tokens processados, e calcula a taxa de geração de tokens por segundo. 

Observe que a latência relatada aqui inclui todos os atrasos de rede, fila e do lado do servidor, não só a velocidade pura de inferência do modelo. Assim, ele mostra a capacidade de resposta real de ponta a ponta, que pode variar dependendo da carga da API e das condições da internet.

• extract_pdf_text() função: Essa função permite que os usuários carreguem e analisem PDFs como contexto de entrada para os modelos. Ele analisa o documento PDF usando o PyPDF2 e extrai o texto bruto, até um limite seguro para documentos muito longos. Se a análise falhar, a função retorna uma mensagem de erro.

Essas funções auxiliares garantem o uso eficiente da memória, inferência confiável baseada em API e extração de contexto suave, proporcionando uma experiência perfeita ao usuário.

Passo 4: Aplicativo Streamlit

Com todos os componentes principais prontos, agora podemos criar nossa aplicação Streamlit.

Passo 4.1: CSS personalizado

O primeiro passo pra montar o fluxo de trabalho voltado pro usuário é o design visual e o layout. Aqui, a gente configura a página Streamlit e coloca um CSS personalizado pra dar uma aparência mais organizada.

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)

Usamos tanto as opções de configuração do Streamlit quanto os parâmetros de estilo CSS personalizados. A chamada st.set_page_config define o título da página e um layout amplo para a saída lado a lado. O CSS personalizado é injetado por meio de st.markdown para estilizar os principais elementos da interface do usuário.

O .main-header centraliza e colore o título, o .metric-card e o .output-box melhoram a exibição das métricas e resultados, e o .model-header separa visualmente as respostas do modelo com um gradiente. O bloco final st.markdown mostra um título e uma breve descrição do aplicativo.

Passo 4.2: Seção de entrada

A gente criou a seção de entrada, dando aos usuários duas opções fáceis de usar: ou carregar um PDF grande como contexto ou digitar diretamente uma pergunta personalizada.

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"
        )

Essa seção de entrada mostra duas colunas lado a lado: a primeira coluna tem um carregador de arquivos PDF para os usuários adicionarem documentos de contexto, enquanto a segunda coluna tem uma área de texto para colocar perguntas ou tópicos. Essa interface permite que os usuários enviem um PDF, digitem uma pergunta ou usem os dois juntos como entrada para a comparação do modelo a jusante.

Passo 4.3: Seleção do modelo

A seção de seleção de modelos dá aos usuários controle total sobre quais modelos Qwen comparar, além de quanto tempo as respostas do modelo podem ter. Depois que o contexto do documento estiver definido, os usuários podem facilmente escolher dois modelos em uma lista suspensa, junto com o tamanho máximo desejado da resposta (em tokens), facilitando a experimentação com saídas curtas e longas.

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."
    )

O código acima primeiro pega o texto de um PDF que você mandou usando uma função auxiliar. Em seguida, ele mostra três menus suspensos: dois para escolher os modelos Qwen (ou qualquer modelo de acordo com a aplicação) para comparar e um para definir o limite máximo de tokens para respostas.

Observação: O limite de tokens controla o comprimento máximo da saída. Para tarefas de raciocínio complexas ou com várias etapas, definir um limite de tokens mais alto garante que o modelo possa gerar uma resposta completa.

Passo 4.4: Envio

Essa etapa implementa a lógica principal de comparação de modelos. Quando o usuário clica em “Enviar e comparar modelos”, o aplicativo valida a entrada, cria um prompt sensível ao contexto e inicia consultas paralelas aos modelos selecionados.

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("---")            

O manipulador de envios organiza o fluxo de trabalho de benchmarking da seguinte forma: 

• Quando o usuário clica em “Enviar e comparar modelos”, o aplicativo verifica se uma pergunta ou PDF foi fornecido e avisa se nenhum dos dois estiver presente.
• Em seguida, ele cria uma solicitação a partir do contexto do documento e da pergunta do usuário, adicionando instruções para respostas detalhadas e passo a passo.
• A área de resultados é dividida em duas colunas para comparação direta e lado a lado dos resultados do modelo.
• Para cada modelo, ele mostra uma barra de progresso, estima o uso de VRAM, consulta a API do OpenRouter e atualiza as mensagens de status enquanto o modelo processa a solicitação.
• Depois de pronto, o aplicativo mostra a latência, tokens por segundo, contagem de tokens e uso de VRAM como métricas de desempenho em cartões.

Testando o Qwen3-Next

Pra testar o desempenho real do modelo Qwen3-Next, fiz algumas experiências.

Teste 1: Perguntas e respostas em contexto longo

Pra avaliar o desempenho do Qwen3-Next em contextos longos, fiz vários experimentos práticos usando o e-book “War and Peace”, um dos romances mais longos e complexos já escritos.

Abaixo estão três casos de teste que mostram como os modelos lidam com contextos superlongos, evitam alucinações e fazem resumos de alta qualidade.

Rastreamento de personagens 

Primeiro, pedi aos dois modelos que identificassem todos os personagens principais que aparecem no primeiro e no último capítulo do romance e que descrevessem brevemente como seus papéis mudam ao longo da história.

: Liste todos os personagens principais que aparecem no primeiro e no último capítulo do romance. Descreva resumidamente como suas funções mudam ao longo do tempo.”

Essa pergunta exige que o modelo processe o texto completo e acompanhe (programa) com precisão os arcos dos personagens. Embora os dois modelos fossem super responsivos, a resposta do Qwen3 Next foi mais clara e mais adequada a cada capítulo do livro.

Teste de alucinação

Depois, eu queria ver se os modelos conseguiam diferenciar conteúdo real de desinformação. Eu dei a ambos os modelos uma frase que não aparece emGuerra e Paz,de , mas que é famosa por vir de outro romance de Tolstói.

Sugestão: O romance tem a frase “Todas as famílias felizes são parecidas; cada família infeliz é infeliz à sua maneira”? Se sim, onde isso aparece no texto?

Essa frase, na verdade, vem de Anna Karenina, não de Guerra e Paz. Um modelo ideal deve responder “Não”, o que mostra uma forte precisão factual e pouca alucinação. É impressionante que o Qwen3-Next tenha dado a resposta certa, enquanto o modelo Qwen3 30B respondeu com uma frase errada.

Resumo

Por fim, testei as habilidades de resumo pedindo aos dois modelos que resumissem o romance em 300 palavras.

Sugestão: Resuma o romance “Guerra e Paz” em 300 palavras, focando na jornada pessoal de Pierre Bezukhov.

Embora a avaliação resumida seja em parte subjetiva, achei a produção do Qwen3-Next mais estruturada, coerente e perspicaz. O resumo não só foi curtinho, mas também mostrou bem a evolução do personagem do Pierre.

Exemplo 2: Raciocínio e lógica em várias etapas

Pra testar as capacidades avançadas de raciocínio dos dois modelos, eu os desafiei com quebra-cabeças lógicos complexos e com várias etapas — tarefas que exigem não só memória, mas dedução passo a passo e eliminação cuidadosa.

Quebra-cabeça de lógica sobre a disposição dos lugares

Primeiro, dei aos modelos um quebra-cabeças de arranjo de assentos:

Sugestão: No banquete de casamento, há cinco convidados, Colin, Emily, Kate, Fred e Irene, que não sabem onde se sentar à mesa de jantar. Eles perguntam pra mãe da noiva, que responde: “Pelo que me lembro, Colin não está ao lado de Kate, Emily não está ao lado de Fred ou Kate.” Nem a Kate nem a Emily estão ao lado da Irene. E o Fred deve sentar à esquerda da Irene. Olhando para eles do outro lado da tabela, você consegue sentar os convidados corretamente da esquerda para a direita?

Explique seu raciocínio passo a passo.

Esse quebra-cabeça exigiu analisar várias restrições e deduzir a única ordem possível para os lugares:

• Verdade fundamental: Emily, Colin, Irene, Fred, Kate
• Saída do Qwen3-Next: Kate, Fred, Irene, Colin, Emily (quase certo, mas ao contrário)
• Saída do Qwen3-30B: Não consegui achar uma resposta válida.

Embora nenhum dos modelos tenha acertado a sequência exata, o Qwen3-Next chegou bem perto, só invertendo a ordem, enquanto o modelo 30B não conseguiu chegar a nenhuma solução. Isso mostra que o Qwen3-Next consegue fazer deduções em várias etapas, mesmo que alguns casos extremos ainda sejam um desafio.

Eliminação dedutiva 

Depois, testei os modelos com um quebra-cabeça de dedução inspirado no clássico “quebra-cabeça da zebra”.

Sugestão: Quatro pessoas (Lisa, Mike, Nora e Omar) compraram cada uma uma fruta diferente (maçã, banana, cereja, tâmara) e dirigiram um carro diferente (Ford, Honda, Kia, Mazda).

• Lisa não comprou a banana.
• O motorista da Ford comprou a cereja.
• Mike dirigia um Honda.
• A Nora comprou a maçã e não dirigia um Mazda.
• O motorista do Kia pagou o encontro.
• Omar não dirigia um Ford.

Quem comprou qual fruta e dirigiu qual carro? Mostre seu trabalho.

Esse problema é propositalmente insolúvel com as restrições fornecidas, mas eis o que os modelos retornaram:

• Saída do Qwen3-Next: Ele identificou corretamente que não existe nenhuma atribuição válida.
• Qwen3-30B output: Ele ficou preso em um loop lógico e não conseguiu concluir dentro do número determinado de tokens de saída.

Esse exemplo mostra como o Qwen3-Next consegue raciocinar de forma dedutiva e perceber quando não tem solução possível.

Conclusão

Esse tutorial mostra como usar o Qwen3-Next-80B-A3B para tarefas de perguntas e respostas e raciocínio, comparando-o com o Qwen3-30B-A3B em um aplicativo Streamlit lado a lado. Os resultados mostram como o Qwen3-Next é bom em lidar com documentos superlongos, fazer inferências rápidas e manter a qualidade da saída, mesmo em problemas de raciocínio complexos.