{"id":104974,"date":"2026-07-17T19:29:31","date_gmt":"2026-07-17T19:29:31","guid":{"rendered":"https:\/\/youzum.net\/nvidia-ai-releases-nemotron-3-embed-an-open-embedding-collection-whose-8b-checkpoint-ranks-1-on-rteb\/"},"modified":"2026-07-17T19:29:31","modified_gmt":"2026-07-17T19:29:31","slug":"nvidia-ai-releases-nemotron-3-embed-an-open-embedding-collection-whose-8b-checkpoint-ranks-1-on-rteb","status":"publish","type":"post","link":"https:\/\/youzum.net\/fr\/nvidia-ai-releases-nemotron-3-embed-an-open-embedding-collection-whose-8b-checkpoint-ranks-1-on-rteb\/","title":{"rendered":"NVIDIA AI Releases Nemotron 3 Embed: An Open Embedding Collection Whose 8B Checkpoint Ranks #1 on RTEB"},"content":{"rendered":"

Embedding models decide which passages an agent ever sees. NVIDIA released Nemotron 3 Embed model<\/a><\/strong> to work on that layer. It targets production-scale RAG, agentic retrieval, code retrieval, and agent memory.<\/p>\n

What is Nemotron 3 Embed?<\/strong><\/h2>\n

The model collection includes three open checkpoints. Nemotron-3-Embed-8B-BF16<\/code> is the accuracy-first option. Nemotron-3-Embed-1B-BF16<\/code> carries the same design into a smaller footprint. Nemotron-3-Embed-1B-NVFP4<\/code> is the Blackwell-optimized 4-bit path.<\/p>\n

All three are transformer encoders trained with bidirectional attention masking<\/strong>. The final embedding comes from average pooling<\/strong> over token-level representations. Maximum sequence length is 32,768 tokens on every checkpoint.<\/p>\n

Each model was evaluated across 34 languages. All three carry the OpenMDW License Agreement, version 1.1 (OpenMDW-1.1)<\/strong>. Notably, the bases are Mistral models. The 8B is built with Ministral-3-8B-Instruct-2512<\/code>. Both 1B variants use Ministral-3-3B-Instruct-2512<\/code>.<\/p>\n

Performance<\/strong><\/h2>\n

Nemotron-3-Embed-8B-BF16<\/code> ranks #1 overall on RTEB<\/a><\/strong> (as of July 17 2026), the Retrieval Embedding Benchmark. Evaluation covers its 16 public tasks. Every figure below is average NDCG@10, at model sequence length 4096.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
Model<\/th>\nParams<\/th>\nEmb dim<\/th>\nRTEB<\/th>\nViDoRe-V3 text<\/th>\nMMTEB (Retrieval)<\/th>\n<\/tr>\n<\/thead>\n
Nemotron-3-Embed-8B-BF16<\/td>\n~8B<\/td>\n4096<\/td>\n78.46<\/strong><\/td>\n60.60<\/strong><\/td>\n75.45<\/strong><\/td>\n<\/tr>\n
Nemotron-3-Embed-1B-BF16<\/td>\n1.14B<\/td>\n2048<\/td>\n72.38<\/td>\n57.74<\/td>\n71.04<\/td>\n<\/tr>\n
Nemotron-3-Embed-1B-NVFP4<\/td>\n1.14B<\/td>\n2048<\/td>\n72.00<\/td>\n\u2014<\/td>\n\u2014<\/td>\n<\/tr>\n
llama-nemotron-embed-vl-1b-v2<\/td>\n\u2014<\/td>\n\u2014<\/td>\n61.98<\/td>\n52.54<\/td>\n59.71<\/td>\n<\/tr>\n
llama-nemotron-embed-1b-v2<\/td>\n\u2014<\/td>\n\u2014<\/td>\n60.47<\/td>\n52.10<\/td>\n59.58<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Two gaps are worth noting. The 1B gains 10.4 RTEB points over llama-nemotron-embed-vl-1b-v2<\/code>, the prior-generation baseline. Separately, NVFP4 costs 0.38 RTEB points against its BF16 parent, or 99.5% retention.<\/p>\n

How the 1B Model was Built<\/strong>?<\/h2>\n

Those 1B scores come from a compression pipeline, not a smaller training run. The parent was nemotron-3-embed-3b<\/code>, pruned and distilled across two iterative rounds.<\/p>\n

First, the 3B parent was pruned to 2B using NVIDIA ModelOpt mcore_minitron Neural Architecture Search (NAS)<\/strong>. The search covers hidden width, FFN size, attention heads, and depth. It then picks the best candidate from the top-10 Pareto front. A 50k in-domain calibration corpus scored those candidates.<\/p>\n

Next, the 2B model was distilled from the fine-tuned 8B embedding teacher. Distillation combined cosine distance loss (COS)<\/strong> and mean squared error (MSE)<\/strong> loss. The data blend was multilingual and in-domain. Finally, the same procedure repeated to produce the 1.14B checkpoint.<\/p>\n

The NVFP4 Serving Tradeoff<\/strong><\/h2>\n

Compression then continues into the serving format. Quantization hit weights and activations of linear layers only, targeting the NVFP4<\/strong> data type. The research team used nvidia-modelopt v0.45.0<\/code>. Quantization-Aware Distillation (QAD)<\/strong> followed, primarily to recover accuracy on long inputs.<\/p>\n

Calibration used 512 samples: 256 queries and 256 passages from abisee\/cnn_dailymail<\/code>. QAD training used 20k samples.<\/p>\n

The rsesearch team reports NVFP4 on Blackwell delivers up to 2x higher throughput than BF16<\/strong>. It retains 99%+ of BF16 retrieval accuracy<\/strong>. The NVFP4 card also documents dynamic embedding sizes. You can slice the 2048-d vector from the start to 1024 or 512 dimensions. Re-normalize afterward.<\/p>\n

\n

Interactive Explainer: The Five-Stage Retrieval Path<\/strong><\/h2>\n

Before touching code, watch the path run. It animates prefixing, bidirectional encoding, average pooling, L2 normalization, and dot-product scoring. Scores come from each card\u2019s published expected output.<\/p>\n

\n<\/div>\n

\n

Deployment Matrix<\/strong><\/h2>\n<\/p>

As that walkthrough implies, the checkpoints do not share runtime paths.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
Feature<\/th>\n8B-BF16<\/th>\n1B-BF16<\/th>\n1B-NVFP4<\/th>\n<\/tr>\n<\/thead>\n
Transformers \/ Sentence Transformers<\/td>\nYes<\/td>\nYes<\/td>\nNo<\/td>\n<\/tr>\n
vLLM for \/v2\/embed<\/code><\/td>\n0.25.0<\/td>\n0.25.0<\/td>\n0.25.0<\/td>\n<\/tr>\n
Microarchitectures<\/td>\nAmpere, Hopper, Blackwell<\/td>\nAmpere, Hopper, Blackwell<\/td>\nAmpere, Hopper, Lovelace, Blackwell<\/td>\n<\/tr>\n
Test hardware<\/td>\nA100 80GB, H100 80GB<\/td>\nA100 80GB, H100 80GB<\/td>\nGB200, RTX 6000 PRO, A100, H100, L40, L4<\/td>\n<\/tr>\n
Training data<\/td>\n50M+ samples<\/td>\n8.5M+ (distillation)<\/td>\n20k (QAD)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Alongside the checkpoints, NVIDIA research team released an optimized NIM microservice<\/strong> for the 1B model. The Rust-based NIM matches or outperforms the vLLM checkpoint on GB200 and RTX PRO 6000. NVIDIA tested input sequence lengths of 256 and 1024. Separately, NVIDIA NeMo AutoModel<\/strong> recipes cover fine-tuning and distillation.<\/p>\n

Using It in Code<\/strong><\/h2>\n

With those paths in mind, prefixes come first. Queries take query:<\/code> and documents take passage: <\/code>. Embeddings are L2-normalized, so dot product equals cosine similarity.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
# pip install --upgrade \"transformers>=5.2.0\" \"sentence-transformers>=5.4.1\"\nimport torch\nfrom sentence_transformers import SentenceTransformer\n\nQUERIES = [\"How can someone reduce exposure to pollen during allergy season?\"]\nDOCUMENTS = [\"People with pollen allergy can reduce exposure by staying indoors \"\n             \"on dry, windy days, avoiding early-morning outdoor activity, and \"\n             \"going outside after rain when pollen levels are lower.\"]\n\nmodel = SentenceTransformer(\n    \"nvidia\/Nemotron-3-Embed-8B-BF16\",\n    device=\"cuda\",\n    model_kwargs={\"dtype\": torch.bfloat16,\n                  # use \"sdpa\" if FlashAttention-2 is unavailable\n                  \"attn_implementation\": \"flash_attention_2\"},\n    processor_kwargs={\"padding_side\": \"left\"},\n)\nmodel.max_seq_length = 32768\n\nq = model.encode_query(QUERIES, batch_size=1, convert_to_tensor=True)\nd = model.encode_document(DOCUMENTS, batch_size=1, convert_to_tensor=True)\nprint(model.similarity(q, d))  # card's published q[3]\/d[3] score: 0.8008<\/code><\/pre>\n<\/div>\n<\/div>\n
encode_query<\/code> and encode_document<\/code> read the saved prompts. So you never add prefixes by hand. For serving, \/v2\/embed<\/code> applies them from input_type<\/code> instead:<\/p>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
vllm serve nvidia\/Nemotron-3-Embed-1B-NVFP4 \n  --max-model-len 4096 \n  --max-num-batched-tokens 4096 \n  --max-cudagraph-capture-size 4096<\/code><\/pre>\n<\/div>\n<\/div>\n
\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
import numpy as np, requests\n\ndef embed(input_type: str, texts: list[str]) -> np.ndarray:\n    r = requests.post(\n        \"http:\/\/localhost:8000\/v2\/embed\",\n        json={\"model\": \"nvidia\/Nemotron-3-Embed-1B-NVFP4\",\n              \"input_type\": input_type,          # \"query\" or \"document\"\n              \"texts\": texts,\n              \"embedding_types\": [\"float\"],\n              \"truncate\": \"END\"},\n        timeout=120,\n    )\n    r.raise_for_status()\n    return np.array(r.json()[\"embeddings\"][\"float\"], dtype=np.float32)\n\nscores = embed(\"query\", QUERIES) @ embed(\"document\", DOCUMENTS).T<\/code><\/pre>\n<\/div>\n<\/div>\n
Use Cases With Examples<\/strong><\/h2>\n