Installer MLX sur Mac avec mlx-lm, et voir ce qu’il envoie

Installez mlx-lm avec pip dans un Python 3.11 ou plus récent, natif, sur un Mac Apple Silicon, puis lancez mlx_lm.chat : la première exécution télécharge un modèle de 1,7 Gio depuis Hugging Face et vous laisse écrire. C’est toute l’installation, en 2 étapes. Des 5 logiciels que nous comparons, MLX est le seul qui ne garde vos conversations nulle part et ne passe pas un seul appel de lui-même en une journée entière. Son serveur, c’est une autre histoire : réglé d’origine, n’importe quel site que vous ouvrez peut s’en servir.

Et le paquet vient de se réveiller. pip install mlx-lm vous donne la 0.32.0, publiée le 1er octobre 2026 après plus de 5 mois sans nouvelle version, et le framework mlx qu’il y a dessous en est à la 0.32.3, du 29 septembre 2026. Les deux versions ont été confirmées sur PyPI le 1er octobre 2026, et chaque commande et chaque valeur par défaut de cette page a été vérifiée le jour même dans le code de la 0.32.0.

Ce qu’est MLX, et ce qu’y ajoute mlx-lm

MLX est le framework de calcul sur tableaux d’Apple pour Apple Silicon : la couche mathématique, de la même famille que NumPy ou PyTorch, publiée par Apple sous licence MIT. Il exploite la mémoire unifiée du Mac : CPU et GPU travaillent sur le même banc de mémoire, sans copie entre les deux. À lui seul, il ne converse avec personne. mlx-lm est le paquet posé dessus : il récupère les modèles de langage sur Hugging Face, génère du texte, sert une API et convertit des modèles. Quand quelqu’un dit faire tourner un modèle « dans MLX », le programme qui tourne est mlx-lm, et c’est lui qui installe MLX pour vous.

Ce qu’il n’est pas, car on le lui prête à chaque fois :

• Pas le Neural Engine. Le code de MLX connaît exactement 2 types de périphérique, CPU et GPU. Le Neural Engine de votre puce reste inactif.
• Pas un lecteur de GGUF. Il exécute des fichiers au format MLX et des safetensors de Hugging Face. Un GGUF que vous avez déjà ne peut pas être chargé, et mlx_lm.convert part des poids d’origine publiés sur Hugging Face, pas d’un GGUF.
• Pas une application. Il n’y a aucune fenêtre : mlx-lm installe des outils en ligne de commande et une bibliothèque Python. Si vous voulez des modèles MLX derrière une fenêtre, LM Studio les exécute avec son propre moteur MLX, et Installer LM Studio et son serveur local, et voir ce qu’il envoie couvre ce chemin-là.

Ce qu’il faut : Apple Silicon, macOS 14 et Python 3.11

Prérequis	Ce que ça veut dire en pratique
Apple Silicon	Les Mac Intel sont exclus : toutes les versions macOS de mlx 0.32.3 sur PyPI sont en arm64, et il n’en existe aucune en x86_64
macOS 14.0 ou plus récent	macOS 15 ou plus récent pour la partie de mlx-lm qui accélère les grands modèles en rendant leur mémoire résidente (voir la partie sur la mémoire)
Un Python 3.11 ou plus récent, natif	mlx-lm 0.32.0 déclare Python 3.11 ; mlx, seul, accepterait 3.10. Avec un 3.10, pip n’échoue pas : il installe sans rien dire l’ancienne 0.31.3, la dernière qui l’accepte

Prérequis tirés du guide d’installation de MLX en version 0.32.2, lu le 27 septembre 2026, et des métadonnées et versions publiées sur PyPI de mlx 0.32.3 et de mlx-lm 0.32.0, lues le 1er octobre 2026.

Un Python qui tourne sous Rosetta n’installe rien : pip répond qu’il ne trouve aucune distribution correspondante. Le guide de MLX donne lui-même la vérification :

python -c "import platform; print(platform.processor())"

Elle doit afficher arm. Si elle affiche i386 sur un Mac à puce de la série M, ce Python n’est pas natif.

MLX sous Windows ou Linux ? Le framework mlx publie des versions pour les deux : Windows x64 et ARM64 depuis juillet 2026, et Linux avec un backend CUDA (pip install "mlx[cuda12]", architecture NVIDIA SM 7.5 ou plus récente) ou processeur seul (pip install "mlx[cpu]"). Pour mlx-lm, c’est une autre affaire. Il ne déclare sa dépendance à mlx que pour macOS, si bien qu’un simple pip install mlx-lm sous Windows ou Linux installe les outils sans le moteur. Sous Linux, mlx-lm 0.32.0 propose les extras cuda12, cuda13 et cpu, qui apportent la version de mlx correspondante. Nous avons installé l’extra cpu sur une machine Linux x86_64 le 1er octobre 2026 : son serveur démarre et répond ; comment un modèle y tourne, nous ne l’avons pas mesuré. La documentation d’aucun des deux paquets ne mentionne Windows.

Installer mlx-lm et vérifier quelle version vous avez

Un environnement virtuel le tient à l’écart de tout autre Python présent sur le Mac :

python3 -m venv ~/mlx-env
source ~/mlx-env/bin/activate
pip install mlx-lm

Le python3 de la première ligne doit être le Python 3.11 ou plus récent, natif, de la partie précédente. Avec conda, la ligne devient conda install -c conda-forge mlx-lm, mais le 1er octobre 2026, conda-forge servait encore la 0.31.3.

Cette seule installation apporte mlx-lm 0.32.0, mlx 0.32.3 (la 0.32.0 demande mlx 0.32.2 ou plus récent, donc pip prend la dernière) et transformers 5.7 ou plus récent pour les tokeniseurs. Elle ajoute aussi 18 commandes à votre PATH, qui commencent toutes par mlx_lm : celles qu’utilise cette page sont mlx_lm.chat, mlx_lm.generate, mlx_lm.server, mlx_lm.manage et mlx_lm.convert. Chacune liste ses options avec -h.

Pour voir ce que vous avez :

pip show mlx mlx-lm
python -c "import mlx.core as mx; print(mx.__version__)"
mlx_lm --version

La première montre les deux paquets, la deuxième le framework seul, la troisième mlx-lm seul. Le 1er octobre 2026, les réponses sont 0.32.3 pour mlx et 0.32.0 pour mlx-lm. Si mlx-lm affiche 0.31.3, regardez votre Python : avec un 3.10, pip ne va pas plus loin.

0.32.0, la fin d’un long silence. mlx-lm a publié 19 versions entre le 25 août 2025 et le 22 avril 2026, la dernière étant la 0.31.3, puis plus rien pendant plus de 5 mois. Le dépôt, lui, ne s’est pas arrêté : entre le 22 avril et le 30 septembre 2026, il a reçu 134 commits sur 50 jours différents, et pendant tout ce temps pip a continué de distribuer le code d’avril. La 0.32.0, publiée le 1er octobre 2026, fait entrer ce travail dans le paquet : le dossier des définitions de modèles passe de 119 à 135 fichiers, dont 16 nouveaux comme mistral4, kimi_k3 ou olmo_hybrid, et aucun retiré. Si vous avez installé pendant l’attente, une ligne suffit pour vous mettre à jour : pip install -U mlx-lm, après quoi pip show mlx mlx-lm doit indiquer 0.32.3 pour mlx et 0.32.0 pour mlx-lm.

Votre premier modèle : mlx_lm.chat et mlx_lm.generate

mlx_lm.chat

Sans --model, mlx_lm.chat comme mlx_lm.generate utilisent mlx-community/Llama-3.2-3B-Instruct-4bit, dont les fichiers pèsent 1,70 Gio sur Hugging Face. La première exécution le télécharge ; ensuite, il se charge depuis le disque. Dans le chat, q quitte, r remet la conversation à zéro et h affiche ces commandes. La conversation vit en mémoire tant que le chat est ouvert et n’est écrite nulle part : quittez, elle disparaît.

Pour choisir le modèle, donnez son nom Hugging Face ou un dossier local. L’organisation mlx-community sur Hugging Face regroupe ceux qui sont déjà convertis :

mlx_lm.chat --model mlx-community/Qwen3-8B-4bit
mlx_lm.generate --model mlx-community/Qwen3-8B-4bit --prompt "How tall is Mt Everest?" --max-tokens 300

Attention à --max-tokens : par défaut, une réponse s’arrête à 100 tokens dans mlx_lm.generate, 256 dans mlx_lm.chat et 512 dans le serveur. Après la réponse, mlx_lm.generate affiche ses chiffres : Prompt: N tokens, X tokens-per-sec, Generation: N tokens, X tokens-per-sec et Peak memory: X GB. Cette dernière ligne est le test le plus honnête dont vous disposiez pour savoir si le modèle tient : ce que le modèle et la conversation ont réellement pris sur votre machine. Depuis la 0.32.0, mlx_lm.chat vous donne la même chose après chaque réponse, sur une ligne qui se termine par peak X GB.

Quel modèle tient dans votre Mac, et comment MLX utilise la mémoire

La mémoire unifiée se partage avec macOS et tout ce que vous avez ouvert. Nos fiches de machine en mettent 3 Gio de côté pour cela et comparent le reste aux 19 modèles que nous mesurons, en Q4_K_M, notre plancher de qualité, avec un contexte de 8 192 tokens :

Mac	Reste pour le modèle	Modèles qui tiennent	Le plus grand qui tient
Mac avec M4 et 16 Go unifiés	13,00 Gio	8 sur 19	gpt-oss-20b
Mac mini avec M6 et 32 Go unifiés	29,00 Gio	15 sur 19	qwen3.6-35b-a3b
Mac avec M4 Max et 64 Go	61,00 Gio	16 sur 19	gpt-oss-120b

Chiffres servis par chaque fiche de machine le 27 septembre 2026, à partir des données machines du 23 septembre. Le trouveur de modèle fait le même calcul pour votre propre machine, votre contexte et votre langue, dans votre navigateur.

Ces tailles sont celles des fichiers GGUF. Un fichier MLX 4 bits est un autre fichier, avec une autre compression : nous avons donc comparé les 3 qui recoupent ce que prend le Mac de 16 Go. Sur Hugging Face, le 27 septembre 2026, mlx-community/Qwen3-4B-Instruct-2507-4bit pesait 2,11 Gio contre 2,33 Gio en Q4_K_M, mlx-community/Qwen3-8B-4bit 4,29 Gio contre 4,68, et mlx-community/gpt-oss-20b-MXFP4-Q4 10,41 Gio contre 10,83. Pour la mémoire, le verdict du trouveur est du côté prudent pour les 3. Pour la qualité, il ne dit rien : MLX 4 bits et Q4_K_M ne sont pas la même compression.

Ce que MLX fait de la mémoire. mlx_lm.generate et mlx_lm.server demandent à macOS combien de mémoire il recommande pour le GPU et en rendent résidente jusqu’à cette quantité : c’est la façon de mlx-lm de garder un grand modèle rapide. Quand un modèle prend plus de 90 % de cette recommandation, mlx_lm.generate vous prévient : [WARNING] Generating with a model that requires … MB which is close to the maximum recommended size of … MB. This can be slow. Le remède que documente mlx-lm exige macOS 15 ou plus récent :

sudo sysctl iogpu.wired_limit_mb=N

N doit être supérieur à la taille du modèle en mégaoctets et inférieur à la mémoire du Mac. Pour les longues conversations, --max-kv-size plafonne la mémoire que prend le contexte avec un cache tournant : 512 consomme très peu et répond moins bien, 4 096 ou plus consomme davantage et répond mieux. Et la 0.32.0 apporte à mlx_lm.generate et à mlx_lm.chat l’option --prefill-step-size, que le serveur avait déjà : un long prompt est lu par tranches de 2 048 tokens par défaut, et une tranche plus petite abaisse le pic pendant cette lecture, au prix d’une lecture plus lente.

Démarrer mlx_lm.server, le serveur compatible OpenAI sur le port 8080

mlx_lm.server --model mlx-community/Qwen3-8B-4bit

Il écoute sur 127.0.0.1:8080 ; --host et --port changent cela. Il répond à POST /v1/chat/completions et POST /v1/completions, plus GET /v1/models et GET /health. 2 vérifications :

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

La première répond {"status": "ok"} ; depuis la 0.32.0, si le fil d’exécution qui génère le texte est tombé, elle répond {"status": "unavailable"} avec un code 503. La seconde liste tous les modèles de votre cache Hugging Face qui ont les fichiers que cherche mlx-lm, pas seulement celui qui est chargé : un original téléchargé pour la conversion y figure aussi. Pour un client OpenAI, l’URL de base est http://127.0.0.1:8080/v1 ; le serveur ne vérifie aucune clé, donc n’importe quelle chaîne fait l’affaire. Sauf si le client les fixe, les réponses utilisent une température de 0,0 et 512 tokens au maximum.

Le champ model est un ordre. Si une requête nomme un autre modèle, le serveur décharge le modèle actuel et charge celui-là, en le téléchargeant d’abord depuis Hugging Face s’il n’est pas dans votre cache. Un seul modèle réside en mémoire à la fois. Jusqu’à la 0.31.3, il y avait en plus un piège : si la configuration du modèle désignait un fichier Python à lui, mlx-lm l’exécutait au chargement, sans rien demander. La 0.32.0 refuse, sauf si le serveur a été lancé avec --trust-remote-code ; nous l’avons essayé avec un modèle de test : la 0.31.3 a exécuté le fichier, la 0.32.0 s’est arrêtée sur une erreur.

Ce que les réglages d’origine laissent ouvert. Il n’y a aucune authentification, et le CORS est ouvert à toute origine, toute méthode et tout en-tête. L’adresse tient les autres machines à l’écart ; le réglage CORS, lui, laisse entrer n’importe quelle page web que vous ouvrez dans votre navigateur, et cette page peut lire les réponses et, par le champ model, faire télécharger un modèle à votre Mac. La documentation de mlx-lm ne mâche pas ses mots sur le serveur : The MLX LM server is not recommended for production as it only implements basic security checks. Autrement dit, il n’est pas fait pour la production, car ses contrôles de sécurité sont élémentaires. Le serveur affiche ce même avertissement à chaque démarrage. Il est bâti sur le serveur HTTP de la bibliothèque standard de Python. Ce qui en ferme l’essentiel :

• Laissez --host sur 127.0.0.1.
• Nommez les pages qui ont le droit de s’en servir : --allowed-origins http://localhost:3000, une liste séparée par des virgules, au lieu du * par défaut.
• Si une autre machine en a besoin, passez par un tunnel SSH (ssh -L 8080:127.0.0.1:8080 vous@votre-mac) plutôt que par --host 0.0.0.0.

Où MLX range les modèles, et comment les supprimer

Quoi	Où
Modèles téléchargés	Le cache de Hugging Face : ~/.cache/huggingface/hub, déplaçable avec HF_HOME ou HF_HUB_CACHE
Modèles que vous convertissez	./mlx_model dans le dossier d’où vous avez lancé la commande, sauf si vous passez --mlx-path
Conversations	Nulle part. Rien n’est écrit
Texte de calibration pour la quantification AWQ, GPTQ ou dynamique	~/.cache/mlx-lm/, créé seulement si vous utilisez ces méthodes

Chemins tirés de la documentation de mlx-lm et de son code, ainsi que de la documentation de Hugging Face sur ses variables de cache, lues le 27 septembre 2026 ; ceux de mlx-lm ont été revérifiés dans le code de la 0.32.0 le 1er octobre 2026.

Le cache appartient à Hugging Face, pas à MLX : les autres outils Hugging Face du Mac le partagent. mlx-lm le gère avec une seule commande :

mlx_lm.manage --scan
mlx_lm.manage --delete --pattern mlx-community/Qwen3-8B-4bit

--scan ne liste que les dépôts dont le nom contient mlx, sauf si vous donnez un autre --pattern : un modèle chargé directement depuis son dépôt d’origine n’apparaîtra donc pas dans le scan simple.

Convertir et quantifier un modèle avec mlx_lm.convert

Quand le modèle que vous voulez n’est pas dans mlx-community, convertissez-le vous-même :

mlx_lm.convert --model Qwen/Qwen3-8B -q

-q seul veut dire 4 bits par groupes de 64, en mode affine. --q-bits 8 change le nombre de bits ; --q-mode accepte aussi mxfp4, nvfp4 et mxfp8 ; --quant-predicate accepte 4 recettes à bits mixtes, de mixed_2_6 à mixed_4_6. Le résultat va dans ./mlx_model, et la commande refuse de s’exécuter si ce dossier existe déjà.

Comptez le téléchargement avant de commencer. La conversion part des poids d’origine : Qwen3-8B compte 8,2 milliards de paramètres en BF16, soit environ 15,3 Gio à récupérer pour un résultat d’environ 4,3 Gio. --upload-repo publierait le modèle converti sur votre compte Hugging Face ; sans cette option, rien ne sort.

Ce que MLX envoie de lui-même, et ce qui part quand vous le demandez

De lui-même, rien. La fiche MLX (mlx-lm) : ce qu’il envoie et si vous pouvez l’auditer compte 0 appel sur une journée sans y toucher : pas de recherche de mises à jour, pas de compte, pas de télémétrie propre. Le 25 août 2026, nous avons balayé tout le paquet mlx_lm, la branche principale comme la 0.31.3 publiée, à la recherche de code de télémétrie et d’analytique, sans rien trouver, et de même dans le framework mlx. Le 1er octobre 2026, nous avons refait le balayage sur la 0.32.0 publiée : toujours rien.

Le réseau commence avec votre première commande. mlx-lm télécharge par la bibliothèque de Hugging Face elle-même, huggingface_hub, depuis huggingface.co, et pas seulement la première fois : chaque fois que vous chargez un modèle par son nom Hugging Face, cette bibliothèque demande à huggingface.co si les fichiers ont une version plus récente, même quand ils sont déjà en cache. Avec la requête part un en-tête user-agent qui contient votre version de Python, celle de huggingface_hub et, s’il est installé, celle de PyTorch. mlx-lm ne s’identifie pas, si bien que l’en-tête commence littéralement par unknown/None. La documentation de Hugging Face indique que ses bibliothèques collectent certaines données d’usage par défaut, et donne l’interrupteur.

Une fois vos modèles téléchargés, 2 variables ferment le robinet :

export HF_HUB_OFFLINE=1
export HF_HUB_DISABLE_TELEMETRY=1
mlx_lm.chat --model mlx-community/Qwen3-8B-4bit

Avec HF_HUB_OFFLINE=1, aucun appel HTTP n’est fait vers Hugging Face : un modèle en cache se charge, et un modèle absent du cache échoue avec une erreur au lieu de se télécharger. DO_NOT_TRACK=1 fait la même chose que la deuxième ligne.

Tout le reste ne part que si vous le demandez : --upload-repo et mlx_lm.upload publient sur Hugging Face, AWQ, GPTQ et la quantification dynamique récupèrent une fois un texte de calibration dans un gist GitHub, DWQ télécharge un jeu de données Hugging Face, un affinage avec un nom de jeu de données Hugging Face télécharge ce jeu de données, et le champ model du serveur télécharge ce que nomme un client. Avec MLXLM_USE_MODELSCOPE=true, les téléchargements vont vers ModelScope au lieu de Hugging Face.

L’objection est légitime. « Aucune télémétrie propre » est une affirmation sur le code de mlx-lm, pas sur votre réseau. Elle vient de la lecture du code publié, pas d’une capture du trafic, et la fiche le dit. La seule bibliothèque qui parle, huggingface_hub, n’est pas d’Apple, et sa version est celle que pip a résolue sur votre machine. Malgré tout, c’est un décompte lu dans le code, ce qui est déjà plus que ce que permet LM Studio : son application est fermée, et ce qu’elle envoie ne peut se décrire qu’à partir de ce que déclare son éditeur. Et ce décompte vaut 0, là où Installer Ollama en local, vérifier qu’il tourne et voir ce qu’il envoie trouve 30 appels par jour, application ouverte.

L’ordre qui vous laisse un MLX qui marche et qui reste silencieux :

1. Vérifiez que votre Python est natif et en 3.11 ou plus récent : platform.processor() doit répondre arm.
2. Créez un environnement virtuel, lancez pip install mlx-lm et confirmez 0.32.0 et 0.32.3 avec pip show mlx mlx-lm.
3. Choisissez le modèle avec le trouveur de modèle ou la fiche de votre Mac, et lisez Peak memory dans mlx_lm.generate.
4. Une fois qu’il est téléchargé, définissez HF_HUB_OFFLINE=1 et HF_HUB_DISABLE_TELEMETRY=1.
5. Avant de lancer mlx_lm.server, réglez --allowed-origins, laissez l’hôte sur 127.0.0.1 et passez par un tunnel SSH pour les autres machines.

Les 5 logiciels sont comparés exactement sur ces points dans 5 logiciels d’IA locale : télémétrie, appels et audit.