Comment déployer un LLM local sans perturber le stockage ni les applications

Eva Wong est la rédactrice technique et bricoleuse résidente chez ZimaSpace. Geek depuis toujours, passionnée par les laboratoires informatiques personnels et les logiciels open source, elle se spécialise dans la vulgarisation de concepts techniques complexes au moyen de guides pratiques et concrets. Eva pense que l’hébergement personnel doit être amusant, et non intimidant. À travers ses tutoriels, elle aide la communauté à démystifier les configurations matérielles, de la construction de leur premier NAS à la maîtrise des conteneurs Docker.

Déployer un LLM local sur un NAS domestique n’est pas difficile parce que la première commande est compliquée. C’est difficile parce que le modèle, le cache, le conteneur, le serveur d’API et les tâches en arrière-plan se disputent le même espace de stockage et les mêmes ressources système que votre NAS utilise déjà pour les fichiers, les sauvegardes, les contenus multimédias, les bases de données et les applications.

L’objectif le plus sûr n’est pas de rendre le LLM aussi rapide que possible dès le premier jour. Il vaut mieux lui attribuer un chemin de stockage connu, des limites strictes en matière de ressources, un parallélisme limité et une procédure de vérification. Un modèle local un peu plus lent est généralement préférable à un modèle rapide qui remplit le disque système, entraîne une pression sur la mémoire ou rend moins fiables les autres applications auto-hébergées.

En bref : réservez un espace et des limites au LLM

Un LLM local doit disposer de son propre espace avant même d’accueillir son premier modèle. Vous devez donc savoir où seront stockés les fichiers de modèle, les caches, les index, les journaux et les données des applications avant de télécharger un modèle ou de connecter une interface Web. Si ces fichiers sont stockés dans un chemin Docker masqué ou sur un petit disque de démarrage, le déploiement peut sembler réussi tout en consommant discrètement l’espace dont le NAS a besoin.

Il faut aussi définir des limites. Les moteurs de LLM peuvent utiliser beaucoup de RAM, de VRAM, de threads du processeur et de mémoire de contexte, en particulier lorsque plusieurs modèles ou des requêtes parallèles sont activés. La documentation de Docker sur les limites de ressources précise que les conteneurs peuvent autrement utiliser les ressources de l’hôte dans les limites autorisées par l’ordonnanceur du noyau, et qu’une pression sur la mémoire peut entraîner un manque de mémoire et affecter les autres processus.

Sur un NAS partagé, cela compte davantage que les résultats maximaux aux benchmarks. Plex, Jellyfin, Home Assistant, les bases de données, les tâches de synchronisation, les sauvegardes et le partage de fichiers ne doivent pas devenir instables parce qu’un serveur de modèles essaie de répondre à une longue requête. Un déploiement sûr d’un LLM local commence par le mappage du stockage, les limites de ressources, le choix du modèle et la vérification.

Points à vérifier avant de télécharger le premier modèle

Avant de télécharger le premier modèle, définissez la première tâche. Un LLM local destiné à de simples conversations n’a pas les mêmes exigences qu’un assistant RAG, un service de génération d’embeddings, un assistant de programmation ou un agent d’automatisation capable de lire et d’écrire des fichiers. Sans cas d’utilisation défini au préalable, il est facile de télécharger un modèle trop volumineux, trop lent ou trop perturbant pour le serveur.

Commencez par ces vérifications :

  • Cas d’utilisation : chat, RAG, embeddings, résumés, automatisation, programmation ou aide à la recherche.
  • Taille du modèle : taille du fichier du modèle et nombre de variantes que vous comptez conserver.
  • Quantification : si le modèle est suffisamment compressé pour le serveur.
  • Chemin de stockage : où les fichiers des modèles et le cache seront stockés sur l’hôte.
  • Chemin dans le conteneur : comment le chemin de l’hôte est associé à celui du conteneur.
  • RAM et VRAM : la quantité de mémoire restante pour les autres applications.
  • Marge CPU : combien de threads le modèle peut utiliser sans priver le NAS de ressources.
  • Parallélisme : combien de requêtes ou de modèles chargés peuvent s’exécuter simultanément.
  • Charge de travail existante : sauvegardes, diffusion multimédia, bases de données, synchronisation et partage de fichiers.
  • Plan de vérification : comment vous allez confirmer que le NAS est toujours en bon état par la suite.

Cette vérification préalable n’est pas une formalité inutile. Elle évite le problème le plus courant lors du déploiement d’un LLM local sur un NAS : le modèle répond, mais le système qui l’héberge devient moins fiable.

Gardez les fichiers de modèles hors du disque système

Les fichiers de modèles peuvent grossir plus vite que prévu. Un seul modèle peut être facile à gérer, mais plusieurs modèles, variantes quantifiées, embeddings, index, données de WebUI et journaux peuvent rapidement occuper des dizaines, voire des centaines de gigaoctets. Si ces fichiers se retrouvent sur le disque système ou à la racine de Docker, le NAS peut manquer d’espace critique même si le pool de stockage principal semble encore en bon état.

La FAQ d’Ollama répertorie les emplacements par défaut des modèles pour différents systèmes d’exploitation et explique que le répertoire de stockage des modèles peut être modifié à l’aide de la variable d’environnement OLLAMA_MODELS. Sur un NAS ou un serveur domestique, ce détail est important, car le chemin par défaut n’est peut-être pas l’endroit où vous souhaitez stocker durablement les fichiers de modèles.

Si vous exécutez Ollama ou un autre moteur de modèles dans Docker, n’oubliez pas qu’un chemin dans le conteneur n’est pas la même chose qu’un chemin sur l’hôte. Un répertoire comme /root/.ollama dans le conteneur doit être associé à un emplacement précis sur l’hôte si vous voulez que le stockage soit prévisible. Sans montage de volume, les fichiers des modèles peuvent rester dans le stockage géré par Docker, ce qui rend leur croissance plus difficile à repérer et leur nettoyage plus compliqué.

Une solution plus sûre consiste à créer un répertoire dédié aux modèles avant le déploiement, par exemple un dossier de stockage IA sur un pool de données ou un volume de stockage d’applications. Séparez-le des destinations de sauvegarde, des bases de données critiques et des données d’applications irremplaçables. Le répertoire des modèles doit être suffisamment grand, facile à inspecter et documenté afin que vous puissiez supprimer les anciens modèles par la suite.

Décidez également où seront stockés les fichiers associés. Les index RAG, les plongements lexicaux, les bases de données vectorielles, les journaux et les documents importés peuvent consommer de l’espace de stockage supplémentaire. Si vous ne prévoyez que le fichier du modèle, le reste de la pile d’IA peut tout de même vous réserver des surprises.

Définir les limites de mémoire, de CPU et de parallélisme

Limites de mémoire

Les LLM locaux nécessitent beaucoup de mémoire. Ils ont besoin de mémoire pour les poids du modèle, le contexte, la surcharge d’exécution et parfois plusieurs modèles chargés simultanément. Si le serveur exécute également des bases de données, des services multimédias, de la synchronisation de fichiers, des conteneurs et des tâches de sauvegarde, le LLM ne devrait pas pouvoir consommer toute la mémoire disponible.

Docker prend en charge les limites de mémoire des conteneurs, qui peuvent empêcher un conteneur de monopoliser l’hôte. Pour un NAS partagé, il s’agit moins d’accélérer le modèle que de protéger le reste du système. Si le conteneur du LLM atteint sa propre limite, c’est généralement préférable à une pression mémoire sur l’ensemble du serveur.

Gardez de la marge pour les services essentiels. Si le NAS dispose de 32 Go de RAM et que les applications habituelles en utilisent 8 à 12 Go pendant les périodes de forte activité, n’allouez pas tout le reste au LLM. Gardez de la place pour le cache du système de fichiers, les tâches de sauvegarde, les bases de données et les pics de charge ponctuels. Un modèle qui ne fonctionne que lorsqu’aucun autre service n’est actif n’est pas un choix par défaut sûr pour un serveur domestique partagé.

La VRAM compte également lorsque l’inférence utilise un GPU. La FAQ d’Ollama explique que l’inférence sur CPU utilise la mémoire système, tandis que l’inférence sur GPU utilise la VRAM, et que le chargement simultané de modèles dépend de la mémoire ou de la VRAM disponible. Un GPU peut donc apporter une aide considérable, mais ne dispense pas de prévoir la mémoire.

Limites du CPU

Les limites du CPU préservent la réactivité. Un LLM local peut utiliser de nombreux threads lors du traitement des requêtes ou de la génération de jetons. S’il sature le CPU, le tableau de bord du NAS peut ralentir, les flux multimédias peuvent mettre en mémoire tampon, les automatisations peuvent prendre du retard et les bases de données peuvent répondre lentement.

Docker fournit des contrôles du CPU tels que --cpus, --cpu-quota et --cpuset-cpus. Il n’est pas toujours nécessaire d’imposer des limites strictes, mais vous devriez décider de la part de CPU que le LLM peut utiliser pendant l’activité normale du NAS. Un modèle qui met légèrement plus de temps à répondre tout en laissant le serveur réactif est généralement préférable à un modèle qui mobilise tous les threads.

L’inférence uniquement sur CPU est particulièrement sensible aux limites. Sans GPU ni NPU, le LLM entre directement en concurrence avec tous les autres services sollicitant le CPU. Si le NAS gère déjà le transcodage multimédia, l’indexation, la compression, les sauvegardes ou des bases de données, le LLM ne devrait pas fonctionner sans restriction aux heures de pointe.

Nombre de modèles et requêtes parallèles

Le parallélisme est facile à négliger. Un modèle répondant à une seule requête peut très bien fonctionner. Plusieurs utilisateurs, une WebUI, un flux d’automatisation et un outil RAG peuvent rapidement générer des requêtes simultanées. Chaque requête peut augmenter la mémoire requise pour le contexte et la charge du processeur.

La FAQ d’Ollama décrit les requêtes parallèles et le comportement des modèles chargés, notamment les paramètres comme OLLAMA_MAX_LOADED_MODELS, OLLAMA_NUM_PARALLEL et OLLAMA_MAX_QUEUE. Ces paramètres sont importants sur un NAS, car la concurrence peut transformer un déploiement stable pour un seul utilisateur en pic de consommation des ressources.

Pour un serveur domestique partagé, commencez avec des limites prudentes. Un seul modèle chargé et une seule requête active constituent un point de départ plus sûr. N’augmentez les limites qu’après avoir vérifié que le stockage, la mémoire, le processeur et les autres services restent stables.

Choisissez un modèle adapté au serveur, pas à la tendance

Le bon premier modèle n’est pas le plus grand que vous puissiez télécharger. C’est le plus petit capable d’accomplir la tâche avec une qualité acceptable. Sur un NAS, le choix du modèle contribue à protéger le système.

Les modèles quantifiés constituent souvent un point de départ pratique. La documentation de llama.cpp explique comment les modèles quantifiés réduisent la précision des poids du modèle, par exemple en convertissant des fichiers de modèle GGUF de haute précision en formats plus petits. Cela peut réduire la taille du modèle et améliorer les performances d’inférence en pratique, mais peut aussi entraîner des compromis sur la qualité.

Ce compromis est généralement acceptable pour de nombreux usages d’un NAS domestique : chat simple, synthèse, embeddings, assistance RAG, organisation de fichiers et petits outils d’automatisation. Il l’est moins si la tâche nécessite un raisonnement approfondi, un contexte long, de bonnes performances pour plusieurs utilisateurs ou une grande précision en programmation.

Prenez l’état du serveur comme point de départ :

État du serveur Point de départ plus sûr À éviter en premier
8 Go à 16 Go de RAM, CPU uniquement Petit modèle quantifié, embeddings, chat léger Grands modèles, contexte long, plusieurs utilisateurs
16 Go à 32 Go de RAM, iGPU / NPU Petit assistant de chat, RAG et recherche Génération d’images, assistant de programmation intensif
GPU avec suffisamment de VRAM Modèle plus grand ou inférence plus rapide Empiler des modèles sans limite
NAS partagé avec de nombreuses applications Tâches d’IA planifiées, un modèle, un utilisateur Inférence intensive en continu
NAS et machine GPU séparée Le NAS stocke les données ; la machine d’IA effectue l’inférence Forcer le NAS à effectuer tous les calculs

Un déploiement sécurisé commence à petite échelle, car cela vous fournit une base stable. Ensuite, vous pouvez tester un modèle plus grand, un contexte plus long ou une intégration WebUI. Si le système ralentit, vous saurez quel changement a provoqué le problème.

Éloignez le LLM des applications critiques et des sauvegardes

Un LLM local ne devrait pas partager les mêmes domaines de défaillance que les services dont vous dépendez le plus. Si le stockage des modèles d’IA, les sauvegardes, les bases de données des applications et les fichiers temporaires se trouvent tous au même endroit, mal organisé, une seule charge de travail peut perturber les autres.

Éloignez le cache des modèles et les données temporaires de l’IA des destinations de sauvegarde. En général, un répertoire de modèles peut être reconstitué, contrairement à un dépôt de sauvegarde. Remplir une destination de sauvegarde avec des fichiers de modèles ou des données temporaires d’IA peut entraîner des sauvegardes manquées, des tâches de synchronisation échouées ou des points de restauration difficiles à interpréter.

Dans la mesure du possible, séparez les bases de données des applications. Home Assistant, les serveurs multimédias, les photothèques, les gestionnaires de mots de passe et les autres applications auto-hébergées peuvent dépendre de petites bases de données sensibles aux pics soudains d’E/S ou au manque d’espace disque. Ne laissez pas le téléchargement d’un modèle volumineux ou une tâche d’indexation RAG encombrer la même zone de stockage sans l’avoir planifié.

Tenez également compte du moment choisi. Si les sauvegardes s’exécutent la nuit, ne planifiez pas d’indexation intensive sur la même plage horaire. Si le streaming multimédia a lieu le soir, ne lancez pas à ce moment-là d’inférence longue avec un grand contexte uniquement sur CPU. Un NAS a souvent assez de capacité pour plusieurs tâches, mais pas pour qu’elles atteignent toutes leur pic en même temps.

Pour les flux de travail LLM capables d’écrire des fichiers ou d’utiliser des outils, ajoutez des garde-fous. Utilisez des chemins isolés, des étapes de confirmation et des journaux. Laissez le modèle proposer des actions, mais exigez du code déterministe ou la confirmation de l’utilisateur pour les écritures, suppressions, déplacements et modifications d’applications. Un déploiement LLM sûr protège non seulement les ressources système, mais aussi les données auxquelles il peut accéder.

Signes indiquant que le LLM prive les autres services de ressources

Un déploiement défectueux ne tombe pas toujours en panne immédiatement. Le plus souvent, il provoque des symptômes qui semblent d’abord sans rapport.

Une hausse soudaine de l’espace disque est un signe d’alerte. Si le disque système, la racine Docker ou le stockage des applications se remplit rapidement après le téléchargement de modèles, le chemin des modèles n’est peut-être pas monté à l’emplacement prévu. Vérifiez le chemin réel sur l’hôte, pas seulement celui du conteneur.

Les redémarrages de conteneurs sont un autre signe. Si le conteneur du LLM, la base de données, Home Assistant, le serveur multimédia ou l’interface Web redémarre sans cesse, vérifiez la pression sur la mémoire, les journaux OOM et la saturation du CPU. Le LLM peut rester opérationnel tandis que les autres services manquent de ressources.

Un tableau de bord NAS lent compte aussi. Si l’interface web devient lente pendant les requêtes, le LLM local utilise peut-être trop de threads CPU, trop de mémoire ou trop d’E/S disque. Le fait que le modèle réponde correctement ne signifie pas que le déploiement est sain.

La mise en mémoire tampon des médias, les automatisations retardées, les partages de fichiers lents et les fenêtres de sauvegarde manquées sont des signes plus révélateurs. Ce sont des fonctions essentielles d’un NAS. Si elles se dégradent après le déploiement du LLM, celui-ci a besoin d’un modèle plus léger, de limites plus strictes, d’une meilleure planification ou d’un hôte de calcul distinct.

Surveillez aussi le comportement de l’API. Si l’API du LLM se bloque, reste indéfiniment en attente ou devient peu fiable lorsqu’une interface Web, un outil RAG ou un système d’automatisation s’y connecte, le parallélisme est peut-être trop élevé pour le serveur. Limitez le nombre de modèles chargés, les requêtes actives et la longueur de la file d’attente avant d’ajouter d’autres intégrations.

Un ordre de déploiement plus sûr pour un LLM local sur NAS

Ne commencez pas par installer tous les outils d’IA en même temps. Commencez par un service LLM local, un modèle, un chemin de stockage et un cas d’utilisation de test. Le déploiement sera ainsi plus facile à comprendre et plus sûr à déboguer.

Un déploiement plus sûr suit l’ordre ci-dessous :

  1. Choisissez un cas d’utilisation, comme un chat léger, des embeddings ou un test RAG.
  2. Choisissez le plus petit modèle capable d’effectuer la tâche.
  3. Créez un répertoire dédié aux modèles dans un emplacement de stockage connu.
  4. Montez ce répertoire dans le conteneur ou configurez le moteur d’exécution pour qu’il l’utilise.
  5. Définissez des limites de mémoire et de CPU.
  6. Limitez les requêtes parallèles et le nombre de modèles chargés.
  7. Commencez par une requête de test ou un petit index RAG.
  8. Surveillez le disque, la RAM, le CPU, le GPU, les journaux et le temps de réponse pendant l’exécution.
  9. Confirmez que les applications existantes et les sauvegardes fonctionnent toujours normalement.
  10. Ajoutez seulement ensuite des intégrations telles qu’Open WebUI, des outils RAG ou des flux d’automatisation.

Cet ordre peut sembler plus lent qu’un guide d’installation rapide, mais il réduit les mauvaises surprises. En cas de problème, vous saurez s’il vient du modèle, du chemin, des limites de ressources, de l’interface Web, de l’index RAG ou d’une autre intégration.

Comment vérifier que le stockage et les applications restent sûrs

La vérification ne doit pas s’arrêter à « le modèle a répondu ». Un LLM local peut répondre à une requête tout en remplissant le mauvais disque, en privant d’autres conteneurs de ressources ou en retardant les tâches de sauvegarde.

Commencez par la vérification du stockage. Confirmez que les fichiers du modèle se trouvent dans le chemin hôte prévu. Vérifiez qu’il reste de l’espace libre sur le disque système. Vérifiez que la racine Docker n’a pas augmenté de façon inattendue. Confirmez que le cache du modèle, les journaux, les index et les données de l’application ne sont pas mélangés aux sauvegardes ou bases de données critiques.

Vérifiez ensuite les ressources. Le CPU devrait retrouver un niveau normal après les requêtes ou l’indexation. La mémoire devrait rester sous la limite prévue. Le swap ne devrait pas augmenter en usage normal. Si l’inférence GPU est activée, vérifiez que le modèle utilise bien le GPU et que la pression sur la VRAM reste acceptable.

Vérifiez ensuite la stabilité des applications. Ouvrez des partages de fichiers, diffusez des médias, déclenchez une automatisation Home Assistant, parcourez le tableau de bord du NAS et vérifiez que les bases de données ou les tableaux de bord des applications restent réactifs. Si ces services ralentissent uniquement lorsque le LLM est actif, vous devez imposer des limites plus strictes au processeur, à la mémoire ou à la planification.

Vérifiez les journaux. Recherchez les boucles de redémarrage, les messages OOM, les échecs de chargement des modèles, les erreurs d’autorisation, l’absence d’accès au GPU, les échecs de montage des volumes et les délais d’attente répétés de l’API. Les journaux révèlent souvent qu’un déploiement qui « fonctionne » est en réalité à peine stable.

Enfin, vérifiez la limite de l’endpoint. Si le serveur de modèles expose une API, sachez où elle est accessible. Un endpoint LLM local ne doit pas devenir public par accident. Gardez-le en interne, sauf si vous l’avez délibérément placé derrière une authentification, des règles de proxy inverse, un accès VPN ou une autre limite contrôlée.

Comment la recherche IA de ZimaOS illustre une approche contrôlée du déploiement de l’IA

Un flux de travail d’IA sur NAS contrôlé doit définir le chemin d’accès au modèle, les besoins en ressources, les attentes concernant l’exécution et la méthode de vérification. Il ne doit pas se comporter comme un service d’arrière-plan illimité qui télécharge des modèles, consomme du temps GPU et écrit des données où bon lui semble.

ZimaOS-AI est un bon exemple de cette approche contrôlée. Le guide ZimaSpace consacré à la recherche par IA explique que le module est conçu pour alimenter la recherche ZimaOS en utilisant un LLM local afin d’extraire les caractéristiques des images, de l’audio et de la vidéo. Cette approche est importante : la charge de travail d’IA facilite la recherche et l’extraction de caractéristiques, sans transformer le NAS en serveur de discussion sans restriction.

Le même guide rend visible la limite des ressources. Il décrit des chemins d’installation distincts pour les systèmes équipés d’un GPU NVIDIA dédié et ceux équipés d’un GPU Intel intégré. Le chemin NVIDIA dépend de la prise en charge d’un GPU compatible CUDA, tandis que le chemin Intel avec GPU intégré nécessite au moins 8GB de RAM disponible et recommande un processeur i5-1235U ou supérieur avec circuit graphique intégré. Il indique également qu’il faut au moins 20GB d’espace système disponible et précise que les fichiers de modèles sont stockés dans /media/ZimaOS-HD/AppData/.models, sauf si AppData a été migré.

C’est le type d’informations dont un déploiement sécurisé de LLM a besoin avant de démarrer. Un appareil cloud privé comme le NAS IA ZimaCube 2 peut prendre en charge des flux de travail d’IA locale plus poussés lorsque le chemin d’accès au modèle, la prise en charge du GPU ou de l’iGPU, la RAM, l’espace de stockage et la planification sont adaptés à la charge de travail. Mais la leçon importante concerne les limites, pas la marque : sachez où se trouve le modèle, quel chemin matériel il utilise et quand il est autorisé à consommer des ressources.

Les détails de dépannage montrent également en quoi consiste la vérification du déploiement. Si la recherche par IA ne renvoie aucun résultat lié à l’IA, le modèle est peut-être encore en cours de téléchargement, l’extraction des caractéristiques est peut-être toujours en cours, l’accès à Hugging Face peut être indisponible ou la VRAM peut être insuffisante, entraînant un basculement vers le CPU ou la mémoire. Le guide indique également aux utilisateurs comment vérifier l’état via Call-History, le trafic réseau et journalctl -xef -u zimaos-ai.

C’est une méthode utile pour tout déploiement local d’un LLM sur un NAS : définissez le chemin et les ressources, surveillez les journaux, vérifiez que la fonctionnalité fonctionne réellement et planifiez les tâches lourdes afin que le NAS reste utilisable.

FAQ

Où stocker les fichiers des modèles de LLM locaux sur un NAS ?

Stockez les fichiers de modèles dans un répertoire dédié et documenté, situé sur un volume de données ou un emplacement de stockage des applications disposant d’assez d’espace. Évitez que les modèles se retrouvent sans que vous le sachiez sur le disque de démarrage, à la racine de Docker ou sur une cible de sauvegarde. Le chemin doit être facile à inspecter, à nettoyer et à migrer.

Dois-je exécuter Ollama directement ou dans Docker ?

Les deux options peuvent convenir. Docker facilite l’isolation et le déploiement, mais vous devez configurer correctement le stockage des modèles et définir des limites de ressources. Une installation directe peut être plus simple sur certains systèmes, mais vous devez tout de même vérifier le répertoire des modèles, les autorisations, l’utilisation de la mémoire et les limites du service.

Quelle quantité de RAM dois-je réserver aux autres applications ?

Réservez suffisamment de RAM au système d’exploitation du NAS, au cache du système de fichiers, aux bases de données, aux services multimédias, aux sauvegardes et aux conteneurs habituels avant d’allouer de la mémoire au LLM. Ne dimensionnez pas le modèle en fonction de la RAM totale. Fondez-vous sur la RAM disponible une fois que les services essentiels ont assez de marge.

Un LLM local peut-il perturber mes autres conteneurs Docker ?

Cela peut perturber leur fonctionnement s’il consomme trop de mémoire, de CPU, d’E/S disque ou d’espace de stockage. Il ne les « casse » pas forcément directement, mais peut entraîner des ralentissements, des boucles de redémarrage, des événements OOM, des fenêtres de sauvegarde manquées ou des échecs d’opérations de base de données s’il est déployé sans limites.

Quand faut-il déplacer le LLM sur une machine distincte ?

Faites tourner le LLM sur une machine distincte si vous avez besoin de modèles plus volumineux, d’un long contexte, de plusieurs utilisateurs, de charges de travail gourmandes en GPU ou de réponses rapides qui ralentissent le NAS. Dans cette configuration, le NAS peut rester la source de stockage et de données, tandis qu’un ordinateur de bureau doté d’un GPU, un mini-PC ou un serveur d’IA se charge de l’inférence.

Un déploiement local sécurisé d’un LLM sur un NAS commence par des limites, pas par les promesses des modèles. Indiquez au modèle un chemin connu, fixez des limites de ressources au conteneur, protégez les applications critiques et les sauvegardes, puis vérifiez l’ensemble du serveur après la première requête. Le déploiement n’est réussi que lorsque le LLM fonctionne et que le NAS reste fiable.

Assistance et conseils

À lire aussi

Get More Builds Like This

Stay in the Loop

Get updates from Zima - new products, exclusive deals, and real builds from the community.

Stay in the Loop preferences

We respect your inbox. Unsubscribe anytime.