Cum rulezi Qwen3.8-27B local pe un NVIDIA RTX 5090

Află cum să rulezi Qwen3.8-27B local cu NVFP4 nativ pentru Blackwell și decodare speculativă MTP, atingând până la 170 de tokeni pe secundă cu llama.cpp.

Actualizat 25 aug. 2026 · 6 min. citire

Explorează cu AI

ChatGPT Claude Perplexity

Qwen3.8-27B devine rapid unul dintre cele mai populare modele pentru AI locală. Deși are doar 27 de miliarde de parametri, oferă performanțe care concurează cu modele mult mai mari la benchmark-uri pentru programare, raționament, agenți și uz general. Se apropie chiar de modele precum GLM-5.2 în mai multe zone, ceea ce l-a făcut deosebit de popular printre cei care experimentează cu hardware local puternic.

RTX 5090 este deosebit de potrivit pentru Qwen3.8-27B deoarece arhitectura sa Blackwell suportă NVFP4, permițând modelului să ruleze la viteze foarte mari menținând în același timp o calitate bună a ieșirii. Combinat cu decodare speculativă prin multi-token prediction (MTP), un build optimizat llama.cpp și modelul GGUF potrivit, Qwen3.8-27B poate oferi bine peste 100 de tokeni pe secundă pe un singur RTX 5090.

În acest ghid, vom configura ceea ce cred că este unul dintre cele mai simple moduri de a obține cel mai bun echilibru între viteză, acuratețe și suport pentru context lung pe un RTX 5090 sau alt GPU Blackwell. Vom compila llama.cpp cu suport Blackwell nativ, vom descărca Qwen3.8-27B NVFP4-MTP GGUF, îl vom rula cu accelerare GPU și decodare speculativă MTP, vom testa API-ul compatibil OpenAI și interfața web integrată, iar la final îl vom conecta la Pi ca să putem folosi Qwen3.8-27B ca un agent de programare complet local.

1. Configurează llama.cpp pentru GPU-urile Blackwell

Mai întâi, ne asigurăm că GPU-ul este detectat corect și verificăm versiunea driverului NVIDIA și a CUDA.

nvidia-smi

Ar trebui să vezi RTX 5090, versiunea driverului, versiunea CUDA, memoria GPU și utilizarea curentă a GPU-ului.

Notă: Acest setup este specific pentru GPU-urile NVIDIA Blackwell, cum ar fi RTX 5090. Build-ul de mai jos țintește SM120, arhitectura de calcul folosită de RTX 5090.

În continuare, vom descărca și compila cea mai recentă versiune de llama.cpp cu suport CUDA.

cd /workspace

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_CUDA_ARCHITECTURES=120

cmake --build build --config Release -j$(nproc)

Partea importantă aici este -DCMAKE_CUDA_ARCHITECTURES=120. Asta îi spune lui llama.cpp să construiască specific pentru arhitectura Blackwell folosită de RTX 5090.

După ce build-ul se termină, vom face llama-server disponibil global ca să îl putem rula din orice folder:

sudo ln -sf "$(realpath ./build/bin/llama-server)" /usr/local/bin/llama-server

Acum, verifică faptul că totul funcționează:

llama-server --version

Ar trebui să primești un output similar cu:

version: 0.1.1-dev (build 10479, commit 0021a77de)
built with GNU 13.3.0 for Linux x86_64

Atât. Acum avem un build llama.cpp cu CUDA care poate profita de RTX 5090 și de suportul său NVFP4 nativ pentru Blackwell.

2. Descarcă modelul Qwen3.8-27B NVFP4-MTP

Acum vom descărca modelul Qwen3.8-27B.

Mai întâi, instalează Hugging Face CLI:

pip install -U huggingface_hub

Creează un folder în care vom păstra modelul:

mkdir -p /workspace/models/qwen38

Apoi descarcă GGUF-ul NVFP4-MTP:

hf download felippeburk/Qwen3.8-27B-NVFP4-MTP-GGUF \
  --local-dir /workspace/models/qwen38

Aceasta este versiunea de care avem nevoie pentru acest setup deoarece folosește NVFP4 și include suport MTP, de unde provine mare parte din îmbunătățirea de viteză pe RTX 5090.

3. Pornește serverul Qwen3.8-27B

Acum vine partea interesantă. Vom servi Qwen3.8-27B complet pe GPU cu Flash Attention, un context window de 131K și decodare speculativă MTP pentru generare mai rapidă.

Rulează:

cd /workspace/llama.cpp

llama-server \
  -m /workspace/models/qwen38/qwen3.8-27b-text-nvfp4-mtp.gguf \
  --alias qwen3.8-27b \
  --host 0.0.0.0 \
  --port 8910 \
  --ctx-size 131072 \
  --n-gpu-layers all \
  --flash-attn on \
  --cache-type-k q8_0 \
  --cache-type-v q8_0 \
  --parallel 1 \
  --spec-type draft-mtp \
  --spec-draft-n-max 4 \
  --spec-draft-p-min 0.75 \
  --spec-draft-ngl all \
  --spec-draft-type-k q8_0 \
  --spec-draft-type-v q8_0 \
  --reasoning-effort medium \
  --jinja

Sunt multe opțiuni aici, dar majoritatea sunt doar pentru a obține cea mai bună performanță de la 5090.

Cele principale de știut sunt:

--ctx-size 131072 ne oferă aproximativ un context window de 131K.
--n-gpu-layers all păstrează modelul pe GPU.
--flash-attn on activează Flash Attention.
--cache-type-k q8_0 și --cache-type-v q8_0 ajută la reducerea utilizării memoriei pentru KV cache.
--spec-type draft-mtp activează decodarea speculativă MTP a Qwen3.8.
--spec-draft-n-max 4 controlează câți tokeni speculativi poate genera MTP deodată.

Pentru acest setup, folosim n-max 4 ca punct de plecare pentru un RTX 5090. Poți experimenta cu valori precum 2 (recomandată de model card pentru acest GGUF) sau 3 ulterior, deoarece setarea cea mai rapidă poate varia ușor în funcție de sistem.

După ce llama-server termină de încărcat modelul, Qwen3.8 va fi disponibil local la http://127.0.0.1:8910.

Acum avem Qwen3.8-27B rulând local. În continuare, vom testa modelul atât prin API, cât și prin interfața de browser integrată.

4. Testează viteza și performanța la programare a Qwen3.8-27B

Cu serverul pornit, deschide un alt terminal și trimite o cerere de test către API-ul compatibil OpenAI:

curl http://127.0.0.1:8910/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
   "model": "qwen3.8-27b",
   "messages": [
     {
       "role": "user",
       "content": "Write a Python FastAPI application that monitors GPU usage."
     }
   ],
   "max_tokens": 2000
 }'

În acest test, Qwen3.8-27B a generat 2.000 de tokeni la 122 tokeni/sec, cu o rată de acceptare MTP impresionantă de 84,9%.

llama.cpp include și o interfață de browser, astfel încât poți testa modelul fără a folosi API-ul.

Deschide http://127.0.0.1:8910 în browser pentru a vedea UI-ul.

Pentru un test mai complex, am folosit acest prompt:

Create a stunning single-file animated HTML website with a dark futuristic 
theme, smooth scrolling, glowing gradients, floating particles, animated cards,
hover effects, and responsive design using only HTML, CSS, and JavaScript.

Pe RTX 5090-ul meu, obțineam în medie aproximativ 142 de tokeni pe secundă, cu viteze de generare care atingeau ocazional în jur de 170 de tokeni pe secundă, ceea ce este extrem de rapid pentru un model de 27B care rulează local.

Qwen3.8-27B a generat un website finisat, complet funcțional, care a rulat imediat. Este o modalitate bună de a testa rapid atât capacitatea de programare a modelului, cât și viteza setup-ului local.

5. Folosește Qwen3.8-27B cu Pi

În această secțiune, vom conecta Qwen3.8-27B la Pi și îl vom folosi ca agent de programare complet local.

Pi este un agent de programare ușor, bazat pe terminal, care te poate ajuta să construiești, editezi, testezi și debugezi proiecte direct din linia de comandă.

Instalează Pi cu:

curl -fsSL https://pi.dev/install.sh | sh

Installerul necesită Node.js și npm. Instalează Pi în prefixul npm global. Dacă nu ai încă Node, instalează-l mai întâi cu nvm sau cu managerul tău de pachete.

După ce instalarea se termină, repornește terminalul.

În continuare, instalează extensia pi-llama și indică lui Pi serverul nostru local llama.cpp:

pi install git:github.com/huggingface/pi-llama

export LLAMA_BASE_URL=http://127.0.0.1:8910/v1

Creează un proiect nou și pornește Pi:

mkdir new-project
cd new-project

Pi

În interiorul Pi, rulează /model, caută llama-cpp și selectează Qwen3.8-27B.

Pentru testare, i-am dat acest prompt:

Build a polished personal finance dashboard from scratch that imports CSV 
bank statements, categorizes spending, shows monthly trends and charts, and 
detects unusual expenses; also generate a realistic sample CSV, import it, 
test the full app end-to-end, and fix any errors automatically.

A construit întregul proiect în câteva minute.

Apoi i-am cerut să pornească serverul și să testeze atât frontend-ul, cât și logica aplicației. A petrecut mai mult timp făcând debugging și testând, pentru a se asigura că totul funcționează corect.

Când am testat eu însumi dashboard-ul, aplicația a funcționat bine, graficele arătau grozav, iar experiența generală a fost cursivă.

Punctul slab principal a fost realizarea unor schimbări precise în UI. După mai multe prompturi ulterioare, a început să facă modificări fără legătură în loc să înțeleagă exact ce voiam, așa că m-am oprit acolo.

Gânduri finale

Qwen3.8-27B este încă foarte nou, iar comunitatea caută activ cea mai bună combinație de cuantizare și decodare speculativă. MTP funcționează extrem de bine, dar sunt testate și abordări mai noi precum DFlash 2 și DSpark, unii utilizatori raportând viteze și mai mari în funcție de hardware și de sarcină.

Unsloth tocmai a lansat și GGUF-urile Dynamic v3.0 pentru Qwen3.8-27B, susținând aproximativ 10% acuratețe mai mare la aceeași dimensiune a modelului comparativ cu cuantizările anterioare. Asta face din Unsloth o opțiune foarte interesantă dacă vrei calitate mai bună păstrând în linii mari același setup de inferență locală.

Pentru moment, cred că NVFP4 + MTP + llama.cpp este unul dintre cele mai simple și mai rapide setup-uri pentru un RTX 5090. Să obții în jur de 140 de tokeni pe secundă de la un model de 27B, având totodată un context window mare și suficientă capabilitate pentru a rula un agent de programare real, este impresionant. Setup-ul va deveni probabil și mai rapid pe măsură ce llama.cpp, Unsloth, DFlash 2 și DSpark continuă să se îmbunătățească.