![\"Granite](\"https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/LrZQDi73p2iIqRJTd25f7.png\" "\\"Granite")
\n\nTL;DR: Two new Apache 2.0 multilingual embedding models built on ModernBERT — a 97M-parameter compact model that beats every open sub-100M multilingual embedder on MTEB Multilingual Retrieval (60.3), and a 311M full-size model that scores 65.2 on MTEB Multilingual Retrieval (#2 among open models under 500M parameters) with Matryoshka support. Both cover 200+ languages, are tuned on 52 languages, handle 32K-token context (64x R1), and add code retrieval across 9 programming languages.
\n
In this post: Enterprise-Ready by Design · A Strong Sub-100M Multilingual Model · What Changed from R1 · Training the Full-Size 311M Model · Building the compact 97M Multilingual Model · Benchmark Results · Matryoshka Embeddings · Deployment Options · For Framework Integrators · Which Model Should You Use? · Try The Models
\nMultilingual embedding models face a persistent tension: broad language coverage usually comes at the cost of model size, and small models usually sacrifice languages. If you work across languages — retrieval-augmented generation over multilingual corpora, cross-lingual search, code retrieval in international teams — you've likely had to choose between a model that's fast enough and one that's good enough.
\nThe Granite Embedding Multilingual R2 release narrows that gap considerably. We're releasing two new multilingual embedding models:
\nBoth models support 200+ languages with enhanced retrieval quality for 52 languages and programming code, handle context lengths up to 32,768 tokens (a 64x increase over their R1 predecessors), and are released under the Apache 2.0 license. They work out of the box with sentence-transformers and transformers, require no task-specific instructions, and are compatible as drop-in replacements in LangChain, LlamaIndex, Haystack, and Milvus with a one-line model name change. For frameworks currently using an English-only default, that one line gives every user in your community support for 200+ languages — no API changes, no new dependencies, no code changes required on their end. Both models ship with ONNX and OpenVINO weights for CPU-optimized inference.
52 enhanced-support languages (click to expand)
\nThe underlying encoder was pretrained on text from 200+ languages, producing general-purpose embeddings for any of them. The following 52 languages receive explicit retrieval-pair and cross-lingual training for higher-quality retrieval:
\nAlbanian (sq), Arabic (ar), Azerbaijani (az), Bengali (bn), Bulgarian (bg), Catalan (ca), Chinese (zh), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (en), Estonian (et), Finnish (fi), French (fr), Georgian (ka), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Icelandic (is), Indonesian (id), Italian (it), Japanese (ja), Kazakh (kk), Khmer (km), Korean (ko), Latvian (lv), Lithuanian (lt), Malay (ms), Marathi (mr), Norwegian (no), Persian (fa), Polish (pl), Portuguese (pt), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es), Swahili (sw), Swedish (sv), Tagalog (tl), Telugu (te), Thai (th), Turkish (tr), Ukrainian (uk), Urdu (ur), Uzbek (uz), Vietnamese (vi).
\nAdditionally, the models are trained on programming code (Python, Go, Java, JavaScript, PHP, Ruby, SQL, C, C++) and support cross-lingual code retrieval.
\nBoth embedding models are trained on a mixture of IBM‑curated datasets, publicly available data, and internally generated or synthetic data. Public web‑derived data used in training is selected and filtered using IBM‑developed quality, deduplication, and governance processes intended to reduce risk in downstream commercial use. We intentionally avoid the use of the MS‑MARCO training dataset and datasets with explicit non‑commercial licensing restrictions. The models are pretrained using GneissWeb, an IBM‑curated dataset derived from publicly available web content and processed using IBM’s data preparation and governance tooling—along with additional IBM‑curated and other publicly available sources. Datasets undergo IBM governance review to assess licensing considerations, ownership signals, and personal data risks. These processes are designed to contribute to responsible use and enterprise deployment.
\nThe standout of this release is granite-embedding-97m-multilingual-r2. At 97 million parameters, it scores 60.3 on Multilingual MTEB Retrieval across 18 languages — the highest retrieval score we've found for any open multilingual embedding model under 100M parameters. The next-best model in that size class, multilingual-e5-small, scores 50.9 on the same benchmark — a +9.4 point gap on a mature benchmark.
\nAt roughly one-third the size of the 311M full-size model, it retains the majority of its retrieval quality across multilingual, code, and long-document benchmarks — a +12.2 point gain on MTEB Multilingual Retrieval over its direct predecessor, driven by a new architecture, better training data, and a novel pruning methodology (more on that below). The full-size granite-embedding-311m-multilingual-r2 scores 65.2 on the same benchmark, a +13.0 point gain over its R1 predecessor.
\nThe Granite Embedding Multilingual R1 models were built on XLM-RoBERTa encoders with a 512-token context window. The R2 generation is a ground-up rebuild:
\n![\"Granite](\"https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/jhz201_Ud5zUWfA3k4ITA.png\")
ModernBERT is a recent encoder architecture that revisits the original BERT design with techniques from the last five years of transformer research. The shift brings several practical benefits: alternating attention lengths reduce computation on long sequences (improves throughput on long sequences significantly), rotary position embeddings allow the 32K context window without the positional interpolation hacks that plague older architectures, and Flash Attention 2.0 support speeds up encoding on modern GPUs.
\nThe new multilingual tokenizers are worth highlighting. Rather than reusing XLM-RoBERTa's 250K-token vocabulary, we adopted existing tokenizers with strong multilingual and code coverage. The 311M model uses the Gemma 3 tokenizer (262K tokens); the 97M model starts from the GPT-OSS tokenizer and prunes it down to a compact 180K-token vocabulary that preserves broad multilingual coverage while reducing the embedding table's parameter footprint. Tokenizer efficiency matters more than people realize — a 32K-token window sounds impressive until your tokenizer burns half of it encoding a single paragraph of Thai.
\nThe 311M model is a 22-layer ModernBERT encoder with a 262K-token multilingual vocabulary, trained through a multi-stage pipeline:
\nThe result is a model that scores 65.2 on MTEB Multilingual Retrieval and 56.3 on the overall average — a +14.5 point average gain over its R1 predecessor.
\nThe 97M model is trained through a combination of vocabulary selection and knowledge distillation:
\nThis approach transfers retrieval-specific knowledge from multiple strong teachers, while reducing the model parameters without sacrificing language coverage. The result is a highly efficient compact model — scoring 60.3 on MTEB Multilingual Retrieval vs. 65.2 for the full-size model, while being approximately 3x smaller.
\nPerformance across the main benchmark suite sorted by model size. Scores are averages across tasks within each benchmark (higher is better):
\n| Model | \nParams | \nActive Params | \nEmbed Dim | \nMTEB Multilingual Retrieval (18) | \nCode (12) | \nEnglish Retrieval (10) | \nLongEmbed (6) | \nRaR-b (17) | \n
|---|---|---|---|---|---|---|---|---|
| F2LLM-v2-80M | \n80M | \n32M | \n320 | \n50.1 | \n68.0 | \n47.5 | \n31.7 | \n17.9 | \n
| multilingual-e5-small | \n118M | \n22M | \n384 | \n50.9 | \n53.5 | \n46.5 | \n38.8 | \n20.3 | \n
| granite-embedding-107m-multilingual (R1) | \n107M | \n11M | \n384 | \n48.1 | \n40.7 | \n47.9 | \n34.3 | \n17.1 | \n
| paraphrase-multilingual-MiniLM-L12-v2 | \n118M | \n22M | \n384 | \n36.6 | \n23.5 | \n35.9 | \n20.9 | \n10.9 | \n
| jina-embeddings-v5-text-nano | \n212M | \n113M | \n768 | \n63.3 | \n71.2 | \n58.8 | \n63.6 | \n25.2 | \n
| harrier-oss-v1-270m | \n268M | \n100M | \n640 | \n66.4 | \n62.4 | \n52.1 | \n64.9 | \n32.9 | \n
| multilingual-e5-base | \n278M | \n86M | \n768 | \n52.7 | \n52.6 | \n49.0 | \n40.5 | \n23.4 | \n
| granite-embedding-278m-multilingual (R1) | \n278M | \n86M | \n768 | \n52.2 | \n48.5 | \n51.5 | \n37.7 | \n18.9 | \n
| embeddinggemma-300m | \n308M | \n106M | \n768 | \n62.5 | \n68.7 | \n54.6 | \n55.4 | \n26.1 | \n
| gte-multilingual-base | \n305M | \n113M | \n768 | \n57.2 | \n57.5 | \n50.8 | \n62.1 | \n19.0 | \n
| snowflake-arctic-embed-m-v2.0 | \n305M | \n113M | \n768 | \n54.8 | \n55.2 | \n58.4 | \n55.4 | \n23.3 | \n
| multilingual-e5-large | \n560M | \n304M | \n1024 | \n53.7 | \n55.8 | \n51.5 | \n40.4 | \n25.4 | \n
| text-embedding-3-small (OpenAI, API only) | \n— | \n— | \n1536 | \n50.7 | \n— | \n53.8 | \n53.6 | \n23.2 | \n
| \n | \n | \n | \n | \n | \n | \n | \n | \n |
| granite-embedding-97m-multilingual-r2 | \n97M | \n28M | \n384 | \n60.3 | \n60.4 | \n50.1 | \n65.6 | \n24.9 | \n
| granite-embedding-311m-multilingual-r2 | \n311M | \n110M | \n768 | \n65.2 (#2) | \n63.8 (#3) | \n52.6 (#5) | \n71.7 (#1) | \n28.0 (#2) | \n
A few things stand out:
\nparaphrase-multilingual-MiniLM-L12-v2 — a widely-used framework default — scores 36.6, a full +23.7 points behind the 97M R2 model, which is also slightly smaller (97M vs 110M parameters) with the same 384-dimensional output.Encoding speed matters for production workloads, especially when you're indexing millions of documents or need low-latency query encoding. We measured latency and throughput on a single NVIDIA H100 GPU using 512-token chunks:
\n![\"Speed](\"https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/1ltJtX2knfzUA5BekMQsh.png\" "\\"Speed")
The 97M model encodes over 2,500 documents per second — comparable throughput to multilingual-e5-small — while delivering substantially higher retrieval quality. The 311M model, at ~1,800 docs/sec, performs better than jina-embeddings-v5-text-nano on retrieval quality (65.2 vs. 63.3) at over 5.5x the encoding speed (note: speed numbers are computed with the latest transformer code, which had a speed regression vs the last 4.57 version - for both the Jina and granite models - see our technical report for details). harrier-oss-v1-270m offers the best combination of speed and retrieval score among the competitors listed here.
\nThe 311M model supports Matryoshka Representation Learning, which lets you truncate embeddings from the full 768 dimensions down to 512, 384, 256, or 128 with graceful quality degradation. This is useful when storage, memory, or similarity-computation cost is a concern — a 256-dimensional embedding takes one-third the storage of a 768-dimensional one, and cosine similarity is proportionally cheaper to compute.
\nHere's how retrieval quality holds up across embedding dimensions:
\n![\"Matryoshka](\"https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/myYhY1YHLY9Vs3l0gyMJB.png\" "\\"Performance")
The quality loss from dimension reduction is remarkably small. Cutting from 768 to 256 dimensions — a 3x reduction in storage and similarity-computation cost — drops MTEB Multilingual Retrieval by just 0.5 points (65.2 → 64.7) and Code Retrieval by 0.5 points (63.9 → 63.4). Even at 128 dimensions (a 6x reduction), the model still scores 63.7 on MTEB Multilingual Retrieval and 62.3 on Code — retaining over 97% of its full-dimension performance. In practice, this means you can substantially reduce your index size and search latency with minimal impact on result quality. (Note,results in the above picture were evaluated with a context length of 1024 for English and Multilingual Retrieval, and 8192 for Code).
\nFor comparison, the 311M model truncated to 384 dimensions (the same dimensionality as the 97M model's native output) still outperforms the 97M model across all three benchmarks. If you need 384-dimensional embeddings and can afford the 311M model's encoding cost, Matryoshka truncation is the stronger option.
\n\n\n = \n\n# Full 768-dimensional embeddings\n = \n # (1, 768)\n\n# Truncated to 384 dimensions\n = \n # (1, 384)\nThe 97M model does not support Matryoshka — 384 dimensions is already compact.
\nAverage performance on cross-lingual tasks within MTEB Retrieval. Belebele measures cross-lingual passage matching across 122 languages; MLQA measures extractive cross-lingual question answering retrieval across 7 languages.
\n| Model | \nBelebele Retrieval | \nMLQA Retrieval | \n
|---|---|---|
| granite-embedding-107m-multilingual (R1) | \n55.1 | \n60.5 | \n
| granite-embedding-278m-multilingual (R1) | \n62.2 | \n63.0 | \n
| granite-embedding-97m-multilingual-r2 | \n52.9 | \n60.5 | \n
| granite-embedding-311m-multilingual-r2 | \n66.5 | \n67.1 | \n
The 311M R2 model gains +4.3 on Belebele and +4.1 on MLQA over its R1 predecessor, showing improved cross-lingual transfer at the larger scale across both benchmarks.
\nThe 97M R2 model scores lower on Belebele (52.9 vs 55.1, −2.2) while matching its R1 predecessor on MLQA (60.5). The Belebele gap is a tradeoff inherent in the pruning and vocabulary reduction process — the R2 model's training prioritized the broader 18-language MTEB Multilingual Retrieval set (where it gains +12.2 over R1) and long-document retrieval (+31.3), while the smaller vocabulary (180K vs. 250K tokens) and reduced layer count (12 vs. 22) affect narrow cross-lingual transfer tasks. If cross-lingual transfer across many language pairs is your primary use case, the full-size 311M model is the better choice.
\nBoth models ship with multiple deployment paths for production use. Install the core library with:
\n\nSentence Transformers (recommended for most users):
\n\n\n = \n\n = \n\n = \n\n = \n = \n\n# Each query scores highest against its matching passage — across languages\nLangChain (pip install langchain-huggingface):
\n\n = \n\n = \n = \n# Drop-in replacement anywhere LangChain accepts an Embeddings object\nLlamaIndex (pip install llama-index-embeddings-huggingface):
\n\n\n = \n = # applies globally to any index or pipeline\nHaystack (pip install sentence-transformers haystack-ai)
\n\n\n\n\n = \n = \n\n\n\n# Embed and index documents\n = \n = \n\n\n# Embed query and retrieve\n = \n = \n = \n\n \n# 0.961 Mount Fuji is Japan's highest peak.\n# 0.913 富士山は日本最高峰の独立峰です。\nMilvus (pip install pymilvus sentence-transformers)
\n\n\n = \n\n# Use "./milvus.db" for local persistence or a server URI for production\n = \n\n\n = \n = \n\n\n = \n = \n\n \n# 0.961 Mount Fuji is Japan's highest peak.\n# 0.913 富士山は日本最高峰の独立峰です。\nBoth models also ship with pre-converted ONNX and OpenVINO weights for optimized CPU/accelerator inference, work as embedding endpoints via vLLM (vllm serve ... --task embed), and can be converted to GGUF for Ollama using llama.cpp. See the model cards for full deployment examples.
If you maintain an embedding framework, vector store, or RAG pipeline library and are evaluating these models as a default, here's what you need to know:
\nall-MiniLM-L6-v2 at the API level. Existing code that calls .encode() works unchanged.paraphrase-multilingual-MiniLM-L12-v2 (471 MB), the most common multilingual default. The quantized ONNX weights are just 98 MB, comparable to all-MiniLM-L6-v2 (91 MB) while covering 200+ languages.ibm-granite/granite-embedding-97m-multilingual-r2 on Hugging Face, maintained by IBM under the Granite model family.To discuss adopting these models as a default in your project, open an issue at ibm-granite/granite-embedding-models.
\nThese two multilingual models are part of the broader Granite Embedding R2 family, which also includes two high-performing English-focused models: granite-embedding-english-r2 (149M parameters) and granite-embedding-small-english-r2 (47M parameters). If your data is predominantly English, the English models offer higher retrieval quality on English benchmarks at a smaller footprint, since they don't need to allocate capacity across 200+ languages.
\n| If you need... | \nUse | \n
|---|---|
| Best multilingual retrieval quality | \ngranite-embedding-311m-multilingual-r2 | \n
| Flexible embedding dimensions (storage/speed tradeoff) | \ngranite-embedding-311m-multilingual-r2 (Matryoshka) | \n
| Maximum throughput / edge deployment / low latency | \ngranite-embedding-97m-multilingual-r2 | \n
| Best cross-lingual transfer across many language pairs | \ngranite-embedding-311m-multilingual-r2 | \n
| Predominantly English data | \ngranite-embedding-english-r2 or granite-embedding-small-english-r2 | \n
Both models are available now on Hugging Face under the IBM Granite Embedding collection:
\n\nYou can try the small models interactively (on CPU) via a Granite Embedding demo here on Hugging Face Spaces, or run the full examples notebook in Google Colab:
\n![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
You can access our detailed technical report covering the full training methodology, per-language evaluations, and pruning ablations here Granite Multilingual Embedding R2 report. For questions, feedback, or issues, visit ibm-granite/granite-embedding-models on GitHub.
\nFramework maintainers: If you'd like to adopt these models as a default in your project, open an issue at ibm-granite/granite-embedding-models — we're happy to help with integration, testing, and any questions about licensing or deployment.
\nGive them a try, and if the embeddings spark joy, smash that ❤️ button on Hugging Face. Our models have feelings too, and every +1 keeps them warm at night.
\n", "content_markdown": "> **TL;DR:** Two new Apache 2.0 multilingual embedding models built on ModernBERT — a 97M-parameter compact model that beats every open sub-100M multilingual embedder on MTEB Multilingual Retrieval (60.3), and a 311M full-size model that scores 65.2 on MTEB Multilingual Retrieval (#2 among open models under 500M parameters) with Matryoshka support. Both cover 200+ languages, are tuned on 52 languages, handle 32K-token context (64x R1), and add code retrieval across 9 programming languages.\n\n[![Granite Embedding Multilingual R2](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/LrZQDi73p2iIqRJTd25f7.png \"Granite Multilingual Embedding Intro Picture\")](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/LrZQDi73p2iIqRJTd25f7.png)\n\n**In this post:** [Enterprise-Ready by Design](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#enterprise-ready-by-design) · [A Strong Sub-100M Multilingual Model](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#a-strong-sub-100m-multilingual-model) · [What Changed from R1](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#what-changed-from-r1) · [Training the Full-Size 311M Model](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#training-the-full-size-311m-model) · [Building the compact 97M Multilingual Model](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#building-the-compact-97m-multilingual-model) · [Benchmark Results](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#benchmark-results) · [Matryoshka Embeddings](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#matryoshka-embeddings-311m) · [Deployment Options](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#deployment-options) · [For Framework Integrators](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#for-framework-integrators) · [Which Model Should You Use?](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#which-model-should-you-use) · [Try The Models](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#try-the-models)\n\nMultilingual embedding models face a persistent tension: broad language coverage usually comes at the cost of model size, and small models usually sacrifice languages. If you work across languages — retrieval-augmented generation over multilingual corpora, cross-lingual search, code retrieval in international teams — you've likely had to choose between a model that's fast enough and one that's good enough.\n\nThe Granite Embedding Multilingual R2 release narrows that gap considerably. We're releasing two new multilingual embedding models:\n\n- [**granite-embedding-311m-multilingual-r2**](https://huggingface.co/ibm-granite/granite-embedding-311m-multilingual-r2) — A 311M-parameter full-size model with 768-dimensional embeddings, Matryoshka dimension support, and top-tier multilingual retrieval quality.\n- [**granite-embedding-97m-multilingual-r2**](https://huggingface.co/ibm-granite/granite-embedding-97m-multilingual-r2) — A 97M-parameter compact model with 384-dimensional embeddings that delivers strong retrieval quality for its size.\n\nBoth models support **200+ languages** with enhanced retrieval quality for **52 languages and programming code**, handle context lengths up to **32,768 tokens** (a 64x increase over their R1 predecessors), and are released under the **Apache 2.0** license. They work out of the box with `sentence-transformers` and `transformers`, require no task-specific instructions, and are compatible as drop-in replacements in **LangChain**, **LlamaIndex**, **Haystack**, and **Milvus** with a one-line model name change. For frameworks currently using an English-only default, that one line gives every user in your community support for 200+ languages — no API changes, no new dependencies, no code changes required on their end. Both models ship with ONNX and OpenVINO weights for CPU-optimized inference.\n\n**52 enhanced-support languages** (click to expand)\n\nThe underlying encoder was pretrained on text from 200+ languages, producing general-purpose embeddings for any of them. The following 52 languages receive explicit retrieval-pair and cross-lingual training for higher-quality retrieval:\n\nAlbanian (sq), Arabic (ar), Azerbaijani (az), Bengali (bn), Bulgarian (bg), Catalan (ca), Chinese (zh), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (en), Estonian (et), Finnish (fi), French (fr), Georgian (ka), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Icelandic (is), Indonesian (id), Italian (it), Japanese (ja), Kazakh (kk), Khmer (km), Korean (ko), Latvian (lv), Lithuanian (lt), Malay (ms), Marathi (mr), Norwegian (no), Persian (fa), Polish (pl), Portuguese (pt), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es), Swahili (sw), Swedish (sv), Tagalog (tl), Telugu (te), Thai (th), Turkish (tr), Ukrainian (uk), Urdu (ur), Uzbek (uz), Vietnamese (vi).\n\nAdditionally, the models are trained on **programming code** (Python, Go, Java, JavaScript, PHP, Ruby, SQL, C, C++) and support cross-lingual code retrieval.\n\n## Enterprise-Ready by Design\n\nBoth embedding models are trained on a mixture of IBM‑curated datasets, publicly available data, and internally generated or synthetic data. Public web‑derived data used in training is selected and filtered using IBM‑developed quality, deduplication, and governance processes intended to reduce risk in downstream commercial use. We intentionally avoid the use of the MS‑MARCO training dataset and datasets with explicit non‑commercial licensing restrictions. The models are pretrained using [GneissWeb](https://huggingface.co/datasets/ibm-granite/GneissWeb), an IBM‑curated dataset derived from publicly available web content and processed using IBM’s data preparation and governance tooling—along with additional IBM‑curated and other publicly available sources. Datasets undergo IBM governance review to assess licensing considerations, ownership signals, and personal data risks. These processes are designed to contribute to responsible use and enterprise deployment.\n\n## A Strong Sub-100M Multilingual Model\n\nThe standout of this release is **granite-embedding-97m-multilingual-r2**. At 97 million parameters, it scores **60.3 on Multilingual MTEB Retrieval** across 18 languages — the highest retrieval score we've found for any open multilingual embedding model under 100M parameters. The next-best model in that size class, multilingual-e5-small, scores 50.9 on the same benchmark — a **+9.4 point gap** on a mature benchmark.\n\nAt roughly one-third the size of the 311M full-size model, it retains the majority of its retrieval quality across multilingual, code, and long-document benchmarks — a **+12.2 point gain on MTEB Multilingual Retrieval** over its direct predecessor, driven by a new architecture, better training data, and a novel pruning methodology (more on that below). The full-size **granite-embedding-311m-multilingual-r2** scores **65.2** on the same benchmark, a **+13.0 point gain** over its R1 predecessor.\n\n## What Changed from R1\n\nThe Granite Embedding Multilingual R1 models were built on XLM-RoBERTa encoders with a 512-token context window. The R2 generation is a ground-up rebuild:\n\n[](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/jhz201_Ud5zUWfA3k4ITA.png)\n\n[ModernBERT](https://huggingface.co/blog/modernbert) is a recent encoder architecture that revisits the original BERT design with techniques from the last five years of transformer research. The shift brings several practical benefits: alternating attention lengths reduce computation on long sequences (improves throughput on long sequences significantly), rotary position embeddings allow the 32K context window without the positional interpolation hacks that plague older architectures, and Flash Attention 2.0 support speeds up encoding on modern GPUs.\n\nThe new multilingual tokenizers are worth highlighting. Rather than reusing XLM-RoBERTa's 250K-token vocabulary, we adopted existing tokenizers with strong multilingual and code coverage. The 311M model uses the Gemma 3 tokenizer (262K tokens); the 97M model starts from the GPT-OSS tokenizer and prunes it down to a compact 180K-token vocabulary that preserves broad multilingual coverage while reducing the embedding table's parameter footprint. Tokenizer efficiency matters more than people realize — a 32K-token window sounds impressive until your tokenizer burns half of it encoding a single paragraph of Thai.\n\n## Training the Full-Size 311M Model\n\nThe 311M model is a 22-layer ModernBERT encoder with a 262K-token multilingual vocabulary, trained through a multi-stage pipeline:\n\n1. **Knowledge distillation**: The model learns from multiple teacher models simultaneously. The teachers are Granite 3.3 Instruct and Mistral v0.2 Instruct decoder models, further finetuned for text embeddings, which transfer retrieval-specific knowledge into the 311M encoder architecture.\n2. **Contrastive fine-tuning**: Standard contrastive training on multilingual retrieval pairs — queries matched with relevant and hard-negative passages across 52 languages and code — sharpens the model's ability to distinguish relevant from irrelevant results.\n3. **Model merging**: After training, we merge checkpoints from different training stages and configurations. This combines the strengths of models optimized for different objectives (e.g., multilingual breadth vs. English depth) into a single set of weights without additional training compute.\n4. **Matryoshka Representation Learning**: The model is trained with Matryoshka objectives so that its 768-dimensional embeddings can be truncated to 512, 384, 256, or 128 dimensions with minimal quality loss (see [Matryoshka Embeddings](https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2#matryoshka-embeddings-311m) below).\n\nThe result is a model that scores 65.2 on MTEB Multilingual Retrieval and 56.3 on the overall average — a +14.5 point average gain over its R1 predecessor.\n\n## Building the compact 97M Multilingual model\n\nThe 97M model is trained through a combination of **vocabulary selection** and **knowledge distillation**:\n\n1. **Vocabulary selection**: The 262K-token vocabulary is reduced to a purpose-trained 180K-token vocabulary that preserves broad multilingual coverage while cutting the embedding table size substantially.\n2. **Knowledge distillation**: The pruned model is then finetuned using knowledge distillation from multiple teacher models (including a [Granite 4.1 8B](https://huggingface.co/ibm-granite/granite-4.1-8b) and Mistral Instruct decoder-based teacher) and contrastive training to improve retrieval quality.\n\nThis approach transfers retrieval-specific knowledge from multiple strong teachers, while reducing the model parameters without sacrificing language coverage. The result is a highly efficient compact model — scoring 60.3 on MTEB Multilingual Retrieval vs. 65.2 for the full-size model, while being approximately 3x smaller.\n\n## Benchmark Results\n\n### Multilingual Retrieval\n\nPerformance across the main benchmark suite sorted by model size. Scores are averages across tasks within each benchmark (higher is better):\n\n| Model | Params | Active Params | Embed Dim | MTEB Multilingual Retrieval (18) | Code (12) | English Retrieval (10) | LongEmbed (6) | RaR-b (17) |\n| ------------------------------------------ | -------- | ------------- | --------- | -------------------------------- | ------------- | ---------------------- | ------------- | ------------- |\n| F2LLM-v2-80M | 80M | 32M | 320 | 50.1 | 68.0 | 47.5 | 31.7 | 17.9 |\n| multilingual-e5-small | 118M | 22M | 384 | 50.9 | 53.5 | 46.5 | 38.8 | 20.3 |\n| granite-embedding-107m-multilingual (R1) | 107M | 11M | 384 | 48.1 | 40.7 | 47.9 | 34.3 | 17.1 |\n| paraphrase-multilingual-MiniLM-L12-v2 | 118M | 22M | 384 | 36.6 | 23.5 | 35.9 | 20.9 | 10.9 |\n| jina-embeddings-v5-text-nano | 212M | 113M | 768 | 63.3 | 71.2 | 58.8 | 63.6 | 25.2 |\n| harrier-oss-v1-270m | 268M | 100M | 640 | 66.4 | 62.4 | 52.1 | 64.9 | 32.9 |\n| multilingual-e5-base | 278M | 86M | 768 | 52.7 | 52.6 | 49.0 | 40.5 | 23.4 |\n| granite-embedding-278m-multilingual (R1) | 278M | 86M | 768 | 52.2 | 48.5 | 51.5 | 37.7 | 18.9 |\n| embeddinggemma-300m | 308M | 106M | 768 | 62.5 | 68.7 | 54.6 | 55.4 | 26.1 |\n| gte-multilingual-base | 305M | 113M | 768 | 57.2 | 57.5 | 50.8 | 62.1 | 19.0 |\n| snowflake-arctic-embed-m-v2.0 | 305M | 113M | 768 | 54.8 | 55.2 | 58.4 | 55.4 | 23.3 |\n| multilingual-e5-large | 560M | 304M | 1024 | 53.7 | 55.8 | 51.5 | 40.4 | 25.4 |\n| text-embedding-3-small (OpenAI, API only) | — | — | 1536 | 50.7 | — | 53.8 | 53.6 | 23.2 |\n| | | | | | | | | |\n| **granite-embedding-97m-multilingual-r2** | **97M** | **28M** | **384** | **60.3** | **60.4** | **50.1** | **65.6** | **24.9** |\n| **granite-embedding-311m-multilingual-r2** | **311M** | **110M** | **768** | **65.2 (#2)** | **63.8 (#3)** | **52.6 (#5)** | **71.7 (#1)** | **28.0 (#2)** |\n\nA few things stand out:\n\n- **The 97M R2 model beats multilingual-e5-base and gte-multilingual-base** (~300M parameter models) on average and on most individual benchmarks, despite being roughly 3x smaller.\n- **`paraphrase-multilingual-MiniLM-L12-v2` — a widely-used framework default — scores 36.6**, a full **+23.7 points** behind the 97M R2 model, which is also slightly smaller (97M vs 110M parameters) with the same 384-dimensional output.\n- **LongEmbed is the biggest R1-to-R2 gain**: +31.3 points for the 97M model, +34.0 for the 311M. This is the direct payoff of the 32K context window — R1's 512-token limit meant your legal contract was being judged by its first page. Many practical multilingual workloads involve long documents (legal contracts, technical manuals, research papers, multi-page reports) that R1 simply could not see in full.\n- **Code retrieval improves dramatically**: +19.7 (97M) and +15.3 (311M) over R1, reflecting the new code training set, larger context window, and better training methodology.\n- **In the broader competitive field**, harrier-oss-v1-270m leads on MTEB Multilingual Retrieval (66.4) and RaR-b (32.9), while jina-embeddings-v5-text-nano leads on Code (71.2) and English Retrieval (58.8). The 311M Granite model is competitive on average (56.3) and leads on LongEmbed (71.7), while offering substantially higher encoding throughput than jina-embeddings-v5-text-nano (see speed table below).\n\n### Speed and Throughput\n\nEncoding speed matters for production workloads, especially when you're indexing millions of documents or need low-latency query encoding. We measured latency and throughput on a single NVIDIA H100 GPU using 512-token chunks:\n\n[![Speed vs. Quality: 97M model matches 300M-class quality at 3x the parameter efficiency](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/1ltJtX2knfzUA5BekMQsh.png \"Speed vs Throughput For Top Multilingual Embedding Models under 500M params\")](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/1ltJtX2knfzUA5BekMQsh.png)\n\nThe 97M model encodes over 2,500 documents per second — comparable throughput to multilingual-e5-small — while delivering substantially higher retrieval quality. The 311M model, at ~1,800 docs/sec, performs better than jina-embeddings-v5-text-nano on retrieval quality (65.2 vs. 63.3) at over 5.5x the encoding speed (note: speed numbers are computed with the latest transformer code, which had a speed regression vs the last 4.57 version - for both the Jina and granite models - see our technical report for details). harrier-oss-v1-270m offers the best combination of speed and retrieval score among the competitors listed here.\n\n## Matryoshka Embeddings (311M)\n\nThe 311M model supports [Matryoshka Representation Learning](https://arxiv.org/abs/2205.13147), which lets you truncate embeddings from the full 768 dimensions down to 512, 384, 256, or 128 with graceful quality degradation. This is useful when storage, memory, or similarity-computation cost is a concern — a 256-dimensional embedding takes one-third the storage of a 768-dimensional one, and cosine similarity is proportionally cheaper to compute.\n\nHere's how retrieval quality holds up across embedding dimensions:\n\n[![Matryoshka embeddings: graceful quality degradation across truncated dimensions](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/myYhY1YHLY9Vs3l0gyMJB.png \"Performance Change While Prunning the Embeddings to Fewer Entries\")](https://cdn-uploads.huggingface.co/production/uploads/642ae74b25442667e9bd72ed/myYhY1YHLY9Vs3l0gyMJB.png)\n\nThe quality loss from dimension reduction is remarkably small. Cutting from 768 to 256 dimensions — a **3x reduction** in storage and similarity-computation cost — drops MTEB Multilingual Retrieval by just 0.5 points (65.2 → 64.7) and Code Retrieval by 0.5 points (63.9 → 63.4). Even at 128 dimensions (a **6x reduction**), the model still scores 63.7 on MTEB Multilingual Retrieval and 62.3 on Code — retaining over **97%** of its full-dimension performance. In practice, this means you can substantially reduce your index size and search latency with minimal impact on result quality. (Note,results in the above picture were evaluated with a context length of 1024 for English and Multilingual Retrieval, and 8192 for Code).\n\nFor comparison, the 311M model truncated to 384 dimensions (the same dimensionality as the 97M model's native output) still outperforms the 97M model across all three benchmarks. If you need 384-dimensional embeddings and can afford the 311M model's encoding cost, Matryoshka truncation is the stronger option.\n\n```python\nfrom sentence_transformers import SentenceTransformer\n\nmodel = SentenceTransformer(\"ibm-granite/granite-embedding-311m-multilingual-r2\")\n\n# Full 768-dimensional embeddings\nfull = model.encode([\"example text\"])\nprint(full.shape) # (1, 768)\n\n# Truncated to 384 dimensions\nsmall = model.encode([\"example text\"], truncate_dim=384)\nprint(small.shape) # (1, 384)\n```\n\nThe 97M model does not support Matryoshka — 384 dimensions is already compact.\n\n### Cross-lingual Retrieval\n\nAverage performance on cross-lingual tasks within MTEB Retrieval. [Belebele](https://huggingface.co/datasets/facebook/belebele) measures cross-lingual passage matching across 122 languages; MLQA measures extractive cross-lingual question answering retrieval across 7 languages.\n\n| Model | Belebele Retrieval | MLQA Retrieval |\n| ------------------------------------------ | ------------------ | -------------- |\n| granite-embedding-107m-multilingual (R1) | 55.1 | 60.5 |\n| granite-embedding-278m-multilingual (R1) | 62.2 | 63.0 |\n| granite-embedding-97m-multilingual-r2 | 52.9 | 60.5 |\n| **granite-embedding-311m-multilingual-r2** | **66.5** | **67.1** |\n\nThe 311M R2 model gains +4.3 on Belebele and +4.1 on MLQA over its R1 predecessor, showing improved cross-lingual transfer at the larger scale across both benchmarks.\n\nThe 97M R2 model scores lower on Belebele (52.9 vs 55.1, −2.2) while matching its R1 predecessor on MLQA (60.5). The Belebele gap is a tradeoff inherent in the pruning and vocabulary reduction process — the R2 model's training prioritized the broader 18-language MTEB Multilingual Retrieval set (where it gains +12.2 over R1) and long-document retrieval (+31.3), while the smaller vocabulary (180K vs. 250K tokens) and reduced layer count (12 vs. 22) affect narrow cross-lingual transfer tasks. If cross-lingual transfer across many language pairs is your primary use case, the full-size 311M model is the better choice.\n\n## Deployment Options\n\nBoth models ship with multiple deployment paths for production use. Install the core library with:\n\n```bash\npip install sentence-transformers\n```\n\n**Sentence Transformers** (recommended for most users):\n\n```python\nfrom sentence_transformers import SentenceTransformer, util\n\nmodel = SentenceTransformer(\"ibm-granite/granite-embedding-97m-multilingual-r2\")\n\nqueries = [\n \"What is the tallest mountain in Japan?\", # English\n \"Wer hat das Lied Achy Breaky Heart geschrieben?\", # German\n \"ドイツの首都はどこですか？\", # Japanese\n]\n\npassages = [\n \"富士山は、静岡県と山梨県にまたがる活火山で、標高3776.12 mで日本最高峰の独立峰である。\", # Japanese\n \"Achy Breaky Heart is a country song written by Don Von Tress.\", # English\n \"Berlin ist die Hauptstadt und ein Land der Bundesrepublik Deutschland.\", # German\n]\n\nq_emb = model.encode(queries)\np_emb = model.encode(passages)\nprint(util.cos_sim(q_emb, p_emb))\n# Each query scores highest against its matching passage — across languages\n```\n\n**LangChain** (`pip install langchain-huggingface`):\n\n```python\nfrom langchain_huggingface import HuggingFaceEmbeddings\n\nembeddings = HuggingFaceEmbeddings(\n model_name=\"ibm-granite/granite-embedding-97m-multilingual-r2\"\n)\n\ndocs = embeddings.embed_documents([\n \"富士山は日本最高峰の独立峰です。\",\n \"Mount Fuji is Japan's highest peak.\",\n])\nquery = embeddings.embed_query(\"What is Japan's tallest mountain?\")\n# Drop-in replacement anywhere LangChain accepts an Embeddings object\n```\n\n**LlamaIndex** (`pip install llama-index-embeddings-huggingface`):\n\n```python\nfrom llama_index.embeddings.huggingface import HuggingFaceEmbedding\nfrom llama_index.core import Settings\n\nembed_model = HuggingFaceEmbedding(\n model_name=\"ibm-granite/granite-embedding-97m-multilingual-r2\"\n)\nSettings.embed_model = embed_model # applies globally to any index or pipeline\n```\n\n**Haystack** (`pip install sentence-transformers haystack-ai`)\n\n```python\nfrom haystack.components.embedders import (\n SentenceTransformersDocumentEmbedder,\n SentenceTransformersTextEmbedder,\n)\nfrom haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever\nfrom haystack.dataclasses import Document\nfrom haystack.document_stores.in_memory import InMemoryDocumentStore\n\ndoc_embedder = SentenceTransformersDocumentEmbedder(\n model=\"ibm-granite/granite-embedding-97m-multilingual-r2\"\n)\nquery_embedder = SentenceTransformersTextEmbedder(\n model=\"ibm-granite/granite-embedding-97m-multilingual-r2\"\n)\ndoc_embedder.warm_up()\nquery_embedder.warm_up()\n\n# Embed and index documents\ndocument_store = InMemoryDocumentStore()\nresult_docs = doc_embedder.run(documents=[\n Document(content=\"富士山は日本最高峰の独立峰です。\"),\n Document(content=\"Mount Fuji is Japan's highest peak.\"),\n Document(content=\"Achy Breaky Heart is a country song written by Don Von Tress.\"),\n Document(content=\"Berlin ist die Hauptstadt und ein Land der Bundesrepublik Deutschland.\"),\n])\ndocument_store.write_documents(result_docs[\"documents\"])\n\n# Embed query and retrieve\nresult_query = query_embedder.run(text=\"What is Japan's tallest mountain?\")\nretriever = InMemoryEmbeddingRetriever(document_store=document_store)\nresults = retriever.run(query_embedding=result_query[\"embedding\"], top_k=2)\nfor doc in results[\"documents\"]:\n print(f\"{doc.score:.3f} {doc.content}\")\n# 0.961 Mount Fuji is Japan's highest peak.\n# 0.913 富士山は日本最高峰の独立峰です。\n```\n\n**Milvus** (`pip install pymilvus sentence-transformers`)\n\n```python\nfrom pymilvus import MilvusClient\nfrom sentence_transformers import SentenceTransformer\n\nmodel = SentenceTransformer(\"ibm-granite/granite-embedding-97m-multilingual-r2\")\n\n# Use \"./milvus.db\" for local persistence or a server URI for production\nclient = MilvusClient(\":memory:\")\nclient.create_collection(collection_name=\"multilingual_docs\", dimension=384)\n\ndocs = [\n \"富士山は日本最高峰の独立峰です。\",\n \"Mount Fuji is Japan's highest peak.\",\n \"Achy Breaky Heart is a country song written by Don Von Tress.\",\n \"Berlin ist die Hauptstadt und ein Land der Bundesrepublik Deutschland.\",\n]\nembeddings = model.encode(docs).tolist()\nclient.insert(\n collection_name=\"multilingual_docs\",\n data=[{\"id\": i, \"vector\": emb, \"text\": doc} for i, (emb, doc) in enumerate(zip(embeddings, docs))],\n)\n\nquery_emb = model.encode([\"What is Japan's tallest mountain?\"]).tolist()\nresults = client.search(\n collection_name=\"multilingual_docs\",\n data=query_emb,\n limit=2,\n output_fields=[\"text\"],\n)\nfor hit in results[0]:\n print(f\"{hit['distance']:.3f} {hit['entity']['text']}\")\n# 0.961 Mount Fuji is Japan's highest peak.\n# 0.913 富士山は日本最高峰の独立峰です。\n```\n\nBoth models also ship with pre-converted **ONNX** and **OpenVINO** weights for optimized CPU/accelerator inference, work as embedding endpoints via **[vLLM](https://docs.vllm.ai/)** (`vllm serve ... --task embed`), and can be converted to GGUF for **[Ollama](https://ollama.com/)** using [llama.cpp](https://github.com/ggerganov/llama.cpp). See the model cards for full deployment examples.\n\n## For Framework Integrators\n\nIf you maintain an embedding framework, vector store, or RAG pipeline library and are evaluating these models as a default, here's what you need to know:\n\n- **License**: Apache 2.0, trained without MS-MARCO\n- **Drop-in behavior**: No task-specific instruction prefix required — behaves like `all-MiniLM-L6-v2` at the API level. Existing code that calls `.encode()` works unchanged.\n- **Dimensionality**: 384-dimensional output (97M) and 768-dimensional output (311M), matching the most common existing defaults. No index migration required.\n- **Model size**: The 97M model's weights are 195 MB (safetensors) — less than half the size of `paraphrase-multilingual-MiniLM-L12-v2` (471 MB), the most common multilingual default. The quantized ONNX weights are just 98 MB, comparable to `all-MiniLM-L6-v2` (91 MB) while covering 200+ languages.\n- **CPU-friendly**: Ships with ONNX and OpenVINO weights for optimized CPU inference. No GPU dependency for a getting-started tutorial.\n- **Multilingual by default**: If your current default is English-only, this is a one-line swap that gives every user in your community support for 200+ languages — without touching their code.\n- **Stable identifier**: `ibm-granite/granite-embedding-97m-multilingual-r2` on Hugging Face, maintained by IBM under the Granite model family.\n\nTo discuss adopting these models as a default in your project, open an issue at [ibm-granite/granite-embedding-models](https://github.com/ibm-granite/granite-embedding-models).\n\n## Which Model Should You Use?\n\nThese two multilingual models are part of the broader **Granite Embedding R2** family, which also includes two high-performing English-focused models: [granite-embedding-english-r2](https://huggingface.co/ibm-granite/granite-embedding-english-r2) (149M parameters) and [granite-embedding-small-english-r2](https://huggingface.co/ibm-granite/granite-embedding-small-english-r2) (47M parameters). If your data is predominantly English, the English models offer higher retrieval quality on English benchmarks at a smaller footprint, since they don't need to allocate capacity across 200+ languages.\n\n| If you need... | Use |\n| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Best multilingual retrieval quality | [granite-embedding-311m-multilingual-r2](https://huggingface.co/ibm-granite/granite-embedding-311m-multilingual-r2) |\n| Flexible embedding dimensions (storage/speed tradeoff) | granite-embedding-311m-multilingual-r2 (Matryoshka) |\n| Maximum throughput / edge deployment / low latency | [granite-embedding-97m-multilingual-r2](https://huggingface.co/ibm-granite/granite-embedding-97m-multilingual-r2) |\n| Best cross-lingual transfer across many language pairs | granite-embedding-311m-multilingual-r2 |\n| Predominantly English data | [granite-embedding-english-r2](https://huggingface.co/ibm-granite/granite-embedding-english-r2) or [granite-embedding-small-english-r2](https://huggingface.co/ibm-granite/granite-embedding-small-english-r2) |\n\n## Try The Models\n\nBoth models are available now on Hugging Face under the [IBM Granite Embedding collection](https://huggingface.co/collections/ibm-granite/granite-embedding-models):\n\n- [granite-embedding-311m-multilingual-r2](https://huggingface.co/ibm-granite/granite-embedding-311m-multilingual-r2)\n- [granite-embedding-97m-multilingual-r2](https://huggingface.co/ibm-granite/granite-embedding-97m-multilingual-r2)\n\nYou can try the small models interactively (on CPU) via a Granite Embedding demo [here](https://huggingface.co/spaces/ibm-granite/granite-embedding) on Hugging Face Spaces, or run the full examples notebook in Google Colab:\n\n[](https://colab.research.google.com/github/ibm-granite/granite-embedding-models/blob/main/code/multilingual_r2_examples.ipynb)\n\nYou can access our detailed technical report covering the full training methodology, per-language evaluations, and pruning ablations here [Granite Multilingual Embedding R2 report](https://arxiv.org/abs/2605.13521). For questions, feedback, or issues, visit [ibm-granite/granite-embedding-models](https://github.com/ibm-granite/granite-embedding-models) on GitHub.\n\n**Framework maintainers:** If you'd like to adopt these models as a default in your project, open an issue at [ibm-granite/granite-embedding-models](https://github.com/ibm-granite/granite-embedding-models) — we're happy to help with integration, testing, and any questions about licensing or deployment.\n\nGive them a try, and if the embeddings spark joy, smash that ❤️ button on Hugging Face. Our models have feelings too, and every +1 keeps them warm at night.\n", "dateCreated": "2026-10-19T01:26:53.998049939+00:00", "date_created": "2026-05-14T18:55:01+00:00", "date_modified": "2026-05-14T18:55:01+00:00", "date_published": "2026-05-14T18:55:01+00:00", "description": "TL;DR: Two new Apache 2.0 multilingual embedding models built on ModernBERT — a 97M-parameter compact model that beats every open sub-100M multilingual embedder on MTEB Multilingual Retrieval (60.3), and a 311M full-size model that scores…", "external_url": "https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2", "git": { "commit": "ebb0941c5c06a2ab2377342d607535262a3e969e", "path": "items/huggingface-co/2026/05/2026-05-14-granite-embedding-multilingual-r2-open-apache-2-0.md", "permalink": "https://github.com/aymericbeaumet/aggr-instance/blob/ebb0941c5c06a2ab2377342d607535262a3e969e/items/huggingface-co/2026/05/2026-05-14-granite-embedding-multilingual-r2-open-apache-2-0.md" }, "id": "urn:aggr:item:2fb9fbfd9680379addd4925bc9f3f7ad9a012825", "isBasedOn": { "@id": "https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2" }, "mainEntity": { "@id": "https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2", "@type": "CreativeWork", "archivedAt": { "@id": "https://aggr.aymericbeaumet.com/items/huggingface-co/2026-05-14-granite-embedding-multilingual-r2-open-apache-2-0/#webpage" }, "dateModified": "2026-05-14T18:55:01+00:00", "datePublished": "2026-05-14T18:55:01+00:00", "headline": "Granite Embedding Multilingual R2: Open Apache 2.0 Multilingual Embeddings with 32K Context — Best Sub-100M Retrieval Quality", "image": { "@type": "ImageObject", "caption": null, "height": 90, "url": "https://cdn-thumbnails.huggingface.co/social-thumbnails/blog/ibm-granite/granite-embedding-multilingual-r2.png", "width": 160 }, "timeRequired": "PT16M", "url": "https://huggingface.co/blog/ibm-granite/granite-embedding-multilingual-r2", "wordCount": 3526 }, "name": "Archived snapshot: Granite Embedding Multilingual R2: Open Apache 2.0 Multilingual Embeddings with 32K Context — Best Sub-100M Retrieval Quality", "preview": { "alt": null, "color": null, "height": 90, "placeholder": { "data_url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=", "hash": "" }, "url": "https://cdn-thumbnails.huggingface.co/social-thumbnails/blog/ibm-granite/granite-embedding-multilingual-r2.png", "width": 160 }, "reading_minutes": 16, "replicated_at": null, "source": "huggingface-co", "source_name": "Hugging Face - Blog", "summary": null, "tags": [], "temporalCoverage": "2026-10-19T01:26:53.998049939+00:00", "title": "Granite Embedding Multilingual R2: Open Apache 2.0 Multilingual Embeddings with 32K Context — Best Sub-100M Retrieval Quality", "url": "https://aggr.aymericbeaumet.com/items/huggingface-co/2026-05-14-granite-embedding-multilingual-r2-open-apache-2-0/", "word_count": 3526 }