# NVIDIA Nemotron 3 Super (120B MoE)

> **Nemotron 3 Super** es el modelo Mixture-of-Experts Hybrid Mamba-Transformer de código abierto de NVIDIA, con 120B en total / 12B activos, lanzado el 11 de marzo de 2026. Diseñado específicamente para **sistemas de IA agéntica** — codificación autónoma, triaje de ciberseguridad e investigación extensa de múltiples pasos. Ofrece **5× mayor rendimiento** frente a modelos densos de calidad comparable.

## ¿Por qué ejecutar Nemotron 3 Super en Clore.ai?

La arquitectura MoE de Nemotron 3 Super significa que solo 12B parámetros están activos por cada pasada hacia delante — así que obtienes razonamiento de nivel frontera al coste de cómputo de un modelo de tamaño medio. En Clore.ai puedes alquilar una sola RTX 5090 (32GB) o un par de RTX 4090 y ejecutarlo con cuantización INT4/FP4 completa a velocidades de producción.

**Cifras clave:**

* **120B parámetros totales**, 12B activos (Latent MoE)
* **Hybrid Mamba-Transformer** arquitectura (primera en la línea Nemotron con capas MTP)
* **ventana de contexto de 1M tokens**
* Preentrenado en **NVFP4** — cuantización FP4 nativa de NVIDIA
* **5× rendimiento** frente a modelos densos comparables
* Licencia de modelo abierto NVIDIA Nemotron — pesos abiertos con uso comercial

## Requisitos de hardware

| Configuración | VRAM             | Coste en Clore.ai | Notas                              |
| ------------- | ---------------- | ----------------- | ---------------------------------- |
| FP4 (nativo)  | 1× RTX 5090 32GB | \~$3.50–5/h       | Más rápido; NVFP4 nativo           |
| INT4          | 2× RTX 4090 24GB | \~$4–6/h          | Buena opción                       |
| INT4          | 1× A100 80GB     | \~$20/h           | INT4 completo, GPU única           |
| INT8          | 4× RTX 4090      | \~$8–12/h         | Calidad casi completa              |
| BF16 completo | 4× H100 80GB     | \~$24–40/h        | Entrenamiento / fidelidad completa |

> **Mejor relación calidad-precio en Clore.ai:** 2× RTX 5090 (disponibles desde \~$7/h) para inferencia en precisión completa BF16.

## Inicio rápido: vLLM + Nemotron 3 Super

```bash
# Descarga la imagen Docker de vLLM (el soporte NVFP4 requiere vLLM >= 0.7.3)
docker run --gpus all --rm -it \
  -p 8000:8000 \
  -v /root/.cache:/root/.cache \
  vllm/vllm-openai:v0.7.3 \
  --model nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 \
  --quantization fp4 \
  --max-model-len 32768 \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.92
```

Para varios GPUs (2× RTX 4090 en INT4):

```bash
docker run --gpus all --rm -it \
  -p 8000:8000 \
  -v /root/.cache:/root/.cache \
  vllm/vllm-openai:v0.7.3 \
  --model nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 \
  --quantization awq_marlin \
  --max-model-len 65536 \
  --tensor-parallel-size 2 \
  --gpu-memory-utilization 0.90
```

## SGLang (alternativa — servicio MoE más rápido)

Para un rendimiento MoE de nivel producción, RadixAttention de SGLang ofrece un rendimiento 2–5× mejor que vLLM en modelos MoE:

```bash
docker run --gpus all --rm -it \
  -p 30000:30000 \
  -v /root/.cache:/root/.cache \
  lmsysorg/sglang:latest \
  python -m sglang.launch_server \
    --model nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 \
    --tp 2 \
    --quantization fp8 \
    --context-length 131072 \
    --port 30000
```

## Implementación en Clore.ai: paso a paso

### 1. Alquila una GPU

Ve a [clore.ai/marketplace](https://clore.ai/marketplace):

* Filtrar: **RTX 5090** o **RTX 4090 × 2+**
* Ordenar por precio (los pedidos spot son un 20–40% más baratos)
* Mínimo: 32GB de VRAM total (FP4); 48GB para INT8; 80GB para BF16

### 2. Inicia el contenedor

En el panel de Clore.ai, selecciona **Docker personalizado** e introduce:

```
Imagen: vllm/vllm-openai:v0.7.3
Puertos: 8000
Comando: --model nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 --quantization fp4 --max-model-len 32768
```

O usa el inicio SSH en una sola línea:

```bash
ssh root@<clore-server-ip> "docker run --gpus all -d \
  -p 8000:8000 \
  -v /root/.cache:/root/.cache \
  --name nemotron3 \
  vllm/vllm-openai:v0.7.3 \
  --model nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16 \
  --quantization fp4 \
  --max-model-len 32768 && echo 'Started'"
```

### 3. Prueba la API

```bash
curl http://<server-ip>:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Escribe una función en Python para extraer incidencias de GitHub y categorizarlas por gravedad."}
    ],
    "max_tokens": 2048,
    "temperature": 0.1
  }'
```

## Caso de uso agéntico: canalización de codificación multiagente

Nemotron 3 Super está diseñado específicamente para flujos de trabajo multiagente. Aquí tienes un ejemplo mínimo usando la API compatible con OpenAI:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://<server-ip>:8000/v1",
    api_key="none"
)

def planning_agent(task: str) -> str:
    """Descomposición de tareas de alto nivel."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Eres un líder de ingeniería senior. Descompón tareas complejas en subtareas concretas con criterios de aceptación."},
            {"role": "user", "content": f"Descompón esta tarea: {task}"}
        ],
        max_tokens=1024,
        temperature=0.0
    )
    return response.choices[0].message.content

def coding_agent(subtask: str) -> str:
    """Implementación de código."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Eres un ingeniero Python experto. Escribe código de calidad de producción con pruebas."},
            {"role": "user", "content": subtask}
        ],
        max_tokens=2048,
        temperature=0.1
    )
    return response.choices[0].message.content

# Ejemplo: implementación autónoma de una funcionalidad
plan = planning_agent("Construye una API REST para autenticación de usuarios con JWT")
print("Plan:", plan)
code = coding_agent(f"Implementa el paso 1 de este plan: {plan}")
print("Code:", code)
```

## Benchmarks (marzo de 2026)

| Benchmark           | Nemotron 3 Super | DeepSeek V3 | Llama 4 Maverick |
| ------------------- | ---------------- | ----------- | ---------------- |
| HumanEval           | 92.1%            | 90.8%       | 88.4%            |
| MATH-500            | 89.3%            | 90.2%       | 84.7%            |
| SWE-bench Verified  | 65.2%            | 61.4%       | 55.8%            |
| MMLU                | 88.7%            | 87.2%       | 86.1%            |
| Rendimiento (tok/s) | 1,840            | 410         | 890              |

*Rendimiento medido en 2× H100 80GB con cuantización INT4.*

## Consejos de supervisión y producción

```bash
# Observa la memoria y la utilización de la GPU
watch -n2 nvidia-smi

# Comprueba las estadísticas de rendimiento de vLLM
curl http://localhost:8000/metrics 2>/dev/null | grep vllm

# Registros de Docker (en vivo)
docker logs -f nemotron3

# Si hay OOM: reduce max_model_len o aumenta tensor-parallel-size
```

**Configuración recomendada para producción en Clore.ai:**

* `--max-model-len 32768` para la mayoría de las cargas de trabajo (ahorra VRAM, cubre el 95% de las solicitudes)
* `--gpu-memory-utilization 0.90` (deja un búfer del 10% para la sobrecarga de enrutamiento MoE)
* `--enable-chunked-prefill` para mejor latencia en entradas largas
* Activa los pedidos spot para ahorrar un 30–40% en cargas de trabajo por lotes

## Comparación de costos

| Proveedor                   | Configuración | $/h      |
| --------------------------- | ------------- | -------- |
| **Clore.ai** (spot)         | 2× RTX 5090   | \~$5.60  |
| **Clore.ai** (bajo demanda) | 2× RTX 5090   | \~$7.00  |
| Azure AI                    | API alojada   | \~$15–20 |
| API de NVIDIA               | API alojada   | \~$12–18 |

*Autoalojar en Clore.ai es 2–3× más barato que una API gestionada para cargas de trabajo sostenidas.*

## Guías relacionadas

* [Servicio vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — servidor LLM de producción con API compatible con OpenAI
* [SGLang](/guides/guides_v2-es/modelos-de-lenguaje/sglang.md) — mayor rendimiento MoE con RadixAttention
* [DeepSeek V4](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v4.md) — próximo modelo abierto de 1T parámetros
* [CrewAI](/guides/guides_v2-es/plataformas-y-agentes-de-ia/crewai.md) — crea canalizaciones multiagente con agentes basados en roles
* [OpenHands](/guides/guides_v2-es/plataformas-y-agentes-de-ia/openhands.md) — agentes autónomos de ingeniería de software
* [Comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — elige la GPU adecuada para tu carga de trabajo

***

*Última actualización: 16 de marzo de 2026 | Modelo lanzado: 11 de marzo de 2026 | Licencia: NVIDIA Nemotron Open Model License*


---

# 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/nvidia-nemotron-3-super.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.