mteb 2.2.2__py3-none-any.whl → 2.3.0__py3-none-any.whl

mteb/__init__.py

@@ -9,8 +9,10 @@ from mteb.filter_tasks import filter_tasks
 from mteb.get_tasks import get_task, get_tasks
 from mteb.load_results import load_results
 from mteb.models import (
+    CacheBackendProtocol,
     CrossEncoderProtocol,
     EncoderProtocol,
+    IndexEncoderSearchProtocol,
     SearchProtocol,
     SentenceTransformerEncoderWrapper,
 )
@@ -27,8 +29,10 @@ __all__ = [
     "AbsTask",
     "Benchmark",
     "BenchmarkResults",
+    "CacheBackendProtocol",
     "CrossEncoderProtocol",
     "EncoderProtocol",
+    "IndexEncoderSearchProtocol",
     "SearchProtocol",
     "SentenceTransformerEncoderWrapper",
     "TaskMetadata",

mteb/models/__init__.py

@@ -1,4 +1,4 @@
-from .cache_wrappers import CachedEmbeddingWrapper
+from .cache_wrappers import CacheBackendProtocol, CachedEmbeddingWrapper
 from .model_meta import ModelMeta
 from .models_protocols import (
     CrossEncoderProtocol,
@@ -6,6 +6,7 @@ from .models_protocols import (
     MTEBModels,
     SearchProtocol,
 )
+from .search_encoder_index.search_backend_protocol import IndexEncoderSearchProtocol
 from .search_wrappers import SearchCrossEncoderWrapper, SearchEncoderWrapper
 from .sentence_transformer_wrapper import (
     CrossEncoderWrapper,
@@ -14,10 +15,12 @@ from .sentence_transformer_wrapper import (
 )
 
 __all__ = [
+    "CacheBackendProtocol",
     "CachedEmbeddingWrapper",
     "CrossEncoderProtocol",
     "CrossEncoderWrapper",
     "EncoderProtocol",
+    "IndexEncoderSearchProtocol",
     "MTEBModels",
     "ModelMeta",
     "SearchCrossEncoderWrapper",

mteb/models/cache_wrappers/__init__.py

@@ -1,3 +1,4 @@
+from .cache_backend_protocol import CacheBackendProtocol
 from .cache_wrapper import CachedEmbeddingWrapper
 
-__all__ = ["CachedEmbeddingWrapper"]
+__all__ = ["CacheBackendProtocol", "CachedEmbeddingWrapper"]

mteb/models/model_implementations/eagerworks_models.py

@@ -0,0 +1,163 @@
+from typing import Any
+
+import torch
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from mteb._requires_package import (
+    requires_image_dependencies,
+    requires_package,
+)
+from mteb.abstasks.task_metadata import TaskMetadata
+from mteb.models.abs_encoder import AbsEncoder
+from mteb.models.model_meta import ModelMeta, ScoringFunction
+from mteb.types import Array, BatchedInput, PromptType
+
+
+class EagerEmbedV1Wrapper(AbsEncoder):
+    """Wrapper for EagerEmbed single-vector embedding models."""
+
+    def __init__(
+        self,
+        model_name: str,
+        revision: str | None = None,
+        device: str | None = None,
+        image_size: int = 784,
+        **kwargs,
+    ):
+        requires_image_dependencies()
+        requires_package(
+            self, "qwen_vl_utils", model_name, "pip install mteb[eager_embed]"
+        )
+        from transformers import AutoProcessor, Qwen3VLForConditionalGeneration
+
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.image_size = image_size
+
+        # Load model
+        self.mdl = Qwen3VLForConditionalGeneration.from_pretrained(model_name, **kwargs)
+        self.mdl = self.mdl.to(self.device)
+        self.mdl.eval()
+
+        # Load processor
+        self.processor = AutoProcessor.from_pretrained(model_name)
+
+    def get_embedding(self, last_hidden_state: torch.Tensor) -> torch.Tensor:
+        """Extract embeddings from last token of last hidden state."""
+        reps = last_hidden_state[:, -1]
+        return reps
+
+    def encode(
+        self,
+        inputs: DataLoader[BatchedInput],
+        *,
+        task_metadata: TaskMetadata,
+        hf_split: str,
+        hf_subset: str,
+        prompt_type: PromptType | None = None,
+        **kwargs: Any,
+    ) -> Array:
+        """Encode inputs (text and/or images) into embeddings."""
+        from qwen_vl_utils import process_vision_info
+
+        all_embeddings: list[torch.Tensor] = []
+
+        with torch.no_grad():
+            for batch in tqdm(inputs, desc="Encoding"):
+                batch_texts = batch.get("text", [])
+                batch_images = batch.get("image", [])
+
+                messages = []
+                for i in range(max(len(batch_texts), len(batch_images))):
+                    text_content = batch_texts[i] if batch_texts else ""
+                    image_content = batch_images[i] if batch_images else None
+
+                    query_prefix = "Query: " if prompt_type == PromptType.query else ""
+                    content = [
+                        {"type": "text", "text": f"{query_prefix}{text_content}"}
+                    ]
+
+                    if image_content is not None:
+                        content.append(
+                            {
+                                "type": "image",
+                                "image": image_content,
+                                "resized_height": self.image_size,
+                                "resized_width": self.image_size,
+                            }
+                        )
+
+                    messages.append([{"role": "user", "content": content}])
+
+                # Prepare inputs
+                texts = [
+                    self.processor.apply_chat_template(
+                        msg, tokenize=False, add_generation_prompt=False
+                    )
+                    + "<|endoftext|>"
+                    for msg in messages
+                ]
+
+                image_inputs = None
+                video_inputs = None
+                if batch_images:
+                    image_inputs, video_inputs = process_vision_info(messages)
+
+                model_inputs = self.processor(
+                    text=texts,
+                    images=image_inputs,
+                    videos=video_inputs,
+                    padding="longest",
+                    return_tensors="pt",
+                ).to(self.device)
+
+                # Get embeddings
+                output = self.mdl(
+                    **model_inputs, return_dict=True, output_hidden_states=True
+                )
+                embeddings = self.get_embedding(output.hidden_states[-1])
+                embeddings = embeddings.cpu().to(torch.float32)
+                embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=-1)
+
+                all_embeddings.append(embeddings)
+
+        return torch.cat(all_embeddings, dim=0)
+
+
+EAGER_EMBED_V1_CITATION = """@article{EagerEmbed,
+  title={Eager Embed V1: Multimodal Dense Embeddings for Retrieval},
+  author={Juan Pablo Balarini},
+  year={2025},
+  publisher={Eagerworks},
+  url={https://github.com/eagerworks/eager-embed},
+}"""
+
+EAGER_EMBED_V1_TRAINING_DATASETS = {"colpali", "bge-ir", "pixmo-docs", "wiki-ss"}
+
+Eager_Embed_V1 = ModelMeta(
+    loader=EagerEmbedV1Wrapper,
+    loader_kwargs=dict(
+        dtype=torch.float16,
+        image_size=784,
+    ),
+    name="eagerworks/eager-embed-v1",
+    languages=["fra-Latn", "spa-Latn", "eng-Latn", "deu-Latn"],
+    revision="a6bec272729c5056e2c26618ce085205c82a3b3c",
+    release_date="2025-11-20",
+    modalities=["image", "text"],
+    n_parameters=4_000_000_000,
+    memory_usage_mb=16929,
+    max_tokens=262144,
+    embed_dim=2560,
+    license="apache-2.0",
+    open_weights=True,
+    framework=["Tevatron"],
+    reference="https://huggingface.co/eagerworks/eager-embed-v1",
+    similarity_fn_name=ScoringFunction.COSINE,
+    use_instructions=True,
+    training_datasets=EAGER_EMBED_V1_TRAINING_DATASETS,
+    citation=EAGER_EMBED_V1_CITATION,
+    adapted_from="https://huggingface.co/Qwen/Qwen3-VL-4B-Instruct",
+    public_training_code="https://github.com/eagerworks/eager-embed",
+    public_training_data="https://github.com/eagerworks/eager-embed/blob/main/dataset_config.yaml",
+)

mteb/models/model_implementations/google_models.py

@@ -275,5 +275,5 @@ embedding_gemma_300m = ModelMeta(
     public_training_data=None,
     training_datasets=GECKO_TRAINING_DATA,
     similarity_fn_name="cosine",
-    memory_usage_mb=578,
+    memory_usage_mb=1155,
 )

mteb/models/model_implementations/nb_sbert.py

@@ -11,7 +11,7 @@ nb_sbert = ModelMeta(
     revision="b95656350a076aeafd2d23763660f80655408cc6",
     release_date="2022-11-23",
     n_parameters=1_780_000_000,
-    memory_usage_mb=197,
+    memory_usage_mb=678,
     embed_dim=4096,
     license="apache-2.0",
     max_tokens=75,

mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py

@@ -146,7 +146,7 @@ llama_nemoretriever_colembed_1b_v1 = ModelMeta(
     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",
@@ -172,7 +172,7 @@ llama_nemoretriever_colembed_3b_v1 = ModelMeta(
     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",

mteb/models/model_implementations/nvidia_models.py

@@ -146,7 +146,7 @@ NV_embed_v1 = ModelMeta(
     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,

mteb/models/model_implementations/ops_moa_models.py

@@ -27,7 +27,7 @@ ops_moa_conan_embedding = ModelMeta(
     languages=["zho-Hans"],
     loader=OPSWrapper,
     n_parameters=int(343 * 1e6),
-    memory_usage_mb=2e3,
+    memory_usage_mb=1308,
     max_tokens=512,
     embed_dim=1536,
     license="cc-by-nc-4.0",
@@ -58,7 +58,7 @@ ops_moa_yuan_embedding = ModelMeta(
     languages=["zho-Hans"],
     loader=OPSWrapper,
     n_parameters=int(343 * 1e6),
-    memory_usage_mb=2e3,
+    memory_usage_mb=1242,
     max_tokens=512,
     embed_dim=1536,
     license="cc-by-nc-4.0",

mteb/models/model_implementations/promptriever_models.py

@@ -80,7 +80,7 @@ promptriever_llama2 = ModelMeta(
     revision="01c7f73d771dfac7d292323805ebc428287df4f9-30b14e3813c0fa45facfd01a594580c3fe5ecf23",  # base-peft revision
     release_date="2024-09-15",
     n_parameters=7_000_000_000,
-    memory_usage_mb=27,
+    memory_usage_mb=26703,
     max_tokens=4096,
     embed_dim=4096,
     license="apache-2.0",
@@ -115,7 +115,7 @@ promptriever_llama3 = ModelMeta(
     },
     release_date="2024-09-15",
     n_parameters=8_000_000_000,
-    memory_usage_mb=31,
+    memory_usage_mb=30518,
     max_tokens=8192,
     embed_dim=4096,
     license="apache-2.0",
@@ -143,7 +143,7 @@ promptriever_llama3_instruct = ModelMeta(
     revision="5206a32e0bd3067aef1ce90f5528ade7d866253f-8b677258615625122c2eb7329292b8c402612c21",  # base-peft revision
     release_date="2024-09-15",
     n_parameters=8_000_000_000,
-    memory_usage_mb=31,
+    memory_usage_mb=30518,
     max_tokens=8192,
     embed_dim=4096,
     training_datasets={
@@ -175,7 +175,7 @@ promptriever_mistral_v1 = ModelMeta(
     revision="7231864981174d9bee8c7687c24c8344414eae6b-876d63e49b6115ecb6839893a56298fadee7e8f5",  # base-peft revision
     release_date="2024-09-15",
     n_parameters=7_000_000_000,
-    memory_usage_mb=27,
+    memory_usage_mb=26703,
     training_datasets={
         # "samaya-ai/msmarco-w-instructions",
         "mMARCO-NL",  # translation not trained on

mteb/models/model_implementations/qwen3_models.py

@@ -139,7 +139,7 @@ Qwen3_Embedding_0B6 = ModelMeta(
     revision="b22da495047858cce924d27d76261e96be6febc0",  # Commit of @tomaarsen
     release_date="2025-06-05",
     n_parameters=595776512,
-    memory_usage_mb=2272,
+    memory_usage_mb=1136,
     embed_dim=1024,
     max_tokens=32768,
     license="apache-2.0",
@@ -161,7 +161,7 @@ Qwen3_Embedding_4B = ModelMeta(
     revision="636cd9bf47d976946cdbb2b0c3ca0cb2f8eea5ff",  # Commit of @tomaarsen
     release_date="2025-06-05",
     n_parameters=4021774336,
-    memory_usage_mb=15341,
+    memory_usage_mb=7671,
     embed_dim=2560,
     max_tokens=32768,
     license="apache-2.0",
@@ -183,7 +183,7 @@ Qwen3_Embedding_8B = ModelMeta(
     revision="4e423935c619ae4df87b646a3ce949610c66241c",  # Commit of @tomaarsen
     release_date="2025-06-05",
     n_parameters=7567295488,
-    memory_usage_mb=28866,
+    memory_usage_mb=14433,
     embed_dim=4096,
     max_tokens=32768,
     license="apache-2.0",

mteb/models/model_implementations/qzhou_models.py

@@ -63,7 +63,7 @@ QZhou_Embedding = ModelMeta(
     revision="f1e6c03ee3882e7b9fa5cec91217715272e433b8",
     release_date="2025-08-24",
     n_parameters=7_070_619_136,
-    memory_usage_mb=29070,
+    memory_usage_mb=14436,
     embed_dim=3584,
     license="apache-2.0",
     max_tokens=8192,

mteb/models/model_implementations/random_baseline.py

@@ -8,6 +8,10 @@ from torch.utils.data import DataLoader
 
 from mteb.abstasks.task_metadata import TaskMetadata
 from mteb.models.model_meta import ModelMeta
+from mteb.similarity_functions import (
+    select_pairwise_similarity,
+    select_similarity,
+)
 from mteb.types._encoder_io import Array, BatchedInput, PromptType
 
 
@@ -155,15 +159,9 @@ class RandomEncoderBaseline:
         Returns:
             Cosine similarity matrix between the two sets of embeddings
         """
-        norm1 = np.linalg.norm(
-            embeddings1.reshape(-1, self.embedding_dim), axis=1, keepdims=True
-        )
-        norm2 = np.linalg.norm(
-            embeddings2.reshape(-1, self.embedding_dim), axis=1, keepdims=True
+        return select_similarity(
+            embeddings1, embeddings2, self.mteb_model_meta.similarity_fn_name
         )
-        normalized1 = embeddings1 / (norm1 + 1e-10)
-        normalized2 = embeddings2 / (norm2 + 1e-10)
-        return np.dot(normalized1, normalized2.T)
 
     def similarity_pairwise(
         self,
@@ -179,17 +177,9 @@ class RandomEncoderBaseline:
         Returns:
             Cosine similarity for each pair of embeddings
         """
-        norm1 = np.linalg.norm(
-            embeddings1.reshape(-1, self.embedding_dim), axis=1, keepdims=True
-        )
-        norm2 = np.linalg.norm(
-            embeddings2.reshape(-1, self.embedding_dim), axis=1, keepdims=True
+        return select_pairwise_similarity(
+            embeddings1, embeddings2, self.mteb_model_meta.similarity_fn_name
         )
-        normalized1 = embeddings1 / (norm1 + 1e-10)
-        normalized2 = embeddings2 / (norm2 + 1e-10)
-        normalized1 = np.asarray(normalized1)
-        normalized2 = np.asarray(normalized2)
-        return np.sum(normalized1 * normalized2, axis=1)
 
 
 random_encoder_baseline = ModelMeta(

mteb/models/search_encoder_index/__init__.py

@@ -0,0 +1,7 @@
+from .search_backend_protocol import IndexEncoderSearchProtocol
+from .search_indexes import FaissSearchIndex
+
+__all__ = [
+    "FaissSearchIndex",
+    "IndexEncoderSearchProtocol",
+]

mteb/models/search_encoder_index/search_backend_protocol.py

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import Protocol
+
+from mteb.types import Array, TopRankedDocumentsType
+
+
+class IndexEncoderSearchProtocol(Protocol):
+    """Protocol for search backends used in encoder-based retrieval."""
+
+    def add_documents(
+        self,
+        embeddings: Array,
+        idxs: list[str],
+    ) -> None:
+        """Add documents to the search backend.
+
+        Args:
+            embeddings: Embeddings of the documents to add.
+            idxs: IDs of the documents to add.
+        """
+
+    def search(
+        self,
+        embeddings: Array,
+        top_k: int,
+        similarity_fn: Callable[[Array, Array], Array],
+        top_ranked: TopRankedDocumentsType | None = None,
+        query_idx_to_id: dict[int, str] | None = None,
+    ) -> tuple[list[list[float]], list[list[int]]]:
+        """Search through added corpus embeddings or rerank top-ranked documents.
+
+        Supports both full-corpus and reranking search modes:
+            - Full-corpus mode: `top_ranked=None`, uses added corpus embeddings.
+            - Reranking mode:  `top_ranked` contains mapping {query_id: [doc_ids]}.
+
+        Args:
+            embeddings: Query embeddings, shape (num_queries, dim).
+            top_k: Number of top results to return.
+            similarity_fn: Function to compute similarity between query and corpus.
+            top_ranked: Mapping of query_id -> list of candidate doc_ids. Used for reranking.
+            query_idx_to_id: Mapping of query index -> query_id. Used for reranking.
+
+        Returns:
+            A tuple (top_k_values, top_k_indices), for each query:
+                - top_k_values: List of top-k similarity scores.
+                - top_k_indices: List of indices of the top-k documents in the added corpus.
+        """
+
+    def clear(self) -> None:
+        """Clear all stored documents and embeddings from the backend."""

mteb/models/search_encoder_index/search_indexes/__init__.py

@@ -0,0 +1,5 @@
+from .faiss_search_index import FaissSearchIndex
+
+__all__ = [
+    "FaissSearchIndex",
+]

mteb/models/search_encoder_index/search_indexes/faiss_search_index.py

@@ -0,0 +1,157 @@
+import logging
+from collections.abc import Callable
+
+import numpy as np
+import torch
+
+from mteb._requires_package import requires_package
+from mteb.models.model_meta import ScoringFunction
+from mteb.models.models_protocols import EncoderProtocol
+from mteb.types import Array, TopRankedDocumentsType
+
+logger = logging.getLogger(__name__)
+
+
+class FaissSearchIndex:
+    """FAISS-based backend for encoder-based search.
+
+    Supports both full-corpus retrieval and reranking (via `top_ranked`).
+
+    Notes:
+        - Stores *all* embeddings in memory (IndexFlatIP or IndexFlatL2).
+        - Expects embeddings to be normalized if cosine similarity is desired.
+    """
+
+    _normalize: bool = False
+
+    def __init__(self, model: EncoderProtocol) -> None:
+        requires_package(
+            self,
+            "faiss",
+            "FAISS-based search",
+            install_instruction="pip install mteb[faiss-cpu]",
+        )
+
+        import faiss
+        from faiss import IndexFlatIP, IndexFlatL2
+
+        # https://github.com/facebookresearch/faiss/wiki/Faiss-indexes
+        if model.mteb_model_meta.similarity_fn_name is ScoringFunction.DOT_PRODUCT:
+            self.index_type = IndexFlatIP
+        elif model.mteb_model_meta.similarity_fn_name is ScoringFunction.COSINE:
+            self.index_type = IndexFlatIP
+            self._normalize = True
+        elif model.mteb_model_meta.similarity_fn_name is ScoringFunction.EUCLIDEAN:
+            self.index_type = IndexFlatL2
+        else:
+            raise ValueError(
+                f"FAISS backend does not support similarity function {model.mteb_model_meta.similarity_fn_name}. "
+                f"Available: {ScoringFunction.DOT_PRODUCT}, {ScoringFunction.COSINE}."
+            )
+
+        self.idxs: list[str] = []
+        self.index: faiss.Index | None = None
+
+    def add_documents(self, embeddings: Array, idxs: list[str]) -> None:
+        """Add all document embeddings and their IDs to FAISS index."""
+        import faiss
+
+        if isinstance(embeddings, torch.Tensor):
+            embeddings = embeddings.detach().cpu().numpy()
+
+        embeddings = embeddings.astype(np.float32)
+        self.idxs.extend(idxs)
+
+        if self._normalize:
+            faiss.normalize_L2(embeddings)
+
+        dim = embeddings.shape[1]
+        if self.index is None:
+            self.index = self.index_type(dim)
+
+        self.index.add(embeddings)
+        logger.info(f"FAISS index built with {len(idxs)} vectors of dim {dim}.")
+
+    def search(
+        self,
+        embeddings: Array,
+        top_k: int,
+        similarity_fn: Callable[[Array, Array], Array],
+        top_ranked: TopRankedDocumentsType | None = None,
+        query_idx_to_id: dict[int, str] | None = None,
+    ) -> tuple[list[list[float]], list[list[int]]]:
+        """Search using FAISS."""
+        import faiss
+
+        if self.index is None:
+            raise ValueError("No index built. Call add_document() first.")
+
+        if isinstance(embeddings, torch.Tensor):
+            embeddings = embeddings.detach().cpu().numpy()
+
+        if self._normalize:
+            faiss.normalize_L2(embeddings)
+
+        if top_ranked is not None:
+            if query_idx_to_id is None:
+                raise ValueError("query_idx_to_id must be provided when reranking.")
+
+            similarities, ids = self._reranking(
+                embeddings,
+                top_k,
+                top_ranked=top_ranked,
+                query_idx_to_id=query_idx_to_id,
+            )
+        else:
+            similarities, ids = self.index.search(embeddings.astype(np.float32), top_k)
+            similarities = similarities.tolist()
+            ids = ids.tolist()
+
+        if issubclass(self.index_type, faiss.IndexFlatL2):
+            similarities = -np.sqrt(np.maximum(similarities, 0))
+
+        return similarities, ids
+
+    def _reranking(
+        self,
+        embeddings: Array,
+        top_k: int,
+        top_ranked: TopRankedDocumentsType | None = None,
+        query_idx_to_id: dict[int, str] | None = None,
+    ) -> tuple[list[list[float]], list[list[int]]]:
+        doc_id_to_idx = {doc_id: i for i, doc_id in enumerate(self.idxs)}
+        scores_all: list[list[float]] = []
+        idxs_all: list[list[int]] = []
+
+        for query_idx, query_emb in enumerate(embeddings):
+            query_id = query_idx_to_id[query_idx]
+            ranked_ids = top_ranked.get(query_id)
+            if not ranked_ids:
+                logger.warning(f"No top-ranked documents for query {query_id}")
+                scores_all.append([])
+                idxs_all.append([])
+                continue
+
+            candidate_indices = [doc_id_to_idx[doc_id] for doc_id in ranked_ids]
+            d = self.index.d
+            candidate_embs = np.vstack(
+                [self.index.reconstruct(idx) for idx in candidate_indices]
+            )
+            sub_reranking_index = self.index_type(d)
+            sub_reranking_index.add(candidate_embs)
+
+            # Search returns scores and indices in one call
+            scores, local_indices = sub_reranking_index.search(
+                query_emb.reshape(1, -1).astype(np.float32),
+                min(top_k, len(candidate_indices)),
+            )
+            # faiss will output 2d arrays even for single query
+            scores_all.append(scores[0].tolist())
+            idxs_all.append(local_indices[0].tolist())
+
+        return scores_all, idxs_all
+
+    def clear(self) -> None:
+        """Clear all stored documents and embeddings from the backend."""
+        self.index = None
+        self.idxs = []

mteb/models/search_wrappers.py

@@ -21,6 +21,7 @@ from mteb.types import (
 )
 
 from .models_protocols import CrossEncoderProtocol, EncoderProtocol
+from .search_encoder_index.search_backend_protocol import IndexEncoderSearchProtocol
 
 logger = logging.getLogger(__name__)
 
@@ -28,13 +29,19 @@ logger = logging.getLogger(__name__)
 class SearchEncoderWrapper:
     """Wrapper for Encoder models to be used in search tasks."""
 
-    corpus_chunk_size = 50_000
     task_corpus: CorpusDatasetType | None
 
-    def __init__(self, model: EncoderProtocol):
+    def __init__(
+        self,
+        model: EncoderProtocol,
+        corpus_chunk_size: int = 50_000,
+        index_backend: IndexEncoderSearchProtocol | None = None,
+    ) -> None:
         self.model = model
         self.task_corpus = None
         self.mteb_model_meta = model.mteb_model_meta
+        self.corpus_chunk_size = corpus_chunk_size
+        self.index_backend = index_backend
 
     def index(
         self,
@@ -56,6 +63,22 @@ class SearchEncoderWrapper:
         """
         # Always retain corpus for potential reranking or fallback flows
         self.task_corpus = corpus
+        if self.index_backend is not None:
+            all_doc_embeddings = self.model.encode(
+                create_dataloader(
+                    corpus,
+                    task_metadata,
+                    prompt_type=PromptType.document,
+                    **encode_kwargs,
+                ),
+                task_metadata=task_metadata,
+                hf_split=hf_split,
+                hf_subset=hf_subset,
+                prompt_type=PromptType.document,
+                **encode_kwargs,
+            )
+
+            self.index_backend.add_documents(all_doc_embeddings, corpus["id"])
 
     def search(
         self,
@@ -105,27 +128,74 @@ class SearchEncoderWrapper:
 
         if top_ranked is not None:
             logger.info("Reranking pre-ranked documents...")
-            result_heaps = self._rerank_documents(
-                query_idx_to_id=query_idx_to_id,
-                query_embeddings=query_embeddings,
-                top_ranked=top_ranked,
-                top_k=top_k,
-                task_metadata=task_metadata,
-                hf_subset=hf_subset,
-                hf_split=hf_split,
-                encode_kwargs=encode_kwargs,
-            )
+            if self.index_backend is None:
+                result_heaps = self._rerank_documents(
+                    query_idx_to_id=query_idx_to_id,
+                    query_embeddings=query_embeddings,
+                    top_ranked=top_ranked,
+                    top_k=top_k,
+                    task_metadata=task_metadata,
+                    hf_subset=hf_subset,
+                    hf_split=hf_split,
+                    encode_kwargs=encode_kwargs,
+                )
+            else:
+                cos_scores_top_k_values, cos_scores_top_k_idx = (
+                    self.index_backend.search(
+                        query_embeddings,
+                        top_k,
+                        similarity_fn=self.model.similarity,
+                        top_ranked=top_ranked,
+                        query_idx_to_id=query_idx_to_id,
+                    )
+                )
+                result_heaps = {qid: [] for qid in query_idx_to_id.values()}
+                for query_itr in range(len(query_embeddings)):
+                    result_heaps = self._rerank_sort_results(
+                        result_heaps=result_heaps,
+                        query_id=query_idx_to_id[query_itr],
+                        ranked_ids=top_ranked[query_idx_to_id[query_itr]],
+                        scores_top_k_idx=torch.tensor(
+                            [cos_scores_top_k_idx[query_itr]]
+                        ),
+                        scores_top_k_values=torch.tensor(
+                            [cos_scores_top_k_values[query_itr]]
+                        ),
+                    )
+                self.index_backend.clear()
         else:
             logger.info("Performing full corpus search...")
-            result_heaps = self._full_corpus_search(
-                query_idx_to_id=query_idx_to_id,
-                query_embeddings=query_embeddings,
-                task_metadata=task_metadata,
-                hf_subset=hf_subset,
-                hf_split=hf_split,
-                top_k=top_k,
-                encode_kwargs=encode_kwargs,
-            )
+            if self.index_backend is None:
+                result_heaps = self._full_corpus_search(
+                    query_idx_to_id=query_idx_to_id,
+                    query_embeddings=query_embeddings,
+                    task_metadata=task_metadata,
+                    hf_subset=hf_subset,
+                    hf_split=hf_split,
+                    top_k=top_k,
+                    encode_kwargs=encode_kwargs,
+                )
+            else:
+                cos_scores_top_k_values, cos_scores_top_k_idx = (
+                    self.index_backend.search(
+                        query_embeddings,
+                        top_k,
+                        similarity_fn=self.model.similarity,
+                        top_ranked=None,
+                        query_idx_to_id=None,
+                    )
+                )
+                result_heaps = {qid: [] for qid in query_idx_to_id.values()}
+                result_heaps = self._sort_full_corpus_results(
+                    result_heaps=result_heaps,
+                    query_idx_to_id=query_idx_to_id,
+                    query_embeddings=query_embeddings,
+                    cos_scores_top_k_idx=cos_scores_top_k_idx,
+                    cos_scores_top_k_values=cos_scores_top_k_values,
+                    sub_corpus_ids=self.task_corpus["id"],
+                    top_k=top_k,
+                )
+                self.index_backend.clear()
 
         # Reset the task corpus dataloader to None to free up memory
         self.task_corpus = None
@@ -192,19 +262,45 @@ class SearchEncoderWrapper:
             cos_scores_top_k_values = cos_scores_top_k_values.cpu().tolist()
 
             sub_corpus_ids = list(sub_corpus_ids)
-            for query_itr in range(len(query_embeddings)):
-                query_id = query_idx_to_id[query_itr]
-                for sub_corpus_id, score in zip(
-                    cos_scores_top_k_idx[query_itr],
-                    cos_scores_top_k_values[query_itr],
-                ):
-                    corpus_id = sub_corpus_ids[sub_corpus_id]
-                    if len(result_heaps[query_id]) < top_k:
-                        # push item on the heap
-                        heapq.heappush(result_heaps[query_id], (score, corpus_id))
-                    else:
-                        # If item is larger than the smallest in the heap, push it on the heap then pop the smallest element
-                        heapq.heappushpop(result_heaps[query_id], (score, corpus_id))
+            result_heaps = self._sort_full_corpus_results(
+                result_heaps=result_heaps,
+                query_idx_to_id=query_idx_to_id,
+                query_embeddings=query_embeddings,
+                cos_scores_top_k_idx=cos_scores_top_k_idx,
+                cos_scores_top_k_values=cos_scores_top_k_values,
+                sub_corpus_ids=sub_corpus_ids,
+                top_k=top_k,
+            )
+        return result_heaps
+
+    def _sort_full_corpus_results(
+        self,
+        result_heaps: dict[str, list[tuple[float, str]]],
+        query_idx_to_id: dict[int, str],
+        query_embeddings: Array,
+        cos_scores_top_k_idx: list[list[int]],
+        cos_scores_top_k_values: list[list[float]],
+        sub_corpus_ids: list[str],
+        top_k: int,
+    ) -> dict[str, list[tuple[float, str]]]:
+        """Sort the heaps into descending order lists.
+
+        Returns:
+            A dictionary mapping query IDs to a sorted list of tuples, each containing a relevance score and a document ID.
+        """
+        for query_itr in range(len(query_embeddings)):
+            query_id = query_idx_to_id[query_itr]
+            for sub_corpus_id, score in zip(
+                cos_scores_top_k_idx[query_itr],
+                cos_scores_top_k_values[query_itr],
+            ):
+                corpus_id = sub_corpus_ids[sub_corpus_id]
+                if len(result_heaps[query_id]) < top_k:
+                    # push item on the heap
+                    heapq.heappush(result_heaps[query_id], (score, corpus_id))
+                else:
+                    # If item is larger than the smallest in the heap, push it on the heap then pop the smallest element
+                    heapq.heappushpop(result_heaps[query_id], (score, corpus_id))
         return result_heaps
 
     def _rerank_documents(
@@ -279,14 +375,34 @@ class SearchEncoderWrapper:
             scores_top_k_values = scores_top_k_values.cpu()
             scores_top_k_idx = scores_top_k_idx.cpu()
 
-            # Build result heap
-            for doc_idx, score in zip(
-                scores_top_k_idx[0].tolist(),
-                scores_top_k_values[0].tolist(),
-            ):
-                corpus_id = ranked_ids[doc_idx]
-                heapq.heappush(result_heaps[query_id], (score, corpus_id))
+            result_heaps = self._rerank_sort_results(
+                result_heaps=result_heaps,
+                query_id=query_id,
+                ranked_ids=ranked_ids,
+                scores_top_k_idx=scores_top_k_idx,
+                scores_top_k_values=scores_top_k_values,
+            )
+        return result_heaps
+
+    def _rerank_sort_results(
+        self,
+        result_heaps: list[tuple[float, str]],
+        query_id: str,
+        ranked_ids: list[str],
+        scores_top_k_idx: torch.Tensor,
+        scores_top_k_values: torch.Tensor,
+    ) -> list[tuple[float, str]]:
+        """Sort the heap into descending order list.
 
+        Returns:
+            A sorted list of tuples, each containing a relevance score and a document ID.
+        """
+        for doc_idx, score in zip(
+            scores_top_k_idx[0].tolist(),
+            scores_top_k_values[0].tolist(),
+        ):
+            corpus_id = ranked_ids[doc_idx]
+            heapq.heappush(result_heaps[query_id], (score, corpus_id))
         return result_heaps
 
     def encode(

mteb/similarity_functions.py

@@ -1,6 +1,7 @@
 import torch
 
 from mteb.models import EncoderProtocol
+from mteb.models.model_meta import ScoringFunction
 from mteb.types import Array
 
 
@@ -38,6 +39,54 @@ def compute_pairwise_similarity(
     return pairwise_cos_sim(embedding1, embedding2)
 
 
+def select_similarity(
+    embedding1: Array,
+    embedding2: Array,
+    similarity_fn: ScoringFunction,
+) -> Array:
+    """Compute similarity between two sets of embeddings using the specified similarity function.
+
+    Args:
+        embedding1: The first set of embeddings.
+        embedding2: The second set of embeddings.
+        similarity_fn: The similarity function to use (COSINE, DOT_PRODUCT, EUCLIDEAN).
+
+    Returns:
+        Array: The computed similarity scores.
+    """
+    if similarity_fn is ScoringFunction.COSINE:
+        return cos_sim(embedding1, embedding2)
+    elif similarity_fn is ScoringFunction.DOT_PRODUCT:
+        return dot_score(embedding1, embedding2)
+    elif similarity_fn is ScoringFunction.EUCLIDEAN:
+        return euclidean_sim(embedding1, embedding2)
+    raise ValueError(f"Unsupported similarity function: {similarity_fn}")
+
+
+def select_pairwise_similarity(
+    embedding1: Array,
+    embedding2: Array,
+    similarity_fn: ScoringFunction,
+) -> Array:
+    """Compute pairwise similarity between two sets of embeddings using the specified similarity function.
+
+    Args:
+        embedding1: The first set of embeddings.
+        embedding2: The second set of embeddings.
+        similarity_fn: The similarity function to use (COSINE, DOT_PRODUCT, EUCLIDEAN).
+
+    Returns:
+        Array: The computed pairwise similarity scores.
+    """
+    if similarity_fn is ScoringFunction.COSINE:
+        return pairwise_cos_sim(embedding1, embedding2)
+    elif similarity_fn is ScoringFunction.DOT_PRODUCT:
+        return pairwise_dot_score(embedding1, embedding2)
+    elif similarity_fn is ScoringFunction.EUCLIDEAN:
+        return pairwise_euclidean_sim(embedding1, embedding2)
+    raise ValueError(f"Unsupported similarity function: {similarity_fn}")
+
+
 def _normalize_embeddings(embeddings: Array) -> torch.Tensor:
     """Normalizes the embeddings matrix, so that each sentence embedding has unit length.
 

mteb/tasks/retrieval/multilingual/vidore2_bench_retrieval.py

@@ -41,7 +41,6 @@ def _load_data(
             },
             remove_columns=["query-id", "query"],
         )
-        query_ds = query_ds.select_columns(["id", "text"])
 
         corpus_ds = load_dataset(
             path,
@@ -66,7 +65,7 @@ def _load_data(
         )
 
         if langs is None:
-            queries[split] = query_ds
+            queries[split] = query_ds.select_columns(["id", "text"])
             corpus[split] = corpus_ds
             relevant_docs[split] = {}
             for row in qrels_ds:
@@ -77,7 +76,8 @@ def _load_data(
                 relevant_docs[split][qid][did] = int(row["score"])
         else:
             for lang in langs:
-                queries[lang][split] = query_ds.filter(lambda x: x["language"] == lang)
+                filtered_query_ds = query_ds.filter(lambda x: x["language"] == lang)
+                queries[lang][split] = filtered_query_ds.select_columns(["id", "text"])
 
                 corpus[lang][split] = corpus_ds
 

{mteb-2.2.2.dist-info → mteb-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mteb
-Version: 2.2.2
+Version: 2.3.0
 Summary: Massive Text Embedding Benchmark
 Author-email: MTEB Contributors <niklas@huggingface.co>, Kenneth Enevoldsen <kenneth.enevoldsen@cas.au.dk>, Nouamane Tazi <nouamane@huggingface.co>, Nils Reimers <info@nils-reimers.de>
 Maintainer-email: Kenneth Enevoldsen <kenneth.enevoldsen@cas.au.dk>, Roman Solomatin <risolomatin@gmail.com>, Isaac Chung <chungisaac1217@gmail.com>
@@ -100,6 +100,8 @@ Provides-Extra: llama-embed-nemotron
 Requires-Dist: transformers==4.51.0; extra == "llama-embed-nemotron"
 Provides-Extra: faiss-cpu
 Requires-Dist: faiss-cpu>=1.12.0; extra == "faiss-cpu"
+Provides-Extra: eager-embed
+Requires-Dist: qwen_vl_utils>=0.0.14; extra == "eager-embed"
 Dynamic: license-file
 
 <h1 align="center">

{mteb-2.2.2.dist-info → mteb-2.3.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mteb/__init__.py,sha256=bl3K7IHalVzP27SIQ3qdo52vy9aAuvMsIKOx0h5P6Sk,1256
+mteb/__init__.py,sha256=h2kru--zMEC0mmLQ688kggdDpBH7dxYz1HhLVHbRjcI,1376
 mteb/__main__.py,sha256=KKWed4HW-OpfpJhCuKDNDPuAAIoppQY1g2gRuCdAmlw,34
 mteb/_create_dataloaders.py,sha256=9aUHM1q2q748XHax_YYcPBmckIOOVCrJ_N2bJYVbn3s,14338
 mteb/_helpful_enum.py,sha256=jh73N1jlcpg7RGz4bj8UpctiMNvqvHpp9wrB7SYEzIU,510
@@ -11,7 +11,7 @@ mteb/evaluate.py,sha256=nSRKXlQikwtd4qb2Ruckn756IAgTigDjXdl-W2nhI6M,17993
 mteb/filter_tasks.py,sha256=5XE1OYmgDDoJYnXwFf4ma_PIT_Lekzs420sQF_kpCiY,7240
 mteb/get_tasks.py,sha256=6Gc18a2bZoLQV1Ms_qdr2KieAqIXg8TDg4l7ZN8rW2I,14218
 mteb/load_results.py,sha256=Xw2ZX7BToU92WwUTQUQKPAgPhX7ucyRRdoCrxAoPHdI,6414
-mteb/similarity_functions.py,sha256=ZkBapSGDXKE5ipTG2FpeFnAC1iWwiVkrAidmKK_I4bI,8799
+mteb/similarity_functions.py,sha256=ySSnrKl4cSKOWfyIKQPVTJtxuy2ZNfcv0COXDp22QlQ,10630
 mteb/_evaluators/__init__.py,sha256=Ag1_RWpxBGMpujzd3FZjI40gY_KQKIpY31tJPuk-hFg,1013
 mteb/_evaluators/_download.py,sha256=jntlcURbJxcxUjTmn2D9Tu6ZnWgDc9t5bY8p9CZCqv4,586
 mteb/_evaluators/any_sts_evaluator.py,sha256=f0V3NDP5Bfp8qEeBwP8E-Enj5F5NbFze-kGmzlkObQA,3762
@@ -1428,15 +1428,15 @@ mteb/leaderboard/benchmark_selector.py,sha256=hnXdo_Kj4UUAruFl6nZkCxAQ88IEfbaH8E
 mteb/leaderboard/figures.py,sha256=Rq20LFpaUhQD4tuKp7P7ExQtAjonMLibgO3ud0ykMag,7491
 mteb/leaderboard/table.py,sha256=qs0H_Gt9FzRvzb-AL0YlqEe0YAsdYsVX3QlncfCBEqg,7828
 mteb/leaderboard/text_segments.py,sha256=iMIkS04QQjPbT-SkU0x6fOcS8xRbUYevryu9HydipKM,6570
-mteb/models/__init__.py,sha256=ycGU-x60LT0OFyP4CYa5pQhM7J5hCimubuT56va9wfM,741
+mteb/models/__init__.py,sha256=ABTuoqiBjBtBWW3LYY7ItBHdylR6jWoy06HH0g6j6fU,910
 mteb/models/abs_encoder.py,sha256=m0JkRfRPMYadDgBR9eozRloI31ZSWkSzDFINpwbfLZk,16533
 mteb/models/get_model_meta.py,sha256=VpZZNINk-QrNeVpPZnlqzlLhtBs8G84eRwTzAb_gRD4,9108
 mteb/models/instruct_wrapper.py,sha256=Ty4nfEvioycL_uATkhd0PGuyeB5Xc9xrRd6HOGgb-tc,9005
 mteb/models/model_meta.py,sha256=b-Nel9nX5bJk4cgJnqkBzEKyMY7uXvxlCBSxmmH1Ios,14769
 mteb/models/models_protocols.py,sha256=D2hYWn_UBGMaKtRwBx3u0B0ni6lHJjSzTxX21XFNwIc,8917
-mteb/models/search_wrappers.py,sha256=9PrS12afZInQKnmky2zdDrY_tVaC-Lwx__3zmoFIgn0,15475
+mteb/models/search_wrappers.py,sha256=AcMhjQyKdeitUjnaqgnP3_zTeVSum8rz1sjBRddHUVQ,20328
 mteb/models/sentence_transformer_wrapper.py,sha256=n5CMsM6Lpg_CFHH0NkpJusMsaLUTt-L9vRmFINQ961k,12338
-mteb/models/cache_wrappers/__init__.py,sha256=j3JBHN73Tr7uMUO92FEvKXstnybxrPpGWmKXU2lAoIE,88
+mteb/models/cache_wrappers/__init__.py,sha256=1w1TnMwulWJSzNkLXjbh5MY3sqgHWc6vUntYn49i9X8,169
 mteb/models/cache_wrappers/cache_backend_protocol.py,sha256=TR7kD7KbN1J4piszIecpegtLZYGy7sRHZt3SDWlImKk,1665
 mteb/models/cache_wrappers/cache_wrapper.py,sha256=KLDeOCe_ndQshbZa5ep2u3jovsl--tfpQzvt9EXyxCA,6589
 mteb/models/cache_wrappers/cache_backends/__init__.py,sha256=hN2Tq7cpTxoOYSCJ1Wnpvb8dEm-kQLfCCahT1N9Bacw,123
@@ -1471,13 +1471,14 @@ mteb/models/model_implementations/dino_models.py,sha256=QFgaFHR5YKrylqJGSljXCBn2
 mteb/models/model_implementations/e5_instruct.py,sha256=9R4GoSFicgqNDCh3HhTN_8L1qhzuEKvatjHYn3T9zlU,7676
 mteb/models/model_implementations/e5_models.py,sha256=vsqkmm6XzZn9ROj_OUR0j2KiN75MEuQsOPeoyc1AeYg,10937
 mteb/models/model_implementations/e5_v.py,sha256=_9W7I0ryIzx_H9eCkzwdm8iHdGX1LIjKGXkhSh_zNv8,6690
+mteb/models/model_implementations/eagerworks_models.py,sha256=NOQkCUqn9jLSpf9p6KyaIHnJxYV1MNlr2z7hO2AcRSc,5744
 mteb/models/model_implementations/emillykkejensen_models.py,sha256=QdhGqCm_1-AURkrniZj2S1MjwwIVOPMzLvpgfJq-3EQ,2779
 mteb/models/model_implementations/en_code_retriever.py,sha256=leZ-0M6LrunocY3XQBYZU1uevDRopeyR5ujIhwqBbd8,1043
 mteb/models/model_implementations/evaclip_models.py,sha256=cPMGYLDIq4s8zJxb4vPXqJ-rqwPaq7KOh2QZSO6cDas,8000
 mteb/models/model_implementations/fa_models.py,sha256=WGal70_ezITWoNdjcMdbOCTSCtoaXzuPadYstLVXxhg,7478
 mteb/models/model_implementations/geogpt_models.py,sha256=Juv86SwhgQX80lVLjAFtim2aSiJT1AcgjniyyiKyk1Q,1923
 mteb/models/model_implementations/gme_v_models.py,sha256=NkfgR3_UdZzoBt1NnalVou6LOR-F7qXM4by9EbAVrys,13568
-mteb/models/model_implementations/google_models.py,sha256=P3Kg6G8UI6JA17MMlhhoDj54SCAcRP8uZ1CudL-Caf0,9295
+mteb/models/model_implementations/google_models.py,sha256=ROo83udaUmPx0U_qfFuS55DSrCILVsRZu3oLp_P-srg,9296
 mteb/models/model_implementations/granite_vision_embedding_models.py,sha256=uqQ5-e_a-ADv3gf3sR9Drk0S4x8Gy8mZkpL-E4X16TM,7241
 mteb/models/model_implementations/gritlm_models.py,sha256=aS_CuioL95JAQMYiaKlGuAWU9wZjabn268Xut3bD8-w,3005
 mteb/models/model_implementations/gte_models.py,sha256=o26Xyu_tucUlP435Q_jB4-bl0xckgj4wtbutTwhYgIo,10073
@@ -1503,25 +1504,25 @@ mteb/models/model_implementations/moco_models.py,sha256=Kl0nBsqkG3crYoo5YulFq1fv
 mteb/models/model_implementations/model2vec_models.py,sha256=D-EY-6P-cKKunbgzk4DHzJL1ogpWYFhpHbTLb8qQjJw,13765
 mteb/models/model_implementations/moka_models.py,sha256=Y5do7Z4JyGxabYrjHhkBLqCKTQKotniS-f4kOgXJjag,4995
 mteb/models/model_implementations/mxbai_models.py,sha256=33ta2BnhvKYBUgE89wFgPNf-CnOb7ooumZvqHOvbZsA,3593
-mteb/models/model_implementations/nb_sbert.py,sha256=Ab0OXvOzEqlFFO1679mMiCdJvMSnvcfCoeFMLzNL74I,861
+mteb/models/model_implementations/nb_sbert.py,sha256=dF3WBn6ERIK7Oqp-tXdLn11Gf0Z7RKLhAoCq0YHxEug,861
 mteb/models/model_implementations/no_instruct_sentence_models.py,sha256=6i-xbLRRNKuDpU-hwklwdQjgu1wnz5CecLSoc6kyd7Q,3976
 mteb/models/model_implementations/nomic_models.py,sha256=mT-v5Gs5-sRH8-ziCw_CtxB9ox3C6FtwWJjNghNrunw,11334
 mteb/models/model_implementations/nomic_models_vision.py,sha256=gEEieMThvw4p-QhRH0G_9-WWTvj-jqOlgFsh6O07dbc,6731
-mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py,sha256=zLo-GSghLsIpIZguAdg0Vf18Dn-mdizwQDrWiSwupr0,6171
-mteb/models/model_implementations/nvidia_models.py,sha256=aeex14J1yGxc2wm8kCDIgxwo_uy0Fu9y9liFVD-LDOg,21555
+mteb/models/model_implementations/nvidia_llama_nemoretriever_colemb.py,sha256=j71ijIGeYammmtPO6O_IQvPHtSRgwvonDjh8QhfwU64,6170
+mteb/models/model_implementations/nvidia_models.py,sha256=acVverAt77lURkILCVkCdXsWgY1BJoG1-ugB7yIhlIM,21555
 mteb/models/model_implementations/openai_models.py,sha256=2tJyEapIW-GtB3ZOXIHwGjSZGgJl2daE_UsbzH4NhBM,9620
 mteb/models/model_implementations/openclip_models.py,sha256=W8XcokgLU1nSmMaWpYXkWWizVd3sQezcP02YtF2fXpo,11436
 mteb/models/model_implementations/opensearch_neural_sparse_models.py,sha256=fuxIjOx_kPoDps5C7LW3JllG-AZj4ktqeTNgJESHZh4,8351
-mteb/models/model_implementations/ops_moa_models.py,sha256=vTZYi6aYe2UYI_BBaoMad3anozknUoadVQw_EBKX3MU,2411
+mteb/models/model_implementations/ops_moa_models.py,sha256=luWw1j2iTMx1z1ydLCjvCI89E9Yvge7ruEawivJTmfE,2413
 mteb/models/model_implementations/ordalietech_solon_embeddings_mini_beta_1_1.py,sha256=qGXv71qRjNCIFluZOwvfBlFlKKyN2bXBokwUPk4KHmM,1066
 mteb/models/model_implementations/piccolo_models.py,sha256=d8Dtkv_ZTUOCmJLLOuwquq-gX-2UfKvAtl_LvAS0Xi0,2113
-mteb/models/model_implementations/promptriever_models.py,sha256=2iB1n4ZSX0NyDBBk9rryKSwdjhc3D6TgUhhlzJxys8E,6316
+mteb/models/model_implementations/promptriever_models.py,sha256=S7uWes_P74p3OZR_KBJHJN_ezlvvRx2__46DMCWqV5M,6328
 mteb/models/model_implementations/pylate_models.py,sha256=yINGQL97S4xjj74-FTWpO4KHX-E9NDOEeyQWyRmmnaE,14772
 mteb/models/model_implementations/qodo_models.py,sha256=JDqffDlQiOEariyheybOIf3iNkqot2gTkEIHWDnRbUE,2037
 mteb/models/model_implementations/qtack_models.py,sha256=biZLH5E3UWIcMZXIZNGgBZFEUvovPpAo6vUyL776W1w,1224
-mteb/models/model_implementations/qwen3_models.py,sha256=IpPJC_y-Kt_1Bq6nT2lX3-lMl-hl0BV6VhAL8Czfyfg,5133
-mteb/models/model_implementations/qzhou_models.py,sha256=90tsGftdCX90Gvu63bxtMyzczGi_u9bsUlg4WAVeH9Q,3536
-mteb/models/model_implementations/random_baseline.py,sha256=NH-epZ73BYvV6qYgu09BsoiFxBWypUNLdJIXRp5QPhM,8030
+mteb/models/model_implementations/qwen3_models.py,sha256=F_o6ciD-6gLFfIlQYD9MsNvcbkmGzJ39eKpFlEog1rM,5132
+mteb/models/model_implementations/qzhou_models.py,sha256=7KaZpHdap-YyK0QxOMHxU0W2aGismx7GZv_bNXkEOcI,3536
+mteb/models/model_implementations/random_baseline.py,sha256=1VNnWBSi0Ph_RLON6clOuQI-Kli5BRtiiDFZMrTj7PM,7489
 mteb/models/model_implementations/rasgaard_models.py,sha256=a8F3kDSBWHH0UR7wRioOrWGQUxtloD5mU7EG27iM-68,1260
 mteb/models/model_implementations/reasonir_model.py,sha256=wSCcJpUgZ0pG2g3vTEzYNmPlPG_CVn_rR0ENVCines0,2218
 mteb/models/model_implementations/repllama_models.py,sha256=89HoqEpzkNysHeuf_-YhU8WETamHTogSRztGIRo6G1s,7321
@@ -1553,6 +1554,10 @@ mteb/models/model_implementations/voyage_v.py,sha256=WnvwYNVv3c5K0ChzGA3v2iTQX2e
 mteb/models/model_implementations/xyz_models.py,sha256=TePlrH6EHwRPO87U_J3Yce9-XHCn_X7I2cJ_6BZ2fUY,1296
 mteb/models/model_implementations/youtu_models.py,sha256=NB74E6z-_36HyXb8GXKn8CrmRLN68uX9eH4xcS57zl0,5938
 mteb/models/model_implementations/yuan_models.py,sha256=yZ6ki6YFaoVrJ_2pPSRQaMKOsIOUo3GtmhPx1qeUl2w,939
+mteb/models/search_encoder_index/__init__.py,sha256=3QFacIuFyEiI7ocsSkb3Lp2S2L7MLkpHCMIJ201fowA,182
+mteb/models/search_encoder_index/search_backend_protocol.py,sha256=TSjlx88stJcMldbAeVqNCf8JsQvE-B5rf5SBRw90isY,1890
+mteb/models/search_encoder_index/search_indexes/__init__.py,sha256=Wm60_oUemUpFsvrCMW111dcPH2L2rt1iZrXMskXmG7o,88
+mteb/models/search_encoder_index/search_indexes/faiss_search_index.py,sha256=WMs3QbbYV13fRuT3dakmdVMZLFdc_9ZzSupS3QxlbVQ,5555
 mteb/results/__init__.py,sha256=EXQqK4Am5eIYzD52dpcGAFSdqnC38oE6JHN302oidHc,158
 mteb/results/benchmark_results.py,sha256=OWqeBxbNsPmOKRhxY980N5CikpdJXToDGJGTXUe64Lw,18209
 mteb/results/model_result.py,sha256=Wdbkpxq7_geliYDr4558i6txDVdsHL-Y9WAv_u7thlI,13689
@@ -2354,7 +2359,7 @@ mteb/tasks/retrieval/multilingual/public_health_qa_retrieval.py,sha256=LJGpx4RkS
 mteb/tasks/retrieval/multilingual/ru_sci_bench_retrieval.py,sha256=Mmcvrt_1cIxPfHZfUzSURPZyaaweGiB02im1ZszlS6M,6837
 mteb/tasks/retrieval/multilingual/statcan_dialogue_dataset_retrieval.py,sha256=iFUQUlO_ogBdQBVYBQW3o-AJDQ792yg1pJtRxA5I3Qo,3796
 mteb/tasks/retrieval/multilingual/vdr_multilingual_retrieval.py,sha256=UduWKefwP7bPYxiDlztPEvSWXmTdw0xElglMbPY6XhA,4449
-mteb/tasks/retrieval/multilingual/vidore2_bench_retrieval.py,sha256=lRrca5HaCCDhlVdsiwhm4RWu4wrE3v3PbRCs-4EQUAg,9034
+mteb/tasks/retrieval/multilingual/vidore2_bench_retrieval.py,sha256=vOfiruHywYkP8pccdAuGLyYyFTw1zK0qcXDnUFA8Z5A,9091
 mteb/tasks/retrieval/multilingual/vidore3_bench_retrieval.py,sha256=wOoC--IVTz0dR6RMVICbz6OWxfCyVahGDSfX_TScCgA,16934
 mteb/tasks/retrieval/multilingual/web_faq_retrieval.py,sha256=TM-Q98yXZny_PKHAFNEvw9o9ET_L6VM3aNis1NJ9DgM,2686
 mteb/tasks/retrieval/multilingual/wikipedia_retrieval_multilingual.py,sha256=zyqAt63bHXNU_I37jb891pwWUyGzZUGkXCyhWlRbed8,1569
@@ -2558,9 +2563,9 @@ mteb/types/_metadata.py,sha256=NN-W0S6a5TDV7UkpRx1pyWtGF4TyyCyoPUfHOwdeci8,2290
 mteb/types/_result.py,sha256=CRAUc5IvqI3_9SyXDwv-PWLCXwXdZem9RePeYESRtuw,996
 mteb/types/_string_validators.py,sha256=PY-dYq4E8O50VS3bLYdldPWp400fl_WzUjfVSkNWe8U,523
 mteb/types/statistics.py,sha256=YwJsxTf1eaCI_RE-J37a-gK5wDeGAsmkeZKoZCFihSo,3755
-mteb-2.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mteb-2.2.2.dist-info/METADATA,sha256=YErx6a_mFp9XhpwLFxw7Z29HM0_jYa72R_fKYIx_Tq4,13573
-mteb-2.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mteb-2.2.2.dist-info/entry_points.txt,sha256=8IJoEJFKoDHmVnNev-qJ9pp4Ln7_1-ma9QsXnzVCzGU,39
-mteb-2.2.2.dist-info/top_level.txt,sha256=OLVIjcQAlWBz0bdmutKlWHLF42FF0hp4uVAg3ZyiG4U,5
-mteb-2.2.2.dist-info/RECORD,,
+mteb-2.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mteb-2.3.0.dist-info/METADATA,sha256=ZXHapOBoYWzV3b_qYW_igqfvEsqDVXky9deYaQDAOFI,13662
+mteb-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mteb-2.3.0.dist-info/entry_points.txt,sha256=8IJoEJFKoDHmVnNev-qJ9pp4Ln7_1-ma9QsXnzVCzGU,39
+mteb-2.3.0.dist-info/top_level.txt,sha256=OLVIjcQAlWBz0bdmutKlWHLF42FF0hp4uVAg3ZyiG4U,5
+mteb-2.3.0.dist-info/RECORD,,