> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/llama4.md).

# Llama 4 (Scout y Maverick)

Ejecuta los modelos MoE Meta Llama 4 Scout y Maverick en GPUs de Clore.ai

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 dirige cada token a subredes especializadas "expertas" — ofreciendo rendimiento de vanguardia a una fracción del costo de cómputo. Hay dos modelos de pesos abiertos disponibles: **Scout** (ideal para una sola GPU) y **Maverick** (potente para varias GPU).

## Características clave

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

## Variantes del modelo

| Modelo       | Parámetros totales | Parámetros activos | Expertos | Contexto | VRAM mínima (Q4) | VRAM mínima (FP16) |
| ------------ | ------------------ | ------------------ | -------- | -------- | ---------------- | ------------------ |
| **Scout**    | 109B               | 17B                | 16       | 10M      | 12GB             | 80 GB              |
| **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        | 80 GB        | 4×24GB        |
| RAM        | 32GB        | 64GB         | 128GB         |
| Disco      | 50GB        | 120GB        | 250GB         |
| CUDA       | 12.8+       | 12.8+        | 12.8+         |

**GPU recomendada de Clore.ai**: RTX 4090 de 24GB ($0.14–0.42/h) para Scout — la mejor relación calidad-precio

## Inicio rápido con Ollama

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

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

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

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

### Ollama como servidor de API

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

# Descargar el modelo
ollama pull llama4-scout

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

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

Para cargas de trabajo 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 GPU (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 GPU
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 de Python para calcular números de Fibonacci"}
    ],
    temperature=0.7,
    max_tokens=1024
)
print(response.choices[0].message.content)
```

## Transformers de HuggingFace

```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 de 4 bits para GPU de 24GB
)

messages = [
    {"role": "system", "content": "Eres un asistente de programación útil."},
    {"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 es importante en Clore.ai

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

* **La misma calidad que los modelos densos de 70B+** a una fracción del costo de VRAM
* **Cabe en una sola RTX 4090** en modo cuantizado
* **contexto de 10M tokens** — procesa bases de código completas, documentos largos, libros
* **Más barato de alquilar** — una RTX 4090 a $0.14–0.42/h en lugar de un equipo multi-GPU para modelos de 70B

## Consejos para usuarios de Clore.ai

* **Empieza con Scout Q4**: La mejor relación calidad-precio en RTX 4090 — $0.14–0.42/h, cubre el 95% de los casos de uso
* **Usa `--max-model-len` con prudencia**: No configures el contexto más alto de lo que necesitas — reserva VRAM. Empieza en 8192 y aumenta según sea necesario
* **Paralelismo tensorial para Maverick**: Alquila máquinas con 4× RTX 4090 para Maverick; usa `--tensor-parallel-size 4`
* **Se requiere iniciar sesión en HuggingFace**: `huggingface-cli login` — primero debes 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 de la GPU**: `observa nvidia-smi` — los modelos MoE pueden disparar la VRAM en secuencias largas

## Solución de problemas

| Problema                            | Solución                                                                                   |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| `OutOfMemoryError`                  | Reduce `--max-model-len`, usa cuantización Q4 o actualiza la GPU                           |
| La descarga del modelo falla        | 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 iniciarse             | Reduce la longitud del contexto; asegúrate de tener instalado CUDA 11.8+                   |
| Ollama muestra el modelo incorrecto | Ejecuta `ollama list` para verificar; `ollama rm` + `ollama pull` para volver a descargar  |

## Lecturas adicionales

* [Publicación del 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 de vLLM](https://docs.vllm.ai/)
* [Biblioteca de modelos de Ollama](https://ollama.com/library/llama4-scout)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/llama4.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.