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