Qwen3-Next: Ein Leitfaden mit Demo-Projekt

Das Qwen-Team hat kürzlich das Qwen3-Next-80B-A3B Modell auf den Markt gebracht, das fortschrittliche Schlussfolgerungen, extrem lange Kontextverarbeitung und eine außergewöhnliche Inferenzgeschwindigkeit mithilfe einer hybriden Mixture-of-Experts (MoE)-Architektur vereint.

In diesem Leitfaden werde ich mich darauf konzentrieren, wie sich Qwen3-Next-80B-A3B bei praktischen, realen Aufgaben im Vergleich zu früheren Qwen-Modellen wie Qwen3-30B-A3B schlägt. Anstelle von abstrakten Benchmarks machen wir praktische, direkte Vergleiche, zum Beispiel mit Logikaufgaben, Code und superlangen Dokumenten, damit du die Unterschiede bei Geschwindigkeit, Ausgabequalität und GPU-Speichernutzung sehen kannst.

Schritt für Schritt zeig ich dir, wie du:

• Du kannst über die OpenRouter-API auf Qwen3-Next-80B-A3B und Qwen3-30B-A3B zugreifen und mit ihnen interagieren, ohne dass du irgendwas einrichten musst.
• Mach eine Streamlit-App, um Modellantworten, Latenz und Ressourcenverbrauch direkt nebeneinander zu vergleichen.
• Mach mal richtig lange Experimente zum Abrufen von Kontext (über 100.000 Token), um die echten Grenzen der Modelle zu testen.
• Analysiere echte Leistungskennzahlen wie Latenz, Tokens/Sekunde und VRAM-Nutzung.

Am Ende sieht deine App so aus:

Was ist Qwen3-Next?

Qwen3-Next ist ein 80B-Parameter Mixture-of-Experts (MoE)-Modell Modell. In der Praxis werden pro Token nur 3B Parameter aktiviert, was das Training bis zu zehnmal günstiger und die Ausführung bis zu zehnmal schneller macht als bei älteren dichten Modellen (wie Qwen3-32B), während die Qualität gleich oder sogar besser ist.

Ein paar wichtige Neuerungen in diesem Modell sind:

• Hybride Architektur: Qwen3-Next nutzt eine Mischung aus 75 % Gated DeltaNet (für schnelle lineare Aufmerksamkeit) und 25 % Gated Attention (für tiefes Erinnerungsvermögen) und bringt so die Vorteile beider Methoden zusammen.
• Ultra-spärliches MoE-: Es hat 512 Experten, nutzt aber nur 10+1 pro Schlussfolgerung, was die Rechenleistung im Vergleich zu dichten LLMs um über 90 % senkt.
• Multi-Token-Vorhersage: Dieses Modell unterstützt spekulatives Decodieren für enorme Geschwindigkeitssteigerungen, vor allem beim Streaming oder Chatten.
• Extrem langer Kontext: Es verarbeitet bis zu 256K Token nativ (über 1 Million mit YaRN-Skalierung) mit minimalem Leistungsabfall und eignet sich super für lange Bücher, Codebasen usw.

Quelle: Qwen

Qwen 3 Next Model gibt's in zwei Versionen:

• Qwen3-Next-80B-A3B-Instruct: Dieses Modell ist für allgemeine Chats, Programmierung und offene Fragen gedacht. allgemeine Chats, Programmierung und offene Fragen und Antworten gedacht.
• Qwen3-Next-80B-A3B-Thinking: Dieses Modell kann für fortgeschrittenes Denken, Gedankengänge und Forschungsabläufe genutzt werden.

Demo: Fragen und Antworten sowie Erläuterungen zu Qwen3-Next mit OpenRouter-API

In diesem Abschnitt zeige ich dir, wie du das Qwen3-Next-Modell über den OpenRouter API einen interaktiven QA- und Argumentationsassistenten erstellen kann.

So läuft's ab:

• Gib eine Frage in das Textfeld ein oder zieh ein langes PDF-Dokument per Drag & Drop hinein.
• Wähle das Max Token und den Modellname aus dem Dropdown-Menü aus.
• Du kannst zwei Modelle gleichzeitig abfragen, um die Ergebnisse direkt zu vergleichen.
• Schau dir detaillierte Metriken für jeden Durchlauf an, wie Antwortzeit (Latenz), Tokens pro Sekunde und Ausgabelänge, um sowohl die Leistung als auch die Effizienz in praktischen Szenarien zu verstehen.

Schritt 1: Was du brauchen solltest

Bevor wir diese Demo starten, checken wir mal, ob wir alles haben, was wir brauchen.

Schritt 1.1: Importe 

Stell zuerst sicher, dass du die folgenden Importe installiert hast:

pip install streamlit requests pypdf

Dieser Befehl installiert alle wichtigen Abhängigkeiten, die zum Erstellen der App gebraucht werden, nämlich Streamlit für die Benutzeroberfläche, requests für API-Aufrufe und pypdf für die Extraktion von PDF-Dokumenten.

Schritt 1.2: Einrichten des OpenRouter-API-Schlüssels 

Das Qwen3-Next-Modell kannst du auch über die offizielle Qwen-API (AlibabaCloud) und HuggingFaceund als quantisierte Version über Ollama. Für dieses Tutorial habe ich OpenRouterverwendet, mit dem man mit einem einzigen API-Schlüssel auf mehrere Modelle zugreifen kann. So richtest du deinen API-Schlüssel für das Modell „Qwen3-next-80b-a3b-instruct“ ein:

• Erstell ein Konto bei https://openrouter.ai/
• Geh zum Tab „Modelle” und such nach den Modellen „Qwen3-next-80b-a3b-instruct” und „Qwen3-30B-A3B”. Du kannst je nach Anwendung zwischen den Varianten „Thinking“ und „Instruct“ wählen. In diesem Tutorial vergleiche ich die beiden Varianten des Instruct-Modells.

• Scroll runter und klick auf „ “ (API-Schlüssel erstellen). Gib den Namen für den Schlüssel und das Kreditlimit (optional) ein und klick auf „erstellen“. Speicher diesen API-Schlüssel für später. 

• Als Nächstes gehst du zum Reiter „Guthaben “ und gibst deine Karten- oder Bankdaten ein. Du kannst auch mit Amazon Pay oder Kryptowährung bezahlen. Für diese Demo hab ich ungefähr 8 Dollar draufgelegt, was gereicht hat.

Jetzt musst du deinen API-Schlüssel als Umgebungsvariable festlegen, bevor du die App startest:

export OPENROUTER_API_KEY=your_api_key

Schritt 2: Modellkonfiguration einrichten

Wir fangen damit an, die Modelle einzurichten, die wir vergleichen wollen. Jedes Modell wird mit einer Kennung (für API-Aufrufe), der Gesamtzahl der Parameter und der Anzahl der aktiven Parameter definiert.

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

Zuerst holen wir uns die Bibliotheken, die wir für die Streamlit-Web-App brauchen, wie streamlit für die Benutzeroberfläche, requests für API-Aufrufe, time für die Zeitmessung und PyPDF2 für die PDF-Textextraktion.

Dann machen wir das Wörterbuch „ MODEL_CONFIG “, das die verfügbaren Modelle zum Vergleich abdeckt, einschließlich ihrer eindeutigen IDs (für API-Aufrufe) und Parameteranzahlen, was es einfach macht, verschiedene Qwen3-Modelle in der gesamten App zu erweitern.

Schritt 3: Hilfsfunktionen

Als Nächstes machen wir ein paar Hilfsfunktionen für das Backend klar. Dazu gehören Funktionen zum Schätzen des Speicherbedarfs, zum Ausführen von Echtzeit-API-Aufrufen an OpenRouter und zum Extrahieren von Text aus hochgeladenen PDF-Dateien.

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

Schauen wir mal, wie jede Funktion in die Pipeline passt:

• estimate_vram() Funktion: Diese Funktion schätzt den für die Ausführung eines Modells benötigten GPU-VRAM und berücksichtigt dabei, ob es sich um ein dichtes oder ein MoE-Modell (Mixture-of-Experts) handelt. Bei MoE-Modellen werden sowohl Gesamtparameter als auch aktive Parameter berücksichtigt und es kommt ein Overhead für Routing und Systemnutzung dazu.
• query_openrouter() Funktion: Diese Funktion ist dafür zuständig, Anweisungen an ein ausgewähltes LLM-Modell zu schicken, das auf OpenRouter läuft, und die Antwort abzurufen. Es misst die Gesamtlatenz (die Zeit vom Anfang bis zum Ende eines API-Aufrufs), holt nützliche Metriken wie die Anzahl der verarbeiteten Token raus und berechnet die Generierungsrate der Token pro Sekunde. 

Beachte, dass die hier angegebene Latenzzeit alle Verzögerungen im Netzwerk, in der Warteschlange und auf dem Server umfasst, nicht nur die reine Modell-Inferenzgeschwindigkeit. Es zeigt also die tatsächliche End-to-End-Reaktionsfähigkeit, die je nach API-Auslastung und Internetbedingungen schwanken kann.

• extract_pdf_text() Funktion: Mit dieser Funktion kannst du PDFs hochladen und analysieren, um sie als Eingabekontext für die Modelle zu nutzen. Es analysiert das PDF-Dokument mit PyPDF2 und holt den Rohtext raus, bis zu einer token-sicheren Grenze für echt lange Dokumente. Wenn das Parsen nicht klappt, gibt die Funktion 'ne Fehlermeldung zurück.

Diese Hilfsfunktionen sorgen für eine effiziente Speichernutzung, zuverlässige API-basierte Schlussfolgerungen und reibungslose Kontextextraktion und bieten so ein nahtloses Benutzererlebnis.

Schritt 4: Streamlit-Anwendung

Jetzt, wo alle wichtigen Teile fertig sind, können wir unsere Streamlit-App erstellen.

Schritt 4.1: Benutzerdefiniertes CSS

Der erste Schritt beim Aufbau des benutzerorientierten Workflows ist das visuelle Design und Layout. Hier richten wir die Streamlit-Seite ein und fügen benutzerdefiniertes CSS ein, damit alles ordentlich aussieht.

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)

Wir nutzen sowohl die Konfigurationsoptionen von Streamlit als auch benutzerdefinierte CSS-Stilparameter. Der Aufruf „ st.set_page_config “ legt den Seitentitel und ein breites Layout für die nebeneinander angeordnete Ausgabe fest. Benutzerdefiniertes CSS wird über st.markdown eingefügt, um wichtige UI-Elemente zu gestalten.

Die Funktion „ .main-header ” zentriert und färbt den Titel, „ .metric-card ” und „ .output-box ” machen die Anzeige von Metriken und Ausgaben besser, und „ .model-header ” trennt die Modellantworten optisch mit einem Farbverlauf. Der letzte Block „ st.markdown “ zeigt eine Überschrift und eine kurze App-Beschreibung an.

Schritt 4.2: Eingabeabschnitt

Wir haben den Eingabebereich so gestaltet, dass die Nutzer zwei einfache Optionen haben: Entweder laden sie ein langes PDF als Kontext hoch oder geben direkt eine eigene Frage ein.

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

Dieser Eingabebereich hat zwei Spalten nebeneinander: In der ersten Spalte gibt's einen PDF-Datei-Uploader, damit du Kontextdokumente hinzufügen kannst, und in der zweiten Spalte ist ein Textfeld, wo du Fragen oder Themen eingeben kannst. Mit dieser Oberfläche kannst du entweder eine PDF-Datei hochladen, eine Frage eingeben oder beides zusammen als Input für den nachgelagerten Modellvergleich nutzen.

Schritt 4.3: Modellauswahl

Der Abschnitt zur Modellauswahl gibt dir die volle Kontrolle darüber, welche Qwen-Modelle du vergleichen möchtest und wie lang die Modellantworten sein dürfen. Sobald der Dokumentkontext festgelegt ist, können die Nutzer ganz einfach zwei Modelle aus einer Dropdown-Liste auswählen und die gewünschte maximale Antwortlänge (in Tokens) festlegen, sodass sie problemlos mit kurzen und langen Ausgaben experimentieren können.

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

Der obige Code holt zuerst mit einer Hilfsfunktion Text aus einer hochgeladenen PDF-Datei raus. Dann kommen drei Dropdown-Menüs: zwei, um die Qwen-Modelle (oder andere Modelle, je nach Anwendung) zum Vergleichen auszuwählen, und eins, um die maximale Token-Anzahl für Antworten festzulegen.

Anmerkung: Das Token-Limit bestimmt, wie lang die Ausgabe maximal sein darf. Bei komplizierten oder mehrstufigen Denkaufgaben sorgt ein höheres Token-Limit dafür, dass das Modell eine vollständige Antwort generieren kann.

Schritt 4.4: Einreichung

Dieser Schritt macht die Hauptlogik für den Modellvergleich klar. Wenn der Nutzer auf „Modelle senden und vergleichen“ klickt, überprüft die App die Eingabe, erstellt eine kontextbezogene Eingabeaufforderung und startet nebeneinander liegende Abfragen an die ausgewählten Modelle.

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

Der Einreichungshandler organisiert den Benchmarking-Workflow wie folgt: 

• Wenn der Nutzer auf „Modelle senden und vergleichen“ klickt, schaut die App nach, ob eine Frage oder eine PDF-Datei da ist, und sagt Bescheid, wenn beides fehlt.
• Dann erstellt es aus dem Dokumentkontext und der Frage des Benutzers eine Eingabeaufforderung und fügt Anweisungen für detaillierte, schrittweise Antworten hinzu.
• Der Ergebnisbereich ist in zwei Spalten aufgeteilt, damit man die Modellergebnisse direkt nebeneinander vergleichen kann.
• Für jedes Modell wird ein Fortschrittsbalken angezeigt, die VRAM-Nutzung geschätzt, die OpenRouter-API abgefragt und die Statusmeldungen aktualisiert, während das Modell die Anfrage verarbeitet.
• Nach dem Start zeigt die App Latenz, Tokens pro Sekunde, Tokenanzahl und VRAM-Nutzung als Leistungskennzahlen in Karten an.

Qwen3-Next testen

Um zu sehen, wie gut das Qwen3-Next-Modell wirklich funktioniert, hab ich ein paar Tests gemacht.

Test 1: Lange Fragen und Antworten

Um die Leistung von Qwen3-Next im Langzeitkontext zu checken, hab ich ein paar praktische Experimente mit das Project Gutenberg eBook „War and Peace” einen der längsten und komplexesten Romane, die je geschrieben wurden.

Hier sind drei Testfälle, die zeigen, wie die Modelle mit superlangen Kontexten klarkommen, Halluzinationen vermeiden und hochwertige Zusammenfassungen liefern.

Zeichenerkennung 

Zuerst hab ich beide Modelle gebeten, alle Hauptfiguren zu nennen, die sowohl im ersten als auch im letzten Kapitel des Romans vorkommen, und kurz zu beschreiben, wie sich ihre Rollen im Laufe der Geschichte verändern.

Prompt: Zähl mal alle Hauptfiguren auf, die sowohl im ersten als auch im letzten Kapitel des Romans vorkommen. Erzähl kurz, wie sich ihre Rollen mit der Zeit ändern.”

Bei dieser Frage muss das Modell den ganzen Text verarbeiten und die Charakterbögen genau verfolgen. Beide Modelle waren echt reaktionsschnell, aber die Antwort von Qwen3 Next war klarer und besser auf jedes Kapitel des Buches zugeschnitten.

Halluzinationstest

Als Nächstes wollte ich sehen, ob die Modelle echte Inhalte von Fehlinformationen unterscheiden können. Ich hab beiden Modellen einen Satz gegeben, der zwar nicht in„ er Krieg und Frieden“ vorkommt, aber aus einem anderen Roman von Tolstoi bekannt ist.

Prompt: Steht in dem Roman der Satz „Alle glücklichen Familien ähneln einander, jede unglückliche Familie ist auf ihre eigene Weise unglücklich“? Wenn ja, wo im Text steht das?

Dieser Satz kommt eigentlich aus „Anna Karenina“, nicht aus „Krieg und Frieden“. Ein gutes Modell sollte mit „Nein“ antworten, was zeigt, dass es echt genau ist und nicht so oft was erfindet. Wahnsinn, Qwen3-Next hat richtig geantwortet, während das Qwen3 30B-Modell mit einem falschen Satz geantwortet hat.

Zusammenfassung

Zum Schluss habe ich die Zusammenfassungsfähigkeiten getestet, indem ich beide Modelle gebeten habe, den Roman in 300 Wörtern zusammenzufassen.

Prompt: Zusammenfass mal den Roman „Krieg und Frieden“ in 300 Wörtern und konzentrier dich dabei auf Pierre Bezuchows persönliche Reise.

Auch wenn die Zusammenfassung ein bisschen subjektiv ist, fand ich die Ergebnisse von Qwen3-Next besser strukturiert, schlüssiger und aufschlussreicher. Die Zusammenfassung war nicht nur kurz und knackig, sondern hat auch die Entwicklung von Pierres Charakter echt gut rübergebracht.

Beispiel 2: Mehrstufiges Denken und Logik

Um die fortgeschrittenen Denkfähigkeiten beider Modelle zu testen, habe ich sie mit komplizierten, mehrstufigen Logikrätseln herausgefordert – Aufgaben, die nicht nur Gedächtnis, sondern auch schrittweises Schlussfolgern und sorgfältiges Ausschließen erfordern.

Logikrätsel zur Sitzordnung

Zuerst hab ich den Modellen eine knifflige Aufgabe zum Thema Sitzordnung:

Prompt: „Bei der Hochzeitsfeier gibt es fünf Gäste, Colin, Emily, Kate, Fred und Irene, die nicht wissen, wo sie am Tisch sitzen sollen. Sie fragen die Mutter der Braut, die antwortet: „Soweit ich mich erinnere, sitzt Colin nicht neben Kate, und Emily sitzt nicht neben Fred oder Kate.“ Weder Kate noch Emily sitzen neben Irene. Und Fred sollte links von Irene sitzen. Wenn du sie von der anderen Seite der Tabelle aus siehst, kannst du die Gäste von links nach rechts richtig platzieren?

Erkläre deine Überlegungen Schritt für Schritt.

Bei diesem Rätsel musste man ein paar Einschränkungen checken und dann die einzige mögliche Sitzordnung herausfinden:

• Die Wahrheit: Emily, Colin, Irene, Fred, Kate
• Qwen3-Nächste Ausgabe: Kate, Fred, Irene, Colin, Emily (fast richtig, aber vertauscht)
• Qwen3-30B-Ausgang: Ich kann keine richtige Antwort finden.

Obwohl keines der Modelle die genaue richtige Reihenfolge gefunden hat, kam Qwen3-Next dem Ergebnis sehr nahe und hat lediglich die Reihenfolge umgekehrt, während das 30B-Modell überhaupt keine Lösung finden konnte. Das zeigt, dass Qwen3-Next in der Lage ist, mehrstufige Schlussfolgerungen zu ziehen, auch wenn einige Randfälle noch schwierig sind.

Deduktive Eliminierung 

Als Nächstes habe ich die Modelle mit einem Deduktionsrätsel getestet, das vom klassischen „Zebra-Rätsel“ inspiriert war.

Prompt: „Vier Leute (Lisa, Mike, Nora und Omar) haben jeder eine andere Frucht gekauft (Apfel, Banane, Kirsche, Dattel) und sind mit einem anderen Auto gefahren (Ford, Honda, Kia, Mazda).

• Lisa hat die Banane nicht gekauft.
• Der Ford-Fahrer hat die Kirsche gekauft.
• Mike fuhr einen Honda.
• Nora hat den Apfel gekauft und fährt keinen Mazda.
• Der Kia-Fahrer hat das Date bezahlt.
• Omar hat keinen Ford gefahren.

Wer hat welche Früchte gekauft und welches Auto gefahren? Zeig mal, was du gemacht hast.

Dieses Problem ist mit den gegebenen Einschränkungen absichtlich nicht lösbar, aber die Modelle haben stattdessen Folgendes geliefert:

• Qwen3-Nächste Ausgabe: Es wurde richtig erkannt, dass es keine gültige Zuweisung gibt.
• Qwen3-30B-Ausgangs: Es ist in einer Logikschleife hängen geblieben und hat es nicht geschafft, innerhalb der vorgegebenen Anzahl von Ausgabetoken fertig zu werden.

Dieses Beispiel zeigt, dass Qwen3-Next deduktiv denken und erkennen kann, wenn es keine Lösung gibt.

Fazit

Dieses Tutorial zeigt, wie man Qwen3-Next-80B-A3B für Fragen-und-Antworten- und Schlussfolgerungsaufgaben nutzt, und vergleicht es mit Qwen3-30B-A3B in einer Streamlit-App. Die Ergebnisse zeigen, wie gut Qwen3-Next mit superlangen Dokumenten klarkommt, schnelle Schlussfolgerungen zieht und die Qualität der Ergebnisse auch bei komplizierten Denkaufgaben aufrechterhält.