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

# NVIDIA Nemotron 3 Super (MoE 120B)

> **Nemotron 3 Super** est le modèle hybride Mamba-Transformer à mélange d’experts open source de NVIDIA, avec 120B de paramètres au total / 12B actifs, publié le 11 mars 2026. Conçu spécifiquement pour des cas complexes **systèmes d’IA agentiques** — codage autonome, triage en cybersécurité et recherche longue à étapes multiples. Offre **un débit 5× supérieur** par rapport à des modèles denses de qualité comparable.

## Pourquoi exécuter Nemotron 3 Super sur Clore.ai ?

L’architecture MoE de Nemotron 3 Super signifie que seuls 12B de paramètres sont actifs à chaque passage avant — vous obtenez donc un raisonnement de pointe au coût de calcul d’un modèle de taille moyenne. Sur Clore.ai, vous pouvez louer une seule RTX 5090 (32 Go) ou une paire de RTX 4090 et l’exécuter avec une quantification INT4/FP4 complète à des vitesses de production.

**Chiffres clés :**

* **120B de paramètres au total**, 12B actifs (MoE latent)
* **Hybrid Mamba-Transformer** architecture (la première de la gamme Nemotron avec des couches MTP)
* **fenêtre de contexte d’1M de jetons**
* Pré-entraîné en **NVFP4** — quantification FP4 native de NVIDIA
* **débit 5×** par rapport à des modèles denses comparables
* Licence NVIDIA Nemotron Open Model — poids ouverts avec usage commercial

## Configuration matérielle requise

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| Configuration | VRAM              | Coût Clore.ai                             | Remarques                      |
| ------------- | ----------------- | ----------------------------------------- | ------------------------------ |
| FP4 (natif)   | 1× RTX 5090 32 Go | 0,25–0,77 $/h                             | La plus rapide ; NVFP4 natif   |
| INT4          | 2× RTX 4090 24 Go | 0,28–0,84 $/h                             | Bonne option                   |
| INT4          | 1× A100 80 Go     | [bare metal](https://clore.ai/bare-metal) | INT4 complet, GPU unique       |
| INT8          | 4× RTX 4090       | 0,56–1,68 $/h                             | Qualité quasi intégrale        |
| BF16 complet  | 4× H100 80 Go     | \~4,16 $/h                                | Entraînement / fidélité totale |

> **Meilleur rapport qualité-prix sur Clore.ai :** 2× RTX 5090 (disponibles à partir de 0,50–1,54 $/h) pour l’inférence BF16 en pleine précision.

## Démarrage rapide : vLLM + Nemotron 3 Super

```bash
# Récupérer l’image Docker vLLM (la prise en charge NVFP4 nécessite 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
```

Pour 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 (alternative — service MoE plus rapide)

Pour un débit MoE de niveau production, RadixAttention de SGLang offre un débit 2 à 5× meilleur que vLLM sur les modèles 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
```

## Déployer sur Clore.ai : étape par étape

### 1. Louer un GPU

Accédez à [clore.ai/marketplace](https://clore.ai/marketplace):

* Filtre : **RTX 5090** ou **RTX 4090 × 2+**
* Trier par prix (le spot est moins cher que l’on-demand sur environ un tiers des serveurs, réduction médiane d’environ 13 %)
* Minimum : 32 Go de VRAM au total (FP4) ; 48 Go pour INT8 ; 80 Go pour BF16

### 2. Lancer le conteneur

Dans le tableau de bord Clore.ai, sélectionnez **Docker personnalisé** et saisissez :

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

Ou utilisez le lancement SSH en une ligne :

```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 'Démarré'"
```

### 3. Tester l’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": "Vous êtes un assistant utile."},
      {"role": "user", "content": "Écrivez une fonction Python pour extraire les issues GitHub et les classer par gravité."}
    ],
    "max_tokens": 2048,
    "temperature": 0.1
  }'
```

## Cas d’usage agentique : pipeline de codage multi-agents

Nemotron 3 Super est spécialement conçu pour les flux de travail multi-agents. Voici un exemple minimal utilisant l’API compatible OpenAI :

```python
from openai import OpenAI

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

def planning_agent(task: str) -> str:
    """Décomposition de tâche de haut niveau."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Vous êtes un responsable d'ingénierie senior. Décomposez les tâches complexes en sous-tâches concrètes avec des critères d'acceptation."},
            {"role": "user", "content": f"Décomposez cette tâche : {task}"}
        ],
        max_tokens=1024,
        temperature=0.0
    )
    return response.choices[0].message.content

def coding_agent(subtask: str) -> str:
    """Implémentation du code."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Vous êtes un ingénieur Python expert. Rédigez du code de qualité production avec des tests."},
            {"role": "user", "content": subtask}
        ],
        max_tokens=2048,
        temperature=0.1
    )
    return response.choices[0].message.content

# Exemple : implémentation autonome d’une fonctionnalité
plan = planning_agent("Construisez une API REST pour l'authentification des utilisateurs avec JWT")
print("Plan:", plan)
code = coding_agent(f"Implémentez l'étape 1 de ce plan : {plan}")
print("Code:", code)
```

## Benchmarks (mars 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%            |
| Débit (tok/s)      | 1,840            | 410         | 890              |

*Débit mesuré sur 2× H100 80 Go avec quantification INT4.*

## Conseils de supervision et de production

```bash
# Surveiller la mémoire et l'utilisation du GPU
watch -n2 nvidia-smi

# Vérifier les statistiques de débit de vLLM
curl http://localhost:8000/metrics 2>/dev/null | grep vllm

# Journaux Docker (en direct)
docker logs -f nemotron3

# Si OOM : réduire max_model_len ou augmenter tensor-parallel-size
```

**Paramètres recommandés pour la production sur Clore.ai :**

* `--max-model-len 32768` pour la plupart des charges de travail (économise de la VRAM, couvre 95 % des requêtes)
* `--gpu-memory-utilization 0.90` (laissez une marge de 10 % pour la surcharge de routage MoE)
* `--enable-chunked-prefill` pour une meilleure latence sur les entrées longues
* Activer les ordres spot pour économiser 30 à 40 % sur les charges de travail par lots

## Comparaison des coûts

| Fournisseur                 | Configuration | $/h       |
| --------------------------- | ------------- | --------- |
| **Clore.ai** (spot)         | 2× RTX 5090   | \~$5.60   |
| **Clore.ai** (à la demande) | 2× RTX 5090   | \~$7.00   |
| Azure AI                    | API hébergée  | \~15–20 $ |
| API NVIDIA                  | API hébergée  | \~12–18 $ |

*L’auto-hébergement sur Clore.ai est 2 à 3× moins cher qu’une API gérée pour les charges de travail continues.*

## Guides associés

* [Service vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — serveur LLM de production avec API compatible OpenAI
* [SGLang](/guides/guides_v2-fr/modeles-de-langage/sglang.md) — débit MoE plus rapide avec RadixAttention
* [DeepSeek V4](/guides/guides_v2-fr/modeles-de-langage/deepseek-v4.md) — futur modèle ouvert à 1T de paramètres
* [CrewAI](/guides/guides_v2-fr/plateformes-ia-et-agents/crewai.md) — créez des pipelines multi-agents avec des agents basés sur les rôles
* [OpenHands](/guides/guides_v2-fr/plateformes-ia-et-agents/openhands.md) — agents autonomes d’ingénierie logicielle
* [Comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — choisissez le bon GPU pour votre charge de travail

***

*Dernière mise à jour : 16 mars 2026 | Modèle publié : 11 mars 2026 | Licence : Licence NVIDIA Nemotron Open Model*


---

# 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-fr/modeles-de-langage/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.
