74ce6b13862c pour les systèmes de production — contrats et vérifications

Ce guide reconstitue le parcours allant des matières premières à un système fonctionnel pour : . L’accent est mis sur les étapes opérationnelles, les vérifications explicites, ainsi que sur du code que vous pouvez intégrer directement dans un dépôt sans devoir deviner son intention.

Exécuter Qwen3.8-Flash-Next localement : un guide complet pour créer un agent de codage local

Pour l’étape d’exécution locale de Qwen3 8-Flash-Next, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Faites approuver par des humains les étapes qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas la complétude du processus métier.

Qwen3.8-Flash-Next
        ↓
UD-Q4_K_XL GGUF
        ↓
llama.cpp
        ↓
OpenAI-compatible API
        ↓
OpenCode
        ↓
Local Coding Agent

Qu’est-ce que Qwen3.8-Flash-Next ?

Pour l’étape What Is Qwen3 8-Flash-Next, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Placez l’état au même endroit que le composant responsable de la mutation. Mettre tout en stockage global rend les erreurs liées aux délais plus difficiles à détecter.

Exigences matérielles

Pour l’étape des exigences matérielles, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Ajoutez un test de fumée qui met en œuvre le chemin critique dans l’CI à l’aide de fichiers de configuration, et non d’API payantes en ligne, chaque fois que le budget le permet.

Étape 1 — Vérifiez votre GPU NVIDIA

Pour l’Étape 1 « Vérifiez votre étape », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Ajoutez un test de fumée qui exécute le chemin critique dans l’CI en utilisant des fichiers de configuration, et non des API payantes en temps réel, chaque fois que le budget le permet.

nvidia-smi

Étape 2 — Installer les dépendances de compilation

Pour l’étape 2 « Installer », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Ajoutez un test de fumée qui met à l’épreuve le parcours critique dans le CI en utilisant des fixtures, et non des API payantes en production, dès que le budget le permet. Pour l’étape 2 « Installer », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse.

sudo apt update

sudo apt install -y \
  git \
  cmake \
  build-essential \
  curl \
  libcurl4-openssl-dev \
  python3-pip

Étape 3 — Construire llama.cpp

Lors de l’exécution de l’étape 3 de construction de llama.cpp, notez d’abord les exigences : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le projet passe d’un environnement de démonstration à des environnements partagés. Rédigez un petit manuel d’utilisation : comment rotationner les clés, comment vider la file d’attente, comment annuler la dernière ingestion.

cd /workspace

git clone \
  --branch qwen4exp/qwen3.8-flash-next \
  https://github.com/unslothai/llama.cpp.git

cd llama.cpp

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_BUILD_TYPE=Release

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

./build/bin/llama-server --version

Étape 4 — Télécharger le modèle GGUF

Lors de l’étape 4 « Télécharger la phase », notez d’abord les éléments requis : les données nécessaires, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Mémorisez les instructions stables du système et les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage de ressources.

pip install -U huggingface_hub

export HF_HUB_DISABLE_XET=1

unset HF_XET_HIGH_PERFORMANCE
unset HF_XET_NUM_CONCURRENT_RANGE_GETS
unset HF_HUB_ENABLE_HF_TRANSFER

cd /workspace
mkdir -p Qwen3.8-Flash-Next-GGUF

for i in 1 2 3 4; do
  shard=$(printf "%05d" "$i")

  hf download unsloth/Qwen3.8-Flash-Next-GGUF \
    "UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-${shard}-of-00004.gguf" \
    --local-dir Qwen3.8-Flash-Next-GGUF &
donewait

Étape 5 — Démarrer le serveur de modèle local

Lors de l’exécution de l’étape 5 « Démarrer », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Cachez les instructions système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage. Lors de l’exécution de l’étape 5 « Démarrer », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses.

cd /workspace/llama.cpp

./build/bin/llama-server \
  -m /workspace/Qwen3.8-Flash-Next-GGUF/UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf \
  --alias qwen3.8-flash-next \
  --host 0.0.0.0 \
  --port 8080 \
  --ctx-size 131072 \
  --parallel 1 \
  --flash-attn on \
  --fit on \
  --fit-target 4096 \
  --jinja \
  --batch-size 1024 \
  --ubatch-size 512 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 20 \
  --min-p 0.0

Étape 6 — Tester l’API

La étape 6 « Tester » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances propres à un groupe.

curl http://127.0.0.1:8080/v1/models

qwen3.8-flash-next

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-next",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that checks whether a number is prime."
      }
    ]
  }'

Étape 7 — Utiliser la WebUI de llama.cpp

La étape 7 « Utiliser la scène » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité vaut mieux que les connaissances propres à un groupe.

http://localhost:8080

Étape 8 — Installer OpenCode

La phase d’installation d’OpenCode de l’Étape 8 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Fixez les versions des dépendances et enregistrez le digest de l’image ayant exécuté la démonstration. La reproductibilité prime sur les connaissances propres à un groupe.

curl -fsSL https://opencode.ai/install | bash

opencode --version

Étape 9 — Connecter OpenCode à llama.cpp

Pour l’étape 9 « Connect OpenCode », définissez les entrées, le responsable de l’étape ainsi que les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés. Ajoutez un test de fumée qui met en œuvre le chemin critique dans le CI à l’aide de fichiers de configuration, et non d’API payantes en ligne, chaque fois que le budget le permet.

mkdir -p ~/.config/opencode

printf '%s\n' '{"$schema":"https://opencode.ai/config.json","model":"llama.cpp/qwen3.8-flash-next","provider":{"llama.cpp":{"npm":"@ai-sdk/openai-compatible","name":"Qwen3.8 Flash Next Local","options":{"baseURL":"http://127.0.0.1:8080/v1"},"models":{"qwen3.8-flash-next":{"name":"Qwen3.8 Flash Next","limit":{"context":65536,"output":32768}}}}}}' > ~/.config/opencode/opencode.json

http://127.0.0.1:8080/v1

Étape 10 — Démarrer votre agent de codage local

Pour l’étape 10 « Démarrez », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Mettez en place une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. Une connexion effectuée en temps de compilation ne garantit pas la complétude des processus métier.

cd /workspace/my-project

opencode

Your Project
     ↓
OpenCode
     ↓
llama.cpp API
     ↓
Qwen3.8-Flash-Next
     ↓
Local AI Coding Agent

Build a modern system analytics and task-management dashboard.
Monitor CPU, RAM, VRAM, GPU usage, temperatures, disk usage,
running processes, and temporary files.

Performance

Pour l’étape de performance, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Ajoutez un test de fumée qui exerce le parcours critique dans l’CI à l’aide de fichiers de configuration, et non d’API payantes en production, dès que le budget le permet. Pour l’étape de performance, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les terminations partielles silencieuses.

Ce que vous avez appris

Lors de l’étape « Ce que vous avez appris », notez d’abord les éléments essentiels du contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le système passe d’un environnement de démonstration à des environnements partagés. Rédigez un petit manuel d’utilisation : comment rotationner les clés, comment vider la file d’attente, et comment annuler la dernière ingestion.

Architecture finale

Lors de la phase d’architecture finale, écrivez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Rédigez un petit manuel d’utilisation : comment rotationner les clés, comment vider la file d’attente, comment revenir en arrière après une dernière ingestion.

┌──────────────────────────┐
│ Qwen3.8-Flash-Next       │
│ 125B MoE / ~6B active   │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ UD-Q4_K_XL GGUF          │
│ ~111GB                   │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ llama.cpp                │
│ CUDA + 131K Context      │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ OpenAI-Compatible API    │
│ localhost:8080/v1        │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ OpenCode                 │
│ Agentic Coding           │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ Fully Local AI Developer │
│ Environment              │
└──────────────────────────┘

Conclusion

Lors de l’étape de conclusion, notez d’abord les éléments requis pour le contrat : les données nécessaires, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Rédigez un petit guide opérationnel : comment rotationner les clés, comment vider la file d’attente, et comment annuler la dernière ingestion.

Liste de contrôle opérationnelle