Strata et Qwen3.8-Flash-Next : faire tourner une IA locale sur GPU en 2026

Salut HaWkers, faire tourner un grand modèle sur son propre ordinateur ne signifie plus forcément acheter plusieurs cartes graphiques professionnelles. Le projet open source Strata propose d'exécuter Qwen3.8-Flash-Next, présenté par ses auteurs comme un modèle de 125 milliards de paramètres, avec un GPU NVIDIA et une quantité importante de mémoire vive. Le dépôt figurait parmi les projets remarqués dans le classement des tendances consulté le 1er octobre 2026. Le nombre d'étoiles d'un dépôt change cependant constamment et ne constitue pas, à lui seul, une mesure de qualité.

Votre machine peut-elle réellement exécuter ce modèle ? Quelle part de cette promesse dépend du matériel ? Et comment essayer l'API sans transformer une démonstration réussie en conclusion hâtive ? Nous allons examiner les besoins en mémoire, la quantification, l'installation et une méthode de mesure que vous pourrez adapter. Les données techniques proviennent du README du projet et de sa documentation détaillée, consultés lors de la préparation de cet article.

Ce que fait Strata et les limites de sa proposition

Strata est un moteur d'inférence et une application locale destinés à exécuter des versions quantifiées de Qwen3.8-Flash-Next. Il propose une interface de discussion dans le navigateur et des points d'accès compatibles avec les clients utilisant les formats OpenAI Chat Completions et Anthropic Messages. Les poids du modèle ne sont pas inclus dans le code du dépôt : l'installation récupère séparément les fichiers nécessaires, soumis à leurs propres licences. La licence du programme ne règle pas automatiquement les droits applicables aux poids.

L'idée technique est de combiner GPU, RAM et SSD au lieu d'exiger que tous les poids tiennent dans la mémoire vidéo. Une partie des données reste en mémoire principale, tandis qu'une grande table demeure sur le stockage. La carte graphique traite les données dont elle a besoin, mais les transferts et les accès aux fichiers contribuent eux aussi au temps de réponse. Dire simplement « cela tourne sur mon GPU » ne donne donc aucune indication suffisante sur la latence, la qualité ou le coût d'exploitation. Une machine disposant de moins de RAM peut démarrer dans un autre mode et présenter un comportement différent.

Il faut également distinguer le modèle, son implémentation et l'interface. Qwen produit la réponse ; Strata organise le chargement, l'exécution et le service HTTP ; votre application envoie les messages et interprète le résultat. Un problème dans l'une de ces couches apparaît souvent à l'utilisateur sous la forme « l'IA a échoué », alors que la correction dépend de la couche concernée. Face à une API hébergée, prenez en compte la disponibilité, la consommation électrique, la confidentialité, l'entretien de la machine et le délai avant le premier mot.

Si vous avez lu notre article sur Falcon-H1R et les limites des modèles compacts, la comparaison est utile. L'objectif ici est de placer un grand modèle sur une machine plus ordinaire grâce à la quantification et à la répartition de la mémoire. Cela ne démontre pas que ce modèle sera le meilleur choix pour chaque usage.

Prérequis : considérer ensemble la RAM, la VRAM et le stockage

Le README actuel mentionne Windows 10/11 ou Linux, un pilote NVIDIA récent, une carte RTX compatible dotée d'au moins 12 Go de VRAM pour la voie standard, assez de RAM pour la variante choisie et environ 80 Go d'espace disque libre. Le README présente 64 Go de RAM comme configuration simple. Les exigences détaillées changent avec la quantification : le tableau du projet indique 37,6 Go de RAM en plus de la VRAM pour Q2_0, 39,2 Go pour IQ2_XS, 47,0 Go pour IQ3_XXS et 54,8 Go pour IQ3_S. Ces chiffres décrivent les besoins du projet et ne garantissent pas qu'il restera suffisamment de mémoire pour le système d'exploitation et vos autres programmes.

Plus de VRAM peut accélérer le traitement sans éliminer le besoin de RAM. Le SSD n'est pas non plus un détail accessoire : la taille des fichiers du modèle et le chargement initial font du stockage une partie de l'expérience. Avant de télécharger des dizaines de gigaoctets, vérifiez l'espace disponible, la version du pilote et la mémoire réellement libre.

Sous Linux, cette petite inspection évite de commencer une installation incompatible. Ces commandes affichent des informations sur votre système ; elles ne modifient pas Strata et ne réalisent aucun benchmark. Si nvidia-smi échoue, réglez d'abord le problème de pilote. La mémoire indiquée par free tient compte de la charge actuelle des autres processus, laquelle peut changer pendant l'inférence.

# Vérifiez le GPU, la VRAM et la version du pilote installé.
nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv

# Consultez la mémoire disponible maintenant, pas seulement la mémoire physique installée.
free -h

# Vérifiez l'espace libre sur le disque qui accueillera les fichiers du modèle.
df -h .

Si votre machine est proche de la limite, ne choisissez pas automatiquement la variante de meilleure qualité. La documentation prévoit des modes utilisant moins de RAM, parfois au prix d'un accès plus fréquent au SSD. Commencez par un format qui tient avec une marge confortable, mesurez les résultats sur vos propres tâches, puis envisagez une variante plus exigeante. Une inférence qui réussit une seule fois, avec le navigateur et les autres services fermés, ne prouve pas encore que l'ordinateur supportera votre travail quotidien.

Quantification : choisir selon la tâche et les ressources disponibles

La quantification consiste à représenter certaines parties du modèle avec moins de bits afin de réduire l'espace occupé et le volume des données déplacées. En général, une compression plus forte facilite l'exécution, mais peut diminuer la fidélité de certaines réponses. Le README recommande IQ2_XS comme point de départ pour un usage général. Q2_0 privilégie la vitesse et une consommation de mémoire inférieure ; IQ3_XXS et IQ3_S demandent davantage de ressources dans le but de préserver plus de qualité. Il existe aussi une variante orientée vers le code, que les auteurs décrivent comme moins performante hors de ce domaine.

Ces noms ne constituent pas une échelle universelle. Q2_0 et IQ3_S désignent des formats et des configurations précis dans cet ensemble de fichiers. Un nombre plus élevé ne garantit ni une meilleure réponse à chaque question ni une exécution plus lente sur toutes les machines. Si votre cas d'usage consiste à résumer des documents français, préparez des exemples en français. S'il s'agit de programmation, essayez des problèmes réels tirés de votre dépôt. Les évaluations publiques aident à sélectionner des candidats, mais votre critère d'acceptation doit mesurer ce que votre produit doit effectivement livrer.

Notez également la taille du contexte, le niveau de raisonnement et le nombre maximal de tokens autorisés. Modifier ces variables entre deux essais change la question à laquelle votre comparaison répond. Conservez les cas où le modèle invente une référence, ne respecte pas un format ou refuse une instruction légitime : ils montrent des limites qu'une mesure de vitesse ne révèle pas.

Installation sous Linux et première réponse locale

La documentation recommande de cloner le dépôt puis d'exécuter ./setup.sh sous Linux. L'installateur propose des choix de modèle et télécharge les composants nécessaires. Selon la distribution, des outils de compilation et CUDA peuvent être requis. Sous Windows, le parcours documenté commence par START-HERE.bat. L'exemple suivant suit le parcours interactif de Linux, sans supposer que votre carte graphique ou votre quantité de RAM conviennent à une quantification donnée.

# Téléchargez le projet officiel et entrez dans le répertoire créé.
git clone https://github.com/Niko1221/Strata.git
cd Strata

# Répondez aux questions sur le modèle, le contexte et la configuration de la machine.
./setup.sh

# Une fois le service démarré, contrôlez l'état du serveur local.
curl --fail --silent http://127.0.0.1:8080/health

L'adresse documentée par défaut est http://127.0.0.1:8080. L'adresse 127.0.0.1 limite l'accès à la machine elle-même : c'est un choix raisonnable pour le premier lancement. Le point d'accès de santé confirme que le service répond, mais ne prouve pas qu'une longue question tiendra dans la fenêtre de contexte ni que la réponse sera correcte. Envoyez donc une vraie demande et examinez le résultat. L'identifiant de modèle strata figure dans l'exemple officiel de l'API.

# Envoyez une courte question au point d'accès compatible avec Chat Completions.
curl --fail --silent http://127.0.0.1:8080/v1/chat/completions \
 -H 'Content-Type: application/json' \
 -d '{
  "model": "strata",
  "messages": [{"role": "user", "content": "Explique em português o que é quantização em duas frases."}],
  "max_tokens": 256
 }'

Si le serveur répond que le modèle est inconnu, consultez /v1/models : d'après la documentation, ce point d'accès énumère le modèle chargé, tandis qu'un nom inexistant reçoit une réponse 404. Si la demande dépasse le contexte configuré, le service peut la rejeter au lieu de tronquer silencieusement l'entrée. Corrigez la configuration ou réduisez le message. Ne masquez pas un problème de contexte derrière un essai réalisé uniquement avec une question minuscule.

Mesurer la vitesse sans reprendre un benchmark hors contexte

Le README publie des mesures effectuées par les auteurs sur une RTX 5070 de 12 Go, un processeur Ryzen 5 7600 et 64 Go de RAM. Dans cet environnement, son tableau donne 93 tokens par seconde pour une réponse courte avec Q2_0 et 79 avec IQ2_XS ; le débit baisse lorsque le contexte s'allonge. Ce sont les chiffres du projet, pas des mesures indépendantes réalisées pour cet article ni une garantie pour votre ordinateur. La lecture d'un long prompt, le chargement et la génération de la réponse sont des étapes distinctes. Un débit élevé pendant la génération ne compense pas toujours une longue attente avant le premier token.

Vous pouvez effectuer une mesure élémentaire avec l'horloge de l'application et le champ usage de la réponse, lorsqu'il est disponible. Le script suivant ne fige pas le nom de votre GPU et ne promet aucun résultat. Il utilise l'interface compatible avec OpenAI documentée par Strata ; installez le paquet openai dans l'environnement Python où vous exécuterez le script. Répétez la même question plusieurs fois, car la première exécution peut charger des fichiers ou réchauffer les caches.

import time
from openai import OpenAI

# La clé est une valeur locale d'exemple ; configurez une vraie clé si vous activez l'authentification.
client = OpenAI(base_url="http://127.0.0.1:8080/v1", api_key="none")
prompt = "Explique quando quantizar um modelo pode alterar a qualidade."

# Mesurez la durée totale de chaque appel avec le même texte et la même configuration.
for tentativa in range(3):
    inicio = time.perf_counter()
    resposta = client.chat.completions.create(
    model="strata",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=256,
    )
    segundos = time.perf_counter() - inicio
    tokens = resposta.usage.completion_tokens if resposta.usage else None
    print({"tentativa": tentativa + 1, "segundos": round(segundos, 2), "tokens_saida": tokens})

Ce temps inclut le réseau local, l'attente éventuelle, le traitement de l'entrée et la génération. Diviser le nombre de tokens produits par la durée totale donne un débit utile pour juger l'expérience utilisateur, mais ce n'est pas la même mesure que le débit de génération isolé indiqué dans le README. Pour comparer avec le tableau du projet, consultez également le point d'accès /metrics et l'onglet Monitor. Notez le matériel, la quantification, le contexte et la taille de l'entrée à côté du résultat ; sans ces éléments, l'affirmation « c'est devenu plus rapide » n'est pas reproductible.

La confidentialité locale exige toujours une politique d'accès

Exécuter les poids sur son ordinateur peut éviter d'envoyer le texte au fournisseur d'une API distante. Cela ne rend pas l'application privée par définition. Votre programme peut enregistrer les prompts, une extension du navigateur peut lire la page et un serveur exposé sur le réseau peut accepter les demandes d'autres personnes. La valeur par défaut 127.0.0.1 réduit cette surface d'exposition. Si vous devez autoriser l'accès depuis un autre appareil, le README recommande de configurer --host 0.0.0.0 avec une clé d'API. Appliquez également les protections habituelles de votre réseau et n'exposez pas directement le port sur Internet.

Soyez particulièrement attentif aux connecteurs et aux outils qu'un agent peut exécuter. La documentation de Strata rappelle que les outils MCP locaux agissent avec les permissions de l'utilisateur et peuvent être influencés par le contenu lu par le modèle. Limitez les répertoires accessibles et privilégiez la lecture seule lorsque la tâche le permet. Aucune quantification ne remplace la validation des entrées, l'examen des actions proposées et des journaux adaptés. La capacité de produire du texte et l'autorisation d'agir sur l'ordinateur sont deux décisions différentes.

Les licences font aussi partie de l'analyse. Le code de Strata est publié sous licence MIT, mais le README précise que les poids, les variantes et les composants tiers disposent de leurs propres licences. Si vous souhaitez distribuer les fichiers ou proposer le modèle en tant que service, lisez les conditions de chaque élément directement sur les pages officielles. Pour un usage personnel, les précautions immédiates sont plus concrètes : planifier les téléchargements volumineux, maintenir le pilote et l'installation à jour, puis conserver l'historique des tests qui justifient votre choix.

Quand utiliser Strata et ce qu'il faudra surveiller ensuite

Strata a du sens si vous possédez un matériel compatible, souhaitez maîtriser une exécution locale et acceptez de gérer fichiers, mémoire et mises à jour. C'est également une façon d'étudier la relation entre quantification et performances sans dépendre uniquement de tableaux publiés par d'autres. Pour plusieurs utilisateurs, mesurez d'abord la charge et le coût total : une seule demande réussie ne représente pas un produit en production.

La démarche est simple : confirmez les prérequis, choisissez une variante qui tient avec une marge, posez des questions issues de votre domaine, consignez réussites et erreurs, puis comparez le temps perçu de bout en bout. Répétez l'évaluation après chaque changement de modèle, de configuration ou de version du moteur. Si une mauvaise réponse peut avoir des conséquences importantes, gardez une validation humaine et des critères objectifs. La meilleure configuration est celle qui accomplit la tâche avec une qualité suffisante et un fonctionnement prévisible, et non celle qui affiche le plus grand nombre dans un tableau.

Il sera intéressant de suivre l'évolution de la compatibilité matérielle, du comportement avec de longs contextes et des outils d'observation du projet. En attendant, considérez les benchmarks publiés comme des hypothèses à vérifier sur votre propre environnement. Une bonne pratique consiste à conserver un petit jeu de prompts et de résultats attendus pour déceler les régressions après une mise à jour. Votre intérêt pour l'IA locale deviendra ainsi une décision technique fondée sur des résultats vérifiables.

Allez, on y va! 🦅

📚 Vous Voulez Suivre Ce Qui Arrive ?

Cet article a présenté Strata et l'IA locale, mais cet écosystème évolue chaque semaine et toutes les nouveautés ne deviennent pas des articles ici.

Sur X, je partage mes essais, les coulisses de mes projets et les nouveautés que je découvre avant de les développer dans un billet.

Suivez-Moi Là-Bas

👉 Suivre @jeffbruchado sur X

💡 Du contenu quotidien sur le développement, la carrière et les outils que j'utilise vraiment