Qwen3.8 Flash Next auf dem Ryzen AI Max+ 395: llama.cpp mit Vulkan und MTP unter Ubuntu

Diese Anleitung richtet sich an Nutzer, die mit dem Linux-Terminal vertraut sind und mehr wollen als eine Chat-Oberfläche: Wir kompilieren llama.cpp selbst, aktivieren Multi-Token-Prediction (MTP) für schnellere Antworten, nutzen die vollen 256K Kontext und betreiben Qwen3.8 Flash Next als dauerhaften systemd-Dienst mit OpenAI-kompatibler API.

Wer einen einfacheren Einstieg sucht, findet in unserer Anleitung gpt-oss-120b lokal installieren den Weg über LM Studio unter Windows.

Das Ergebnis im Test

Auf unserem Testsystem hat diese Konfiguration folgende Werte erreicht:

Qwen3.8 Flash Next kurz erklärt

Qwen3.8 Flash Next ist ein offenes, multimodales Mixture-of-Experts-Modell mit rund 125 Milliarden Parametern und einem Kontextfenster von 262K Token (Unsloth). Für 128-GB-Systeme ist die Quantisierung UD-IQ4_XS mit 93,7 GB der sinnvollste Kompromiss aus Qualität und Speicherbedarf.

MTP (Multi-Token-Prediction) ist eine Form des spekulativen Decodings: Ein kleines Draft-Modell schlägt mehrere Token im Voraus vor, das Hauptmodell prüft sie in einem Durchgang. Werden die Vorschläge akzeptiert, steigt die Ausgabegeschwindigkeit, ohne dass sich das Ergebnis ändert.

Schritt 1: Kernel für großen GPU-Speicher vorbereiten

Unter Linux teilt der Kernel der integrierten Grafik standardmäßig nur einen Teil des Arbeitsspeichers als GTT-Speicher zu. Für ein 94-GB-Modell reicht das nicht. Dieser Schritt fehlt in vielen Anleitungen und ist die häufigste Ursache für Abbrüche beim Laden.

BIOS: Stelle die UMA Frame Buffer Size auf Auto oder den kleinsten Wert (512 MB). Ein fest reservierter Grafikspeicher im BIOS wäre für Linux dauerhaft blockiert. Den Speicher teilen wir stattdessen dynamisch über den Kernel zu.

Kernel-Parameter setzen:

sudo nano /etc/default/grub

Ergänze die Zeile GRUB_CMDLINE_LINUX_DEFAULT so:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash ttm.pages_limit=31457280 amdgpu.gttsize=120000"

sudo update-grub
sudo reboot

ttm.pages_limit=31457280 entspricht 120 GB (31.457.280 Seiten à 4 KB). So bleiben rund 8 GB für das Betriebssystem (Zypher Systems).

Prüfen:

sudo dmesg | grep -i "gtt memory"

Schritt 2: Pakete installieren und Vulkan prüfen

sudo apt update
sudo apt install -y git curl aria2 cmake ninja-build build-essential \
  vulkan-tools libvulkan-dev glslc

vulkaninfo --summary | grep -i devicename

Schritt 3: Modell-Laufwerk fest einbinden

Das Originalsetup nutzt den automatischen Mount-Pfad des Desktops (/run/media/…). Das hat einen Haken: Der Desktop hängt Laufwerke erst nach der Anmeldung ein. Startet der Dienst beim Booten vorher, findet er das Modell nicht. Deshalb binden wir das Laufwerk fest per /etc/fstab ein.

lsblk -f

Notiere die UUID der Partition und lege den Mount-Punkt an:

sudo mkdir -p /mnt/models

Trage das Laufwerk in /etc/fstab ein. Für eine ext4-Partition (empfohlen):

UUID=DEINE-UUID  /mnt/models  ext4  defaults,nofail  0  2

Für eine NTFS-Partition (z. B. eine bestehende Windows-Datenplatte):

UUID=DEINE-UUID  /mnt/models  ntfs3  uid=1000,gid=1000,nofail  0  0

UUID=DEINE-UUID  /mnt/models  ntfs3  uid=1000,gid=1000,nofail  0  0

sudo systemctl daemon-reload
sudo mount -a
sudo chown "$USER:$USER" /mnt/models  # nur bei ext4 nötig

Ab hier arbeiten wir mit Variablen statt fester Pfade. So musst du Benutzernamen und Laufwerk nur an einer Stelle anpassen:

export MODEL_ROOT=/mnt/models
export QWEN_DIR="$MODEL_ROOT/Qwen3.8-Flash-Next-GGUF"
export LLAMA_DIR="$HOME/llama.cpp"

Schritt 4: Modell und MTP-Draft herunterladen

mkdir -p "$QWEN_DIR/UD-IQ4_XS" "$QWEN_DIR/MTP"

BASE=https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/resolve/main

# Hauptmodell: alle drei Teile sind erforderlich
for i in 1 2 3; do
  aria2c -x8 -s8 -c -d "$QWEN_DIR/UD-IQ4_XS" \
    "$BASE/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-0000${i}-of-00003.gguf"
done

# MTP-Draft-Modell
aria2c -x8 -s8 -c -d "$QWEN_DIR/MTP" \
  "$BASE/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf"

-c setzt abgebrochene Downloads fort, -x8 -s8 lädt über acht parallele Verbindungen. Bei 100 Mbit/s dauert der Download rund 2 Stunden, bei 1 Gbit/s etwa 15 Minuten.

ls -lh "$QWEN_DIR"/UD-IQ4_XS "$QWEN_DIR"/MTP

Schritt 5: llama.cpp mit MTP-Patch kompilieren

git clone https://github.com/ggml-org/llama.cpp.git "$LLAMA_DIR"
cd "$LLAMA_DIR"
git rev-parse --short HEAD  # Commit notieren, falls du später reproduzieren willst

MTP-Unterstützung für Qwen3.8 Flash Next ist zum Zeitpunkt des Tests noch nicht im Hauptzweig von llama.cpp enthalten. Sie kommt über Pull Request #28243:

curl -L "https://github.com/ggml-org/llama.cpp/pull/28243.diff" -o /tmp/pr-28243.diff
git apply --check /tmp/pr-28243.diff && git apply /tmp/pr-28243.diff

Vulkan-Build:

cmake -B build-vulkan-mtp -S . -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DGGML_VULKAN=ON \
  -DGGML_NATIVE=OFF \
  -DGGML_OPENMP=ON \
  -DGGML_LTO=ON \
  -DBUILD_SHARED_LIBS=OFF

cmake --build build-vulkan-mtp --config Release --target llama-server -j"$(nproc)"

Schritt 6: Erster Start im Terminal

"$LLAMA_DIR/build-vulkan-mtp/bin/llama-server" \
  -m "$QWEN_DIR/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf" \
  -md "$QWEN_DIR/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf" \
  --spec-type draft-mtp --spec-draft-n-max 2 \
  -ngl 999 -fa on \
  -ctk q8_0 -ctv q8_0 \
  -c 262144 -b 4096 -ub 1024 \
  -t 4 --parallel 1 --jinja --no-webui \
  --host 127.0.0.1 --port 8080

Bei geteilten GGUF-Dateien reicht es, den ersten Teil (-00001-of-00003) anzugeben. llama.cpp lädt die übrigen Teile automatisch.

In einem zweiten Terminal testen:

curl http://localhost:8080/health

Schritt 7: Als systemd-Dienst mit Autostart einrichten

Statt alle Pfade im Service-File zu wiederholen, lagern wir die Konfiguration in eine Umgebungsdatei aus. Änderungen am Kontext oder Port brauchen dann keinen Eingriff in die Unit.

mkdir -p ~/.config/llama-server ~/.config/systemd/user
nano ~/.config/llama-server/qwen.env

LLAMA_BIN=/home/DEIN-BENUTZER/llama.cpp/build-vulkan-mtp/bin/llama-server
MODEL=/mnt/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf
DRAFT=/mnt/models/Qwen3.8-Flash-Next-GGUF/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf
CTX=262144
HOST=127.0.0.1
PORT=8080
EXTRA_ARGS=

nano ~/.config/systemd/user/llama-server.service

[Unit]
Description=Qwen3.8 Flash Next (llama-server)
After=network-online.target
StartLimitIntervalSec=0

[Service]
Type=simple
EnvironmentFile=%h/.config/llama-server/qwen.env
ExecStartPre=/usr/bin/test -f ${MODEL}
ExecStart=${LLAMA_BIN} -m ${MODEL} -md ${DRAFT} \
  --spec-type draft-mtp --spec-draft-n-max 2 \
  -ngl 999 -fa on -ctk q8_0 -ctv q8_0 \
  -c ${CTX} -b 4096 -ub 1024 -t 4 --parallel 1 \
  --jinja --no-webui --host ${HOST} --port ${PORT} $EXTRA_ARGS
Restart=always
RestartSec=5
MemoryMax=120G
TimeoutStopSec=30

[Install]
WantedBy=default.target

Dienst aktivieren. enable-linger sorgt dafür, dass der Benutzerdienst schon beim Booten startet, ohne dass du dich anmelden musst:

sudo loginctl enable-linger "$USER"
systemctl --user daemon-reload
systemctl --user enable --now llama-server
systemctl --user status llama-server --no-pager

Schritt 8: Die API nutzen

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen","messages":[{"role":"user","content":"Hallo, wer bist du?"}],"max_tokens":200}'

Den Modellnamen wertet llama-server nicht aus, da nur ein Modell geladen ist. Ein beliebiger Wert wie „qwen“ genügt.

Python mit dem OpenAI-Client:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="nicht-benoetigt"
)

antwort = client.chat.completions.create(
    model="qwen",
    messages=[
        {
            "role": "user",
            "content": "Fasse die Vorteile lokaler KI in drei Punkten zusammen."
        }
    ],
    temperature=1.0,
    top_p=0.95,
    extra_body={"top_k": 20},
)

print(antwort.choices[0].message.content)

Empfohlene Sampling-Werte laut Unsloth:

Schritt 9: Zugriff im Heimnetz absichern

Standardmäßig lauscht der Dienst nur auf 127.0.0.1. Für den Zugriff von anderen Geräten im Heimnetz gehören drei Dinge zusammen: Netzwerk-Bindung, API-Schlüssel und Firewall-Regel.

openssl rand -hex 24  # erzeugt einen zufälligen API-Schlüssel

In qwen.env anpassen:

HOST=0.0.0.0
EXTRA_ARGS=--api-key DEIN-SCHLUESSEL

Firewall nur für das eigene Netz öffnen (Beispiel für das Standardnetz einer FRITZ!Box):

sudo ufw allow from 192.168.178.0/24 to any port 8080 proto tcp
sudo ufw enable
systemctl --user restart llama-server

Clients nutzen dann http://IP-DES-SERVERS:8080/v1 und den Schlüssel als API-Key.

Schritt 10: Betrieb, Monitoring und Updates

llama.cpp aktualisieren: Da der MTP-Patch noch nicht gemergt ist, empfiehlt sich ein separates Build-Verzeichnis. So läuft der funktionierende Dienst weiter, bis der neue Build getestet ist:

cd "$LLAMA_DIR" && git stash && git pull

# Patch erneut anwenden (oder entfällt, falls PR #28243 gemergt ist)

cmake -B build-vulkan-mtp-neu -S . -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DGGML_VULKAN=ON \
  -DGGML_NATIVE=OFF \
  -DGGML_OPENMP=ON \
  -DGGML_LTO=ON \
  -DBUILD_SHARED_LIBS=OFF

cmake --build build-vulkan-mtp-neu --target llama-server -j"$(nproc)"

# Nach erfolgreichem Test LLAMA_BIN in qwen.env umstellen und Dienst neu starten

Fehlerbehebung

FAQ

Fazit

Mit selbst kompiliertem llama.cpp, Vulkan und MTP holst du aus dem GEEKOM A9 Mega mit Strix Halo und 128 GB ein Setup heraus, das ein 125B-Modell mit vollem 256K-Kontext als dauerhaften Dienst bereitstellt. Die entscheidenden Stellschrauben sind das GTT-Limit im Kernel, ein fest eingebundenes Modell-Laufwerk und ein systemd-Dienst mit ausgelagerter Konfiguration. Da der MTP-Patch noch in Entwicklung ist, lohnt es sich, PR #28243 im Blick zu behalten.