Aller au contenu

Comment exécuter des LLM sur Mac Mini M4 (Llama, Mistral, Phi)

L'architecture mémoire unifiée d'Apple Silicon fait du Mac Mini M4 l'une des plateformes les plus rentables pour exécuter des grands modèles de langage en local. Ce guide couvre Ollama, llama.cpp et MLX avec des benchmarks réels et des exemples de code pratiques.

IA et Machine Learning 20 min de lecture Mis à jour en octobre 2026 Intermédiaire

Pourquoi le Mac Mini M4 pour les LLM ?

Le Mac Mini M4 est particulièrement adapté à l'exécution de grands modèles de langage grâce à l'architecture d'Apple Silicon. Contrairement aux serveurs GPU traditionnels où la VRAM limite la taille des modèles, la mémoire unifiée du M4 permet au CPU, au GPU et au Neural Engine de partager le même pool mémoire, ce qui signifie qu'un Mac Mini de 24 Go peut charger des modèles qui nécessiteraient un GPU coûteux avec 24 Go de VRAM.

Architecture mémoire unifiée

Contrairement aux GPU NVIDIA avec une VRAM séparée, la mémoire unifiée du M4 permet au GPU d'accéder à la totalité de la RAM système. Un Mac Mini de 24 Go dispose effectivement de 24 Go de "VRAM" pour le chargement des modèles, sans le goulot d'étranglement PCI-E.

Neural Engine

Le Neural Engine 16 cœurs du M4 délivre jusqu'à 38 TOPS de performance ML. CoreML l'exploite pour accélérer les modèles exécutés en local, tandis qu'Ollama, llama.cpp et MLX font tourner les LLM sur le GPU du M4 via Metal.

Efficacité énergétique

Le Mac Mini M4 ne consomme que 5 à 15 W sous charge d'inférence LLM typique, contre 300 à 450 W pour un NVIDIA A100. Cela se traduit par des coûts d'hébergement considérablement réduits et aucun refroidissement spécialisé requis.

Rentabilité

À partir de 85 $/mois (USD, HT) pour un Mac Mini M4 dédié avec 16 Go, vous bénéficiez d'une tarification prévisible sans coûts API par token. Exécutez des requêtes d'inférence illimitées 24h/24 à une fraction du prix du cloud GPU.

Point clé : Pour les charges de travail d'inférence (pas l'entraînement), le Mac Mini M4 offre le meilleur rapport performance-prix du marché. Vous obtenez du matériel dédié sans voisins bruyants, sans facturation par token et avec la bande passante mémoire d'Apple Silicon allant jusqu'à 120 Go/s.

Comparaison des frameworks LLM

Trois frameworks dominent l'écosystème LLM sur Apple Silicon. Chacun a des forces distinctes selon votre cas d'usage.

Comparaison des frameworks LLM
Ollama llama.cpp MLX
Facilité d'installation Très facile Modérée Facile
Support GPU Metal Oui (auto) Oui (flag) Oui (natif)
Serveur API Intégré Intégré Intégré (mlx_lm.server)
Format de modèle GGUF (téléchargement auto) GGUF SafeTensors / MLX
Performance Bonne Meilleure pour GGUF Meilleure pour Apple Silicon
Bibliothèque de modèles Sélectionnée (ollama.com) HuggingFace GGUF HuggingFace MLX
Langage Go (CLI/API) C++ (CLI/API) Python
Idéal pour Déploiement rapide, serving API Contrôle maximal, builds personnalisés Pipelines ML Python, recherche

Configuration avec Ollama

Ollama est le moyen le plus simple de démarrer avec les LLM sur Mac Mini M4. Il gère le téléchargement des modèles, la quantification et le serving API avec un seul binaire.

Étape 1 : Installer Ollama

# Install Ollama with Homebrew
# (or download the macOS app from ollama.com, which starts the server for you)
brew install ollama

# Start the server and leave it running (Step 6 starts it automatically)
ollama serve

# In a second terminal, verify installation
ollama --version

Étape 2 : Télécharger des modèles

# Download Llama 3 8B (4.7GB, fits 16GB RAM)
ollama pull llama3:8b

# Download Mistral 7B (4.1GB)
ollama pull mistral:7b

# Download Phi-3 Mini (2.3GB, great for constrained setups)
ollama pull phi3:mini

# Download Llama 3 70B (requires 48GB+ RAM)
ollama pull llama3:70b

# List downloaded models
ollama list
# NAME            SIZE     MODIFIED
# llama3:8b       4.7 GB   2 minutes ago
# mistral:7b      4.1 GB   5 minutes ago
# phi3:mini       2.3 GB   8 minutes ago

Étape 3 : Lancer le chat interactif

# Start an interactive chat session
ollama run llama3:8b

# Example interaction:
# >>> What is the capital of France?
# The capital of France is Paris. It is the largest city in France
# and serves as the country's political, economic, and cultural center.

Étape 4 : Servir via API

Ollama démarre automatiquement un serveur API REST sur le port 11434. Vous pouvez l'interroger depuis n'importe quelle application via l'API compatible OpenAI.

# The Ollama server from Step 1 listens on localhost:11434

# Query using curl (OpenAI-compatible endpoint)
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3:8b",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a Python function to calculate fibonacci numbers."}
    ],
    "temperature": 0.7,
    "max_tokens": 500
  }'

# Native Ollama API endpoint
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3:8b",
    "prompt": "Explain quantum computing in 3 sentences.",
    "stream": false
  }'

Étape 5 : Utiliser depuis Python

# pip install openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require an API key
)

response = client.chat.completions.create(
    model="llama3:8b",
    messages=[
        {"role": "system", "content": "You are a senior Python developer."},
        {"role": "user", "content": "Write a FastAPI endpoint for user registration."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

Étape 6 : Exécuter Ollama comme service en arrière-plan

# Create a LaunchAgent: Ollama starts with your user session and restarts
# if it crashes (enable automatic login so it also returns after a reboot)
# (Homebrew on Apple Silicon installs ollama in /opt/homebrew/bin; check with: which ollama)
cat <<EOF > ~/Library/LaunchAgents/com.ollama.server.plist
<?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.ollama.server</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/bin/ollama</string>
        <string>serve</string>
    </array>
    <key>EnvironmentVariables</key>
    <dict>
        <key>OLLAMA_HOST</key>
        <string>127.0.0.1:11434</string>
    </dict>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF

# First stop the server you started by hand in Step 1 (Ctrl+C in its terminal):
# the service needs port 11434

# Load the service
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# Verify it's running
curl http://localhost:11434/api/tags

Configuration avec llama.cpp

llama.cpp vous donne un contrôle maximal sur les paramètres d'inférence et offre souvent les meilleures performances brutes sur Apple Silicon grâce à son backend Metal optimisé à la main.

Étape 1 : Cloner et compiler avec Metal

# Install dependencies
brew install cmake

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

# Build (Metal GPU acceleration is enabled by default on macOS)
cmake -B build
cmake --build build --config Release -j

# The binaries are in ./build/bin
./build/bin/llama-cli --version

Étape 2 : Télécharger des modèles GGUF

# Install the Hugging Face CLI (hf) for easy downloads
pip install -U huggingface_hub

# Download Llama 3 8B Instruct Q4_K_M (best quality/speed balance)
hf download \
  bartowski/Meta-Llama-3-8B-Instruct-GGUF \
  Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  --local-dir ./models

# Download Mistral 7B Q4_K_M
hf download \
  TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
  mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --local-dir ./models

# Download Phi-3 Mini Q4
hf download \
  microsoft/Phi-3-mini-4k-instruct-gguf \
  Phi-3-mini-4k-instruct-q4.gguf \
  --local-dir ./models

Étape 3 : Exécuter l'inférence

# Run Llama 3 8B with Metal GPU offloading (all layers)
./build/bin/llama-cli \
  -m ./models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  -t 8 \
  --temp 0.7 \
  -p "Explain how transformers work in machine learning:"

# Key flags:
# -ngl 99     : Offload all layers to Metal GPU
# -c 4096     : Context window size
# -t 8        : Number of CPU threads (M4 has 10 cores)
# --temp 0.7  : Temperature for sampling

Étape 4 : Démarrer le serveur API

# Start OpenAI-compatible API server
./build/bin/llama-server \
  -m ./models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080 \
  --parallel 4

# Test the API
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Configuration avec MLX

MLX est le framework de machine learning d'Apple, conçu spécifiquement pour Apple Silicon. Pensé pour la mémoire unifiée, il s'exécute sur le CPU et le GPU du M4, ce qui en fait le choix idéal pour les workflows ML basés sur Python.

Étape 1 : Installer MLX

# Create a virtual environment
python3 -m venv ~/mlx-env
source ~/mlx-env/bin/activate

# Install MLX and the LLM package
pip install mlx mlx-lm

# Verify installation
python3 -c "import mlx.core as mx; print(mx.default_device())"
# Device(gpu, 0)

Étape 2 : Exécuter l'inférence avec MLX

# Run Llama 3 8B using mlx-lm CLI
mlx_lm.generate \
  --model mlx-community/Meta-Llama-3-8B-Instruct-4bit \
  --prompt "Write a Python decorator for rate limiting:" \
  --max-tokens 500 \
  --temp 0.7

# Run Mistral 7B
mlx_lm.generate \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --prompt "Explain microservices architecture:" \
  --max-tokens 500

Étape 3 : Intégration Python

from mlx_lm import load, generate, stream_generate
from mlx_lm.sample_utils import make_sampler

# Load the model (downloads on first run)
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

# Sampling settings are passed as a sampler object
sampler = make_sampler(temp=0.7, top_p=0.9)

# Generate text
prompt = "Write a bash script to monitor disk usage and send alerts:"
response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=500,
    sampler=sampler
)
print(response)

# Streaming generation: each chunk is a response object with .text
for chunk in stream_generate(
    model, tokenizer,
    prompt="Explain Docker networking:",
    max_tokens=300
):
    print(chunk.text, end="", flush=True)

Étape 4 : Construire une API simple avec MLX

# pip install fastapi uvicorn mlx-lm
# (mlx-lm also ships an OpenAI-compatible server: mlx_lm.server --model <repo>)
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mlx_lm import load, stream_generate
import json

app = FastAPI()
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

@app.post("/v1/completions")
async def completions(request: dict):
    prompt = request.get("prompt", "")
    max_tokens = request.get("max_tokens", 256)

    response = ""
    for chunk in stream_generate(model, tokenizer, prompt=prompt, max_tokens=max_tokens):
        response += chunk.text

    return {"choices": [{"text": response}]}

@app.post("/v1/chat/completions")
async def chat(request: dict):
    messages = request.get("messages", [])
    prompt = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )

    response = ""
    for chunk in stream_generate(model, tokenizer, prompt=prompt, max_tokens=512):
        response += chunk.text

    return {
        "choices": [{
            "message": {"role": "assistant", "content": response}
        }]
    }

# Run: uvicorn server:app --host 0.0.0.0 --port 8000

Benchmarks de performance

Benchmarks réels mesurés avec Ollama et la quantification Q4_K_M. Tous les tests utilisent un prompt de 512 tokens, une génération de 256 tokens et les paramètres d'échantillonnage par défaut.

Benchmarks de performance
Matériel Modèle Tokens/s Temps jusqu'au premier token Coût/mois
Mac Mini M4 16GB Llama 3 8B Q4 ~35 tok/s ~180ms $85
Mac Mini M4 16GB Mistral 7B Q4 ~38 tok/s ~160ms $85
Mac Mini M4 24GB Llama 3 13B Q4 ~22 tok/s ~320ms $129
Mac Mini M4 Pro 48GB Llama 3 70B Q4 ~12 tok/s ~850ms $299
RTX 4090 (cloud) Llama 3 8B Q4 ~120 tok/s ~50ms $500+

Prix My Remote Mac : USD, HT, par mois.

Note : Bien que les GPU NVIDIA offrent un débit brut supérieur, le Mac Mini M4 délivre d'excellents tokens/seconde pour les cas d'usage interactifs à une fraction du coût. À 35 tok/s, les réponses semblent instantanées pour les applications de chat. Le véritable avantage est le coût : un usage illimité pour 85 $/mois (USD, HT) vs une tarification API par token qui peut facilement dépasser 500 $/mois.

Quels modèles pour quelle configuration ?

Le facteur clé est la mémoire unifiée. Avec la quantification Q4, les modèles utilisent environ 0,5 à 0,6 Go par milliard de paramètres, plus la surcharge pour le contexte et l'OS.

Quels modèles pour quelle configuration ?
Taille de modèle Exemples de modèles Prix/mois
16 GB 7B - 13B (Q4) Llama 3 8B, Mistral 7B, Phi-3 Mini, Gemma 7B $85
24 GB 13B - 34B (Q4) Llama 3 13B, CodeLlama 34B, Yi 34B $129
48 GB 34B - 70B (Q4) Llama 3 70B, Mixtral 8x7B, DeepSeek 67B $299
64 GB+ 70B+ (Q4/Q6) Llama 3 70B Q6, Mixtral 8x22B, Command-R+ $449

Prix My Remote Mac : USD, HT, par mois.

# Quick formula to estimate memory requirements:
# Memory needed = (Parameters in B * Bits per weight / 8) + context overhead
#
# Example: Llama 3 70B at Q4 quantization
# = (70 * 4 / 8) GB = 35 GB model weights
# + ~4 GB context/overhead
# = ~39 GB total → fits in 48GB Mac Mini M4 Pro
#
# Check current memory usage while running a model:
ollama ps
# NAME          SIZE     PROCESSOR    UNTIL
# llama3:8b     5.1 GB   100% GPU     4 minutes from now

Cas d'usage

Assistant IA privé

Exécutez un assistant de type ChatGPT qui garde toutes les données sur votre serveur. Aucune donnée ne quitte votre infrastructure. Parfait pour le traitement de documents sensibles, de données clients ou de code propriétaire.

Recommandé : Llama 3 8B sur 16 Go

Pipeline RAG

Construisez un système de génération augmentée par récupération qui recherche dans vos documents et génère des réponses. Utilisez ChromaDB ou Qdrant pour les embeddings avec Ollama pour la génération.

Recommandé : Mistral 7B sur 16 Go

Génération de code

Utilisez des modèles de code spécialisés comme CodeLlama ou DeepSeek Coder pour l'autocomplétion, la revue de code et le refactoring automatisé. Intégrez avec VS Code ou JetBrains via Continue.dev.

Recommandé : CodeLlama 34B sur 48 Go

Génération de contenu

Générez des textes marketing, des articles de blog, des descriptions de produits et des modèles d'emails à grande échelle. Exécutez des traitements par lots pendant la nuit sans que les coûts API par token ne s'accumulent.

Recommandé : Llama 3 70B sur 48 Go

Conseils de performance

Choisir le bon niveau de quantification

Le niveau de quantification impacte considérablement la vitesse et la qualité. Q4_K_M offre le meilleur équilibre pour la plupart des cas d'usage.

# Quantization levels (from fastest to best quality):
# Q2_K  - Fastest, lowest quality, smallest size
# Q3_K  - Fast, acceptable quality
# Q4_K_M - Best balance of speed and quality (RECOMMENDED)
# Q5_K_M - Slower, better quality
# Q6_K  - Slow, near-original quality
# Q8_0  - Slowest, best quality, largest size
# F16   - Full precision, requires 2x memory

# Example: Download Q4_K_M for best balance
ollama pull llama3:8b-instruct-q4_K_M

Maximiser le déchargement GPU Metal

Assurez-vous que toutes les couches du modèle s'exécutent sur le GPU pour des performances maximales. Le déchargement partiel sur le CPU réduit significativement le débit.

# llama.cpp: offload all layers to GPU
./build/bin/llama-cli -m model.gguf -ngl 99

# Check GPU utilization
sudo powermetrics --samplers gpu_power -n 1 -i 1000

# Monitor memory pressure
memory_pressure
# System-wide memory free percentage: 45%

Optimiser la taille des lots et le contexte

Réduire la taille de la fenêtre de contexte libère de la mémoire et peut améliorer le débit. N'utilisez que la quantité de contexte dont votre application a réellement besoin.

# Default context is often 4096 or 8192 tokens
# Reduce if you don't need long context.
# Ollama: set it inside an interactive session...
ollama run llama3:8b
# >>> /set parameter num_ctx 2048

# ...or as the default for every model the server loads: add it to the
# EnvironmentVariables dict of ~/Library/LaunchAgents/com.ollama.server.plist
# (Step 6), then reload the service (a variable set in a shell does not
# reach the launchd service, and a second ollama serve would clash on port 11434)
#   <key>OLLAMA_CONTEXT_LENGTH</key>
#   <string>2048</string>
launchctl unload ~/Library/LaunchAgents/com.ollama.server.plist
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# For llama.cpp, set context and batch size:
#   -c 2048       Context window
#   -b 512        Batch size for prompt processing
#   --parallel 2  Concurrent request slots
./build/bin/llama-server -m model.gguf -ngl 99 \
  -c 2048 \
  -b 512 \
  --parallel 2

Garder les modèles chargés en mémoire

Le chargement d'un modèle depuis le disque prend plusieurs secondes. Gardez les modèles fréquemment utilisés résidant en mémoire pour des réponses instantanées.

# Ollama: set keep-alive to keep model in memory indefinitely
curl http://localhost:11434/api/generate -d '{
  "model": "llama3:8b",
  "keep_alive": -1
}'

# Or make it the server default: add OLLAMA_KEEP_ALIVE to the
# EnvironmentVariables dict of the Step 6 plist, then reload the service
#   <key>OLLAMA_KEEP_ALIVE</key>
#   <string>-1</string>
launchctl unload ~/Library/LaunchAgents/com.ollama.server.plist
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# Check which models are loaded
ollama ps

Questions fréquentes

Puis-je exécuter des modèles de niveau ChatGPT sur un Mac Mini M4 ?
Oui. Des modèles comme Llama 3 8B et Mistral 7B offrent une qualité comparable à GPT-3.5 pour de nombreuses tâches. Pour une qualité de niveau GPT-4, vous aurez besoin d'un modèle 70B qui nécessite plus de 48 Go de mémoire unifiée (Mac Mini M4 Pro). L'expérience est excellente pour l'assistance au codage, le Q&A documentaire et la génération de contenu.
35 tokens/seconde est-il assez rapide pour le chat en temps réel ?
Absolument. La vitesse de lecture moyenne d'un humain est d'environ 4 à 5 mots par seconde, ce qui correspond à environ 5 à 7 tokens par seconde. À 35 tok/s, le modèle génère du texte 5 à 7 fois plus vite qu'un humain ne peut le lire. Pour les applications de chat, cela semble complètement instantané.
Combien d'utilisateurs simultanés un Mac Mini M4 peut-il gérer ?
Avec un modèle 7B, un seul Mac Mini M4 peut gérer 2 à 4 requêtes simultanées avec une latence acceptable. Pour une concurrence plus élevée, vous pouvez utiliser plusieurs Mac Minis derrière un répartiteur de charge. Les serveurs Ollama et llama.cpp prennent tous deux en charge la mise en file d'attente de requêtes simultanées.
Puis-je faire du fine-tuning de modèles sur Mac Mini M4 ?
Oui, avec des limitations. Vous pouvez faire du fine-tuning de modèles 7B en utilisant les techniques LoRA/QLoRA sur des appareils de 16 Go avec MLX ou la bibliothèque Hugging Face PEFT. Le fine-tuning complet de modèles plus grands nécessite plus de mémoire. Pour le fine-tuning en production de modèles 70B et plus, les serveurs GPU sont plus pratiques.
Quel framework choisir : Ollama, llama.cpp ou MLX ?
Choisissez Ollama si vous voulez l'installation la plus rapide et un serving API facile. Choisissez llama.cpp pour un contrôle maximal sur les paramètres d'inférence et les meilleures performances avec les modèles GGUF. Choisissez MLX si vous construisez des pipelines ML en Python et souhaitez une optimisation native Apple Silicon. Beaucoup d'utilisateurs commencent avec Ollama et passent à llama.cpp ou MLX à mesure que leurs besoins évoluent.

Commencez à exécuter des LLM sur Apple Silicon

Obtenez un serveur Mac Mini M4 dédié et exécutez Llama, Mistral ou Phi avec une inférence illimitée. À partir de 85 $/mois (USD, HT).

Besoin de plus de détails ?

Parcourez la documentation complète : guides pas à pas, références de configuration et dépannage.

Ouvrir la documentation →