# Llama 4 (Scout & Maverick)

Metas Llama 4, veröffentlicht im April 2025, markiert einen grundlegenden Wechsel zu **Mixture of Experts (MoE)** Architektur. Anstatt alle Parameter für jedes Token zu aktivieren, leitet Llama 4 jedes Token zu spezialisierten "Expert"-Teilnetzwerken — und bietet Spitzenleistung bei einem Bruchteil der Rechenkosten. Zwei Modelle mit offenem Gewicht sind verfügbar: **Scout** (ideal für eine einzelne GPU) und **Maverick** (Multi-GPU-Kraftpaket).

## Hauptmerkmale

* **MoE-Architektur**: Nur 17B Parameter pro Token aktiv (von insgesamt 109B/400B)
* **Enorme Kontextfenster**: Scout unterstützt 10M Token, Maverick unterstützt 1M Token
* **Nativ multimodal**: Versteht von Haus aus sowohl Text als auch Bilder
* **Zwei Modelle**: Scout (16 Experten, single-GPU-freundlich) und Maverick (128 Experten, Multi-GPU)
* **Wettbewerbsfähige Leistung**: Scout entspricht Gemma 3 27B; Maverick konkurriert mit Modellen der GPT-4o-Klasse
* **Offene Gewichte**: Llama Community License (für die meisten kommerziellen Nutzungen kostenlos)

## Modellvarianten

| Modell       | Gesamtparameter | Aktive Parameter | Experten | Kontext | Min. VRAM (Q4) | Min. VRAM (FP16) |
| ------------ | --------------- | ---------------- | -------- | ------- | -------------- | ---------------- |
| **Scout**    | 109B            | 17B              | 16       | 10M     | 12GB           | 80GB             |
| **Maverick** | 400B            | 17B              | 128      | 1M      | 48GB (multi)   | 320GB (multi)    |

## Anforderungen

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

**Empfohlene Clore.ai-GPU**: RTX 4090 24GB (\~0,5–2 $/Tag) für Scout — bestes Preis-Leistungs-Verhältnis

## Schnellstart mit Ollama

Der schnellste Weg, Llama 4 zum Laufen zu bringen:

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

# Scout ausführen (quantisiert, ~12GB VRAM)
ollama run llama4-scout

# Für längeren Kontext (verwendet mehr VRAM)
ollama run llama4-scout --ctx-size 32768
```

### Ollama als API-Server

```bash
# Server im Hintergrund starten
ollama serve &

# Modell herunterladen
ollama pull llama4-scout

# Abfrage über OpenAI-kompatible API
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4-scout",
    "messages": [{"role": "user", "content": "Erkläre die MoE-Architektur in 3 Sätzen"}]
  }'
```

## vLLM-Einrichtung (Produktion)

Für Produktions-Workloads mit höherem Durchsatz:

```bash
# Installiere vLLM
pip install vllm

# Scout auf einer einzelnen GPU bereitstellen (quantisiert)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Scout auf 2 GPUs bereitstellen (längerer Kontext)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 128000 \
  --gpu-memory-utilization 0.90

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

### vLLM-Server abfragen

```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": "You are a helpful assistant."},
        {"role": "user", "content": "Schreibe eine Python-Funktion zur Berechnung von Fibonacci-Zahlen"}
    ],
    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  # 4-Bit-Quantisierung für 24GB-GPUs
)

messages = [
    {"role": "system", "content": "Du bist ein hilfreicher Coding-Assistent."},
    {"role": "user", "content": "Schreibe eine REST-API mit FastAPI, die eine To-Do-Liste verwaltet"}
]

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))
```

## Docker Quick Start

```bash
# Verwendung des vLLM Docker-Images
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
```

## Warum MoE auf Clore.ai wichtig ist

Traditionelle dichte Modelle (wie Llama 3.3 70B) benötigen massiven VRAM, weil alle 70B Parameter aktiv sind. Llama 4 Scout hat 109B insgesamt, aktiviert aber nur 17B pro Token — das bedeutet:

* **Gleiche Qualität wie 70B+ dichte Modelle** bei einem Bruchteil der VRAM-Kosten
* **Passt auf eine einzelne RTX 4090** im quantisierten Modus
* **10M Token Kontext** — verarbeitet komplette Codebasen, lange Dokumente, Bücher
* **Günstiger zu mieten** — 0,5–2 $/Tag statt 6–12 $/Tag für 70B-Modelle

## Tipps für Clore.ai-Nutzer

* **Beginne mit Scout Q4**: Bestes Preis-Leistungs-Verhältnis auf der RTX 4090 — 0,5–2 $/Tag, deckt 95 % der Anwendungsfälle ab
* **Verwenden Sie `--max-model-len` weise**: Setze den Kontext nicht höher als nötig — er reserviert VRAM. Beginne bei 8192 und erhöhe bei Bedarf
* **Tensor-Parallel für Maverick**: Miete 4× RTX 4090-Maschinen für Maverick; verwende `--tensor-parallel-size 4`
* **HuggingFace-Login erforderlich**: `huggingface-cli login` — du musst die Llama-Lizenz auf HF zuerst akzeptieren
* **Ollama für Schnelltests, vLLM für Produktion**: Ollama ist schneller einzurichten; vLLM bietet höheren Durchsatz für API-Serving
* **GPU-Speicher überwachen**: `watch nvidia-smi` — MoE-Modelle können bei langen Sequenzen VRAM-Spitzen verursachen

## Fehlerbehebung

| Problem                         | Lösung                                                                                          |
| ------------------------------- | ----------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`              | Reduzieren `--max-model-len`, verwende Q4-Quantisierung oder rüste die GPU auf                  |
| Modelldownload schlägt fehl     | Ausführen `huggingface-cli login` und akzeptiere die Llama-4-Lizenz auf hf.co                   |
| Langsame Generierung            | Stelle sicher, dass die GPU verwendet wird (`nvidia-smi`); prüfe `--gpu-memory-utilization`     |
| vLLM stürzt beim Start ab       | Reduziere die Kontextlänge; stelle sicher, dass CUDA 11.8+ installiert ist                      |
| Ollama zeigt falsches Modell an | Ausführen `ollama list` um zu überprüfen; `ollama rm` + `ollama pull` um erneut herunterzuladen |

## Weiterführende Lektüre

* [Meta Llama 4 Blogbeitrag](https://llama.meta.com/)
* [HuggingFace Model Card](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct)
* [vLLM-Dokumentation](https://docs.vllm.ai/)
* [Ollama Model Library](https://ollama.com/library/llama4-scout)