# Llama 4 (Scout & Maverick)

Lancement de Llama 4 par Meta en avril 2025 marque un changement fondamental vers **Mixture of Experts (MoE)** architecture. Au lieu d'activer tous les paramètres pour chaque token, Llama 4 oriente chaque token vers des sous-réseaux spécialisés « experts » — offrant des performances de pointe à une fraction du coût de calcul. Deux modèles à poids ouverts sont disponibles : **Scout** (idéal pour un seul GPU) et **Maverick** (puissance multi-GPU).

## Principales caractéristiques

* **Architecture MoE**: Seulement 17B de paramètres actifs par token (sur 109B/400B au total)
* **Fenêtres de contexte massives**: Scout prend en charge 10M de tokens, Maverick prend en charge 1M de tokens
* **Nativement multimodal**: Comprend à la fois le texte et les images dès la sortie de la boîte
* **Deux modèles**: Scout (16 experts, adapté au single-GPU) et Maverick (128 experts, multi-GPU)
* **Performances compétitives**: Scout égalise Gemma 3 27B ; Maverick rivalise avec des modèles de la classe GPT-4o
* **Poids ouverts**: Licence Llama Community (gratuite pour la plupart des usages commerciaux)

## Variantes de modèle

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

## Exigences

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

**GPU recommandé par Clore.ai**: RTX 4090 24GB (\~0,5–2 $/jour) pour Scout — meilleur rapport qualité/prix

## Démarrage rapide avec Ollama

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

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

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

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

### Ollama en tant que 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": "Expliquez l'architecture MoE en 3 phrases"}]
  }'
```

## Configuration vLLM (Production)

Pour des charges de production nécessitant 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 GPUs (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 GPUs
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 serviable."},
        {"role": "user", "content": "Écrivez une fonction Python pour calculer les nombres de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)
print(response.choices[0].message.content)
```

## HuggingFace Transformers

```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 4 bits pour les GPU 24GB
)

messages = [
    {"role": "system", "content": "Vous êtes un assistant de codage utile."},
    {"role": "user", "content": "Écrivez une API REST avec FastAPI qui gère une liste de tâches (todo)"}
]

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 Docker

```bash
# Utilisation de 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 MoE est important sur Clore.ai

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

* **Même qualité que les modèles denses de 70B+** à une fraction du coût en VRAM
* **Tient sur un seul RTX 4090** en mode quantifié
* **Contexte de 10M de tokens** — traiter des bases de code entières, des documents longs, des livres
* **Moins cher à louer** — 0,5–2 $/jour au lieu de 6–12 $/jour pour les modèles 70B

## Conseils pour les utilisateurs de Clore.ai

* **Commencez avec Scout Q4**: Meilleur rapport qualité/prix sur RTX 4090 — 0,5–2 $/jour, couvre 95 % des cas d'utilisation
* **Utilisez `--max-model-len` judicieusement**: Ne définissez pas le contexte plus haut 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 tests rapides, vLLM pour production**: Ollama est plus rapide à configurer ; vLLM offre un débit plus élevé pour la mise en service d'API
* **Surveillez la mémoire GPU**: `watch nvidia-smi` — les modèles MoE peuvent provoquer des pics de VRAM sur de longues séquences

## Dépannage

| Problème                          | Solution                                                                                |
| --------------------------------- | --------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                | Réduire `--max-model-len`, utilisez la quantification Q4, ou mettez à niveau le GPU     |
| Échec du téléchargement du modèle | 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   |

## Lectures complémentaires

* [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: 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:

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

The question should be specific, self-contained, and written in natural language.
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.