Qwen3-Next: Panduan dengan Proyek Demo

Tim Qwen baru-baru ini meluncurkan model Qwen3-Next-80B-A3B yang memadukan penalaran tingkat lanjut, kemampuan konteks super panjang, dan kecepatan inferensi luar biasa menggunakan arsitektur hybrid Mixture-of-Experts (MoE).

Dalam panduan ini, saya akan berfokus pada bagaimana Qwen3-Next-80B-A3B tampil pada tugas praktis dunia nyata dibandingkan model Qwen sebelumnya seperti Qwen3-30B-A3B. Alih-alih tolok ukur abstrak, kita akan menjalankan pengujian langsung berdampingan, termasuk penalaran, kode, dan prompt dokumen super panjang, sehingga Anda dapat melihat kompromi pada kecepatan, kualitas keluaran, dan penggunaan memori GPU.

Secara bertahap, saya akan menunjukkan cara:

• Mengakses dan berinteraksi dengan Qwen3-Next-80B-A3B dan Qwen3-30B-A3B melalui API OpenRouter, tanpa perlu penyiapan
• Membangun aplikasi Streamlit untuk perbandingan instan berdampingan atas respons model, latensi, dan penggunaan sumber daya
• Menjalankan eksperimen pengambilan konteks super panjang (100K+ token) untuk menguji batas nyata model
• Menganalisis metrik performa dunia nyata seperti latensi, token/detik, dan penggunaan VRAM.

Di akhir, aplikasi Anda akan terlihat seperti ini:

Apa itu Qwen3-Next?

Qwen3-Next adalah model Mixture-of-Experts (MoE) dengan 80 miliar parameter. Dalam praktiknya, ia hanya mengaktifkan 3 miliar parameter per token, sehingga hingga sepuluh kali lebih murah untuk dilatih dan sepuluh kali lebih cepat dijalankan daripada model dense lama (seperti Qwen3-32B) sambil menyamai atau melampaui kualitasnya.

Beberapa peningkatan kunci pada model ini mencakup:

• Arsitektur hibrida: Qwen3-Next menggunakan campuran 75:25 antara Gated DeltaNet (untuk atensi linear cepat) dan Gated Attention (untuk daya ingat mendalam), menggabungkan kekuatan kedua metode.
• Ultra-Sparse MoE: Menggunakan 512 expert namun hanya mengaktifkan 10+1 per inferensi, mengurangi komputasi lebih dari 90% dibanding LLM dense
• Prediksi multi-token: Model ini mendukung speculative decoding untuk lonjakan kecepatan besar, terutama pada streaming atau chat.
• Konteks sangat panjang: Memproses hingga 256K token secara native (1M+ dengan skala YaRN) dengan penurunan performa minimal, ideal untuk buku panjang, basis kode, dan sebagainya.

Sumber: Qwen

Model Qwen 3 Next tersedia dalam dua varian:

• Qwen3-Next-80B-A3B-Instruct: Model ini dirancang untuk chat tujuan umum, pengodean, dan open QA.
• Qwen3-Next-80B-A3B-Thinking: Meski model ini dapat digunakan untuk penalaran lanjutan, chain-of-thought, dan alur kerja riset.

Demo: Q&A dan Penalaran dengan Qwen3-Next melalui OpenRouter API

Di bagian ini, saya akan menunjukkan cara menggunakan model Qwen3-Next melalui API OpenRouter untuk membangun asisten QA dan penalaran interaktif.

Berikut cara kerjanya:

• Masukkan pertanyaan di kotak teks, atau seret dan lepas dokumen PDF panjang.
• Max token dan nama model pilih dari dropdown
• Langsung menanyakan dua model secara berdampingan untuk perbandingan keluaran secara langsung.
• Lihat metrik terperinci untuk setiap run, termasuk waktu respons (latensi), token per detik, dan panjang keluaran untuk memahami performa dan efisiensi dalam skenario praktis.

Langkah 1: Prasyarat

Sebelum menjalankan demo ini, mari pastikan semua prasyarat telah siap.

Langkah 1.1: Import 

Pertama, pastikan Anda telah memasang import berikut:

pip install streamlit requests pypdfDidukung oleh

Perintah ini memasang semua dependensi inti yang dibutuhkan untuk membangun aplikasi, yaitu Streamlit untuk UI, requests untuk melakukan panggilan API, dan pypdf untuk ekstraksi dokumen PDF.

Langkah 1.2: Menyiapkan kunci API OpenRouter 

Model Qwen3-Next juga tersedia melalui API Qwen resmi (AlibabaCloud), HuggingFace, dan sebagai versi terkuantisasi melalui Ollama. Untuk tutorial ini, saya menggunakan OpenRouter, yang memungkinkan Anda mengakses banyak model dengan satu kunci API. Berikut cara menyiapkan kunci API untuk model Qwen3-next-80b-a3b-instruct:

• Buat akun di https://openrouter.ai/
• Masuk ke tab Models dan cari model “Qwen3-next-80b-a3b-instruct” dan “Qwen3-30B-A3B”. Anda dapat memilih antara varian Thinking dan Instruct sesuai aplikasi Anda. Untuk tutorial ini, saya membandingkan dua varian model Instruct.

• Gulir ke bawah dan klik Create API Key. Isi nama key dan batas kredit (opsional), lalu klik Create. Simpan kunci API ini untuk digunakan nanti. 

• Selanjutnya, buka tab Credits dan tambahkan informasi kartu atau bank Anda. Anda juga dapat membayar melalui Amazon Pay atau kripto. Untuk demo ini, saya menambahkan sekitar $8, dan itu sudah cukup.

Sekarang, atur kunci API Anda sebagai variabel lingkungan sebelum menjalankan aplikasi:

export OPENROUTER_API_KEY=your_api_keyDidukung oleh

Langkah 2: Menyiapkan Konfigurasi Model

Kita mulai dengan mengonfigurasi model yang ingin dibandingkan. Setiap model didefinisikan dengan pengenal (untuk panggilan API), jumlah total parameter, dan jumlah parameter aktif.

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

Kita mulai dengan mengimpor pustaka yang diperlukan untuk membangun aplikasi web Streamlit, termasuk streamlit untuk UI, requests untuk panggilan API, time untuk pengukuran waktu, dan PyPDF2 untuk ekstraksi teks PDF.

Lalu, kita mendefinisikan dictionary MODEL_CONFIG yang mencakup model yang tersedia untuk dibandingkan, termasuk ID uniknya (untuk panggilan API) dan jumlah parameter, sehingga mudah memperluas ke berbagai model Qwen3 di seluruh aplikasi.

Langkah 3: Fungsi Pembantu

Selanjutnya, kita mendefinisikan beberapa fungsi pembantu untuk backend. Ini termasuk fungsi untuk memperkirakan kebutuhan memori, melakukan panggilan API real-time ke OpenRouter, dan mengekstrak teks dari PDF yang diunggah.

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

Mari pahami bagaimana setiap fungsi masuk ke dalam alur:

• estimate_vram() function: Fungsi ini memperkirakan VRAM GPU yang dibutuhkan untuk menjalankan model, dengan mempertimbangkan apakah modelnya dense atau MoE (Mixture-of-Experts). Untuk model MoE, fungsi ini mempertimbangkan parameter total dan aktif serta menambahkan overhead untuk routing dan penggunaan sistem.
• query_openrouter() function: Fungsi ini bertanggung jawab mengirim prompt ke model LLM pilihan yang dihosting di OpenRouter dan mengambil responsnya. Fungsi ini mengukur total latensi (waktu panggilan API end-to-end), mengekstrak metrik seperti jumlah token yang diproses, dan menghitung laju generasi token per detik. 

Perlu dicatat bahwa latensi yang dilaporkan mencakup semua penundaan jaringan, antrean, dan sisi server, bukan hanya kecepatan inferensi model murni. Dengan demikian, ini mencerminkan responsivitas end-to-end dunia nyata, yang dapat berfluktuasi tergantung pada beban API dan kondisi internet.

• extract_pdf_text() function: Fungsi ini memungkinkan pengguna mengunggah dan menganalisis PDF sebagai konteks input untuk model. Ia mengurai dokumen PDF menggunakan PyPDF2 dan mengekstrak teks mentahnya, hingga batas aman token untuk dokumen yang sangat panjang. Jika parsing gagal, fungsi mengembalikan pesan kesalahan.

Fungsi-fungsi pembantu ini memastikan penggunaan memori yang efisien, inferensi andal berbasis API, dan ekstraksi konteks yang lancar, sehingga memberikan pengalaman pengguna yang mulus.

Langkah 4: Aplikasi Streamlit

Dengan semua komponen inti siap, sekarang kita dapat membangun aplikasi Streamlit.

Langkah 4.1: CSS Kustom

Langkah pertama dalam membangun alur kerja yang berhadapan dengan pengguna adalah desain visual dan tata letak. Di sini, kita mengonfigurasi halaman Streamlit dan menyuntikkan CSS kustom untuk tampilan yang terstruktur.

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)Didukung oleh

Kami menggunakan opsi konfigurasi Streamlit dan parameter penataan CSS kustom. Panggilan st.set_page_config mengatur judul halaman dan tata letak lebar untuk keluaran berdampingan. CSS kustom disuntikkan melalui st.markdown untuk menata elemen UI utama.

Kelas .main-header memusatkan dan memberi warna pada judul, .metric-card dan .output-box memperindah tampilan metrik dan keluaran, dan .model-header memisahkan respons model secara visual dengan gradien. Blok st.markdown terakhir merender judul dan deskripsi singkat aplikasi.

Langkah 4.2: Bagian input

Kami merancang bagian input, memberi pengguna dua opsi intuitif: unggah PDF panjang sebagai konteks atau langsung ketikkan pertanyaan kustom.

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

Bagian input ini menampilkan dua kolom berdampingan: kolom pertama menyediakan pengunggah file PDF bagi pengguna untuk menambahkan dokumen konteks, sementara kolom kedua menawarkan area teks untuk memasukkan pertanyaan atau topik. Antarmuka ini memungkinkan pengguna mengunggah PDF, mengetik pertanyaan, atau menggunakan keduanya sebagai input untuk perbandingan model di tahap berikutnya.

Langkah 4.3: Pemilihan model

Bagian pemilihan model memberi kontrol penuh kepada pengguna atas model Qwen mana yang akan dibandingkan, serta seberapa panjang respons model. Setelah konteks dokumen ditetapkan, pengguna dapat dengan mudah memilih dua model dari dropdown, bersama panjang respons maksimum yang diinginkan (dalam token), sehingga mudah bereksperimen dengan keluaran pendek maupun panjang.

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

Kode di atas terlebih dahulu mengekstrak teks dari PDF yang diunggah menggunakan fungsi pembantu. Lalu menampilkan tiga dropdown: dua untuk memilih model Qwen (atau model lain sesuai aplikasi) yang akan dibandingkan, dan satu untuk menentukan batas token maksimum untuk respons.

Catatan: Batas token mengontrol panjang keluaran maksimum. Untuk tugas penalaran kompleks atau multi-langkah, menetapkan batas token yang lebih tinggi memastikan model dapat menghasilkan jawaban yang lengkap.

Langkah 4.4: Pengiriman

Langkah ini mengimplementasikan logika utama perbandingan model. Saat pengguna mengeklik "Submit & Compare Models," aplikasi memvalidasi input, membangun prompt yang menyadari konteks, dan meluncurkan kueri berdampingan ke model yang dipilih

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

Penanganan pengiriman menyusun alur benchmarking sebagai berikut: 

• Saat pengguna mengeklik "Submit & Compare Models," aplikasi memeriksa apakah pertanyaan atau PDF disediakan dan memberi peringatan jika keduanya tidak ada.
• Kemudian membangun prompt dari konteks dokumen dan pertanyaan pengguna, menambahkan instruksi untuk jawaban yang rinci dan bertahap.
• Area hasil dibagi menjadi dua kolom untuk perbandingan keluaran model secara langsung dan berdampingan.
• Untuk setiap model, aplikasi menampilkan bilah progres, memperkirakan penggunaan VRAM, melakukan kueri ke API OpenRouter, dan memperbarui status saat model memproses permintaan.
• Setelah selesai, aplikasi menampilkan latensi, token per detik, jumlah token, dan penggunaan VRAM sebagai metrik performa dalam kartu.

Pengujian Qwen3-Next

Untuk menguji performa nyata model Qwen3-Next, saya mencoba beberapa eksperimen.

Uji 1: Q&A konteks panjang

Untuk mengevaluasi performa konteks panjang Qwen3-Next, saya menjalankan beberapa eksperimen langsung menggunakan Project Gutenberg eBook “War and Peace,” salah satu novel terpanjang dan paling kompleks yang pernah ditulis.

Di bawah ini tiga kasus uji yang menunjukkan bagaimana model menangani konteks super panjang, menghindari halusinasi, dan menghasilkan rangkuman berkualitas tinggi.

Pelacakan karakter 

Pertama, saya meminta kedua model untuk mengidentifikasi semua tokoh utama yang muncul di bab pertama dan terakhir novel, serta menjelaskan secara singkat bagaimana peran mereka berubah sepanjang cerita.

Prompt: “Daftarkan semua tokoh utama yang muncul di bab pertama dan terakhir novel. Jelaskan secara singkat bagaimana peran mereka berubah seiring waktu.”

Pertanyaan ini mengharuskan model memproses teks penuh dan melacak alur karakter secara akurat. Meski keduanya sangat responsif, respons Qwen3 Next lebih bersih dan lebih terarah pada tiap bab buku.

Uji halusinasi

Berikutnya, saya ingin melihat apakah model dapat membedakan konten nyata dari misinformasi. Saya memberi kedua model sebuah frasa yang tidak muncul di War and Peace, tetapi terkenal berasal dari novel Tolstoy lainnya.

Prompt: “Apakah novel ini memuat frasa ‘Semua keluarga bahagia itu serupa; setiap keluarga yang tidak bahagia tidak bahagia dengan caranya sendiri’? Jika ya, di mana frasa ini muncul dalam teks?”

Frasa ini sebenarnya berasal dari Anna Karenina, bukan War and Peace. Model yang ideal harus menjawab "Tidak" yang menunjukkan akurasi faktual kuat dan halusinasi rendah. Secara mengesankan, Qwen3-Next memberikan jawaban yang benar sementara model Qwen3 30B merespons dengan frasa yang keliru.

Perangkuman

Terakhir, saya menguji kemampuan rangkuman dengan meminta kedua model merangkum novel dalam 300 kata.

Prompt: “Rangkum novel ‘War and Peace’ dalam 300 kata, dengan fokus pada perjalanan pribadi Pierre Bezukhov.”

Meskipun evaluasi rangkuman sebagian bersifat subjektif, saya menemukan keluaran Qwen3-Next lebih terstruktur, koheren, dan bernas. Rangkuman tersebut tidak hanya ringkas tetapi juga menangkap evolusi karakter Pierre dengan jelas.

Contoh 2: Penalaran multi-langkah dan logika

Untuk menguji kemampuan penalaran tingkat lanjut kedua model, saya menantang mereka dengan teka-teki logika multi-langkah yang kompleks—tugas yang tidak hanya membutuhkan ingatan, tetapi juga deduksi bertahap dan eliminasi cermat.

Teka-teki logika penataan kursi

Pertama saya memberikan teka-teki penataan kursi kepada model:

Prompt: “Di resepsi pernikahan, ada lima tamu, Colin, Emily, Kate, Fred, dan Irene, yang tidak yakin di mana harus duduk di meja makan. Mereka bertanya kepada ibu mempelai, yang menjawab, \"Seingat saya, Colin tidak di sebelah Kate, Emily tidak di sebelah Fred atau Kate. Baik Kate maupun Emily tidak di sebelah Irene. Dan Fred harus duduk di sebelah kiri Irene.\" Saat Anda melihat mereka dari sisi berlawanan meja, dapatkah Anda menata tempat duduk tamu dari kiri ke kanan dengan benar?

Jelaskan penalaran Anda selangkah demi selangkah.”

Teka-teki ini memerlukan analisis beberapa batasan dan menyimpulkan satu-satunya urutan duduk yang mungkin:

• Jawaban baku: Emily, Colin, Irene, Fred, Kate
• Keluaran Qwen3-Next: Kate, Fred, Irene, Colin, Emily (hampir benar, namun terbalik)
• Keluaran Qwen3-30B: Tidak mampu menemukan jawaban yang valid

Meski tidak ada yang mendapatkan urutan tepat, Qwen3-Next sangat dekat, hanya membalik urutannya, sementara model 30B gagal mencapai solusi sama sekali. Ini menunjukkan Qwen3-Next mampu melakukan deduksi multi-langkah, meski beberapa kasus tepi masih menantang.

Eliminasi deduktif 

Berikutnya, saya menguji model dengan teka-teki deduksi yang terinspirasi dari “Zebra puzzle.”

Prompt: “Empat orang (Lisa, Mike, Nora, dan Omar) masing-masing membeli buah yang berbeda (apel, pisang, ceri, kurma) dan mengendarai mobil berbeda (Ford, Honda, Kia, Mazda).

• Lisa tidak membeli pisang.
• Pengemudi Ford membeli ceri.
• Mike mengendarai Honda.
• Nora membeli apel dan tidak mengendarai Mazda.
• Pengemudi Kia membeli kurma.
• Omar tidak mengendarai Ford.

Siapa membeli buah apa dan mengendarai mobil mana? Tunjukkan langkah pengerjaannya.”

Masalah ini sengaja tidak dapat dipecahkan dengan batasan yang diberikan, namun berikut yang dikembalikan model:

• Keluaran Qwen3-Next: Mengidentifikasi dengan benar bahwa tidak ada penugasan yang valid.
• Keluaran Qwen3-30B: Terjebak dalam loop logika dan gagal menyimpulkan dalam jumlah token keluaran yang diberikan.

Contoh ini menunjukkan kemampuan Qwen3-Next untuk bernalar secara deduktif dan mengenali saat tidak ada solusi yang mungkin.

Kesimpulan

Tutorial ini menunjukkan cara menggunakan Qwen3-Next-80B-A3B untuk tugas Q&A dan penalaran, membandingkannya dengan Qwen3-30B-A3B dalam aplikasi Streamlit berdampingan. Hasilnya menyoroti kekuatan Qwen3-Next dalam menangani dokumen super panjang, memberikan inferensi cepat, dan menjaga kualitas keluaran, bahkan pada masalah penalaran yang kompleks.