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


---

# 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-de/sprachmodelle/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.