Votre Mac Mini peut faire tourner une IA locale gratuitement : le guide ultime

Les factures mensuelles des API d'intelligence artificielle peuvent vite devenir un casse-tête. Entre Anthropic qui pousse vers des abonnements payants et OpenAI qui facture à chaque requête, l'addition grimpe vite. Faire tourner un modèle local sur votre propre Matériel change la donne : plus de frais récurrents, plus de dépendance aux serveurs externes. Votre Mac Mini, même d'entrée de gamme, peut héberger une IA puissante capable de gérer vos agents OpenClaw sans rien payer.

Ce guide pas à pas explique comment installer llama.cpp, un outil optimisé pour Mac, avec accélération Metal (le GPU intégré des Mac). Vous allez télécharger le modèle Qwen3.5 9B, le quantifier pour qu'il tienne en mémoire, et le faire tourner en arrière-plan comme un service système. À la fin, votre Mac Mini deviendra une centrale IA gratuite, prête à alimenter tous vos agents OpenClaw.

POURQUOI PASSER À L'IA LOCALE ?

Les modèles locaux ont longtemps eu mauvaise réputation : trop lents, trop gourmands, incompatibles avec les agents. Pourtant, avec les bonnes optimisations, ces critiques ne tiennent plus. Un modèle comme Qwen3.5 9B, correctement configuré, répond à vos besoins quotidiens avec une fluidité surprenante. Pour des tâches simples comme rédiger un email, organiser votre agenda ou automatiser votre maison connectée, la différence avec une API payante est imperceptible.

Le vrai changement ? Le coût. Une facture mensuelle de 50 à 200 euros pour des requêtes API devient un investissement unique dans du matériel. Un Mac Mini M2 avec 24 Go de RAM suffit largement pour faire tourner un modèle local performant. Même avec 16 Go de RAM, c'est jouable, même si vous risquez de rencontrer des limites avec des contextes très longs.

Attention : ce guide ne couvre pas l'installation complète d'OpenClaw. Il se concentre sur la configuration du modèle local pour qu'il fonctionne avec vos agents existants. Si vous débutez avec OpenClaw, commencez par suivre le guide officiel avant de revenir ici.

PRÉPARER VOTRE MAC MINI POUR L'IA LOCALE

Avant de commencer, assurez-vous que votre Mac Mini est prêt. Les spécifications recommandées : un processeur M2 ou supérieur, et au moins 24 Go de RAM. Avec 16 Go, vous pouvez vous en sortir, mais les performances seront limitées, surtout avec des contextes longs.

Première étape : installer les outils nécessaires. Homebrew, le gestionnaire de paquets pour Mac, va nous aider à installer les dépendances. Ouvrez le Terminal et collez cette commande :

$ brew install cmake curl

Ces outils sont indispensables pour compiler llama.cpp, le moteur qui va faire tourner notre modèle local. CMake sert à configurer la compilation, et curl permettra de télécharger les fichiers nécessaires depuis Internet.

COMPILER LLAMA.CPP AVEC ACCÉLÉRATION METAL

llama.cpp est un projet open source qui optimise les modèles de langage pour qu'ils tournent localement, même sur des machines modestes. La particularité de ce projet ? Il prend en charge l'accélération matérielle via Metal, la technologie Apple pour utiliser le GPU des Mac. Résultat : des performances jusqu'à 70 % plus rapides qu'avec une version standard.

Pour compiler llama.cpp avec Metal, suivez ces étapes dans le Terminal :

# Clone llama.cpp
git clone https://github.com/ggml-org/llama.cpp

# Configurer la compilation avec Metal
cmake llama.cpp -B llama.cpp/build \
    -DBUILDSHAREDLIBS=OFF \
    -DGGML_METAL=ON \
    -DGGML_CUDA=OFF

# Lancer la compilation
cmake --build llama.cpp/build \
    --config Release \
    -j$(sysctl -n hw.ncpu) \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

Quelques explications sur ces commandes :

• -DBUILDSHAREDLIBS=OFF : Désactive la création de bibliothèques partagées pour optimiser les performances.
• -DGGML_METAL=ON : Active l'accélération Metal, essentielle pour tirer parti du GPU de votre Mac.
• -DGGML_CUDA=OFF : Désactive l'accélération NVIDIA (inutile sur Mac).
• -j$(sysctl -n hw.ncpu) : Utilise tous les cœurs de votre processeur pour compiler plus vite.

Une fois la compilation terminée, vous aurez accès à plusieurs outils, dont llama-server, qui servira de serveur local pour votre modèle.

TÉLÉCHARGER UN MODÈLE PERFORMANT ET QUANTIFIÉ

Les modèles de langage sont énormes. Un Qwen3.5 27B, par exemple, pèse plusieurs dizaines de gigaoctets. Pour le faire tenir en mémoire sur un Mac Mini, il faut le quantifier. La quantification, c'est comme compresser un fichier : on réduit sa taille en perdant un peu de précision, mais sans altérer ses capacités principales.

Le modèle choisi ici est le Qwen3.5 9B, une version allégée mais très performante. En juin 2026, il surpasse même des modèles comme Gemma 4-12B dans les benchmarks locaux. Avec 16 Go de RAM, il tourne sans problème. Avec 24 Go, vous aurez de la marge pour des contextes plus longs.

Pour télécharger ce modèle quantifié, utilisez cette commande dans le Terminal :

curl -L -o models/Qwen3.5-9B-UD-Q4KKL.gguf \
"https://huggingface.co/unsloth/Qwen3.5-9B-MTP-GGUF/resolve/main/Qwen3.5-9B-UD-Q4KXL.gguf?download=true"

Le fichier Q4KKL.gguf pèse environ 6 à 8 Go. C'est la version quantifiée qui permet au modèle de tenir en mémoire. Sans quantification, il faudrait plusieurs dizaines de Go, ce qui est impossible sur un Mac Mini standard.

CONFIGURER LE MODÈLE POUR OPENCLAW

OpenClaw a besoin d'un template de chat spécifique pour fonctionner correctement avec les modèles locaux. Sans ce fichier, vos agents ne comprendront pas vos requêtes. Heureusement, un template compatible existe déjà :

mkdir templates && \
curl -o templates/qwen35.jinja \
"https://huggingface.co/froggeric/Qwen-Fixed-Chat-Templates/resolve/main/chat_template.jinja"

Ce fichier qwen35.jinja contient les instructions pour que le modèle comprenne le format des conversations OpenClaw. Sans lui, votre IA locale répondra de manière chaotique, voire pas du tout.

LANCER LE SERVEUR LOCAL AVEC LLAMA-SERVER

Tout est prêt : le modèle est téléchargé, le template est installé, et llama.cpp est compilé. Il est temps de lancer le serveur local qui va servir de pont entre votre Mac Mini et OpenClaw. Ouvrez le Terminal et exécutez :

./llama.cpp/llama-server \
  -m models/Qwen3.5-9B-UD-Q4KXL.gguf \
  --chat-template-file templates/qwen35.jinja \
  --temp 0.7 \
  --top-p 0.9 \
  --top-k 20 \
  -c 64000 \
  -ngl 20 \
  --host 127.0.0.1 \
  --port 8080

Voici ce que signifient ces paramètres :

• -m models/Qwen3.5-9B-UD-Q4KXL.gguf : Spécifie le modèle à utiliser.
• --chat-template-file templates/qwen35.jinja : Indique où se trouve le template de chat.
• --temp 0.7 : Température de 0.7, un bon compromis entre créativité et stabilité.
• --top-p 0.9 : Utilise le top-p sampling avec un seuil de 0.9 pour des réponses plus cohérentes.
• --top-k 20 : Limite le choix aux 20 meilleures options à chaque étape.
• -c 64000 : Taille du contexte à 64 000 tokens, idéal pour des conversations longues.
• -ngl 20 : Utilise 20 couches de GPU (Metal) pour accélérer l'inférence.
• --host 127.0.0.1 --port 8080 : Le serveur écoute uniquement sur votre machine, sur le port 8080.

Si tout se passe bien, vous devriez voir un message comme celui-ci dans le Terminal :

srv  llama_server: model loaded
 llama_server: server is listening on http://127.0.0.1:8080
 update_slots: all slots are idle

Cela signifie que votre modèle est chargé et que le serveur est prêt à recevoir des requêtes. Gardez ce Terminal ouvert : il continuera à tourner en arrière-plan.

CRÉER UN SERVICE SYSTÈME POUR UN DÉMARRAGE AUTOMATIQUE

Redémarrer votre Mac Mini ne doit pas signifier éteindre votre modèle local. Pour que le serveur démarre automatiquement au lancement du système, vous allez créer un service système avec launchd, l'équivalent macOS de systemd sous Linux.

Créez un fichier de configuration avec cette commande (remplacez YOUR_USERNAME par votre nom d'utilisateur Mac) :

sudo nano /Library/LaunchDaemons/com.openclaw.llama-server.plist

Collez-y ce contenu :

<?xml version="1.0" encoding="UTF-8"?>

<.DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">

<plist version="1.0">
<dict>

<key>Label</key>
<string>com.openclaw.llama-server</string>

<key>UserName</key>
<string>YOUR_USERNAME</string>

<key>ProgramArguments</key>
<array>
    <string>/Users/YOUR_USERNAME/llama.cpp/llama-server</string>

    <string>-m</string>
    <string>/Users/YOURUSERNAME/models/Qwen3.5-9B-UD-Q4K_XL.gguf</string>

    <string>--chat-template-file</string>
    <string>/Users/YOUR_USERNAME/templates/qwen35.jinja</string>

    <string>--temp</string>
    <string>0.7</string>

    <string>--top-p</string>
    <string>0.9</string>

    <string>--top-k</string>
    <string>20</string>

    <string>-c</string>
    <string>64000</string>

    <string>-ngl</string>
    <string>20</string>

    <string>--host</string>
    <string>127.0.0.1</string>

    <string>--port</string>
    <string>8080</string>
</array>

<key>WorkingDirectory</key>
<string>/Users/YOUR_USERNAME</string>

<key>RunAtLoad</key>
<true/>

<key>KeepAlive</key>
<true/>

<key>StandardOutPath</key>
<string>/tmp/llama-server.log</string>

<key>StandardErrorPath</key>
<string>/tmp/llama-server.err</string>

</dict>
</plist>

Enregistrez le fichier (Ctrl+O, puis Entrée sous nano), puis quittez (Ctrl+X).

Pour activer ce service, exécutez ces commandes dans le Terminal :

sudo chown root:wheel /Library/LaunchDaemons/com.openclaw.llama-server.plist && \
sudo chmod 644 /Library/LaunchDaemons/com.openclaw.llama-server.plist && \
sudo launchctl bootstrap system /Library/LaunchDaemons/com.openclaw.llama-server.plist

Votre serveur local démarrera désormais automatiquement au prochain redémarrage de votre Mac. Pour vérifier son bon fonctionnement, surveillez les logs avec :

tail -f /tmp/llama-server.err

CONFIGURER OPENCLAW POUR UTILISER LE MODÈLE LOCAL

Votre modèle local est prêt, mais OpenClaw ne sait pas encore qu'il existe. Il faut lui indiquer où trouver votre nouveau serveur et comment l'utiliser. Pour cela, modifiez le fichier de configuration d'OpenClaw :

Ouvrez le fichier ~/.openclaw/openclaw.json avec un éditeur de texte et ajoutez cette section dans le bloc models :

{
  "models": {
    "providers": {
      "local": {
        "baseUrl": "http://127.0.0.1:8080/v1",
        "apiKey": "sk-local",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3-9b",
            "name": "Qwen3.5 9B Local",
            "contextWindow": 64000,
            "maxTokens": 8192
          }
        ]
      }
    }
  }
}

Quelques points importants :

• baseUrl : L'adresse de votre serveur local (127.0.0.1:8080).
• apiKey : Une clé fictive pour indiquer qu'il s'agit d'un modèle local.
• api : Le type d'API, ici compatible avec OpenAI.
• contextWindow : La taille du contexte, 64 000 tokens.
• maxTokens : Le nombre maximum de tokens générés, 8 192.

Ensuite, définissez ce modèle comme défaut pour vos agents en ajoutant cette section :

"agents": {
    "defaults": {
      "model": {
        "primary": "local/qwen3-9b"
      },
      "models": {
        "local/qwen3-9b": {}
      }
 }
}

Ces modifications permettent à OpenClaw de savoir qu'il peut utiliser votre modèle local pour toutes ses tâches.

VALIDER LA CONFIGURATION ET DÉMARRER LE GATEWAY

Avant de redémarrer OpenClaw, vérifiez que votre configuration est correcte. Exécutez cette commande pour valider le fichier JSON :

openclaw config validate

Si tout est bon, vous devriez voir un message de confirmation. Sinon, corrigez les erreurs signalées. Une fois la validation passée, redémarrez le gateway d'OpenClaw pour appliquer les changements :

openclaw gateway restart

Votre modèle local est maintenant intégré à OpenClaw. Pour vérifier qu'il est bien reconnu, listez tous les modèles disponibles :

openclaw models list --provider local

Vous devriez voir apparaître votre modèle Qwen3.5 9B Local dans la liste. Si c'est le cas, félicitations : votre IA locale est opérationnelle .

TESTER LE MODÈLE LOCAL AVEC UNE REQUÊTE SIMPLE

Pour être sûr que tout fonctionne parfaitement, testez votre modèle avec une requête basique. Exécutez cette commande :

openclaw infer model run \
  --model local/qwen3-9b \
  --prompt "Reply with exactly: pong" \
  --json

Vous devriez recevoir une réponse au format JSON, comme celle-ci :

{
  "ok": true,
  "capability": "model.run",
  "transport": "local",
  "provider": "local",
  "model": "qwen3-9b",
  "attempts": [],
  "outputs": [
    {
      "text": "pong",
      "mediaUrl": null
    }
  ]
}

Si la réponse contient bien le mot pong et aucun autre texte parasite, votre modèle local est prêt à l'emploi. Si vous voyez des balises ou du texte supplémentaire, vérifiez votre template de chat ou relancez le serveur.

CRÉER UNE COMPÉTENCE LOCALE POUR TESTER LES OUTILS

OpenClaw permet d'ajouter des compétences (skills) pour étendre les capacités de vos agents. Pour vérifier que votre modèle local gère bien les appels d'outils, créons une compétence de calcul simple.

Cette compétence, appelée python-calc, permettra à votre agent de faire des calculs mathématiques en utilisant Python. Créez-la avec ces commandes :

mkdir -p ~/.openclaw/workspace/skills/python-calc

cat << 'EOF' > ~/.openclaw/workspace/skills/python-calc/SKILL.md
---
name: python-calc
description: A tool that evaluates mathematical expressions by executing a Python one-liner.
version: 1.0.0
---
## Instructions
1. Extract the exact mathematical expression the user wants to calculate.
2. Use your built-in shell tool to run this exact command, replacing ` with the expression: python3 -c "print()"`
3. Wait for the shell tool to return the stdout output.
4. You MUST generate a final conversational response to the user containing the exact numeric result returned by the script.
EOF

Cette compétence est maintenant disponible pour tous vos agents OpenClaw. Pour l'activer, redémarrez le gateway :

openclaw gateway restart

TESTER L'APPEL D'OUTILS AVEC UN CALCUL MATHEMATIQUE

Tout est prêt : le modèle local, la compétence python-calc, et le gateway d'OpenClaw. Il est temps de tester si votre agent peut utiliser correctement les outils locaux. Exécutez cette commande :

openclaw agent --local --agent main --verbose on --thinking high --message \
"Use the python-calc skill to calculate 8664 multiplied by 222. 
Do not use skill_workshop. Tell me the final answer."

Votre agent devrait :

1. Reconnaître la compétence python-calc.
2. Extraire l'expression mathématique (8664 * 222).
3. Appeler la compétence pour effectuer le calcul.
4. Recevoir le résultat (1 923 408).
5. Vous retourner la réponse finale.

Si tout se passe bien, vous verrez apparaître le message :

The final answer is 1,923,408.

Félicitations . Votre modèle local gère parfaitement les appels d'outils, ce qui signifie qu'il est prêt pour des tâches plus complexes.

DÉBOGUER ET OPTIMISER VOS PERFORMANCES

Si quelque chose ne fonctionne pas, la première étape est de vérifier les logs du serveur. Dans un nouveau Terminal, exécutez :

tail -f /tmp/llama-server.err

Cette commande affiche en temps réel les erreurs et messages du serveur. Vous y verrez si le modèle a bien chargé, s'il y a des problèmes de mémoire, ou si le template de chat pose problème.

Quelques problèmes courants et leurs solutions :

• Le serveur ne démarre pas : Vérifiez que le chemin vers llama-server est correct dans le fichier .plist. Assurez-vous aussi que le modèle et le template sont bien téléchargés.
• Des erreurs de mémoire : Réduisez la taille du contexte (-c) ou utilisez un modèle plus petit (comme Qwen3.5 4B).
• Les réponses sont incohérentes : Vérifiez que vous utilisez bien le bon template de chat. Sans lui, le modèle ne comprend pas le format des conversations.

Si vous avez des questions ou des blocages, n'hésitez pas à consulter la documentation officielle de llama.cpp ou à demander de l'aide sur les forums dédiés.

CONCLUSION : VOTRE MAC MINI, UNE IA GRATUITE À PORTÉE DE MAIN

Installer un modèle d'IA local sur un Mac Mini, c'est comme passer d'un abonnement de salle de sport à une salle dans votre salon. Plus besoin de payer pour chaque séance : vous avez tout sous la main, prêt à l'emploi. Avec ce guide, vous avez transformé votre machine en une centrale IA performante, capable de gérer vos agents OpenClaw sans frais mensuels.

Les performances sont là : pour des tâches quotidiennes, la différence avec une API payante est minime. Et si vous avez besoin de plus de puissance, vous pouvez toujours ajouter un modèle de secours plus lourd en configuration.

Le plus dur ? La première installation. Une fois que tout est configuré, votre Mac Mini devient une machine autonome, indépendante des serveurs externes. Plus de factures surprises, plus de latence, juste une IA qui répond instantanément à vos demandes.

Alors, prêt à dire adieu à vos factures d'API ? Suivez ce guide, et votre Mac Mini deviendra bien plus qu'un simple ordinateur : une IA locale, gratuite et puissante.