# llama.cpp — le moteur d'inférence open source de référence

llama.cpp : le moteur d'inférence (MIT) sous Ollama, LM Studio et Jan. Modèles GGUF, CPU ou GPU, serveur API compatible OpenAI. Installation et commandes.

URL canonique : https://www.osfria.fr/llama-cpp.html

---

OSIALab · Moteur d'inférence

## llama.cpp — le moteur d'inférence open source de référence

llama.cpp fait tourner des modèles de langage en C/C++ pur, directement sur votre matériel — du portable sans carte graphique au serveur multi-GPU. C'est le moteur sur lequel reposent [Ollama](https://www.osfria.fr/ollama.html), LM Studio, Jan et une grande partie de l'écosystème local. Quand on veut le contrôle fin, on revient à la source : llama.cpp.

### Fiabilité & transparence

🟢 **Fiable et activement maintenu**

- **Maintenance** : build b9555 publiée le 8 juin 2026 — rythme quasi quotidien, projet classé dans les top contributeurs de GitHub Octoverse 2025 ; nouvelles architectures de modèles intégrées très rapidement.
- **Adoption** : moteur de référence de l'IA locale, embarqué par Ollama, LM Studio, Jan, KoboldCpp et des dizaines d'autres outils.
- **Sécurité** : aucune faille majeure connue sur le moteur. Le serveur llama-server écoute par défaut sur 127.0.0.1:8080, sans authentification forte — à garder en local ou à protéger par reverse-proxy si exposé.
- **Verdict** : outil de référence pour qui veut contrôler finement l'inférence (quantification, GPU layers, contexte). Courbe d'apprentissage réelle en ligne de commande — si vous préférez la simplicité, Ollama repose sur ce même moteur.

> Page informative, sans valeur de conseil. Téléchargez depuis la **source officielle**, vérifiez la **licence** du logiciel *et* de chaque modèle, et gardez en tête qu'un modèle de langage **peut se tromper** : croisez les informations importantes.

### À quoi ça sert

llama.cpp est un **moteur d'inférence** : un programme qui charge un modèle de langage et génère du texte, en exploitant au mieux votre processeur, votre carte graphique, ou les deux. Il est écrit en C/C++ avec un minimum de dépendances, ce qui lui permet de tourner à peu près partout — Windows, macOS (avec accélération Metal sur Apple Silicon), Linux, et même sur des machines modestes. Il fonctionne avec des modèles au format **GGUF**, conçu précisément pour lui.

**À retenir :** llama.cpp n'est pas une interface graphique. C'est un moteur en ligne de commande (plus un serveur). Si vous cherchez à démarrer en un clic, [Ollama](https://www.osfria.fr/ollama.html) enveloppe llama.cpp et vous épargne ces détails — au prix de moins de contrôle.

### Ce qui fait sa force

- **Le socle de l'IA locale.** Ollama, LM Studio, Jan, KoboldCpp et bien d'autres embarquent llama.cpp. Comprendre llama.cpp, c'est comprendre ce qui tourne réellement sous le capot de presque tous les outils grand public.
- **Une portabilité matérielle exceptionnelle.** CPU seul, GPU NVIDIA (CUDA), AMD (ROCm/Vulkan), Apple Silicon (Metal), Intel… llama.cpp s'adapte. C'est le moteur qui fait tourner un modèle là où d'autres abandonnent, y compris sans carte graphique.
- **La quantification GGUF, à la carte.** Le format GGUF et son outil de quantification permettent de réduire un modèle (Q8, Q6_K, Q4_K_M…) pour l'ajuster à votre RAM/VRAM. Vous arbitrez vous-même entre empreinte mémoire et qualité — un contrôle qu'aucune surcouche n'offre aussi finement.
- **Un serveur HTTP compatible OpenAI inclus.** `llama-server` expose une API au format OpenAI : vous branchez dessus [Open WebUI](https://www.osfria.fr/open-webui.html), un éditeur de code ou vos scripts, sans réécrire le code prévu pour OpenAI.
- **Rythme de développement intense.** Le projet intègre les nouvelles architectures de modèles très tôt. Si un modèle vient de sortir, son support arrive souvent d'abord ici.

### Pour qui

Pour qui est à l'aise avec un terminal et veut le contrôle : choisir sa quantification, ses couches déchargées sur le GPU, sa taille de contexte. Développeurs, bricoleurs exigeants, curieux du fonctionnement réel. Si la ligne de commande vous rebute, [Ollama](https://www.osfria.fr/ollama.html) repose sur le même moteur en masquant la complexité.

### Installation

#### Binaires précompilés (le plus simple)

Dépôt officiel : **[github.com/ggml-org/llama.cpp](https://github.com/ggml-org/llama.cpp)** (le projet a migré de l'organisation `ggerganov` vers `ggml-org`). Dans l'onglet **Releases**, téléchargez l'archive correspondant à votre système et, pour un GPU, à votre backend (CUDA, Vulkan, Metal…). Aucune compilation requise.

#### Gestionnaires de paquets

```
# macOS / Linux (Homebrew)
brew install llama.cpp

# Windows (winget)
winget install llama.cpp
```

#### Compiler depuis les sources (pour activer un backend précis)

```
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build --config Release
```

Pour activer CUDA : `cmake -B build -DGGML_CUDA=ON` (Vulkan : `-DGGML_VULKAN=ON`). Les binaires se retrouvent dans `build/bin/`.

#### Obtenir un modèle GGUF

Les modèles GGUF se trouvent sur **[Hugging Face](https://huggingface.co/models?library=gguf)**. Choisissez une quantification adaptée à votre mémoire : `Q4_K_M` est un bon compromis qualité/taille pour démarrer.

#### Lancer une inférence

```
llama-cli -m chemin/vers/modele.gguf \
  -p "Explique en une phrase ce qu'est l'IA locale." -n 256
```

Options courantes :

- `-m` : chemin du modèle GGUF
- `-n` : nombre de tokens à générer
- `-ngl` : nombre de couches déchargées sur le GPU (0 = CPU seul ; un grand nombre = tout sur GPU)
- `-c` : taille du contexte (en tokens)

#### Pratique : télécharger et lancer en une commande

llama.cpp sait récupérer un modèle directement depuis Hugging Face avec `-hf` :

```
llama-cli -hf bartowski/Llama-3.2-3B-Instruct-GGUF
```

### Aller plus loin : le serveur API

`llama-server` lance un serveur HTTP avec une interface web intégrée *et* une API compatible OpenAI :

```
llama-server -m chemin/vers/modele.gguf -ngl 99 -c 8192
```

Par défaut, il écoute sur `http://127.0.0.1:8080` (interface web à cette adresse, API sur `/v1`). C'est par là qu'on branche [Open WebUI](https://www.osfria.fr/open-webui.html) ou ses propres scripts, toujours en local. Pour pointer un outil « OpenAI » vers llama.cpp, il suffit de remplacer l'URL de base par `http://localhost:8080/v1`.

### Points de vigilance

llama.cpp est un outil sain : tout reste local, le code est sous licence permissive, et un modèle trop lourd ne fait que **ralentir** ou refuser de se charger — sans rien casser. Les vrais points à connaître tiennent à la provenance des modèles et à l'exposition du serveur.

| Point d'attention | Niveau | Ce qu'il faut savoir |
| --- | --- | --- |
| Licence du modèle (≠ celle du moteur) | 🟡 selon le modèle | llama.cpp est sous licence **MIT** (« The ggml authors »), très permissive. Mais chaque modèle GGUF a sa propre licence : Llama et Gemma imposent des conditions, Mistral et Qwen (Apache 2.0) sont plus souples. À vérifier avant un usage commercial. |
| Provenance du fichier GGUF | 🟡 selon la source | Un GGUF, ce sont des *poids*, pas du code exécuté par le moteur. Le risque est surtout d'obtenir un modèle altéré ou douteux : téléchargez depuis des dépôts réputés (Hugging Face, comptes reconnus comme bartowski, unsloth…). |
| Sécuriser `llama-server` si vous l'exposez | 🟡 selon configuration | Le serveur écoute sur `127.0.0.1:8080` et n'a **pas d'authentification forte** par défaut (une simple clé via `--api-key` existe, basique). En local, parfait ; si vous le publiez sur le réseau (`--host 0.0.0.0`), placez-le derrière un reverse-proxy authentifié ou un VPN. |
| Courbe d'apprentissage réelle | 🟢 pas un risque, un choix | Quantifications, backends, options en ligne de commande : il y a un temps d'apprentissage. Ce n'est pas un défaut, c'est le prix du contrôle. Pour aller vite, [Ollama](https://www.osfria.fr/ollama.html) reste l'enveloppe pratique. |

### Sécurité

- **Gardez le serveur en local** (`127.0.0.1:8080`) par défaut. Pour un accès distant, passez par un reverse-proxy avec authentification (Caddy, Nginx) ou un VPN.
- **Téléchargez modèles et binaires depuis des sources fiables** — Releases officielles du dépôt et dépôts GGUF réputés sur Hugging Face.
- **Tenez llama.cpp à jour.** Le rythme est soutenu : nouvelles architectures, gains de performance et correctifs arrivent souvent.
- **Vérifiez la licence du modèle GGUF** sur sa page Hugging Face avant tout usage professionnel.

### Aller plus loin

- [Ollama](https://www.osfria.fr/ollama.html) — l'enveloppe la plus simple, qui repose sur llama.cpp.
- [Open WebUI](https://www.osfria.fr/open-webui.html) — une interface web à brancher sur `llama-server`.
- [vLLM](https://www.osfria.fr/vllm.html) — l'autre approche, orientée débit GPU pour servir plusieurs utilisateurs.
- [OSIALab](https://www.osfria.fr/osialab.html) — comparer tous les outils d'IA locale.

### Sources

- Dépôt officiel : [github.com/ggml-org/llama.cpp](https://github.com/ggml-org/llama.cpp) — licence **MIT** (The ggml authors)
- Documentation du serveur : [tools/server/README.md](https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md)
- Modèles GGUF : [huggingface.co/models?library=gguf](https://huggingface.co/models?library=gguf)