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

# NVIDIA Nemotron 3 Super (120B MoE)

> **Nemotron 3 Super** es el modelo híbrido Mamba-Transformer de Mezcla de Expertos de código abierto de NVIDIA con 120B totales / 12B activos, lanzado el 11 de marzo de 2026. Diseñado específicamente para complejos **sistemas de IA agéntica** — codificación autónoma, triaje de ciberseguridad e investigación de varios pasos y de larga duración. 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 hay 12B parámetros activos por pasada hacia adelante — así obtienes razonamiento de vanguardia a un costo computacional propio 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.

**Números clave:**

* **120B parámetros totales**, 12B activos (MoE latente)
* **híbrida 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

{% 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             | Coste de Clore.ai                         | Notas                              |
| ------------- | ---------------- | ----------------------------------------- | ---------------------------------- |
| FP4 (nativa)  | 1× RTX 5090 32GB | $0.25–0.77/h                              | La más rápida; NVFP4 nativa        |
| INT4          | 2× RTX 4090 24GB | $0.28–0.84/h                              | Buena opción                       |
| INT4          | 1× A100 80GB     | [bare metal](https://clore.ai/bare-metal) | INT4 completo, GPU única           |
| INT8          | 4× RTX 4090      | $0.56–1.68/h                              | Calidad casi completa              |
| BF16 completo | 4× H100 80GB     | \~4,16 $/h                                | Entrenamiento / fidelidad completa |

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

## 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 multi-GPU (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 de producción, RadixAttention de SGLang ofrece entre 2 y 5× mejor rendimiento 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
```

## Despliegue en Clore.ai: paso a paso

### 1. Alquila una GPU

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

* Filtro: **RTX 5090** o **RTX 4090 × 2+**
* Ordena por precio (el spot supera al bajo demanda en aproximadamente un tercio de los servidores, mediana \~13% de descuento)
* 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 por 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 'Iniciado'\"
```

### 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": "Eres un asistente útil."},
      {"role": "user", "content": "Escribe una función de Python para rastrear issues de GitHub y clasificarlos por gravedad."}
    ],
    "max_tokens": 2048,
    "temperature": 0.1
  }'
```

## Caso de uso de IA agéntica: 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 sénior. Desglosa tareas complejas en subtareas concretas con criterios de aceptación."},
            {"role": "user", "content": f"Desglosa 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("Código:", 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 verificado | 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 monitorización y producción

```bash
# Vigila la memoria y 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
```

**Configuraciones recomendadas 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 margen del 10% para la sobrecarga de enrutamiento de MoE)
* `--enable-chunked-prefill` para una mejor latencia en entradas largas
* Activa órdenes spot para ahorrar entre un 30 y un 40% en cargas 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 |

*Alojarlo por tu cuenta en Clore.ai es entre 2 y 3× más barato que una API gestionada para cargas sostenidas.*

## Guías relacionadas

* [Servicio vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — servidor de 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: Licencia de modelo abierto NVIDIA Nemotron*


---

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