mteb 2.1.4__py3-none-any.whl → 2.7.2__py3-none-any.whl

mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py

@@ -1,8 +1,9 @@
 from typing import Any
 
 import torch
-from PIL import Image
+from packaging.version import Version
 from torch.utils.data import DataLoader
+from transformers import __version__ as transformers_version
 
 from mteb.abstasks.task_metadata import TaskMetadata
 from mteb.models.abs_encoder import AbsEncoder
@@ -31,6 +32,14 @@ class LlamaNemoretrieverColembed(AbsEncoder):
         attn_implementation="flash_attention_2",
         **kwargs,
     ):
+        required_transformers_version = "4.49.0"
+
+        if Version(transformers_version) != Version(required_transformers_version):
+            raise RuntimeError(
+                f"transformers version {transformers_version} is not match with required "
+                f"install version {required_transformers_version} to run `nvidia/llama-nemoretriever-colembed`"
+            )
+
         from transformers import AutoModel
 
         self.model = AutoModel.from_pretrained(
@@ -53,6 +62,7 @@ class LlamaNemoretrieverColembed(AbsEncoder):
         **kwargs,
     ):
         import torchvision.transforms.functional as F
+        from PIL import Image
 
         all_images = []
         if isinstance(images, DataLoader):
@@ -61,14 +71,16 @@ class LlamaNemoretrieverColembed(AbsEncoder):
             iterator = DataLoader(images, batch_size=batch_size)
 
         for batch in iterator:
-            for b in batch:
+            for image in batch["image"]:
                 pil_img = (
-                    F.to_pil_image(b.to("cpu")) if not isinstance(b, Image.Image) else b
+                    image
+                    if isinstance(image, Image.Image)
+                    else F.to_pil_image(image.to("cpu"))
                 )
                 all_images.append(pil_img)
 
         batch_size = 1
-        return self.model.forward_passages(all_images, batch_size=batch_size)
+        return self.model.forward_images(all_images, batch_size=batch_size)
 
     def calculate_probs(self, text_embeddings, image_embeddings):
         scores = self.similarity(text_embeddings, image_embeddings)
@@ -117,19 +129,18 @@ class LlamaNemoretrieverColembed(AbsEncoder):
 
 TRAINING_DATA = {
     # from https://huggingface.co/datasets/vidore/colpali_train_set
-    "DocVQA",
-    "InfoVQA",
-    "TATDQA",
-    "arXivQA",
-    "hotpotqa",
-    "miracl",
+    "VidoreDocVQARetrieval",
+    "VidoreInfoVQARetrieval",
+    "VidoreTatdqaRetrieval",
+    "VidoreArxivQARetrieval",
+    "HotpotQA",
+    "MIRACLRetrieval",
     "NQ",
-    "stackexchange",
+    "StackExchangeClustering",
     "SQuAD",
     "WebInstructSub",
     "docmatix-ir",
-    "vdr-multilingual-train",
-    "colpali_train_set",  # as it contains PDFs
+    "VDRMultilingualRetrieval",
     "VisRAG-Ret-Train-Synthetic-data",
     "VisRAG-Ret-Train-In-domain-data",
     "wiki-ss-nq",
@@ -141,19 +152,20 @@ llama_nemoretriever_colembed_1b_v1 = ModelMeta(
         trust_remote_code=True,
     ),
     name="nvidia/llama-nemoretriever-colembed-1b-v1",
+    model_type=["late-interaction"],
     languages=["eng-Latn"],
-    revision="1f0fdea7f5b19532a750be109b19072d719b8177",
+    revision="6eade800103413033f260bb55b49fe039fd28a6e",
     release_date="2025-06-27",
     modalities=["image", "text"],
     n_parameters=2_418_000_000,
-    memory_usage_mb=9224,
+    memory_usage_mb=4610,
     max_tokens=8192,
     embed_dim=2048,
     license="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1/blob/main/LICENSE",
     open_weights=True,
     public_training_code="Proprietary Code",
     public_training_data="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1#training-dataset",
-    framework=["PyTorch"],
+    framework=["PyTorch", "Transformers", "safetensors"],
     reference="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1",
     similarity_fn_name="MaxSim",
     use_instructions=True,
@@ -167,19 +179,20 @@ llama_nemoretriever_colembed_3b_v1 = ModelMeta(
         trust_remote_code=True,
     ),
     name="nvidia/llama-nemoretriever-colembed-3b-v1",
+    model_type=["late-interaction"],
     languages=["eng-Latn"],
-    revision="50c36f4d5271c6851aa08bd26d69f6e7ca8b870c",
+    revision="4194bdd2cd2871f220ddba6273ce173ef1217a1e",
     release_date="2025-06-27",
     modalities=["image", "text"],
     n_parameters=4_407_000_000,
-    memory_usage_mb=16811,
+    memory_usage_mb=8403,
     max_tokens=8192,
     embed_dim=3072,
     license="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1/blob/main/LICENSE",
     open_weights=True,
     public_training_code="Proprietary Code",
     public_training_data="https://huggingface.co/nvidia/llama-nemoretriever-colembed-1b-v1#training-dataset",
-    framework=["PyTorch"],
+    framework=["PyTorch", "Transformers", "safetensors"],
     reference="https://huggingface.co/nvidia/llama-nemoretriever-colembed-3b-v1",
     similarity_fn_name="MaxSim",
     use_instructions=True,

mteb/models/model_implementations/nvidia_models.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Callable
 from typing import Any
 
 import torch
@@ -9,8 +10,9 @@ from tqdm import tqdm
 from transformers import AutoModel, AutoTokenizer
 from transformers import __version__ as transformers_version
 
-from mteb import TaskMetadata
 from mteb._requires_package import requires_package
+from mteb.abstasks.task_metadata import TaskMetadata
+from mteb.models import CrossEncoderWrapper
 from mteb.models.abs_encoder import AbsEncoder
 from mteb.models.instruct_wrapper import InstructSentenceTransformerModel
 from mteb.models.model_meta import ModelMeta, ScoringFunction
@@ -18,18 +20,28 @@ from mteb.types import Array, BatchedInput, PromptType
 
 logger = logging.getLogger(__name__)
 
-NV_RETRIEVER_CITATION = """@misc{moreira2025nvretrieverimprovingtextembedding,
-      title={NV-Retriever: Improving text embedding models with effective hard-negative mining},
-      author={Gabriel de Souza P. Moreira and Radek Osmulski and Mengyao Xu and Ronay Ak and Benedikt Schifferer and Even Oldridge},
+NV_RETRIEVER_CITATION = """@misc{lee2025nvembedimprovedtechniquestraining,
+      title={NV-Embed: Improved Techniques for Training LLMs as Generalist Embedding Models},
+      author={Chankyu Lee and Rajarshi Roy and Mengyao Xu and Jonathan Raiman and Mohammad Shoeybi and Bryan Catanzaro and Wei Ping},
       year={2025},
-      eprint={2407.15831},
+      eprint={2405.17428},
       archivePrefix={arXiv},
-      primaryClass={cs.IR},
-      url={https://arxiv.org/abs/2407.15831}
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2405.17428},
+}"""
+
+LlamaEmbedNemotron_CITATION = """@misc{babakhin2025llamaembednemotron8buniversaltextembedding,
+      title={Llama-Embed-Nemotron-8B: A Universal Text Embedding Model for Multilingual and Cross-Lingual Tasks},
+      author={Yauhen Babakhin and Radek Osmulski and Ronay Ak and Gabriel Moreira and Mengyao Xu and Benedikt Schifferer and Bo Liu and Even Oldridge},
+      year={2025},
+      eprint={2511.07025},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2511.07025},
 }"""
 
 
-def instruction_template(
+def _instruction_template(
     instruction: str, prompt_type: PromptType | None = None
 ) -> str:
     return f"Instruct: {instruction}\nQuery: " if instruction else ""
@@ -100,10 +112,77 @@ nvidia_training_datasets = {
     "MrTidyRetrieval",
 }
 
+
+class _NVEmbedWrapper(InstructSentenceTransformerModel):
+    """Inherited, because nvembed requires `sbert==2`, but it doesn't have tokenizers kwargs"""
+
+    def __init__(
+        self,
+        model_name: str,
+        revision: str,
+        instruction_template: str
+        | Callable[[str, PromptType | None], str]
+        | None = None,
+        max_seq_length: int | None = None,
+        apply_instruction_to_passages: bool = True,
+        padding_side: str | None = None,
+        add_eos_token: bool = False,
+        prompts_dict: dict[str, str] | None = None,
+        **kwargs: Any,
+    ):
+        from sentence_transformers import __version__ as sbert_version
+
+        required_transformers_version = "4.42.4"
+        required_sbert_version = "2.7.0"
+
+        if Version(transformers_version) != Version(required_transformers_version):
+            raise RuntimeError(
+                f"transformers version {transformers_version} is not match with required "
+                f"install version {required_transformers_version} to run `nvidia/NV-Embed-v2`"
+            )
+
+        if Version(sbert_version) != Version(required_sbert_version):
+            raise RuntimeError(
+                f"sbert version {sbert_version} is not match with required "
+                f"install version {required_sbert_version} to run `nvidia/NV-Embed-v2`"
+            )
+
+        requires_package(
+            self, "flash_attn", model_name, "pip install 'mteb[flash_attention]'"
+        )
+
+        from sentence_transformers import SentenceTransformer
+
+        if (
+            isinstance(instruction_template, str)
+            and "{instruction}" not in instruction_template
+        ):
+            raise ValueError(
+                "Instruction template must contain the string '{instruction}'."
+            )
+        if instruction_template is None:
+            logger.warning(
+                "No instruction template provided. Instructions will be used as-is."
+            )
+
+        self.instruction_template = instruction_template
+
+        self.model_name = model_name
+        self.model = SentenceTransformer(model_name, revision=revision, **kwargs)
+        self.model.tokenizer.padding_side = padding_side
+        self.model.tokenizer.add_eos_token = add_eos_token
+
+        if max_seq_length:
+            # https://github.com/huggingface/sentence-transformers/issues/3575
+            self.model.max_seq_length = max_seq_length
+        self.apply_instruction_to_passages = apply_instruction_to_passages
+        self.prompts_dict = prompts_dict
+
+
 NV_embed_v2 = ModelMeta(
-    loader=InstructSentenceTransformerModel,
+    loader=_NVEmbedWrapper,
     loader_kwargs=dict(
-        instruction_template=instruction_template,
+        instruction_template=_instruction_template,
         trust_remote_code=True,
         max_seq_length=32768,
         padding_side="right",
@@ -111,6 +190,7 @@ NV_embed_v2 = ModelMeta(
         add_eos_token=True,
     ),
     name="nvidia/NV-Embed-v2",
+    model_type=["dense"],
     languages=["eng-Latn"],
     open_weights=True,
     revision="7604d305b621f14095a1aa23d351674c2859553a",
@@ -122,7 +202,7 @@ NV_embed_v2 = ModelMeta(
     max_tokens=32768,
     reference="https://huggingface.co/nvidia/NV-Embed-v2",
     similarity_fn_name=ScoringFunction.COSINE,
-    framework=["Sentence Transformers", "PyTorch"],
+    framework=["Sentence Transformers", "PyTorch", "Transformers", "safetensors"],
     use_instructions=True,
     training_datasets=nvidia_training_datasets,
     public_training_code=None,
@@ -131,9 +211,9 @@ NV_embed_v2 = ModelMeta(
 )
 
 NV_embed_v1 = ModelMeta(
-    loader=InstructSentenceTransformerModel,
+    loader=_NVEmbedWrapper,
     loader_kwargs=dict(
-        instruction_template=instruction_template,
+        instruction_template=_instruction_template,
         trust_remote_code=True,
         max_seq_length=32768,
         padding_side="right",
@@ -141,18 +221,19 @@ NV_embed_v1 = ModelMeta(
         add_eos_token=True,
     ),
     name="nvidia/NV-Embed-v1",
+    model_type=["dense"],
     languages=["eng-Latn"],
     open_weights=True,
     revision="570834afd5fef5bf3a3c2311a2b6e0a66f6f4f2c",
     release_date="2024-09-13",  # initial commit of hf model.
     n_parameters=7_850_000_000,
-    memory_usage_mb=29945,
+    memory_usage_mb=14975,
     embed_dim=4096,
     license="cc-by-nc-4.0",
     max_tokens=32768,
     reference="https://huggingface.co/nvidia/NV-Embed-v1",
     similarity_fn_name=ScoringFunction.COSINE,
-    framework=["Sentence Transformers", "PyTorch"],
+    framework=["Sentence Transformers", "PyTorch", "safetensors"],
     use_instructions=True,
     training_datasets=nvidia_training_datasets,
     public_training_code=None,
@@ -335,6 +416,7 @@ class LlamaEmbedNemotron(AbsEncoder):
         self,
         model_name: str,
         revision: str,
+        device: str | None = None,
     ) -> None:
         required_transformers_version = "4.51.0"
         if Version(transformers_version) != Version(required_transformers_version):
@@ -353,7 +435,7 @@ class LlamaEmbedNemotron(AbsEncoder):
         self.attn_implementation = (
             "flash_attention_2" if torch.cuda.is_available() else "eager"
         )
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
         self.task_prompts = TASK_PROMPTS
         self.instruction_template = self._instruction_template
 
@@ -528,6 +610,7 @@ class LlamaEmbedNemotron(AbsEncoder):
 llama_embed_nemotron_8b = ModelMeta(
     loader=LlamaEmbedNemotron,
     name="nvidia/llama-embed-nemotron-8b",
+    model_type=["dense"],
     languages=llama_embed_nemotron_evaluated_languages,
     open_weights=True,
     revision="84a375593d27d3528beb4e104822515659e093b4",
@@ -539,11 +622,63 @@ llama_embed_nemotron_8b = ModelMeta(
     max_tokens=32768,
     reference="https://huggingface.co/nvidia/llama-embed-nemotron-8b",
     similarity_fn_name="cosine",
-    framework=["PyTorch"],
+    framework=["PyTorch", "Sentence Transformers", "safetensors", "Transformers"],
     use_instructions=True,
     training_datasets=llama_embed_nemotron_training_datasets,
-    public_training_code=None,  # Will be released later
-    public_training_data=None,  # Will be released later
+    public_training_code="https://github.com/NVIDIA-NeMo/Automodel/tree/main/examples/biencoder/llama_embed_nemotron_8b",
+    public_training_data="https://huggingface.co/datasets/nvidia/embed-nemotron-dataset-v1",
     contacts=["ybabakhin"],
-    citation=NV_RETRIEVER_CITATION,
+    citation=LlamaEmbedNemotron_CITATION,
+)
+
+
+def _nemotron_rerank_model(model: str, revision: str, **kwargs) -> CrossEncoderWrapper:
+    required_transformers_version = "4.47.1"
+
+    if Version(transformers_version) != Version(required_transformers_version):
+        raise RuntimeError(
+            f"transformers version {transformers_version} is not match with required "
+            f"install version {required_transformers_version} to run `nvidia/llama-nemotron-rerank-1b-v2`"
+        )
+
+    return CrossEncoderWrapper(
+        model=model,
+        revision=revision,
+        **kwargs,
+    )
+
+
+nemotron_rerank_1b_v2 = ModelMeta(
+    loader=_nemotron_rerank_model,
+    loader_kwargs=dict(
+        trust_remote_code=True,
+        query_prefix="question:",
+        passage_prefix=" \n \n passage:",
+        model_kwargs={"torch_dtype": torch.float32},
+    ),
+    name="nvidia/llama-nemotron-rerank-1b-v2",
+    revision="78efcfdc23b53a753f6c73f2d78b18132a34ac4d",
+    release_date="2025-10-16",
+    languages=["eng-Latn"],
+    n_parameters=1235816448,
+    memory_usage_mb=2357.0,
+    max_tokens=4096,
+    embed_dim=2048,
+    license="https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-open-model-license/",
+    open_weights=True,
+    public_training_code=None,
+    public_training_data=None,
+    framework=["PyTorch", "Sentence Transformers"],
+    reference="https://huggingface.co/nvidia/llama-nemotron-rerank-1b-v2",
+    similarity_fn_name=ScoringFunction.COSINE,
+    use_instructions=None,
+    training_datasets=set(
+        # private
+    ),
+    adapted_from="meta-llama/Llama-3.2-1B",
+    superseded_by=None,
+    modalities=["text"],
+    model_type=["cross-encoder"],
+    citation=None,
+    contacts=None,
 )

mteb/models/model_implementations/octen_models.py

@@ -0,0 +1,254 @@
+from mteb.models.instruct_wrapper import InstructSentenceTransformerModel
+from mteb.models.model_meta import ModelMeta
+from mteb.models.models_protocols import PromptType
+
+
+def instruction_template(
+    instruction: str, prompt_type: PromptType | None = None
+) -> str:
+    if (
+        prompt_type == PromptType.document
+    ):  # to avoid this issue: https://huggingface.co/Qwen/Qwen3-Embedding-8B/discussions/21
+        return " "
+    if not instruction:
+        return ""
+    if isinstance(instruction, dict):
+        if prompt_type is None:
+            instruction = next(iter(instruction.values()))  # TODO
+        else:
+            instruction = instruction[prompt_type]
+    return f"Instruct: {instruction}\nQuery:"
+
+
+multilingual_langs = [
+    "afr-Latn",
+    "ara-Arab",
+    "aze-Latn",
+    "bel-Cyrl",
+    "bul-Cyrl",
+    "ben-Beng",
+    "cat-Latn",
+    "ceb-Latn",
+    "ces-Latn",
+    "cym-Latn",
+    "dan-Latn",
+    "deu-Latn",
+    "ell-Grek",
+    "eng-Latn",
+    "spa-Latn",
+    "est-Latn",
+    "eus-Latn",
+    "fas-Arab",
+    "fin-Latn",
+    "fra-Latn",
+    "glg-Latn",
+    "guj-Gujr",
+    "heb-Hebr",
+    "hin-Deva",
+    "hrv-Latn",
+    "hat-Latn",
+    "hun-Latn",
+    "hye-Armn",
+    "ind-Latn",
+    "isl-Latn",
+    "ita-Latn",
+    "jpn-Jpan",
+    "jav-Latn",
+    "kat-Geor",
+    "kaz-Cyrl",
+    "khm-Khmr",
+    "kan-Knda",
+    "kor-Hang",
+    "kir-Cyrl",
+    "lao-Laoo",
+    "lit-Latn",
+    "lav-Latn",
+    "mkd-Cyrl",
+    "mal-Mlym",
+    "mon-Cyrl",
+    "mar-Deva",
+    "msa-Latn",
+    "mya-Mymr",
+    "nep-Deva",
+    "nld-Latn",
+    "nor-Latn",
+    "nob-Latn",
+    "nno-Latn",
+    "pan-Guru",
+    "pol-Latn",
+    "por-Latn",
+    "que-Latn",
+    "ron-Latn",
+    "rus-Cyrl",
+    "sin-Sinh",
+    "slk-Latn",
+    "slv-Latn",
+    "swa-Latn",
+    "tam-Taml",
+    "tel-Telu",
+    "tha-Thai",
+    "tgl-Latn",
+    "tur-Latn",
+    "ukr-Cyrl",
+    "urd-Arab",
+    "vie-Latn",
+    "yor-Latn",
+    "zho-Hans",
+]
+
+OCTEN_CITATION = """@misc{octen-embedding-2025,
+  title={Octen-Embedding-8B: A Fine-tuned Multilingual Text Embedding Model},
+  author={Octen Team},
+  year={2025},
+  url={https://huggingface.co/bflhc/bflhc/Octen-Embedding-8B}
+}"""
+
+training_data = {
+    "T2Retrieval",
+    "DuRetrieval",
+    "MMarcoReranking",
+    "CMedQAv2-reranking",
+    "NQ",
+    "MSMARCO",
+    "HotpotQA",
+    "FEVER",
+    "MrTidyRetrieval",
+    "MIRACLRetrieval",
+    "CodeSearchNet",
+}
+
+# Predefined prompts for various RTEB tasks
+_PREDEFINED_PROMPTS = {
+    # ========== Open Datasets ==========
+    # Legal domain
+    "AILACasedocs": "Given a legal case scenario, retrieve the most relevant case documents",
+    "AILAStatutes": "Given a legal scenario, retrieve the most relevant statute documents",
+    "LegalQuAD": "Given a legal question, retrieve relevant legal documents that answer the question",
+    "LegalSummarization": "Given a query, retrieve relevant legal documents for summarization",
+    # Code domain
+    "AppsRetrieval": "Given a query about mobile applications, retrieve relevant app information",
+    "HumanEvalRetrieval": "Given a code problem description, retrieve relevant code examples",
+    "MBPPRetrieval": "Given a programming problem description, retrieve relevant code solutions",
+    "DS1000Retrieval": "Given a data science problem, retrieve relevant code snippets",
+    "FreshStackRetrieval": "Given a programming question, retrieve relevant Stack Overflow posts",
+    # Finance domain
+    "FinQARetrieval": "Given a financial question, retrieve relevant financial documents",
+    "FinanceBenchRetrieval": "Given a financial query, retrieve relevant financial information",
+    "HC3FinanceRetrieval": "Given a finance-related query, retrieve relevant documents",
+    # Medical domain
+    "CUREv1": "Given a medical query, retrieve relevant clinical documents",
+    "ChatDoctorRetrieval": "Given a medical question, retrieve relevant medical information",
+    # SQL domain
+    "WikiSQLRetrieval": "Given a natural language query, retrieve relevant SQL examples",
+    # Multilingual
+    "MIRACLRetrievalHardNegatives": "Given a question, retrieve Wikipedia passages that answer the question",
+    # ========== Private/Closed Datasets ==========
+    # Code domain (Private)
+    "Code1Retrieval": "Given a code problem description, retrieve relevant code examples",
+    "JapaneseCode1Retrieval": "Given a code problem description, retrieve relevant code examples",
+    # Finance domain (Private)
+    "EnglishFinance1Retrieval": "Given a financial query, retrieve relevant financial documents",
+    "EnglishFinance2Retrieval": "Given a financial query, retrieve relevant financial documents",
+    "EnglishFinance3Retrieval": "Given a financial query, retrieve relevant financial documents",
+    "EnglishFinance4Retrieval": "Given a financial query, retrieve relevant financial documents",
+    # Healthcare domain (Private)
+    "EnglishHealthcare1Retrieval": "Given a medical question, retrieve relevant medical information",
+    "GermanHealthcare1Retrieval": "Given a medical question, retrieve relevant medical information",
+    # Legal domain (Private)
+    "FrenchLegal1Retrieval": "Given a legal query, retrieve relevant legal documents",
+    "GermanLegal1Retrieval": "Given a legal query, retrieve relevant legal documents",
+    "JapaneseLegal1Retrieval": "Given a legal query, retrieve relevant legal documents",
+    # General/Multilingual (Private)
+    "French1Retrieval": "Given a query, retrieve relevant passages",
+    "German1Retrieval": "Given a query, retrieve relevant passages",
+}
+
+Octen_Embedding_0B6 = ModelMeta(
+    loader=InstructSentenceTransformerModel,
+    loader_kwargs=dict(
+        instruction_template=instruction_template,
+        apply_instruction_to_passages=True,
+        prompts_dict=_PREDEFINED_PROMPTS,
+        max_seq_length=18480,
+        model_kwargs={"torch_dtype": "bfloat16"},
+    ),
+    name="bflhc/Octen-Embedding-0.6B",
+    languages=multilingual_langs,
+    open_weights=True,
+    revision="1a00a4e837bd788f6f8d91bc43201a5e52cf8ef8",
+    release_date="2026-01-10",
+    n_parameters=595776512,
+    memory_usage_mb=1136,
+    embed_dim=1024,
+    max_tokens=32768,
+    license="apache-2.0",
+    reference="https://huggingface.co/bflhc/Octen-Embedding-0.6B",
+    similarity_fn_name="cosine",
+    framework=["Sentence Transformers", "PyTorch", "safetensors"],
+    use_instructions=True,
+    public_training_code=None,
+    public_training_data=None,
+    training_datasets=training_data,
+    citation=OCTEN_CITATION,
+    adapted_from="Qwen/Qwen3-Embedding-0.6B",
+)
+
+Octen_Embedding_4B = ModelMeta(
+    loader=InstructSentenceTransformerModel,
+    loader_kwargs=dict(
+        instruction_template=instruction_template,
+        apply_instruction_to_passages=True,
+        prompts_dict=_PREDEFINED_PROMPTS,
+        max_seq_length=18480,
+        model_kwargs={"torch_dtype": "bfloat16"},
+    ),
+    name="bflhc/Octen-Embedding-4B",
+    languages=multilingual_langs,
+    open_weights=True,
+    revision="6e188e3b072c3e3678b235ad84e6e97bcbb71e8f",
+    release_date="2025-12-30",
+    n_parameters=4021774336,
+    memory_usage_mb=7671,
+    embed_dim=2560,
+    max_tokens=32768,
+    license="apache-2.0",
+    reference="https://huggingface.co/bflhc/Octen-Embedding-4B",
+    similarity_fn_name="cosine",
+    framework=["Sentence Transformers", "PyTorch", "safetensors"],
+    use_instructions=True,
+    public_training_code=None,
+    public_training_data=None,
+    training_datasets=training_data,
+    citation=OCTEN_CITATION,
+    adapted_from="Qwen/Qwen3-Embedding-4B",
+)
+
+Octen_Embedding_8B = ModelMeta(
+    loader=InstructSentenceTransformerModel,
+    loader_kwargs=dict(
+        instruction_template=instruction_template,
+        apply_instruction_to_passages=True,
+        prompts_dict=_PREDEFINED_PROMPTS,
+        max_seq_length=18480,
+        model_kwargs={"torch_dtype": "bfloat16"},
+    ),
+    name="bflhc/Octen-Embedding-8B",
+    languages=multilingual_langs,
+    open_weights=True,
+    revision="f7db178d5a82fb841f606a6a67c423cead2fdbba",
+    release_date="2025-12-23",
+    n_parameters=7567295488,
+    memory_usage_mb=14433,
+    embed_dim=4096,
+    max_tokens=32768,
+    license="apache-2.0",
+    reference="https://huggingface.co/bflhc/Octen-Embedding-8B",
+    similarity_fn_name="cosine",
+    framework=["Sentence Transformers", "PyTorch", "safetensors"],
+    use_instructions=True,
+    public_training_code=None,
+    public_training_data=None,
+    training_datasets=training_data,
+    citation=OCTEN_CITATION,
+    adapted_from="Qwen/Qwen3-Embedding-8B",
+)