---
title: "Guide pratique : faire tourner un LLM local en production"
description: Commandes concrètes llama.cpp, vLLM et Ollama, flags clés et
  configurations réelles pour servir Qwen3.6 sur GPU discret ou mémoire unifiée.
date: 2026-06-01T00:00:00.000Z
dateModified: 2026-06-01T00:00:00.000Z
author:
  name: Antoine Michéa
  url: https://sobercloud.fr/
  sameAs:
    - https://altilink.eu/
tags:
  - llamacpp
  - vllm
  - inference
  - gguf
section: Pratique
canonical: https://sobercloud.fr/decouvertes/guide-pratique/
---

# Guide pratique : faire tourner un LLM local en production

Passons aux commandes concrètes : installation, téléchargement de modèles et configurations d'inférence éprouvées. Les exemples ci-dessous reprennent les flags réellement utilisés lors de nos tests sur deux profils matériels, l'un à mémoire unifiée, l'autre sur GPU discret.

## Installer llama.cpp

```bash
# Cloner le dépôt officiel llama.cpp (ggml-org sur GitHub)
git clone ggml-org/llama.cpp
cd llama.cpp

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

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

# Vulkan (iGPU AMD, ex. Strix Halo)
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release
```

## Télécharger un modèle GGUF

```python
from huggingface_hub import snapshot_download

# Qwen3.6-27B dense, Q4_K_XL Unsloth (~18 Go, idéal GPU discret)
snapshot_download(
    repo_id="unsloth/Qwen3.6-27B-Instruct-GGUF",
    local_dir="./models/qwen3.6-27b",
    allow_patterns=["*UD-Q4_K_XL*"],
)

# Qwen3.6-35B-A3B MoE (35B total, seulement 3B actifs/token)
snapshot_download(
    repo_id="unsloth/Qwen3.6-35B-A3B-Instruct-GGUF",
    local_dir="./models/qwen3.6-35b-a3b",
    allow_patterns=["*Q5_K_XL*"],
)
```

## Lancer l'inférence avec llama.cpp

```bash
# Configuration optimisée : Flash Attention + KV cache quantifié
./llama-cli -m models/qwen3.6-27b-UD-Q4_K_XL.gguf \
    --conversation \
    --ctx-size 65536 \
    --ngl 999 \
    -fa 1 \
    --cache-type-k q8_0 \
    --cache-type-v q8_0 \
    --temp 0.7 --top-p 0.8 --top-k 20 \
    --repeat-penalty 1.05

# Serveur OpenAI-compatible
./llama-server -m models/qwen3.6-27b-UD-Q4_K_XL.gguf \
    --port 8080 --ngl 999 -fa 1
```

### Cas mémoire unifiée (Strix Halo)

Sur **Strix Halo** (iGPU Radeon 8060S, 128 Gio UMA partagée CPU/GPU), trois flags sont déterminants. Le `--no-mmap` est **obligatoire** : le memory-mapping fait crasher l'allocation sur UMA.

```bash
./llama-server -m models/qwen3.6-35b-a3b-Q5_K_XL.gguf \
    --ngl 999 \
    -fa 1 \
    --no-mmap \
    --cache-type-k q8_0 --cache-type-v q8_0 \
    --parallel 2 \
    --n-predict 32768 \
    --ctx-size 65536
```

Cette config sert le MoE Q5_K_XL (~26 Go) autour de **73 t/s** via le backend Vulkan, avec deux requêtes parallèles.

### Décodage spéculatif

Un petit modèle « draft » propose plusieurs tokens d'avance que le grand modèle valide en un seul passage, ce qui accélère le decode de 2 à 3 fois sur le code et le texte structuré.

```bash
./llama-server -m models/qwen3.6-27b-UD-Q4_K_XL.gguf \
    --model-draft models/qwen3-0.6b-Q4_K_M.gguf \
    --spec-draft-n-max 3 \
    --ngl 999 -fa 1 --ctx-size 32768
```

### Offloading automatique avec `--fit on`

Depuis fin 2025, `--fit on` détermine automatiquement le nombre optimal de couches à placer sur GPU : il charge un maximum sur le GPU puis bascule le reste sur CPU, ce qui évite de régler `--ngl` à la main.

```bash
./llama-cli -m model.gguf --fit on -fa 1
```

### Flags llama.cpp essentiels

| Rôle | Flag | Effet |
|------|------|-------|
| Offload GPU | `--ngl 999` | Place toutes les couches sur GPU |
| Auto-offload | `--fit on` | Répartition GPU/CPU optimale |
| Flash Attention | `-fa 1` | Active Flash Attention |
| KV cache K/V | `--cache-type-k/v q8_0` | Quantifie le cache (-50 % mémoire) |
| UMA | `--no-mmap` | Obligatoire sur mémoire unifiée |
| Parallélisme | `--parallel 2` | Requêtes concurrentes |
| Budget sortie | `--n-predict 32768` | Tokens max générés |
| Draft spéculatif | `--spec-draft-n-max 3` | Tokens proposés par le draft |

## Servir avec vLLM (RTX 3090)

Sur **RTX 3090** (24 Go GDDR6X, ~23,56 Gio utilisables), vLLM sert **Qwen3.6-27B** en int4 AutoRound avec un KV cache en fp8 pour pousser le contexte à 81k.

```bash
vllm serve Qwen/Qwen3.6-27B-Instruct-int4-AutoRound \
    --quantization auto-round \
    --kv-cache-dtype fp8_e5m2 \
    --max-model-len 81920 \
    --gpu-memory-utilization 0.92 \
    --port 8000
```

Flash Attention est activé par défaut sous vLLM, et le continuous batching maximise le throughput en multi-utilisateurs.

## Démarrage rapide avec Ollama

```bash
# Installer Ollama via le script officiel ollama.com
curl -fsSL ollama.com/install.sh | sh

ollama run qwen3.6:27b        # dense, 256K ctx natif
ollama run qwen3.6:35b-a3b    # MoE économique

# Modèle GGUF personnalisé
cat > Modelfile << 'EOF'
FROM ./models/qwen3.6-27b-UD-Q4_K_XL.gguf
PARAMETER temperature 0.7
PARAMETER top_p 0.8
PARAMETER top_k 20
PARAMETER num_ctx 32768
EOF
ollama create mon-modele -f Modelfile
ollama run mon-modele
```

Ollama active Flash Attention automatiquement mais n'expose pas la quantification du KV cache : pour ce niveau de contrôle, passez par llama.cpp ou vLLM.

## Conseil final

Commencez avec les valeurs par défaut puis ajustez : la config optimale dépend du matériel, du modèle et du cas d'usage. Mesurez les tokens/s et la qualité des réponses pour trouver votre point d'équilibre.

## Pour aller plus loin

- [Logiciels d'inférence](/decouvertes/logiciels-inference/)
- [Aide-mémoire LLM](/decouvertes/aide-memoire/)
- [Décodage accéléré](/decouvertes/decodage-accelere/)