Comment exécuter Qwen3.8 Flash Next en local sur un mini PC Ryzen AI Max+ 395

Faire tourner un grand modèle de langage sur votre propre matériel, c’est garder vos prompts privés, supprimer la facturation au token et ne plus dépendre d’un fournisseur cloud. En clair : une IA locale, entièrement sous votre contrôle. Ce guide, pensé pour les débutants, vous montre comment exécuter Qwen3.8 Flash Next en local sur un système AMD Ryzen AI Max+ 395 doté de 128 Go de mémoire unifiée, à l’aide de llama.cpp, du backend Vulkan et du décodage spéculatif MTP. À la fin, le modèle tournera comme un service en arrière-plan et exposera une API compatible OpenAI sur votre propre réseau.

Les étapes reposent sur un déploiement réel, testé le 8 septembre 2026. Si vous cherchez une machine compacte bâtie sur la même plateforme, le GEEKOM A9 Mega AI Mini PC associe le Ryzen AI Max+ 395 à jusqu’à 128 Go de mémoire LPDDR5X dans un châssis de 171 × 171 mm.

Ce que vous obtiendrez

Une fois ce guide terminé, Qwen3.8 Flash Next fonctionnera comme un service en arrière-plan, avec les caractéristiques suivantes (mesurées sur le système de test) :

• Vitesse de génération : environ 31 à 33 tokens/s en interne
• Débit HTTP de bout en bout : environ 26 à 36 tokens/s
• Utilisation mémoire : environ 110 Go
• Fenêtre de contexte : jusqu’à 256K tokens
• Fiabilité : démarrage automatique au boot et redémarrage après un incident

Ce qu’il vous faut

Pourquoi 128 Go ? La plateforme Ryzen AI Max+ repose sur une mémoire unifiée partagée entre le CPU et le GPU. C’est précisément ce qui permet à un modèle de cette taille, accompagné d’un cache KV à long contexte, de tenir entièrement sur le GPU intégré. Pour en savoir plus sur la puce elle-même, consultez notre présentation d’AMD Strix Halo.

Chemins utilisés dans ce guide. Les commandes emploient $HOME/models comme dossier de modèles et $HOME/llama.cpp comme dossier source. Si vous stockez les modèles sur un autre disque, adaptez ces chemins partout où ils apparaissent, y compris dans le fichier de service de l’étape 4.

Installer les outils nécessaires

Sur Ubuntu ou Debian :

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

Vérifiez que Vulkan détecte bien le GPU AMD :

vulkaninfo --summary

Si aucun GPU AMD n’apparaît, corrigez le pilote graphique avant de poursuivre.

Étape 1 : Télécharger les modèles

Créez les dossiers de modèles :

mkdir -p $HOME/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS
mkdir -p $HOME/models/Qwen3.8-Flash-Next-GGUF/MTP

Téléchargez les trois parties du modèle principal :

cd $HOME/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS

aria2c -x8 -s8 -c \
  "https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/resolve/main/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf"

aria2c -x8 -s8 -c \
  "https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/resolve/main/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00002-of-00003.gguf"

aria2c -x8 -s8 -c \
  "https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/resolve/main/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00003-of-00003.gguf"

Téléchargez ensuite le modèle brouillon MTP :

cd $HOME/models/Qwen3.8-Flash-Next-GGUF/MTP

aria2c -x8 -s8 -c \
  "https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/resolve/main/MTP/mtp-Qwen3.8-Flash-Next-shared-Q8_0.gguf"

L’option -c reprend un téléchargement interrompu. Les trois fichiers du modèle principal sont tous indispensables.

Étape 2 : Compiler llama.cpp avec Vulkan et le support MTP

Récupérez le code source :

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

Appliquez le correctif qui ajoute le support MTP requis :

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

Si vous obtenez patch failed ou does not apply, arrêtez-vous. Le correctif a peut-être déjà été fusionné, ou le code source actuel ne correspond plus à la version testée. Vérifiez l’état de la PR #28243 avant de continuer.

Compilez la version Vulkan :

cmake -B build-vulkan-mtp -S . \
  -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 -j8

Le binaire du serveur est créé dans $HOME/llama.cpp/build-vulkan-mtp/bin/llama-server.

Étape 3 : Lancer le serveur pour la première fois

Lancez le serveur dans un terminal pour vérifier que tout fonctionne :

$HOME/llama.cpp/build-vulkan-mtp/bin/llama-server \
  -m $HOME/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf \
  -md $HOME/models/Qwen3.8-Flash-Next-GGUF/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 0.0.0.0 --port 8080

Rôle des principales options :

Option	Rôle
-md	Charge le modèle brouillon MTP
--spec-draft-n-max 2	Génère jusqu’à deux tokens d’avance à la fois
-ngl 999	Place le maximum de couches du modèle sur le GPU et la mémoire unifiée
-ctk q8_0 -ctv q8_0	Utilise un cache KV en 8 bits pour réduire l’usage mémoire
-c 262144	Active une fenêtre de contexte de 256K

Une fois le serveur à l’écoute, ouvrez un second terminal et vérifiez son état de santé :

curl http://localhost:8080/health

Une réponse correcte signifie que le serveur fonctionne. Appuyez sur Ctrl+C dans le terminal du serveur une fois vos tests terminés.

À court de mémoire ? Divisez par deux la fenêtre de contexte en remplaçant -c 262144 par -c 131072.

Étape 4 : Exécuter en arrière-plan et au démarrage

Un service utilisateur systemd permet de garder le modèle actif sans terminal ouvert. Créez le fichier de service :

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

Collez le contenu suivant. Dans les fichiers d’unité systemd, %h désigne votre répertoire personnel : aucune modification n’est donc nécessaire si vous avez conservé les chemins par défaut ci-dessus :

[Unit]
Description=Qwen3.8 Flash Next llama-server
After=network.target

[Service]
Type=simple
WorkingDirectory=%h/models
ExecStartPre=/bin/sh -c 'for i in 1 2 3 4 5 6 7 8 9 10; do [ -f %h/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf ] && exit 0; sleep 3; done; exit 1'
ExecStart=%h/llama.cpp/build-vulkan-mtp/bin/llama-server -m %h/models/Qwen3.8-Flash-Next-GGUF/UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00003.gguf -md %h/models/Qwen3.8-Flash-Next-GGUF/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 0.0.0.0 --port 8080
Restart=always
RestartSec=5
MemoryMax=120G
TimeoutStopSec=30
KillSignal=SIGTERM

[Install]
WantedBy=default.target

Dans nano, appuyez sur Ctrl+O, puis Entrée, puis Ctrl+X pour enregistrer et quitter.

Activez et démarrez le service :

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

Vérifiez son état :

systemctl --user status llama-server --no-pager

Le service est prêt lorsqu’il affiche active (running).

Étape 5 : Utiliser l’API compatible OpenAI

Votre point de terminaison local est :

http://localhost:8080/v1

Testez-le avec curl :

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen","messages":[{"role":"user","content":"Hello"}],"max_tokens":100}'

Ou avec Python :

from openai import OpenAI

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

response = client.chat.completions.create(
    model="qwen",
    messages=[{"role": "user", "content": "Hello"}],
)

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

Pour utiliser le modèle depuis un autre appareil de votre réseau, remplacez localhost par l’adresse IP locale du serveur. Un mini PC doté d’un double port Ethernet 2,5 GbE, comme l’A9 Mega, se prête parfaitement au rôle de petit serveur d’IA toujours allumé, pour la maison ou le bureau.

Note de sécurité : l’API n’exige aucune authentification par défaut, et les commandes ci-dessus écoutent sur toutes les interfaces réseau (–host 0.0.0.0). N’exposez jamais le port 8080 directement sur l’Internet public. Si vous n’avez besoin d’y accéder que depuis la même machine, remplacez cette valeur par –host 127.0.0.1.

Gérer et dépanner le service

Consultez les journaux récents :

journalctl --user -u llama-server -n 100 --no-pager

Redémarrez ou arrêtez le service :

systemctl --user restart llama-server
systemctl --user stop llama-server

Après avoir modifié le fichier de service, exécutez toujours :

systemctl --user daemon-reload
systemctl --user restart llama-server

Problèmes courants

• Modèle introuvable : vérifiez que le disque des modèles est bien monté et que chaque chemin du fichier de service est correct.
• Mémoire insuffisante : remplacez -c 262144 par -c 131072, puis rechargez et redémarrez le service.
• Le port 8080 est occupé : lancez ss -ltnp | grep ‘:8080’ pour voir ce qui l’utilise, ou choisissez un autre port.
• Option MTP inconnue : le correctif n’a pas été appliqué correctement, ou un autre binaire llama-server est en cours d’exécution.

Questions fréquentes

En résumé

Avec environ 110 Go de mémoire unifiée mobilisée, une fenêtre de contexte de 256K et des débits de l’ordre de 26 à 36 tokens/s de bout en bout, une seule machine compacte suffit à héberger un serveur LLM privé et performant. Si vous cherchez le matériel adapté, jetez un œil au GEEKOM A9 Mega AI Mini PC : il réunit le Ryzen AI Max+ 395, 128 Go de mémoire, deux emplacements de stockage M.2 et une garantie de 3 ans.