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

# NVIDIA Nemotron 3 Super (120B MoE)

> **Nemotron 3 Super** ist NVIDIAs Open-Source Mixture-of-Experts-Hybrid-Mamba-Transformer-Modell mit insgesamt 120B / 12B aktiven Parametern, veröffentlicht am 11. März 2026. Speziell entwickelt für komplexe **agentische KI-Systeme** — autonomes Programmieren, Cybersecurity-Triage und langwierige mehrstufige Recherchen. Liefert **5× höheren Durchsatz** im Vergleich zu dichten Modellen vergleichbarer Qualität.

## Warum Nemotron 3 Super auf Clore.ai betreiben?

Die MoE-Architektur von Nemotron 3 Super bedeutet, dass pro Forward Pass nur 12B Parameter aktiv sind — so erhältst du erstklassiges Reasoning zu den Rechenkosten eines mittelgroßen Modells. Auf Clore.ai kannst du eine einzelne RTX 5090 (32 GB) oder ein Paar RTX 4090 mieten und es mit vollständiger INT4/FP4-Quantisierung mit Produktionsgeschwindigkeit betreiben.

**Wichtige Kennzahlen:**

* **120B Parameter insgesamt**, 12B aktiv (Latent MoE)
* **Hybrid-Mamba-Transformer** Architektur (die erste in der Nemotron-Reihe mit MTP-Layern)
* **1M-Token-Kontextfenster**
* Vortrainiert in **NVFP4** — native NVIDIA-FP4-Quantisierung
* **5× Durchsatz** im Vergleich zu vergleichbaren dichten Modellen
* NVIDIA Nemotron Open Model License — offene Gewichte mit kommerzieller Nutzung

## Hardware-Anforderungen

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

| Konfiguration | VRAM              | Clore.ai-Kosten                           | Hinweise                      |
| ------------- | ----------------- | ----------------------------------------- | ----------------------------- |
| FP4 (nativ)   | 1× RTX 5090 32GB  | 0,25–0,77 $/Std.                          | Am schnellsten; natives NVFP4 |
| INT4          | 2× RTX 4090 24 GB | $0.28–0.84/Std.                           | Starke Option                 |
| INT4          | 1× A100 80GB      | [Bare Metal](https://clore.ai/bare-metal) | Volles INT4, einzelne GPU     |
| INT8          | 4× RTX 4090       | $0,56–1,68/Std.                           | Nahezu volle Qualität         |
| BF16 voll     | 4× H100 80 GB     | \~$4,16/h                                 | Training / volle Genauigkeit  |

> **Bestes Preis-Leistungs-Verhältnis auf Clore.ai:** 2× RTX 5090 (verfügbar ab $0,50–1,54/Std.) für BF16-Inferenz in voller Präzision.

## Schnellstart: vLLM + Nemotron 3 Super

```bash
# Ziehe das vLLM-Docker-Image (NVFP4-Unterstützung erfordert 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
```

Für Multi-GPU (2× RTX 4090 in 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 — schnellere MoE-Auslieferung)

Für produktionsrelevanten MoE-Durchsatz liefert SGLangs RadixAttention 2–5× besseren Durchsatz als vLLM bei MoE-Modellen:

```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
```

## Bereitstellung auf Clore.ai: Schritt für Schritt

### 1. GPU mieten

Gehe zu [clore.ai/marketplace](https://clore.ai/marketplace):

* Filter: **RTX 5090** oder **RTX 4090 × 2+**
* Nach Preis sortieren (Spot schlägt On-Demand auf etwa einem Drittel der Server, Median \~13 % Rabatt)
* Minimum: 32 GB VRAM insgesamt (FP4); 48 GB für INT8; 80 GB für BF16

### 2. Container starten

Wähle im Clore.ai-Dashboard **Benutzerdefiniertes Docker** und gib ein:

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

Oder nutze den SSH-Start per Einzeiler:

```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 'Gestartet'"
```

### 3. API testen

```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": "Du bist ein hilfreicher Assistent."},
      {"role": "user", "content": "Schreibe eine Python-Funktion, die GitHub-Issues ausliest und sie nach Schweregrad kategorisiert."}
    ],
    "max_tokens": 2048,
    "temperature": 0.1
  }'
```

## Anwendungsfall für agentische Systeme: Multi-Agent-Coding-Pipeline

Nemotron 3 Super wurde speziell für Multi-Agent-Workflows entwickelt. Hier ist ein minimales Beispiel mit der OpenAI-kompatiblen API:

```python
from openai import OpenAI

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

def planning_agent(task: str) -> str:
    """Hochstufige Zerlegung der Aufgabe."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Du bist eine leitende technische Führungskraft. Zerlege komplexe Aufgaben in konkrete Teilaufgaben mit Akzeptanzkriterien."},
            {"role": "user", "content": f"Zerlege diese Aufgabe: {task}"}
        ],
        max_tokens=1024,
        temperature=0.0
    )
    return response.choices[0].message.content

def coding_agent(subtask: str) -> str:
    """Code-Implementierung."""
    response = client.chat.completions.create(
        model="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
        messages=[
            {"role": "system", "content": "Du bist ein erfahrener Python-Engineer. Schreibe produktionsreifen Code mit Tests."},
            {"role": "user", "content": subtask}
        ],
        max_tokens=2048,
        temperature=0.1
    )
    return response.choices[0].message.content

# Beispiel: autonome Feature-Implementierung
plan = planning_agent("Erstelle eine REST-API für die Benutzerauthentifizierung mit JWT")
print("Plan:", plan)
code = coding_agent(f"Implementiere Schritt 1 aus diesem Plan: {plan}")
print("Code:", code)
```

## Benchmarks (März 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%            |
| Durchsatz (Tok./s) | 1,840            | 410         | 890              |

*Der Durchsatz wurde auf 2× H100 80 GB mit INT4-Quantisierung gemessen.*

## Monitoring- und Produktionstipps

```bash
# GPU-Speicher und Auslastung beobachten
watch -n2 nvidia-smi

# vLLM-Durchsatzstatistiken prüfen
curl http://localhost:8000/metrics 2>/dev/null | grep vllm

# Docker-Logs (live)
docker logs -f nemotron3

# Bei OOM: max_model_len reduzieren oder tensor-parallel-size erhöhen
```

**Empfohlene Einstellungen für den produktiven Einsatz auf Clore.ai:**

* `--max-model-len 32768` für die meisten Workloads (spart VRAM, deckt 95 % der Anfragen ab)
* `--gpu-memory-utilization 0.90` (10 % Puffer für den MoE-Routing-Overhead lassen)
* `--enable-chunked-prefill` für bessere Latenz bei langen Eingaben
* Spot-Aufträge aktivieren, um bei Batch-Workloads 30–40 % Kosten zu sparen

## Kostenvergleich

| Provider                 | Konfiguration | $/Std.   |
| ------------------------ | ------------- | -------- |
| **Clore.ai** (Spot)      | 2× RTX 5090   | \~$5.60  |
| **Clore.ai** (On-Demand) | 2× RTX 5090   | \~$7.00  |
| Azure AI                 | Gehostete API | \~$15–20 |
| NVIDIA API               | Gehostete API | \~$12–18 |

*Self-Hosting auf Clore.ai ist für anhaltende Workloads 2–3× günstiger als eine verwaltete API.*

## Verwandte Leitfäden

* [vLLM Serving](/guides/guides_v2-de/sprachmodelle/vllm.md) — produktionsreifer LLM-Server mit OpenAI-kompatibler API
* [SGLang](/guides/guides_v2-de/sprachmodelle/sglang.md) — schnellerer MoE-Durchsatz mit RadixAttention
* [DeepSeek V4](/guides/guides_v2-de/sprachmodelle/deepseek-v4.md) — kommendes 1T-Parameter-Open-Model
* [CrewAI](/guides/guides_v2-de/ki-plattformen-and-agenten/crewai.md) — baue Multi-Agent-Pipelines mit rollenbasierten Agenten
* [OpenHands](/guides/guides_v2-de/ki-plattformen-and-agenten/openhands.md) — autonome Software-Engineering-Agenten
* [GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — wähle die richtige GPU für deinen Workload

***

*Zuletzt aktualisiert: 16. März 2026 | Modell veröffentlicht: 11. März 2026 | Lizenz: NVIDIA Nemotron Open Model License*


---

# 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-de/sprachmodelle/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.
