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

mteb/models/cache_wrappers/cache_backends/numpy_cache.py

@@ -1,11 +1,11 @@
 import json
 import logging
+import warnings
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 
-from mteb.types import BatchedInput
-
 from ._hash_utils import _hash_item
 
 logger = logging.getLogger(__name__)
@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 class NumpyCache:
     """Generic vector cache for both text and images."""
 
-    def __init__(self, directory: str | Path, initial_vectors: int = 100000):
+    def __init__(self, directory: str | Path, initial_vectors: int = 100_000):
         self.directory = Path(directory)
         self.directory.mkdir(parents=True, exist_ok=True)
         self.vectors_file = self.directory / "vectors.npy"
@@ -27,7 +27,7 @@ class NumpyCache:
         logger.info(f"Initialized VectorCacheMap in directory: {self.directory}")
         self._initialize_vectors_file()
 
-    def add(self, item: list[BatchedInput], vectors: np.ndarray) -> None:
+    def add(self, items: list[dict[str, Any]], vectors: np.ndarray) -> None:
         """Add a vector to the cache."""
         try:
             if self.vector_dim is None:
@@ -38,12 +38,17 @@ class NumpyCache:
                 self._save_dimension()
                 logger.info(f"Initialized vector dimension to {self.vector_dim}")
 
-            for item, vec in zip(item, vectors):
+            if self.vectors is None:
+                raise RuntimeError(
+                    "Vectors file not initialized. Call _initialize_vectors_file() first."
+                )
+
+            for item, vec in zip(items, vectors):
                 item_hash = _hash_item(item)
                 if item_hash in self.hash_to_index:
-                    logger.warning(
-                        "Hash collision or duplicate item. Overwriting existing vector."
-                    )
+                    msg = f"Hash collision or duplicate item for hash {item_hash}. Overwriting existing vector."
+                    logger.warning(msg)
+                    warnings.warn(msg)
                     index = self.hash_to_index[item_hash]
                 else:
                     index = len(self.hash_to_index)
@@ -74,18 +79,26 @@ class NumpyCache:
                 shape=(self.initial_vectors, self.vector_dim),
             )
         else:
-            self.vectors = np.memmap(self.vectors_file, dtype="float32", mode="r+")
-            self.vectors = self.vectors.reshape(-1, self.vector_dim)
+            self.vectors = np.memmap(
+                self.vectors_file,
+                dtype="float32",
+                mode="r+",
+                shape=(-1, self.vector_dim),
+            )
         logger.info(f"Vectors file initialized with shape: {self.vectors.shape}")
 
     def _double_vectors_file(self) -> None:
+        if self.vectors is None or self.vector_dim is None:
+            raise RuntimeError(
+                "Vectors file not initialized. Call _initialize_vectors_file() first."
+            )
         current_size = len(self.vectors)
         new_size = current_size * 2
         logger.info(f"Doubling vectors file from {current_size} to {new_size} vectors")
         self.vectors.flush()
         new_vectors = np.memmap(
-            self.vectors_file,
-            dtype="float32",
+            str(self.vectors_file),
+            dtype=np.float32,
             mode="r+",
             shape=(new_size, self.vector_dim),
         )
@@ -107,9 +120,9 @@ class NumpyCache:
                 f"Loaded vector dimension {self.vector_dim} from {self.dimension_file}"
             )
         else:
-            logger.warning(
-                "Dimension file not found. Vector dimension remains uninitialized."
-            )
+            msg = "Dimension file not found. Vector dimension remains uninitialized."
+            logger.warning(msg)
+            warnings.warn(msg)
 
     def save(self) -> None:
         """Persist VectorCacheMap to disk."""
@@ -146,25 +159,30 @@ class NumpyCache:
 
                 if self.vector_dim is not None:
                     self.vectors = np.memmap(
-                        self.vectors_file, dtype="float32", mode="r+"
+                        self.vectors_file,
+                        dtype="float32",
+                        mode="r+",
+                        shape=(-1, self.vector_dim),
                     )
-                    self.vectors = self.vectors.reshape(-1, self.vector_dim)
                     logger.info(f"Loaded vectors file with shape: {self.vectors.shape}")
                 else:
-                    logger.warning(
-                        "Vector dimension not set. Unable to load vectors file."
-                    )
+                    msg = "Vector dimension not set. Unable to load vectors file."
+                    logger.warning(msg)
+                    warnings.warn(msg)
                 logger.info(f"Loaded VectorCacheMap from {self.directory}")
             else:
-                logger.warning(
-                    "No existing files found. Initialized empty VectorCacheMap."
-                )
+                msg = "No existing files found. Initialized empty VectorCacheMap."
+                logger.warning(msg)
+                warnings.warn(msg)
         except Exception as e:
             logger.error(f"Error loading VectorCacheMap: {str(e)}")
             raise
 
-    def get_vector(self, item: BatchedInput) -> np.ndarray | None:
+    def get_vector(self, item: dict[str, Any]) -> np.ndarray | None:
         """Retrieve vector from index by hash."""
+        if self.vectors is None:
+            return None
+
         try:
             item_hash = _hash_item(item)
             if item_hash not in self.hash_to_index:
@@ -176,7 +194,7 @@ class NumpyCache:
             logger.error(f"Error retrieving vector for item: {str(e)}")
             raise
 
-    def __contains__(self, item: BatchedInput) -> bool:
+    def __contains__(self, item: dict[str, Any]) -> bool:
         return _hash_item(item) in self.hash_to_index
 
     def __del__(self):

mteb/models/cache_wrappers/cache_wrapper.py

@@ -90,9 +90,9 @@ class CachedEmbeddingWrapper:
         try:
             cache = self._get_or_create_cache(task_name)
 
-            uncached_items: list[BatchedInput] = []
+            uncached_items: list[dict[str, Any]] = []
             uncached_indices: list[int] = []
-            all_items = inputs.dataset
+            all_items: Dataset = inputs.dataset
             cached_vectors: dict[int, np.ndarray] = {}
 
             for i, item in enumerate(all_items):
@@ -112,7 +112,7 @@ class CachedEmbeddingWrapper:
                     dataset,
                     task_metadata=task_metadata,
                     prompt_type=prompt_type,
-                    batch_size=batch_size,
+                    **kwargs,
                 )
                 new_vectors = self._model.encode(
                     dl,

mteb/models/get_model_meta.py

@@ -1,25 +1,15 @@
-from __future__ import annotations
-
 import difflib
 import logging
 from collections.abc import Iterable
-from typing import TYPE_CHECKING, Any
-
-from huggingface_hub import ModelCard
-from huggingface_hub.errors import RepositoryNotFoundError
+from typing import Any
 
 from mteb.abstasks import AbsTask
 from mteb.models import (
-    CrossEncoderWrapper,
     ModelMeta,
     MTEBModels,
-    sentence_transformers_loader,
 )
 from mteb.models.model_implementations import MODEL_REGISTRY
 
-if TYPE_CHECKING:
-    from sentence_transformers import CrossEncoder, SentenceTransformer
-
 logger = logging.getLogger(__name__)
 
 
@@ -31,6 +21,7 @@ def get_model_metas(
     n_parameters_range: tuple[int | None, int | None] = (None, None),
     use_instructions: bool | None = None,
     zero_shot_on: list[AbsTask] | None = None,
+    model_types: Iterable[str] | None = None,
 ) -> list[ModelMeta]:
     """Load all models' metadata that fit the specified criteria.
 
@@ -43,6 +34,7 @@ def get_model_metas(
             If (None, None), this filter is ignored.
         use_instructions: Whether to filter by models that use instructions. If None, all models are included.
         zero_shot_on: A list of tasks on which the model is zero-shot. If None this filter is ignored.
+        model_types: A list of model types to filter by. If None, all model types are included.
 
     Returns:
         A list of model metadata objects that fit the specified criteria.
@@ -51,6 +43,7 @@ def get_model_metas(
     model_names = set(model_names) if model_names is not None else None
     languages = set(languages) if languages is not None else None
     frameworks = set(frameworks) if frameworks is not None else None
+    model_types_set = set(model_types) if model_types is not None else None
     for model_meta in MODEL_REGISTRY.values():
         if (model_names is not None) and (model_meta.name not in model_names):
             continue
@@ -67,6 +60,10 @@ def get_model_metas(
             model_meta.use_instructions != use_instructions
         ):
             continue
+        if model_types_set is not None and not model_types_set.intersection(
+            model_meta.model_type
+        ):
+            continue
 
         lower, upper = n_parameters_range
         n_parameters = model_meta.n_parameters
@@ -85,7 +82,10 @@ def get_model_metas(
 
 
 def get_model(
-    model_name: str, revision: str | None = None, **kwargs: Any
+    model_name: str,
+    revision: str | None = None,
+    device: str | None = None,
+    **kwargs: Any,
 ) -> MTEBModels:
     """A function to fetch and load model object by name.
 
@@ -95,30 +95,23 @@ def get_model(
     Args:
         model_name: Name of the model to fetch
         revision: Revision of the model to fetch
+        device: Device used to load the model
         **kwargs: Additional keyword arguments to pass to the model loader
 
     Returns:
         A model object
     """
-    from sentence_transformers import CrossEncoder, SentenceTransformer
-
     meta = get_model_meta(model_name, revision)
-    model = meta.load_model(**kwargs)
-
-    # If revision not available in the modelmeta, try to extract it from sentence-transformers
-    if hasattr(model, "model") and isinstance(model.model, SentenceTransformer):  # type: ignore
-        _meta = _model_meta_from_sentence_transformers(model.model)  # type: ignore
-        if meta.revision is None:
-            meta.revision = _meta.revision if _meta.revision else meta.revision
-        if not meta.similarity_fn_name:
-            meta.similarity_fn_name = _meta.similarity_fn_name
-
-    elif isinstance(model, CrossEncoder):
-        _meta = _model_meta_from_cross_encoder(model.model)
-        if meta.revision is None:
-            meta.revision = _meta.revision if _meta.revision else meta.revision
-
-    model.mteb_model_meta = meta  # type: ignore
+    model = meta.load_model(device=device, **kwargs)
+
+    if kwargs:
+        logger.info(
+            f"Model '{model_name}' loaded with additional arguments: {list(kwargs.keys())}"
+        )
+        meta = meta.model_copy(deep=True)
+        meta.loader_kwargs |= kwargs
+
+    model.mteb_model_meta = meta  # type: ignore[misc]
     return model
 
 
@@ -147,12 +140,8 @@ def get_model_meta(
         logger.info(
             "Model not found in model registry. Attempting to extract metadata by loading the model ({model_name}) using HuggingFace."
         )
-        try:
-            meta = _model_meta_from_hf_hub(model_name)
-            meta.revision = revision
-            return meta
-        except RepositoryNotFoundError:
-            pass
+        meta = ModelMeta.from_hub(model_name, revision)
+        return meta
 
     not_found_msg = f"Model '{model_name}' not found in MTEB registry"
     not_found_msg += " nor on the Huggingface Hub." if fetch_from_hf else "."
@@ -170,85 +159,3 @@ def get_model_meta(
             suggestion = f" Did you mean: '{close_matches[0]}'?"
 
     raise KeyError(not_found_msg + suggestion)
-
-
-def _model_meta_from_hf_hub(model_name: str) -> ModelMeta:
-    card = ModelCard.load(model_name)
-    card_data = card.data.to_dict()
-    frameworks = ["PyTorch"]
-    loader = None
-    if card_data.get("library_name", None) == "sentence-transformers":
-        frameworks.append("Sentence Transformers")
-        loader = sentence_transformers_loader
-    revision = card_data.get("base_model_revision", None)
-    license = card_data.get("license", None)
-    return ModelMeta(
-        loader=loader,
-        name=model_name,
-        revision=revision,
-        release_date=None,
-        languages=None,
-        license=license,
-        framework=frameworks,  # type: ignore
-        training_datasets=None,
-        similarity_fn_name=None,
-        n_parameters=None,
-        memory_usage_mb=None,
-        max_tokens=None,
-        embed_dim=None,
-        open_weights=True,
-        public_training_code=None,
-        public_training_data=None,
-        use_instructions=None,
-    )
-
-
-def _model_meta_from_cross_encoder(model: CrossEncoder) -> ModelMeta:
-    return ModelMeta(
-        loader=CrossEncoderWrapper,
-        name=model.model.name_or_path,
-        revision=model.config._commit_hash,
-        release_date=None,
-        languages=None,
-        framework=["Sentence Transformers"],
-        similarity_fn_name=None,
-        n_parameters=None,
-        memory_usage_mb=None,
-        max_tokens=None,
-        embed_dim=None,
-        license=None,
-        open_weights=True,
-        public_training_code=None,
-        public_training_data=None,
-        use_instructions=None,
-        training_datasets=None,
-    )
-
-
-def _model_meta_from_sentence_transformers(model: SentenceTransformer) -> ModelMeta:
-    name: str | None = (
-        model.model_card_data.model_name
-        if model.model_card_data.model_name
-        else model.model_card_data.base_model
-    )
-    embeddings_dim = model.get_sentence_embedding_dimension()
-    meta = ModelMeta(
-        loader=sentence_transformers_loader,
-        name=name,
-        revision=model.model_card_data.base_model_revision,
-        release_date=None,
-        languages=None,
-        framework=["Sentence Transformers"],
-        similarity_fn_name=None,
-        n_parameters=None,
-        memory_usage_mb=None,
-        max_tokens=None,
-        embed_dim=embeddings_dim,
-        license=None,
-        open_weights=True,
-        public_training_code=None,
-        public_training_data=None,
-        use_instructions=None,
-        training_datasets=None,
-    )
-    return meta

mteb/models/instruct_wrapper.py

@@ -17,7 +17,8 @@ logger = logging.getLogger(__name__)
 def instruct_wrapper(
     model_name_or_path: str,
     mode: str,
-    instruction_template: str | Callable[[str], str] | None = None,
+    instruction_template: str | Callable[[str, PromptType | None], str] | None = None,
+    device: str | None = None,
     **kwargs,
 ):
     """Instruct wrapper for models. Uses GritLM to pass instructions to the model.
@@ -28,6 +29,7 @@ def instruct_wrapper(
         model_name_or_path: Model name or path.
         mode: Mode of the model. Either 'query' or 'passage'.
         instruction_template: Instruction template. Should contain the string '{instruction}'.
+        device: Device used to load the model.
         **kwargs: Additional arguments to pass to the model.
     """
     requires_package(
@@ -40,7 +42,10 @@ def instruct_wrapper(
             self,
             model_name_or_path: str,
             mode: str,
-            instruction_template: str | Callable[[str, PromptType], str] | None = None,
+            device: str | None = None,
+            instruction_template: str
+            | Callable[[str, PromptType | None], str]
+            | None = None,
             **kwargs,
         ):
             if (
@@ -61,7 +66,12 @@ def instruct_wrapper(
                 )
 
             self.instruction_template = instruction_template
-            super().__init__(model_name_or_path=model_name_or_path, mode=mode, **kwargs)
+            super().__init__(
+                model_name_or_path=model_name_or_path,
+                mode=mode,
+                device=device,
+                **kwargs,
+            )
 
         def encode(
             self,
@@ -82,15 +92,20 @@ def instruct_wrapper(
             logger.info(
                 f"Using instruction: '{instruction}' for task: '{task_metadata.name}'"
             )
-            embeddings = super().encode(
-                _inputs, instruction=instruction, *args, **kwargs
+            embeddings = super().encode(  # type: ignore[safe-super,call-arg]
+                _inputs,  # type: ignore[arg-type]
+                instruction=instruction,
+                *args,
+                **kwargs,
             )
             if isinstance(embeddings, torch.Tensor):
                 # sometimes in kwargs can be return_tensors=True
                 embeddings = embeddings.cpu().detach().float().numpy()
             return embeddings
 
-    return InstructGritLMModel(model_name_or_path, mode, instruction_template, **kwargs)
+    return InstructGritLMModel(
+        model_name_or_path, mode, instruction_template=instruction_template, **kwargs
+    )
 
 
 class InstructSentenceTransformerModel(AbsEncoder):
@@ -100,6 +115,7 @@ class InstructSentenceTransformerModel(AbsEncoder):
         self,
         model_name: str,
         revision: str,
+        device: str | None = None,
         instruction_template: str
         | Callable[[str, PromptType | None], str]
         | None = None,
@@ -117,12 +133,14 @@ class InstructSentenceTransformerModel(AbsEncoder):
         Arguments:
             model_name: Model name of the sentence transformers model.
             revision: Revision of the sentence transformers model.
+            device: Device used to load the model.
             instruction_template: Model template. Should contain the string '{instruction}'.
             max_seq_length: Maximum sequence length. If None, the maximum sequence length will be read from the model config.
             apply_instruction_to_passages: Whether to apply the instruction template to the passages.
             padding_side: Padding side. If None, the padding side will be read from the model config.
             add_eos_token: Whether to add the eos token to each input example.
-            prompts_dict: Dictionary of task names to prompt names. If None, the prompts will be read from the model config.
+            prompts_dict: Dictionary of task names to prompt names. If task name is missing in the dict or prompts dict is None, prompt from task metadata or
+                AbsTask.abstask_prompt will be used.
             **kwargs: Kwargs for Sentence Transformer model.
         """
         from sentence_transformers import SentenceTransformer
@@ -140,7 +158,7 @@ class InstructSentenceTransformerModel(AbsEncoder):
             )
 
         self.instruction_template = instruction_template
-        tokenizer_params = {}
+        tokenizer_params: dict[str, Any] = {}
         if add_eos_token:
             tokenizer_params["add_eos_token"] = add_eos_token
         if max_seq_length is not None:
@@ -152,7 +170,12 @@ class InstructSentenceTransformerModel(AbsEncoder):
         kwargs.setdefault("tokenizer_kwargs", {}).update(tokenizer_params)
 
         self.model_name = model_name
-        self.model = SentenceTransformer(model_name, revision=revision, **kwargs)
+        self.model = SentenceTransformer(
+            model_name, revision=revision, device=device, **kwargs
+        )
+        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
 
@@ -189,6 +212,7 @@ class InstructSentenceTransformerModel(AbsEncoder):
             The encoded input in a numpy array or torch tensor of the shape (Number of sentences) x (Embedding dimension).
         """
         sentences = [text for batch in inputs for text in batch["text"]]
+        instruction: str | None
         instruction = self.get_task_instruction(task_metadata, prompt_type)
 
         # to passage prompts won't be applied to passages

mteb/models/model_implementations/align_models.py

@@ -105,6 +105,7 @@ class ALIGNModel(AbsEncoder):
 align_base = ModelMeta(
     loader=ALIGNModel,
     name="kakaobrain/align-base",
+    model_type=["dense"],
     languages=["eng-Latn"],
     revision="e96a37facc7b1f59090ece82293226b817afd6ba",
     release_date="2023-02-24",
@@ -117,11 +118,17 @@ align_base = ModelMeta(
     open_weights=True,
     public_training_code="https://github.com/kakaobrain/coyo-align",
     public_training_data=True,
-    framework=["PyTorch"],
+    framework=["PyTorch", "Transformers"],
     reference="https://huggingface.co/kakaobrain/align-base",
     similarity_fn_name=ScoringFunction.COSINE,
     use_instructions=False,
     training_datasets=set(
         #  COYO-700M
     ),
+    citation="""@misc{kakaobrain2022coyo-align,
+    title         = {COYO-ALIGN},
+    author        = {Yoon, Boogeo and Lee, Youhan and Baek, Woonhyuk},
+    year          = {2022},
+    howpublished  = {https://github.com/kakaobrain/coyo-align},
+}""",
 )

mteb/models/model_implementations/amazon_models.py

@@ -3,6 +3,7 @@ from mteb.models.model_meta import ModelMeta, ScoringFunction
 amazon_titan_text_embeddings_v2 = ModelMeta(
     loader=None,
     name="amazon/Titan-text-embeddings-v2",
+    model_type=["dense"],
     revision="1",
     release_date="2024-04-30",
     languages=["eng-Latn"],

mteb/models/model_implementations/andersborges.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from mteb.models.model_implementations.model2vec_models import Model2VecModel
+from mteb.models.model_meta import ModelMeta, ScoringFunction
+
+model2vecdk = ModelMeta(
+    loader=Model2VecModel,
+    name="andersborges/model2vecdk",
+    model_type=["dense"],
+    languages=["dan-Latn"],
+    open_weights=True,
+    revision="cb576c78dcc1b729e4612645f61db59929d69e61",
+    release_date="2025-11-21",
+    n_parameters=48042496,
+    memory_usage_mb=183,
+    max_tokens=np.inf,
+    embed_dim=256,
+    license="mit",
+    similarity_fn_name=ScoringFunction.COSINE,
+    framework=["NumPy", "Sentence Transformers", "safetensors"],
+    reference="https://huggingface.co/andersborges/model2vecdk",
+    use_instructions=False,
+    adapted_from="https://huggingface.co/jealk/TTC-L2V-supervised-2",
+    superseded_by=None,
+    training_datasets=set(),  # distilled
+    public_training_code="https://github.com/andersborges/dkmodel2vec",
+    public_training_data="https://huggingface.co/datasets/DDSC/nordic-embedding-training-data",
+    citation="""@article{minishlab2024model2vec,
+  author = {Tulkens, Stephan and {van Dongen}, Thomas},
+  title = {Model2Vec: Fast State-of-the-Art Static Embeddings},
+  year = {2024},
+  url = {https://github.com/MinishLab/model2vec}
+}""",
+)
+
+
+model2vecdk_stem = ModelMeta(
+    loader=Model2VecModel,
+    name="andersborges/model2vecdk-stem",
+    model_type=["dense"],
+    languages=["dan-Latn"],
+    open_weights=True,
+    revision="cb576c78dcc1b729e4612645f61db59929d69e61",
+    release_date="2025-11-21",
+    n_parameters=48578560,
+    memory_usage_mb=185,
+    max_tokens=np.inf,
+    embed_dim=256,
+    license="mit",
+    similarity_fn_name=ScoringFunction.COSINE,
+    framework=["NumPy", "Sentence Transformers", "safetensors"],
+    reference="https://huggingface.co/andersborges/model2vecdk",
+    use_instructions=False,
+    adapted_from="https://huggingface.co/jealk/TTC-L2V-supervised-2",
+    superseded_by=None,
+    training_datasets=set(),  # distilled
+    public_training_code="https://github.com/andersborges/dkmodel2vec",
+    public_training_data="https://huggingface.co/datasets/DDSC/nordic-embedding-training-data",
+    citation="""@article{minishlab2024model2vec,
+  author = {Tulkens, Stephan and {van Dongen}, Thomas},
+  title = {Model2Vec: Fast State-of-the-Art Static Embeddings},
+  year = {2024},
+  url = {https://github.com/MinishLab/model2vec}
+}""",
+)

mteb/models/model_implementations/ara_models.py

@@ -4,6 +4,7 @@ from mteb.models.sentence_transformer_wrapper import sentence_transformers_loade
 arabic_triplet_matryoshka = ModelMeta(
     loader=sentence_transformers_loader,
     name="Omartificial-Intelligence-Space/Arabic-Triplet-Matryoshka-V2",
+    model_type=["dense"],
     languages=["ara-Arab"],
     open_weights=True,
     revision="ed357f222f0b6ea6670d2c9b5a1cb93950d34200",
@@ -15,7 +16,7 @@ arabic_triplet_matryoshka = ModelMeta(
     max_tokens=768,
     reference="https://huggingface.co/Omartificial-Intelligence-Space/Arabic-Triplet-Matryoshka-V2",
     similarity_fn_name=ScoringFunction.COSINE,
-    framework=["Sentence Transformers", "PyTorch"],
+    framework=["Sentence Transformers", "PyTorch", "safetensors", "Transformers"],
     use_instructions=False,
     public_training_code=None,
     adapted_from="aubmindlab/bert-base-arabertv02",
@@ -23,4 +24,11 @@ arabic_triplet_matryoshka = ModelMeta(
     training_datasets=set(
         #  "akhooli/arabic-triplets-1m-curated-sims-len"
     ),
+    citation="""
+    @article{nacar2025gate,
+    title={GATE: General Arabic Text Embedding for Enhanced Semantic Textual Similarity with Matryoshka Representation Learning and Hybrid Loss Training},
+    author={Nacar, Omer and Koubaa, Anis and Sibaee, Serry and Al-Habashi, Yasser and Ammar, Adel and Boulila, Wadii},
+    journal={arXiv preprint arXiv:2505.24581},
+    year={2025}
+}""",
 )