Qwen3-Next lokaal draaien: zo doe je dat

Open‑source AI ontwikkelt zich razendsnel; bijna dagelijks verschijnen er nieuwe modellen die eerdere versies overtreffen, terwijl ze sneller worden, eenvoudiger te trainen zijn en meer “agent‑ready”.

In deze hands-on tutorial duiken we in Qwen3‑Next, draaien we het lokaal, starten we een simpele lokale server en richten we alles zo in dat je het later in je applicaties kunt integreren. Het mooiste is: we doen alles uitsluitend met het Hugging Face Transformers‑framework, zowel voor inferentie als voor serving.

Aan het eind kun je:

• Begrijpen wat er nieuw is in Qwen3‑Next
• Qwen3‑Next lokaal draaien met Transformers
• Een 4‑bit bitsandbytes (bnb) variant gebruiken om geheugen te besparen
• Qwen3‑Next via HTTP serven met transformers serve
• Met de server interacteren via zowel cURL als Python

Kennismaken met Qwen3-Next

Qwen3-Next is een nieuwe architectuur die is ontworpen om zowel de contextlengte als het totaal aantal parameters op te schalen. Het basismodel met 80 miljard parameters activeert tijdens inferentie slechts ongeveer 3 miljard parameters, terwijl het prestaties behaalt die gelijk zijn aan of iets beter dan het Dense Qwen3‑32B‑model, en dat met minder dan 10% van de trainingskosten. Daarnaast levert het meer dan 10 keer de throughput voor contextlengtes van meer dan 32.000 tokens.

Wat betreft post‑training varianten: het Instruct‑model concurreert met het vlaggenschipmodel met 235 miljard parameters en ondersteunt contextlengtes tot 256.000 tokens. Bovendien overtreft de Thinking‑variant de Qwen3‑30B‑A3B‑ en Qwen3‑32B‑modellen, evenals Gemini‑2.5‑Flash‑Thinking, en komt het in de buurt van de prestaties van het Thinking‑model met 235 miljard parameters.

Bron: Qwen

Wat is er nieuw in Qwen3‑Next: 

• Hybride attention (Gated DeltaNet + Gated Attention, 3:1): Combineert een snelle, geheugenarme attention voor lange invoer met standaard attention voor precieze recall. De output‑gate, grotere heads (256) en gedeeltelijke RoPE (25%) maken het zowel nauwkeurig als efficiënt op zeer lange reeksen.
• Ultra‑spaarzame MoE (512 experts; 10 gerouteerd + 1 gedeeld; ~3B/80B actief): Slechts een klein deel van het model draait per token, waardoor rekenwerk en geheugen worden gereduceerd terwijl de kwaliteit hoog blijft. Global load balancing verdeelt het werk over experts, zodat je consistente prestatiewinst krijgt zonder verspilling.
• Stability‑first training: Output‑gated attention voorkomt runaway‑activaties; Zero‑Centered RMSNorm met weight decay houdt normalisatiewichten in toom; genormaliseerde MoE‑router‑init voorkomt chaos in de vroege trainingsfase. Nettoresultaat: minder haperingen tijdens training en soepelere schaalbaarheid.
• Native Multi‑Token Prediction (MTP): Laat het model met vertrouwen meerdere volgende tokens tegelijk voorstellen, wat de decodeersnelheid verhoogt. Multi‑step training sluit aan bij het gebruik tijdens inferentie, waardoor de acceptatie van speculative decoding stijgt zonder kwaliteitsverlies.
• RL‑stabiliteitsfixes: Fine‑tuning met reinforcement learning draait sneller en crasht minder vaak op de hybride‑attention, hoog‑sparse MoE‑setup—waardoor je sneller betere eindprestaties bereikt.

Je kunt Qwen3‑Next ophalen op Hugging Face en ModelScope om lokaal te downloaden, of het als server uitrollen met frameworks zoals vLLM, SGLang of Transformers Serve.

Qwen3-Next lokaal draaien

Om Qwen3‑Next lokaal te draaien, installeren we de transformers-bibliotheek vanuit de main‑repository, samen met accelerate, bitsandbytes, flash-linear-attention en causal-conv1d voor een snellere backend.

Start na de installatie de Jupyter‑notebookkernel opnieuw.

%%capture

!pip install git+https://github.com/huggingface/transformers.git@main
!pip install accelerate bitsandbytes

!pip install git+https://github.com/fla-org/flash-linear-attention.git
!pip install git+https://github.com/Dao-AILab/causal-conv1d.gitMogelijk gemaakt door

Download en laad vervolgens de tokenizers en het model met de juiste datatypes en device map.

We laden een 4‑bit gequantiseerd model, waarmee onze geheugenvraag vier keer kleiner wordt. Je hebt dus minder opslagruimte en minder VRAM nodig om te laden en inferentie te draaien.

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "unsloth/Qwen3-Next-80B-A3B-Instruct-bnb-4bit"

# --- Load tokenizer ---
tokenizer = AutoTokenizer.from_pretrained(model_name)

# --- Load model ---
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto", 
    dtype="auto", 
)Mogelijk gemaakt door

Daarna maken we een prompt, formuleren we een bericht en halen we dit door een chattemplate om te zorgen dat het de juiste opmaak heeft die door het Qwen3‑Next‑model wordt herkend.

# prepare the model input
prompt = "Write a short introduction to large language models, highlighting how learners can explore them through DataCamp's interactive courses and hands-on projects."
messages = [
    {"role": "user", "content": prompt},
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)Mogelijk gemaakt door

Vervolgens tokenizen we de tekst, sturen we die door het model en halen we alleen de outputtokens eruit. Daarna decoderen we en tonen we de uiteindelijke respons.

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

# conduct text completion
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=512,
)
output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 

content = tokenizer.decode(output_ids, skip_special_tokens=True)

print("content:", content)Mogelijk gemaakt door

De output ziet er perfect uit:

content: Large language models (LLMs) are advanced AI systems trained on vast amounts of text data to understand, generate, and reason with human language. 
From answering questions and writing code to summarizing documents and engaging in conversation, LLMs are transforming how we interact with technology--and how we learn. 
At DataCamp, learners can explore the power of LLMs through interactive courses and hands-on projects that bridge theory with real-world application. 
Whether you're building your first chatbot, fine-tuning a model with Hugging Face, or evaluating AI-generated text, DataCamp's guided, code-based learning environment lets you experiment safely and effectively--no prior AI expertise required. 
Start your journey into the future of language AI today.Mogelijk gemaakt door

Een paar dingen om in gedachten te houden: 

1. 4‑bit formaat: Het Qwen3‑Next‑model op 4‑bit is ~60 GB alleen al aan gewichten; met overhead/kv‑cache wil je typisch ~60–80 GB VRAM voor comfortabele generatie. Alleen CPU is mogelijk, maar erg traag.
2. Laadtijd: Op tragere schijven (bijv. HDD/netwerk) kan de initiële laadfase even duren. SSD/NVMe helpt enorm.
3. Blijf in VRAM: Eenmaal geladen blijft het model in GPU‑geheugen totdat je het vrijgeeft of de kernel herstart; daaropvolgende inferenties zijn veel sneller.
4. Zorg voor GPU‑gebruik: Als torch.cuda.is_available() False is, draai je op CPU. Controleer je CUDA/driver‑setup.

Qwen3-Next serven

Je kunt Qwen3‑Next lokaal serven met SGLang of vLLM, zoals getoond op de modelpagina van Qwen. In deze tutorial leren we echter iets nieuws: de Transformers CLI gebruiken om het model te serven en er toegang toe te krijgen via een chatinterface van Transformers, vergelijkbaar met Ollama.

Installeer eerst de Transformers‑bibliotheek met serving‑mogelijkheden:

pip install transformers[serving]Mogelijk gemaakt door

Start vervolgens de Transformers‑server vanuit je terminal. Dit is een algemene server, vergelijkbaar met Ollama.

transformers serveMogelijk gemaakt door

Zoals je ziet, is de server bereikbaar op poort 8000:

INFO:     Started server process [3502]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://localhost:8000 (Press CTRL+C to quit)Mogelijk gemaakt door

De eenvoudigste manier om met de server te praten is met de Transformers chat‑CLI. Daarmee maak je verbinding met de server en krijg je in je terminal een chatachtige interface.

Open een nieuw terminalvenster en installeer de Rich‑bibliotheek:

pip install richMogelijk gemaakt door

Voer vervolgens het volgende commando uit om de chatinterface te starten met het modelpad:

transformers chat localhost:8000 \
  --model-name-or-path unsloth/Qwen3-Next-80B-A3B-Instruct-bnb-4bitMogelijk gemaakt door

Transformers chat kiest automatisch welk reeds gedownload model geladen wordt. In het begin kan het even duren om het model te laden, maar daarna kun je direct chatten.

Zoals je ziet interacteren we lokaal met het Qwen3‑Next‑model via de chatinterface.

Interactie met de Qwen3-Next-server

Er zijn veel manieren om met de server te interacteren. Je kunt de AsyncInferenceClient van Hugging Face Hub gebruiken, een CURL‑commando doen, Python’s requests-bibliotheek gebruiken, of de server benaderen via de OpenAI API.

Deze server is OpenAI‑compatibel, wat betekent dat je hem kunt integreren in je VSCode, agentische workflow, of gebruiken als een MCP‑server.

Eerst draaien we een simpel CURL‑commando in de nieuwe terminal om te checken hoeveel modellen er beschikbaar zijn op de server:

curl -s http://localhost:8000/v1/modelsMogelijk gemaakt door

Daarna gebruiken we de responses‑API. We geven het model en de prompts mee en zetten streaming op false:

curl -s http://localhost:8000/v1/responses \
  -H "Content-Type: application/json" \
  -d '{
    "model": "unsloth/Qwen3-Next-80B-A3B-Instruct-bnb-4bit",
    "input": "One line: what is Qwen3-Next?",
    "stream": false
  }'Mogelijk gemaakt door

Het resultaat is een gegenereerde respons met informatie over het Qwen3‑Next‑model.

{"response":{"id":"resp_req_0","created_at":1758494863.6661901,"model":"unsloth/Qwen3-Next-80B-A3B-Instruct-bnb-4bit@main","object":"response","output":[{"id":"msg_req_0","content":[{"annotations":[],"text":"Qwen3-Next is the next-generation large language model in Alibaba's Qwen series, featuring enhanced performance, broader knowledge, and improved reasoning capabilities.","type":"output_text"}],"role":"assistant","status":"completed","type":"message","annotations":[]}],"parallel_tool_calls":false,"tool_choice":"auto","tools":[],"status":"completed","text":{"format":{"type":"text"}}},"sequence_number":40,"type":"response.completed"}Mogelijk gemaakt door

Op een vergelijkbare manier kun je een Python‑bestand maken, de volgende code toevoegen en uitvoeren.

De code initialiseert de OpenAI‑client met de lokale server‑URL. We geven de modelnaam en input mee en genereren responses als stream.

from openai import OpenAI

# Connect to your local server
client = OpenAI(
    base_url="http://localhost:8000/v1",  # transformers serve endpoint
    api_key="not-needed"                  # required by SDK, but can be dummy
)

# Create a streaming response request
response = client.responses.create(
    model="unsloth/Qwen3-Next-80B-A3B-Instruct-bnb-4bit",  # use your loaded model
    instructions="You are a helpful assistant.",
    input="What is love?",
    stream=True,                      # enable SSE streaming
    metadata={"source": "local-test"} # optional metadata
)

# Iterate over server-sent events
for event in response:
    if event.type == "response.output_text.delta":
        # This event contains the incremental text
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        print("\n--- done ---")Mogelijk gemaakt door

We ontvingen keurig resultaten als streamingrespons. Dit is geweldig.

Love is one of the most profound, complex, and universal human experiences -- a powerful emotion that defies simple definition but shapes our lives in countless ways.

At its core, **love** is a deep affection, care, and connection toward another person -- or even a thing, idea, or cause. It can manifest in many forms:

### Types of Love (from ancient Greek philosophy):
- **Eros**: Passionate, romantic, or sexual love.
- **Philia**: Deep friendship and platonic affection.
- **Storge**: Familial love -- the natural affection between parents and children.
- **Agape**: Selfless, unconditional love -- often spiritual or altruistic.
- **Ludus**: Playful, flirtatious love.
- **Pragma**: Long-lasting, committed love built on patience and compromise.
- **Philautia**: Self-love -- healthy self-regard that enables us to love others.

### What Love Feels Like:
- **Emotionally**: Warmth, safety, joy, vulnerability, longing, and sometimes pain.
- **Behaviorally**: Acts of kindness, sacrifice, patience, listening, and presence.
- **Biologically**: Involves neurotransmitters like oxytocin, dopamine, and serotonin -- chemicals that bond us and create attachment.

### Love Is Also a Choice:
Beyond feelings, love is often a decision -- to show up, to forgive, to stay even when it's hard. It's not just a rush of butterflies; it's the quiet commitment to care for someone day after day.

### In Essence:
> **Love is seeing someone's soul -- and choosing to hold it gently.**

It's the reason people write poetry, compose music, risk everything for another, and find meaning in life. Love connects us -- to others, to ourselves, and to something greater than just our individual existence.

So what is love?  
It's complicated. It's messy. It's beautiful.  
And above all -- it's human. ❤️
--- done ---Mogelijk gemaakt door

Conclusie

Op het moment van schrijven is de GGUF‑versie van Qwen3‑Next niet beschikbaar, wat betekent dat je het niet lokaal kunt draaien met Ollama of Llama.cpp. Het volledige model vereist vier A100‑GPU’s om effectief te draaien, dus kozen we voor een gequantiseerde versie waarmee we het model op één A100‑GPU met 80GB VRAM kunnen draaien. Hoewel het wat tijd kostte om het model te downloaden en in te richten, hebben we succesvol geleerd hoe we inferentie kunnen draaien.

In deze tutorial verkenden we het Qwen3‑Next‑model, dat qua snelheid en nauwkeurigheid concurreert met andere toonaangevende propriëtaire modellen, ondanks dat het kleiner is.

Na het model lokaal te hebben gedraaid, benaderden we het via het curl‑commando en de OpenAI Python SDK. De volgende stap is het model optimaliseren voor jouw specifieke machine. We kunnen kleinere versies verkennen, zoals de 1,2‑bit modellen, om de inferentiesnelheid te verhogen, zeker op GPU’s aan de onderkant van het spectrum.

Je zou ook kunnen overwegen een GPU‑server te huren om je eigen private LLM‑server op te zetten; Runpod is hiervoor een goede optie om te verkennen.