Comment exécuter GLM-5 localement gratuitement

Vous voulez accéder à l'un des modèles ouverts les plus performants de 2026—GLM-5 de Z.ai—sans payer un seul centime pour les appels API ou le calcul cloud. Les ingénieurs et développeurs y parviennent aujourd'hui en exécutant GLM-5 localement sur du matériel grand public et prosumer. La quantification agressive d'Unsloth réduit le modèle Mixture-of-Experts de 744 milliards de paramètres (40 milliards actifs) de 1,65 To à seulement 241 Go, et vous pouvez le déployer via llama.cpp, Ollama ou vLLM.

💡

Avant de commencer, téléchargez Apidog gratuitement. Ce puissant client API transforme la façon dont vous testez et déboguez votre point d'accès GLM-5 local. Vous construisez des requêtes visuellement, générez du code SDK, exécutez des tests automatisés et surveillez l'utilisation des jetons—tout en gardant vos expériences complètement privées. Apidog s'associe parfaitement aux serveurs compatibles OpenAI que vous allez démarrer, vous permettant de passer de simples requêtes curl à des intégrations prêtes pour la production en quelques minutes.

button

Vous exécutez GLM-5 localement ! Le processus exige une attention particulière au matériel, des étapes de construction précises et des stratégies de déchargement intelligentes. Ce guide vous accompagne à travers chaque méthode, explique pourquoi chaque commande est importante et vous montre comment tirer le maximum de performances de votre configuration. Vous bénéficiez d'une souveraineté totale des données, d'une latence nulle pour les flux de travail agentiques et d'une inférence illimitée.

Qu'est-ce qui fait de GLM-5 un tournant pour le déploiement local ?

Z.ai a publié GLM-5 en tant que successeur de GLM-4.7. Le modèle s'étend à 744 milliards de paramètres au total, avec 40 milliards actifs par jeton, entraîné sur 28,5 billions de jetons. Il offre des résultats de pointe sur les benchmarks agentiques : 77,8 % sur SWE-bench Verified, 89,7 % sur τ²-Bench et 61,1 % sur Terminal-Bench 2.0 avec des outils.

Vous bénéficiez d'une fenêtre de contexte de 200K grâce à DeepSeek Sparse Attention. Le modèle excelle dans le raisonnement à long terme, l'appel d'outils multi-tours et la génération de code complexe. De plus, la licence MIT ouverte vous permet de l'exécuter, de le modifier et même de le commercialiser sans restrictions.

Cependant, le modèle brut nécessite 1,65 To de stockage et une VRAM massive. Unsloth a changé la donne en publiant des quantifications Dynamic 2.0 GGUF—UD-IQ2_XXS à 241 Go (-85%) et 1-bit à 176 Go (-89%). Ces versions préservent la qualité du raisonnement grâce à un "upcasting" intelligent des couches tout en s'adaptant à un Mac avec 256 Go de mémoire unifiée ou à un seul GPU de 24 Go associé à 256 Go de RAM système.

Vous exécutez GLM-5 localement avec ces quantifications car elles équilibrent taille, vitesse et capacités. Les benchmarks montrent une dégradation minimale sur les tâches de codage et d'agent par rapport à la pleine précision.

Pourquoi exécuter GLM-5 localement plutôt que d'utiliser des API Cloud ?

Vous éliminez les coûts récurrents. Les fournisseurs de cloud facturent par jeton, et les capacités de GLM-5 rendent une utilisation intensive rapidement coûteuse. L'inférence locale ne coûte rien au-delà de l'électricité.

Vous protégez les données sensibles. Les entreprises et les chercheurs conservent les codes propriétaires, les dossiers médicaux ou les requêtes clients entièrement hors ligne.

Vous obtenez une latence plus faible. Les modèles locaux répondent en millisecondes pour les boucles de chat et d'appel d'outils. Vous enchaînez les agents sans sauts réseau.

Vous personnalisez librement. Vous pouvez affiner avec Unsloth, créer des Modelfiles dans Ollama, ou développer des outils personnalisés dans vLLM.

De plus, vous expérimentez sans limites de débit. Vous testez des contextes de 200K, menez des conversations en 1000 tours, ou évaluez la précision des appels d'outils pendant la nuit.

Exigences Matérielles : Ce dont vous avez réellement besoin

Vous adaptez votre configuration au niveau de quantification.

2-bit UD-IQ2_XXS (241 Go) : Fonctionne sur les séries Apple M avec 256 Go de mémoire unifiée ou un GPU NVIDIA de 24 Go + 256 Go de RAM avec déchargement MoE.
1-bit (176 Go) : Tient dans 180 Go de RAM.
FP8 (vLLM) : Nécessite 8×H200 ou équivalent—plus de 800 Go de VRAM au total.
Minimum viable : 64 Go de RAM + un CPU moderne pour de très petits contextes ; 128 Go et plus recommandés pour un travail pratique.

Vous surveillez l'utilisation avec nvidia-smi sur Linux ou le Moniteur d'activité sur macOS. Le stockage SSD accélère le déchargement. Vous allouez au moins 50 Go d'espace libre pour les fichiers du modèle et le cache.

Méthode 1 : Exécuter GLM-5 localement avec Unsloth GGUF dans llama.cpp (la plus accessible)

Vous choisissez cette voie pour une flexibilité et une efficacité maximales sur du matériel mixte.

Étape 1 : Construire llama.cpp avec le support GLM-5

Vous avez besoin de la dernière version de llama.cpp avec la PR 19460 fusionnée.

apt-get update && apt-get install -y build-essential cmake curl libcurl4-openssl-dev pciutils
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch origin pull/19460/head:MASTER
git checkout MASTER
mkdir build && cd build
cmake .. -DGGML_CUDA=ON  # Use -DGGML_CUDA=OFF for CPU-only
cmake --build . --config Release -j
cd ..
cp build/bin/llama-* .

Vous exécutez ceci une seule fois. La compilation prend 10 à 20 minutes selon votre machine.

Étape 2 : Télécharger le modèle quantifié

Vous utilisez huggingface_hub pour des transferts rapides.

pip install -U huggingface_hub hf_transfer
export HF_HUB_ENABLE_HF_TRANSFER=1
hf download unsloth/GLM-5-GGUF --local-dir GLM-5-GGUF --include "*UD-IQ2_XXS*"

Vous disposez maintenant du modèle de 241 Go réparti sur plusieurs "shards".

Étape 3 : Lancer l'inférence

Vous démarrez l'interface en ligne de commande (CLI) pour une utilisation interactive.

export LLAMA_CACHE="GLM-5-GGUF"
./llama-cli \
  -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \
  --jinja \
  --ctx-size 32768 \
  --flash-attn on \
  --temp 0.7 \
  --top-p 1.0 \
  --fit on

Vous ajoutez --threads 32 pour les configurations gourmandes en CPU ou -ot ".ffn_.*_exps.=CPU" pour décharger les experts MoE.

Étape 4 : Servir en tant qu'API OpenAI

Vous exposez le modèle pour les applications.

./llama-server \
  --model GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \
  --alias "glm-5" \
  --fit on \
  --ctx-size 32768 \
  --port 8000 \
  --jinja

Vous pouvez maintenant diriger n'importe quel client OpenAI vers http://localhost:8000/v1.

Vous atteignez 3 à 8 jetons/seconde sur un GPU de 24 Go avec cette configuration. Vous pouvez augmenter le contexte jusqu'à 128K sans plantage lorsque vous utilisez --fit on.

Méthode 2 : Exécuter GLM-5 localement avec Ollama (la plus facile pour les débutants)

Vous préférez la simplicité. Ollama gère automatiquement les téléchargements, la quantification et le service.

Installation

Vous téléchargez depuis ollama.com et exécutez l'installateur. Sur Linux :

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

Télécharger et exécuter GLM-5

Vous utilisez le tag optimisé par la communauté.

ollama pull glm-5:cloud
ollama run glm-5:cloud

Vous interagissez directement dans le terminal ou via l'API à http://localhost:11434/v1.

Créer un Modelfile personnalisé

Vous personnalisez l'invite système et les paramètres.

FROM glm-5:cloud
SYSTEM You are an expert software architect with deep knowledge of distributed systems.
PARAMETER temperature 0.6
PARAMETER num_ctx 131072

Vous construisez et exécutez :

ollama create my-glm5 -f Modelfile
ollama run my-glm5

Vous intégrez avec Claude Code, Cursor ou Continue.dev en définissant le point d'accès Ollama. Vous obtenez une alternative locale raffinée aux agents de codage cloud.

Méthode 3 : Déploiement avancé avec vLLM (Performances maximales)

Vous avez besoin du débit le plus élevé pour les agents de production.

Vous installez la version "nightly" :

uv pip install --upgrade vllm --extra-index-url https://wheels.vllm.ai/nightly/cu130

Vous lancez le serveur (la version FP8 nécessite 8×H200) :

vllm serve unsloth/GLM-5-FP8 \
  --served-model-name glm-5 \
  --tensor-parallel-size 8 \
  --kv-cache-dtype fp8 \
  --tool-call-parser glm47 \
  --reasoning-parser glm45 \
  --max-model-len 200000 \
  --gpu-memory-utilization 0.93

Vous activez le décodage spéculatif et l'appel d'outils. Vous servez des milliers de requêtes par minute sur un cluster multi-GPU.

Tester et déboguer votre GLM-5 local avec Apidog

Vous connectez Apidog à votre point d'accès et vérifiez que tout fonctionne.

Vous créez un nouveau projet, définissez l'URL de base sur http://localhost:8000/v1 (ou 11434 pour Ollama), et définissez le point d'accès /chat/completions.

Vous construisez des requêtes visuellement :

Modèle : glm-5
Messages : système + utilisateur
Température : 0.7
Outils : définissez les schémas JSON pour l'appel de fonctions

Vous envoyez des requêtes, inspectez les réponses en streaming et enregistrez des collections pour les tests de régression. Vous générez instantanément des SDK Python ou JavaScript. Vous simulez des réponses pour les équipes frontend.

Apidog transforme votre GLM-5 local en une plateforme de développement de premier ordre. Vous itérez sur les agents, validez les sorties d'outils et mesurez la latence—le tout sans quitter l'interface.

Techniques d'optimisation des performances

Vous tirez plus de vitesse de votre matériel.

Vous activez l'attention flash et --fit on dans llama.cpp.
Vous ne déchargez que les experts MoE vers le CPU lorsque la VRAM est limitée.
Vous utilisez 4-bit pour le chat et 2-bit pour le codage agentique.
Vous définissez --prio 3 dans le serveur pour une priorité de processus plus élevée.
Vous surveillez avec nvtop ou htop et ajustez --n-gpu-layers.

Vous atteignez 15 à 25 jetons/seconde sur une configuration double RTX 4090 avec ces ajustements.

Problèmes courants et comment les résoudre

Vous rencontrez des erreurs de mémoire. Vous réduisez le contexte à 16K ou déchargez plus de couches.

Vous constatez un mauvais appel d'outils. Vous définissez la température à 1.0 et top-p à 0.95, puis utilisez l'option --tool-call-parser glm47.

Vous subissez des téléchargements lents. Vous activez hf_transfer et utilisez un miroir rapide.

Vous rencontrez des erreurs CUDA de mémoire insuffisante. Vous ajoutez --gpu-memory-utilization 0.85 et fermez les processus d'arrière-plan.

Vous consultez toujours la documentation Unsloth et le dépôt GLM-5 GGUF pour les dernières "shards".

La voie à suivre : GLM-5 local et au-delà

Vous assistez au passage à l'IA souveraine. Des modèles comme GLM-5 prouvent qu'une capacité de pointe peut fonctionner sur du matériel que vous possédez déjà. Vous le combinez avec des bases de données vectorielles locales, des serveurs d'outils et des frameworks d'agents pour construire des systèmes privés et performants.

Vous rejoignez la communauté sur Hugging Face, r/LocalLLaMA sur Reddit, et le Discord d'Unsloth. Vous partagez des Modelfiles, des résultats de benchmarks et des quantifications personnalisées.

Vous exécutez GLM-5 localement dès aujourd'hui. Vous contrôlez le calcul, les données et l'avenir de votre pile IA.

Commencez avec le GGUF 2-bit dans llama.cpp. Téléchargez Apidog. Démarrez le serveur. Vous serez étonné de ce que vous pouvez construire lorsque le modèle réside sur votre machine.

L'ère des modèles de pointe véritablement locaux est arrivée. Profitez-en au maximum.

button