# Llama 4 (Scout y Maverick)

Llama 4 de Meta, lanzado en abril de 2025, marca un cambio fundamental hacia **Mezcla de Expertos (MoE)** arquitectura. En lugar de activar todos los parámetros para cada token, Llama 4 enruta cada token a subredes "expertas" especializadas — ofreciendo rendimiento de vanguardia a una fracción del costo de cómputo. Están disponibles dos modelos de pesos abiertos: **Scout** (ideal para una sola GPU) y **Maverick** (potencia para múltiples GPU).

## Características clave

* **Arquitectura MoE**: Solo 17B de parámetros activos por token (de 109B/400B en total)
* **Ventanas de contexto masivas**: Scout admite 10M de tokens, Maverick admite 1M de tokens
* **Multimodal de forma nativa**: Entiende tanto texto como imágenes desde el primer momento
* **Dos modelos**: Scout (16 expertos, amigable para una sola GPU) y Maverick (128 expertos, multi-GPU)
* **Rendimiento competitivo**: Scout iguala a Gemma 3 27B; Maverick compite con modelos de clase GPT-4o
* **Pesos abiertos**: Licencia de la Comunidad Llama (gratis para la mayoría de usos comerciales)

## Variantes de modelo

| Modelo       | Parámetros totales | Parámetros activos | Expertos | Contexto | VRAM mínima (Q4) | VRAM mínima (FP16) |
| ------------ | ------------------ | ------------------ | -------- | -------- | ---------------- | ------------------ |
| **Scout**    | 109B               | 17B                | 16       | 10M      | 12GB             | 80GB               |
| **Maverick** | 400B               | 17B                | 128      | 1M       | 48GB (multi)     | 320GB (multi)      |

## Requisitos

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

**GPU recomendada de Clore.ai**: RTX 4090 24GB (\~$0.5–2/día) para Scout — mejor relación calidad-precio

## Inicio rápido con Ollama

La forma más rápida de poner Llama 4 en funcionamiento:

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

# Ejecutar Scout (cuantizado, ~12GB VRAM)
ollama run llama4-scout

# Para contexto más largo (usa más VRAM)
ollama run llama4-scout --ctx-size 32768
```

### Ollama como servidor API

```bash
# Iniciar servidor en segundo plano
ollama serve &

# Descargar modelo
ollama pull llama4-scout

# Consultar vía API compatible con OpenAI
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama4-scout",
    "messages": [{"role": "user", "content": "Explica la arquitectura MoE en 3 frases"}]
  }'
```

## Configuración de vLLM (Producción)

Para cargas de producción con mayor rendimiento:

```bash
# Instalar vLLM
pip install vllm

# Servir Scout en una sola GPU (cuantizado)
vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Servir Scout en 2 GPUs (contexto más largo)
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 en 4 GPUs
vllm serve meta-llama/Llama-4-Maverick-17B-128E-Instruct \
  --tensor-parallel-size 4 \
  --max-model-len 65536
```

### Consultar el servidor 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": "Eres un asistente útil."},
        {"role": "user", "content": "Escribe una función en Python para calcular números 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  # cuantización a 4 bits para GPUs de 24GB
)

messages = [
    {"role": "system", "content": "Eres un asistente de programación servicial."},
    {"role": "user", "content": "Escribe una API REST con FastAPI que gestione una lista de tareas"}
]

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

## Inicio rápido con Docker

```bash
# Usando la imagen Docker de 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
```

## Por qué MoE importa en Clore.ai

Los modelos densos tradicionales (como Llama 3.3 70B) necesitan VRAM masiva porque los 70B parámetros están todos activos. Llama 4 Scout tiene 109B en total pero solo activa 17B por token — lo que significa:

* **La misma calidad que modelos densos de 70B+** a una fracción del coste de VRAM
* **Cabe en una sola RTX 4090** en modo cuantizado
* **Contexto de 10M de tokens** — procesa bases de código completas, documentos largos, libros
* **Más barato de alquilar** — $0.5–2/día en lugar de $6–12/día para modelos de 70B

## Consejos para usuarios de Clore.ai

* **Comienza con Scout Q4**: Mejor relación calidad-precio en RTX 4090 — $0.5–2/día, cubre el 95% de los casos de uso
* **Usa `--max-model-len` con prudencia**: No establezcas el contexto más alto de lo que necesitas — reserva VRAM. Empieza en 8192, aumenta según sea necesario
* **Paralelismo tensorial para Maverick**: Alquila máquinas 4× RTX 4090 para Maverick; usa `--tensor-parallel-size 4`
* **Inicio de sesión en HuggingFace requerido**: `huggingface-cli login` — primero necesitas aceptar la licencia de Llama en HF
* **Ollama para pruebas rápidas, vLLM para producción**: Ollama es más rápido de configurar; vLLM ofrece mayor rendimiento para servir APIs
* **Monitorea la memoria GPU**: `watch nvidia-smi` — los modelos MoE pueden aumentar la VRAM en secuencias largas

## Solución de problemas

| Problema                            | Solución                                                                                   |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| `OutOfMemoryError`                  | Reducir `--max-model-len`, usa cuantización Q4, o actualiza la GPU                         |
| Fallo en la descarga del modelo     | Ejecuta `huggingface-cli login` y acepta la licencia de Llama 4 en hf.co                   |
| Generación lenta                    | Asegúrate de que se esté usando la GPU (`nvidia-smi`); verifica `--gpu-memory-utilization` |
| vLLM falla al iniciar               | Reduce la longitud del contexto; asegúrate de tener CUDA 11.8+ instalado                   |
| Ollama muestra el modelo incorrecto | Ejecuta `ollama list` para verificar; `ollama rm` + `ollama pull` para volver a descargar  |

## Lecturas adicionales

* [Publicación en el blog de Meta Llama 4](https://llama.meta.com/)
* [Ficha del modelo en HuggingFace](https://huggingface.co/meta-llama/Llama-4-Scout-17B-16E-Instruct)
* [Documentación vLLM](https://docs.vllm.ai/)
* [Biblioteca de modelos de 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-es/modelos-de-lenguaje/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.