> 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/llama33.md).

# Llama 3.3 70B

Ejecuta el modelo Llama 3.3 70B de Meta en GPUs de Clore.ai

{% hint style="info" %}
**¡Hay una versión más reciente disponible!** Publicado por Meta [**Llama 4**](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) en abril de 2025 con arquitectura MoE — Scout (17B activos, cabe en una RTX 4090) ofrece una calidad similar con una fracción de la VRAM. Considera actualizar.
{% endhint %}

El modelo 70B más reciente y eficiente de Meta en GPUs de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## ¿Por qué Llama 3.3?

* **Mejor modelo 70B** - Igual a Llama 3.1 405B en rendimiento a una fracción del coste
* **Multilingüe** - Admite 8 idiomas de forma nativa
* **Contexto de 128K** - Procesamiento de documentos largos
* **Pesos abiertos** - Gratis para uso comercial

## Descripción general del modelo

| Especificaciones       | Valor                             |
| ---------------------- | --------------------------------- |
| Parámetros             | 70B                               |
| Longitud del contexto  | 128K tokens                       |
| Datos de entrenamiento | 15T+ tokens                       |
| Idiomas                | EN, DE, FR, IT, PT, HI, ES, TH    |
| Licencia               | Licencia comunitaria de Llama 3.3 |

### Rendimiento frente a otros modelos

| Benchmark   | Llama 3.3 70B | Llama 3.1 405B | GPT-4o |
| ----------- | ------------- | -------------- | ------ |
| MMLU        | 86.0          | 87.3           | 88.7   |
| HumanEval   | 88.4          | 89.0           | 90.2   |
| MATH        | 77.0          | 73.8           | 76.6   |
| Multilingüe | 91.1          | 91.6           | -      |

## Requisitos de GPU

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

| Configuración   | VRAM  | Rendimiento | Costo                                                    |
| --------------- | ----- | ----------- | -------------------------------------------------------- |
| Cuantizado a Q4 | 40 GB | Bueno       | A100 40GB ([bare metal](https://clore.ai/bare-metal))    |
| Cuantizado a Q8 | 70GB  | Mejor       | A100 80GB ([bare metal](https://clore.ai/bare-metal))    |
| FP16 completo   | 140GB | Mejor       | 2x A100 80GB ([bare metal](https://clore.ai/bare-metal)) |

**Recomendado:** A100 40GB con cuantización Q4 para la mejor relación precio/rendimiento.

## Despliegue rápido en CLORE.AI

### Usando Ollama (lo más fácil)

**Imagen de Docker:**

```
ollama/ollama
```

**Puertos:**

```
22/tcp
11434/http
```

**Después del despliegue:**

```bash
ollama pull llama3.3
ollama run llama3.3
```

### Usando vLLM (producción)

**Imagen de Docker:**

```
vllm/vllm-openai:latest
```

**Puertos:**

```
22/tcp
8000/http
```

**Comando:**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \\
    --tensor-parallel-size 1 \
    --max-model-len 32768 \
    --host 0.0.0.0
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Métodos de instalación

### Método 1: Ollama (recomendado para pruebas)

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

# Descargar Llama 3.3 (descarga automáticamente la versión Q4)
ollama pull llama3.3

# Ejecutar de forma interactiva
ollama run llama3.3

# O servir API
ollama serve
```

**Uso de la API:**

```bash
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.3",
  "prompt": "Explica la computación cuántica en términos simples"
}'
```

### Método 2: vLLM (producción)

```bash
pip install vllm

# GPU única (A100 40GB con cuantización AWQ)
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \\
    --quantization awq \\
    --max-model-len 16384 \
    --host 0.0.0.0

# MultigPU (2x A100 para precisión completa)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \\
    --tensor-parallel-size 2 \\
    --max-model-len 32768 \
    --host 0.0.0.0
```

**Uso de API (compatible con OpenAI):**

```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-3.3-70B-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)
```

### Método 3: Transformers + bitsandbytes

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

# Configuración de cuantización a 4 bits
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model_id = "meta-llama/Llama-3.3-70B-Instruct"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto"
)

# Generar
messages = [
    {"role": "system", "content": "Eres un asistente de programación útil."},
    {"role": "user", "content": "Escribe un web scraper de Python usando BeautifulSoup"}
]

input_ids = tokenizer.apply_chat_template(
    messages,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    input_ids,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Método 4: llama.cpp (híbrido CPU+GPU)

```bash
# Clona y compila
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUDA=1

# Descargar modelo GGUF
wget https://huggingface.co/bartowski/Llama-3.3-70B-Instruct-GGUF/resolve/main/Llama-3.3-70B-Instruct-Q4_K_M.gguf

# Ejecutar servidor
./llama-server \\
    -m Llama-3.3-70B-Instruct-Q4_K_M.gguf \\
    -c 8192 \\
    -ngl 80 \\
    --host 0.0.0.0 \\
    --port 8080
```

## Pruebas comparativas

### Rendimiento (tokens/segundo)

| GPU          | Q4    | Q8    | FP16  |
| ------------ | ----- | ----- | ----- |
| A100 40GB    | 25-30 | -     | -     |
| A100 80GB    | 35-40 | 25-30 | -     |
| 2x A100 80GB | 50-60 | 40-45 | 30-35 |
| H100 80GB    | 60-70 | 45-50 | 35-40 |

### Tiempo hasta el primer token (TTFT)

| GPU          | Q4       | FP16     |
| ------------ | -------- | -------- |
| A100 40GB    | 0.8-1.2s | -        |
| A100 80GB    | 0.6-0.9s | -        |
| 2x A100 80GB | 0.4-0.6s | 0.8-1.0s |

### Longitud de contexto vs VRAM

| Contexto | VRAM Q4 | VRAM Q8 |
| -------- | ------- | ------- |
| 4K       | 38GB    | 72GB    |
| 8K       | 40 GB   | 75GB    |
| 16K      | 44GB    | 80 GB   |
| 32K      | 52GB    | 90GB    |
| 64K      | 68GB    | 110GB   |
| 128K     | 100GB   | 150GB   |

## Casos de uso

### Generación de código

```python
messages = [
    {"role": "system", "content": "Eres un programador experto. Escribe código limpio, eficiente y bien documentado."},
    {"role": "user", "content": "Crea una API REST en FastAPI con autenticación de usuarios usando tokens JWT"}
]
```

### Análisis de documentos (contexto largo)

```python
# Cargar documento largo
with open("large_document.txt") as f:
    document = f.read()

messages = [
    {"role": "system", "content": "Eres un analista de documentos. Proporciona un análisis detallado y preciso."},
    {"role": "user", "content": f"Analiza este documento y proporciona un resumen con los puntos clave:\n\n{document}"}
]
```

### Tareas multilingües

```python
messages = [
    {"role": "system", "content": "Eres un asistente multilingüe."},
    {"role": "user", "content": "Traduce esto al alemán, francés y español: 'El rápido zorro marrón salta sobre el perro perezoso'"}
]
```

### Razonamiento y análisis

```python
messages = [
    {"role": "system", "content": "Piensa paso a paso. Muestra tu razonamiento."},
    {"role": "user", "content": "Un tren sale de la estación A a las 9:00 AM viajando a 60 mph. Otro tren sale de la estación B (a 300 millas de distancia) a las 10:00 AM viajando hacia la estación A a 90 mph. ¿Cuándo y dónde se encuentran?"}
]
```

## Consejos de optimización

### Optimización de memoria

```python
# vLLM con optimización de memoria
python -m vllm.entrypoints.openai.api_server \
    --model casperhansen/llama-3.3-70b-instruct-awq \\
    --quantization awq \\
    --gpu-memory-utilization 0.95 \\
    --max-model-len 8192
```

### Optimización de velocidad

```python
# Habilitar Flash Attention
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-70B-Instruct \\
    --tensor-parallel-size 2 \\
    --enable-prefix-caching
```

### Procesamiento por lotes

```python
# Procesar múltiples solicitudes de forma eficiente
responses = client.chat.completions.create(
    model="meta-llama/Llama-3.3-70B-Instruct",
    messages=messages,
    n=4,  # Generar 4 respuestas
    temperature=0.8
)
```

## Comparación con otros modelos

| Función      | Llama 3.3 70B | Llama 3.1 70B | Qwen 2.5 72B | Mixtral 8x22B |
| ------------ | ------------- | ------------- | ------------ | ------------- |
| MMLU         | 86.0          | 83.6          | 85.3         | 77.8          |
| Programación | 88.4          | 80.5          | 85.4         | 75.5          |
| Matemáticas  | 77.0          | 68.0          | 80.0         | 60.0          |
| Contexto     | 128K          | 128K          | 128K         | 64K           |
| Idiomas      | 8             | 8             | 29           | 8             |
| Licencia     | Abre          | Abre          | Abre         | Abre          |

**Veredicto:** Llama 3.3 70B ofrece el mejor rendimiento general en su clase, especialmente para tareas de programación y razonamiento.

## Solución de problemas

### Sin memoria

```bash
# Usar cuantización AWQ (la más eficiente en memoria)
--model casperhansen/llama-3.3-70b-instruct-awq --quantization awq

# Reduce la longitud de contexto
--max-model-len 8192

# Usar paralelismo de tensores
--tensor-parallel-size 2
```

### Primera respuesta lenta

* La primera solicitud carga el modelo en la GPU: espera 30-60 segundos
* Usa `--enable-prefix-caching` para solicitudes posteriores más rápidas
* Precalentar con una solicitud ficticia

### Acceso a Hugging Face

```bash
# Inicia sesión en HF (requerido para el modelo restringido)
huggingface-cli login

# O establece la variable de entorno
export HUGGING_FACE_HUB_TOKEN=hf_xxxxx
```

## Estimación de costos

| Configuración | GPU            | $/hora  | tokens/$ |
| ------------- | -------------- | ------- | -------- |
| Económico     | A100 40GB (Q4) | \~$0.17 | \~530K   |
| Equilibrado   | A100 80GB (Q4) | \~$0.25 | \~500K   |
| Rendimiento   | 2x A100 80GB   | \~$0.50 | \~360K   |
| Máximo        | H100 80GB      | \~$0.50 | \~500K   |

## Siguientes pasos

* [Guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Despliegue en producción
* [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración local sencilla
* [Configuración multi-GPU](/guides/guides_v2-es/avanzado/multi-gpu-setup.md) - Escalar a modelos más grandes
* [Integración de API](/guides/guides_v2-es/avanzado/api-integration.md) - Crear aplicaciones


---

# 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/llama33.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.