> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/llama4.md).

# Llama 4 (Scout et Maverick)

Exécutez les modèles MoE Meta Llama 4 Scout et Maverick sur les GPU Clore.ai

Llama 4 de Meta, publié en avril 2025, marque une transition fondamentale vers **Mélange d'experts (MoE)** architecture. Au lieu d'activer tous les paramètres pour chaque jeton, Llama 4 achemine chaque jeton vers des sous-réseaux « experts » spécialisés — offrant des performances de pointe pour une fraction du coût de calcul. Deux modèles à poids ouverts sont disponibles : **Scout** (idéal pour un seul GPU) et **Maverick** (bête de course multi-GPU).

## Caractéristiques clés

* **Architecture MoE**: Seulement 17 milliards de paramètres actifs par jeton (sur 109 milliards/400 milliards au total)
* **Fenêtres de contexte massives**: Scout prend en charge 10 millions de jetons, Maverick prend en charge 1 million de jetons
* **Nativement multimodal**: Comprend à la fois le texte et les images dès le départ
* **Deux modèles**: Scout (16 experts, compatible avec un seul GPU) et Maverick (128 experts, multi-GPU)
* **Performances compétitives**: Scout égale Gemma 3 27B ; Maverick rivalise avec les modèles de la classe GPT-4o
* **Poids ouverts**: Licence communautaire Llama (gratuite pour la plupart des usages commerciaux)

## Variantes de modèle

| Modèle       | Paramètres totaux | Paramètres actifs | Experts | Contexte | VRAM min. (Q4) | VRAM min. (FP16) |
| ------------ | ----------------- | ----------------- | ------- | -------- | -------------- | ---------------- |
| **Scout**    | 109B              | 17B               | 16      | 10M      | 12 Go          | 80 Go            |
| **Maverick** | 400B              | 17B               | 128     | 1M       | 48 Go (multi)  | 320 Go (multi)   |

## Exigences

| Composant | Scout (Q4)  | Scout (FP16) | Maverick (Q4) |
| --------- | ----------- | ------------ | ------------- |
| GPU       | 1× RTX 4090 | 1× H100      | 4× RTX 4090   |
| VRAM      | 24GB        | 80 Go        | 4×24 Go       |
| RAM       | 32 Go       | 64 Go        | 128 Go        |
| Disque    | 50 Go       | 120 Go       | 250 Go        |
| CUDA      | 12.8+       | 12.8+        | 12.8+         |

**GPU Clore.ai recommandé**: RTX 4090 24 Go (0,14–0,42 $/h) pour Scout — meilleur rapport qualité-prix

## Démarrage rapide avec Ollama

La façon la plus rapide de faire fonctionner Llama 4 :

```bash
# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Exécuter Scout (quantifié, ~12 Go de VRAM)
ollama run llama4-scout

# Pour un contexte plus long (utilise plus de VRAM)
ollama run llama4-scout --ctx-size 32768
```

### Ollama comme serveur API

```bash
# Démarrer le serveur en arrière-plan
ollama serve &

# Télécharger le modèle
ollama pull llama4-scout

# Interroger via une API compatible OpenAI
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4-scout",
    "messages": [{"role": "user", "content": "Explique l'architecture MoE en 3 phrases"}]
  }'
```

## Configuration vLLM (production)

Pour des charges de travail de production avec un débit plus élevé :

```bash
# Installer vLLM
pip install vllm

# Servir Scout sur un seul GPU (quantifié)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Servir Scout sur 2 GPU (contexte plus long)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 128000 \
  --gpu-memory-utilization 0.90

# Servir Maverick sur 4 GPU
vllm serve meta-llama/Llama-4-Maverick-17B-128E-Instruct \
  --tensor-parallel-size 4 \
  --max-model-len 65536
```

### Interroger le serveur vLLM

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Écris une fonction Python pour calculer les nombres de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)
print(response.choices[0].message.content)
```

## Transformers HuggingFace

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Llama-4-Scout-17B-16E-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # quantification en 4 bits pour les GPU de 24 Go
)

messages = [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Écris une API REST avec FastAPI qui gère une liste de tâches"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=2048, temperature=0.7, do_sample=True)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))
```

## Démarrage rapide avec Docker

```bash
# Utiliser l'image Docker vLLM
docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768
```

## Pourquoi le MoE est important sur Clore.ai

Les modèles denses traditionnels (comme Llama 3.3 70B) nécessitent énormément de VRAM car les 70 milliards de paramètres sont tous actifs. Llama 4 Scout a 109 milliards au total mais n'active que 17 milliards par jeton — ce qui signifie :

* **La même qualité que les modèles denses 70B+** pour une fraction du coût en VRAM
* **Tient sur une seule RTX 4090** en mode quantifié
* **Contexte de 10 millions de jetons** — traiter des bases de code entières, de longs documents, des livres
* **Moins cher à louer** — une seule RTX 4090 à 0,14–0,42 $/h au lieu d'une configuration multi-GPU pour les modèles 70B

## Conseils pour les utilisateurs de Clore.ai

* **Commencez avec Scout Q4**: Le meilleur rapport qualité-prix sur RTX 4090 — 0,14–0,42 $/h, couvre 95 % des cas d'utilisation
* **Utilisez `--max-model-len` avec prudence**: Ne définissez pas un contexte plus élevé que nécessaire — cela réserve de la VRAM. Commencez à 8192, augmentez si besoin
* **Parallélisme tensoriel pour Maverick**: Louez des machines 4× RTX 4090 pour Maverick ; utilisez `--tensor-parallel-size 4`
* **Connexion HuggingFace requise**: `huggingface-cli login` — vous devez d'abord accepter la licence Llama sur HF
* **Ollama pour les tests rapides, vLLM pour la production**: Ollama est plus rapide à configurer ; vLLM offre un débit plus élevé pour le service d'API
* **Surveiller la mémoire GPU**: `surveillez nvidia-smi` — les modèles MoE peuvent faire grimper la VRAM sur les longues séquences

## Dépannage

| Problème                           | Solution                                                                                |
| ---------------------------------- | --------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                 | Réduisez `--max-model-len`, utilisez la quantification Q4, ou mettez à niveau le GPU    |
| Le téléchargement du modèle échoue | Exécutez `huggingface-cli login` et acceptez la licence Llama 4 sur hf.co               |
| Génération lente                   | Assurez-vous que le GPU est utilisé (`nvidia-smi`); vérifiez `--gpu-memory-utilization` |
| vLLM plante au démarrage           | Réduisez la longueur du contexte ; assurez-vous que CUDA 11.8+ est installé             |
| Ollama affiche le mauvais modèle   | Exécutez `ollama list` pour vérifier ; `ollama rm` + `ollama pull` pour retélécharger   |

## Pour aller plus loin

* [Article de blog Meta Llama 4](https://llama.meta.com/)
* [Fiche modèle HuggingFace](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct)
* [Documentation vLLM](https://docs.vllm.ai/)
* [Bibliothèque de modèles Ollama](https://ollama.com/library/llama4-scout)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/llama4.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.