Démarrage rapide de llama.cpp avec le CLI et le serveur

Je reviens sans cesse à llama.cpp pour l’inférence locale — il vous offre un contrôle que Ollama et autres outils abstractent, et il fonctionne tout simplement. Facile d’exécuter des modèles GGUF de manière interactive avec llama-cli ou d’exposer une API HTTP compatible OpenAI avec llama-server.

Si vous hésitez encore entre les approches locales, auto-hébergées et le cloud, commencez par le guide pilier : LLM Hosting in 2026: Local, Self-Hosted & Cloud Infrastructure Compared.

Pourquoi llama.cpp en 2026

llama.cpp est un moteur d’inférence léger, avec une orientation vers :

• la portabilité sur CPU et plusieurs backends GPU,
• une latence prévisible sur une machine unique,
• la flexibilité de déploiement, des ordinateurs portables aux nœuds on-premises.

Il brille lorsque vous voulez la confidentialité et le fonctionnement hors ligne, lorsque vous avez besoin d’un contrôle déterministe sur les drapeaux d’exécution, ou lorsque vous souhaitez intégrer l’inférence dans un système plus grand sans exécuter une pile lourde basée sur Python.

Il est également utile de comprendre llama.cpp, même si vous choisissez plus tard un serveur d’inférence à plus haut débit. Par exemple, si votre objectif est le débit maximal de service sur GPU, vous voudrez peut-être le comparer à vLLM en utilisant : vLLM Quickstart: High-Performance LLM Serving et vous pouvez effectuer des benchmarks des choix d’outils dans : Ollama vs vLLM vs LM Studio: Best Way to Run LLMs Locally in 2026?.

Si Ollama est spécifiquement l’alternative que vous comparez à llama-server, llama.cpp vs Ollama in 2026 est la comparaison en face à face dédiée, avec des déclencheurs concrets pour savoir quand conserver Ollama et quand passer au llama.cpp direct.

Installer llama.cpp sur Windows, macOS et Linux

Il existe trois chemins d’installation pratiques, selon que vous souhaitez la commodité, la portabilité ou la performance maximale.

Installation via les gestionnaires de paquets

C’est l’option la plus rapide pour « le faire fonctionner ».

# macOS ou Linux
brew install llama.cpp

# Windows
winget install llama.cpp

# macOS (MacPorts)
sudo port install llama.cpp

# macOS ou Linux (Nix)
nix profile install nixpkgs#llama-cpp

Astuce : après l’installation, vérifiez que les outils existent :

llama-cli --version
llama-server --version

Installation via des binaires pré-compilés

Si vous souhaitez une installation propre sans compilateurs, utilisez les binaires pré-compilés officiels publiés dans les releases GitHub de llama.cpp. Ils couvrent généralement plusieurs cibles OS et plusieurs backends (variantes CPU uniquement et GPU activé).

Un flux de travail courant :

# 1) Téléchargez l'archive correcte pour votre OS et backend
# 2) Extrayez-la
# 3) Exécutez depuis le dossier extrait

./llama-cli --help
./llama-server --help

Compilation depuis le code source pour votre matériel exact

Si vous tenez à extraire les meilleures performances de votre backend CPU/GPU, compilez depuis le code source avec CMake.

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

# Build CPU
cmake -B build
cmake --build build --config Release

Après la compilation, les binaires se trouvent généralement ici :

ls -la ./build/bin/

Builds GPU en une commande

Activez le backend qui correspond à votre matériel (exemples montrés pour CUDA et Vulkan) :

# NVIDIA CUDA
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Vulkan
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

Ubuntu 24.04 + GPU NVIDIA : guide de compilation complet

Sur Ubuntu 24.04 avec un GPU NVIDIA, vous avez besoin de la suite CUDA et d’OpenSSL avant de compiler. Voici une séquence testée :

1. Installer la suite CUDA 13.1

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin
sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/13.1.1/local_installers/cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2404-13-1-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-13-1

2. Ajouter CUDA à votre environnement (ajoutez à ~/.bashrc) :

# cuda toolkit
export PATH=/usr/local/cuda-13.1/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-13.1/lib64:$LD_LIBRARY_PATH

Puis exécutez source ~/.bashrc ou ouvrez un nouveau terminal.

3. Installer les en-têtes de développement OpenSSL (nécessaire pour une compilation propre) :

sudo apt update
sudo apt install libssl-dev

4. Compiler llama.cpp (depuis le dossier contenant votre clone llama.cpp, avec CUDA activé) :

cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split llama-embedding
cp llama.cpp/build/bin/llama-* llama.cpp

Cela produit llama-cli, llama-mtmd-cli, llama-server, llama-embedding et llama-gguf-split dans le dossier llama.cpp.

Vous pouvez également compiler plusieurs backends et choisir les périphériques à l’exécution. C’est utile si vous déployez la même compilation sur des machines hétérogènes.

Choisir un modèle GGUF et une quantification

Pour exécuter l’inférence, vous avez besoin d’un fichier de modèle GGUF (*.gguf). GGUF est un format monofichier qui regroupe les poids du modèle et les métadonnées standardisées nécessaires par des moteurs comme llama.cpp.

Deux façons d’obtenir un modèle

Option A : Utiliser un fichier GGUF local

Téléchargez ou copiez un GGUF dans ./models/ :

mkdir -p models
# Placez votre GGUF dans models/my-model.gguf

Puis exécutez-le par chemin :

llama-cli -m models/my-model.gguf -p "Bonjour ! Explique ce qu'est llama.cpp." -n 128

Option B : Laisser llama.cpp télécharger depuis Hugging Face

Les compilations modernes de llama.cpp peuvent télécharger depuis Hugging Face et garder les fichiers dans un cache local. C’est souvent le flux de travail le plus simple pour des expérimentations rapides.

# Télécharge un modèle de HF et exécute une invite
llama-cli \
  --hf-repo ggml-org/tiny-llamas \
  --hf-file stories15M-q4_0.gguf \
  -p "Il était une fois," \
  -n 200

Vous pouvez également spécifier la quantification dans le sélecteur de dépôt et laisser l’outil sélectionner un fichier correspondant :

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Résumez le concept de quantification en un paragraphe." \
  -n 160

Si vous avez besoin plus tard d’un flux de travail entièrement hors ligne, --offline force l’utilisation du cache et empêche l’accès au réseau.

Choix de quantification pour l’inférence locale

La quantification est la réponse pratique à la question « Quelle quantification GGUF choisir pour l’inférence locale » car elle équilibre directement qualité, taille du modèle et vitesse.

Un point de départ pragmatique :

• commencez par une variante Q4 ou Q5 pour les machines basées sur CPU,
• passez à une précision plus élevée (ou une quantification moins agressive) lorsque vous pouvez vous le permettre en RAM ou VRAM,
• lorsque le modèle « semble bête » pour votre tâche, la solution est souvent un meilleur modèle ou une quantification moins agressive, et pas seulement des ajustements de tirage.

N’oubliez pas non plus que la fenêtre de contexte compte : des tailles de contexte plus importantes augmentent l’utilisation de la mémoire (parfois drastiquement), même lorsque le fichier GGUF lui-même tient.

Démarrage rapide de llama-cli et paramètres clés

llama-cli est la façon la plus rapide de valider que votre modèle se charge, que votre backend fonctionne et que vos invites se comportent correctement.

Exécution minimale

llama-cli \
  -m models/my-model.gguf \
  -p "Écrivez une courte comparaison TCP vs UDP." \
  -n 200

Exécution de chat interactive

Le mode conversation est conçu pour les modèles de chat. Il active généralement le comportement interactif et formate les invites selon le modèle du modèle.

llama-cli \
  -m models/my-model.gguf \
  --conversation \
  --system-prompt "Vous êtes un assistant en ingénierie des systèmes concis." \
  --ctx-size 4096

Pour terminer la génération lorsque le modèle affiche une séquence spécifique, utilisez une invite inverse. C’est particulièrement utile en mode interactif.

Principaux drapeaux de llama-cli qui comptent

Plutôt que de mémoriser 200 drapeaux, concentrez-vous sur ceux qui dominent la justesse, la latence et la mémoire.

Modèle et téléchargement

Contexte et débit

Transfert GPU et sélection du matériel

Tirage et qualité de la sortie

Exemples de charges de travail avec llama-cli

Résumer un fichier, pas juste une invite

llama-cli \
  -m models/my-model.gguf \
  --system-prompt "Vous résumez des documents techniques. Sortie : cinq points max." \
  --file ./docs/incident-report.txt \
  -n 300

Rendre les résultats plus reproductibles

Lorsque vous déboguez des invites, fixez la graine et réduisez l’aléatoire :

llama-cli \
  -m models/my-model.gguf \
  -p "Extrayez les risques clés de cette note de conception." \
  -n 200 \
  --seed 42 \
  --temp 0.2

Démarrage rapide de llama-server avec API compatible OpenAI

llama-server est un serveur HTTP intégré qui peut exposer :

• des points de terminaison compatibles OpenAI pour le chat, les complétions, les embeddings et les réponses,
• une interface Web pour les tests interactifs,
• des points de terminaison de surveillance optionnels pour la visibilité en production.

Démarrer un serveur avec un modèle local

llama-server \
  -m models/my-model.gguf \
  -c 4096

Par défaut, il écoute sur 127.0.0.1:8080.

Pour lier à l’extérieur (par exemple dans Docker ou un LAN), spécifiez l’hôte et le port :

llama-server \
  -m models/my-model.gguf \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080

Drapeaux de serveur optionnels mais importants

Si vous exécutez dans des conteneurs, beaucoup de paramètres peuvent également être contrôlés via des variables d’environnement LLAMA_ARG_*.

Exemples d’appels API

Complétions de chat avec curl

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      { "role": "system", "content": "Vous êtes un assistant utile." },
      { "role": "user", "content": "Donnez-moi une liste de contrôle rapide pour llama.cpp." }
    ],
    "temperature": 0.7
  }'

Astuce pour les déploiements réels : si vous définissez --api-key, vous pouvez l’envoyer via un en-tête x-api-key (ou continuer à utiliser les en-têtes Authorization selon votre passerelle).

Client Python OpenAI ciblant llama-server

Avec un serveur compatible OpenAI, beaucoup de clients peuvent fonctionner en changeant uniquement base_url.

import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="sk-no-key-required",
)

resp = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant concis."},
        {"role": "user", "content": "Expliquez threads vs batch size dans llama.cpp."},
    ],
)

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

Embeddings

Les embeddings compatibles OpenAI sont exposés sur /v1/embeddings, mais le modèle doit supporter un mode de pooling d’embedding qui n’est pas none.

curl http://localhost:8080/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "input": ["bonjour", "monde"],
    "model": "GPT-4",
    "encoding_format": "float"
  }'

Si vous exécutez un modèle d’embedding dédié, envisagez de démarrer le serveur en mode uniquement embeddings :

llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

ou si vous voulez exécuter llama-cpp avec un modèle d’embedding sur CPU :

CUDA_VISIBLE_DEVICES="" llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

essayez comme ceci :

CUDA_VISIBLE_DEVICES="" llama-embedding \
  -m /path/to/Qwen3-Embedding-0.6B-Q8_0.gguf \
  -p "votre texte ici" \
  --pooling last \
  --verbose-prompt

Servir plusieurs modèles depuis un seul processus

Les exemples ci-dessus lient llama-server à un seul modèle au démarrage. Si vous devez basculer entre les modèles à la demande — sans redémarrer le processus — c’est à quoi sert le mode routeur. Voir llama-server router mode: dynamic model switching without restarts. Pour un flux de déchargement de tous scriptable qui libère la VRAM sans redémarrer le routeur, voir Unload All llama.cpp Router Models Without Restarting.

Performance, surveillance et durcissement de production

La question FAQ « Quelles options de ligne de commande de llama.cpp comptent le plus pour la vitesse et la mémoire » devient beaucoup plus facile lorsque vous traitez l’inférence comme un système :

• La limite de mémoire est généralement la première contrainte (RAM sur CPU, VRAM sur GPU).
• La taille du contexte est un multiplicateur de mémoire majeur.
• Le transfert des couches GPU est souvent le chemin le plus rapide vers un nombre de jetons par seconde plus élevé.
• Les tailles de lot et les threads peuvent améliorer le débit, mais peuvent aussi augmenter la pression mémoire.

Pour une vue plus approfondie, centrée sur l’ingénierie, voir : LLM Performance in 2026: Benchmarks, Bottlenecks & Optimization.

Si vous voulez des résultats mesurés de type llama-cli sur un GPU de classe 16 Go — jetons par seconde, VRAM et charge GPU en parcourant le contexte (19K / 32K / 64K) à travers des GGUF denses et MoE — voir 16 GB VRAM LLM benchmarks with llama.cpp (speed and context).

Pour Qwen 3.6 spécifiquement, llama.cpp prend désormais en charge la décodage spéculatif Multi-Token Prediction (MTP) intégré qui peut augmenter considérablement le débit de génération. Pour un guide complet couvrant toutes les méthodes de décodage spéculatif dans llama.cpp, voir Speculative Decoding. Pour les benchmarks spécifiques MTP de Qwen 3.6, voir Qwen 3.6 MTP vs Standard on 16GB GPU.

Surveillance de llama-server avec Prometheus et Grafana

llama-server peut exposer des métriques compatibles Prometheus sur /metrics lorsque --metrics est activé. Cela s’associe naturellement aux configurations de scraping Prometheus et aux tableaux de bord Grafana.

Pour les tableaux de bord et les alertes spécifiques à llama.cpp (et vLLM, TGI) : Monitor LLM Inference in Production (2026): Prometheus & Grafana for vLLM, TGI, llama.cpp. Guides plus larges : Observability: Monitoring, Metrics, Prometheus & Grafana Guide et Observability for LLM Systems.

Liste de contrôle de durcissement de base

Lorsque votre llama-server est accessible au-delà de localhost :

• utilisez --api-key (ou --api-key-file) pour que les requêtes soient authentifiées,
• évitez de lier à 0.0.0.0 sauf si vous en avez besoin,
• envisagez le TLS via les drapeaux SSL du serveur ou terminez le TLS à un proxy inverse,
• restreignez la concurrence avec --parallel pour protéger la latence sous charge.

Corrections de problèmes rapides

Le modèle se charge mais les réponses sont bizarres en chat

Les points de terminaison de chat sont meilleurs lorsque le modèle a un modèle de chat pris en charge. Si les sorties semblent non structurées, essayez :

• d’utiliser llama-cli --conversation plus un --system-prompt explicite,
• de vérifier que votre modèle est une variante d’instruction ou de chat,
• de tester en utilisant l’interface Web du serveur avant de l’intégrer à une application.

Vous atteignez la limite de mémoire

Réduisez le contexte ou choisissez une quantification plus petite :

• baissez --ctx-size,
• réduisez --n-gpu-layers si la VRAM est le problème,
• passez à un modèle plus petit ou à une quantification plus compressée.

C’est lent sur CPU

Commencez par :

• --threads égal à vos cœurs physiques,
• des tailles de lot modérées,
• de valider que vous avez installé une compilation qui correspond à votre machine (caractéristiques CPU et backend).

Références

• Dépôt et documentation officielle llama.cpp
• Documentation officielle des drapeaux CLI
• Documentation officielle et détails de l’API de llama-server