[ENH] Add muvera support

Author: jairad26

chromadb/test/ef/test_ef.py

@@ -54,6 +54,7 @@ def test_get_builtins_holds() -> None:
         "Bm25EmbeddingFunction",
         "ChromaCloudQwenEmbeddingFunction",
         "ChromaCloudSpladeEmbeddingFunction",
+        "PylateColBERTEmbeddingFunction",
     }
 
     assert expected_builtins == embedding_functions.get_builtins()

chromadb/utils/embedding_functions/__init__.py

@@ -83,7 +83,9 @@
 from chromadb.utils.embedding_functions.chroma_cloud_splade_embedding_function import (
     ChromaCloudSpladeEmbeddingFunction,
 )
-
+from chromadb.utils.embedding_functions.pylate_colbert_embedding_function import (
+    PylateColBERTEmbeddingFunction,
+)
 
 # Get all the class names for backward compatibility
 _all_classes: Set[str] = {
@@ -116,6 +118,7 @@
     "Bm25EmbeddingFunction",
     "ChromaCloudQwenEmbeddingFunction",
     "ChromaCloudSpladeEmbeddingFunction",
+    "PylateColBERTEmbeddingFunction",
 }
 
 
@@ -150,6 +153,7 @@ def get_builtins() -> Set[str]:
     "cloudflare_workers_ai": CloudflareWorkersAIEmbeddingFunction,
     "together_ai": TogetherAIEmbeddingFunction,
     "chroma-cloud-qwen": ChromaCloudQwenEmbeddingFunction,
+    "pylate_colbert": PylateColBERTEmbeddingFunction,
 }
 
 sparse_known_embedding_functions: Dict[str, Type[SparseEmbeddingFunction]] = {  # type: ignore
@@ -273,6 +277,7 @@ def config_to_embedding_function(config: Dict[str, Any]) -> EmbeddingFunction:
     "Bm25EmbeddingFunction",
     "ChromaCloudQwenEmbeddingFunction",
     "ChromaCloudSpladeEmbeddingFunction",
+    "PylateColBERTEmbeddingFunction",
     "register_embedding_function",
     "config_to_embedding_function",
     "known_embedding_functions",

chromadb/utils/embedding_functions/jina_embedding_function.py

@@ -11,6 +11,7 @@
 import os
 import numpy as np
 import warnings
+from chromadb.utils.muvera import create_fdes
 import importlib
 import base64
 import io
@@ -37,6 +38,7 @@ def __init__(
         dimensions: Optional[int] = None,
         embedding_type: Optional[str] = None,
         normalized: Optional[bool] = None,
+        return_multivector: Optional[bool] = None,
         query_config: Optional[JinaQueryConfig] = None,
     ):
         """
@@ -95,6 +97,7 @@ def __init__(
         self.dimensions = dimensions
         self.embedding_type = embedding_type
         self.normalized = normalized
+        self.return_multivector = return_multivector
         self.query_config = query_config
 
         self._api_url = "https://api.jina.ai/v1/embeddings"
@@ -143,6 +146,8 @@ def _build_payload(self, input: Embeddable, is_query: bool) -> Dict[str, Any]:
             payload["embedding_type"] = self.embedding_type
         if self.normalized is not None:
             payload["normalized"] = self.normalized
+        if self.return_multivector is not None:
+            payload["return_multivector"] = self.return_multivector
 
         # overwrite parameteres when query payload is used
         if is_query and self.query_config is not None:
@@ -164,6 +169,30 @@ def _convert_resp(self, resp: Any, is_query: bool = False) -> Embeddings:
         if "data" not in resp:
             raise RuntimeError(resp.get("detail", "Unknown error"))
 
+        if self.return_multivector:
+            # if it gives back multivector embeddings
+            multi_embeddings_data: List[Dict[str, Any]] = resp["data"]
+            sorted_multi_embeddings = sorted(
+                multi_embeddings_data, key=lambda e: e["index"]
+            )
+            multi_embeddings: List[Embeddings] = [
+                [
+                    np.array(vec, dtype=np.float32)
+                    for vec in multi_embedding_obj["embeddings"]
+                ]
+                for multi_embedding_obj in sorted_multi_embeddings
+            ]
+
+            dims = len(multi_embeddings[0][0])
+            fdes = create_fdes(
+                multi_embeddings,
+                dims=dims,
+                is_query=is_query,
+                fill_empty_partitions=not is_query,
+            )
+
+            return fdes
+
         embeddings_data: List[Dict[str, Union[int, List[float]]]] = resp["data"]
 
         # Sort resulting embeddings by index
@@ -225,6 +254,7 @@ def build_from_config(config: Dict[str, Any]) -> "EmbeddingFunction[Embeddable]"
         dimensions = config.get("dimensions")
         embedding_type = config.get("embedding_type")
         normalized = config.get("normalized")
+        return_multivector = config.get("return_multivector")
         query_config = config.get("query_config")
 
         if api_key_env_var is None or model_name is None:
@@ -239,6 +269,7 @@ def build_from_config(config: Dict[str, Any]) -> "EmbeddingFunction[Embeddable]"
             dimensions=dimensions,
             embedding_type=embedding_type,
             normalized=normalized,
+            return_multivector=return_multivector,
             query_config=query_config,
         )
 
@@ -252,6 +283,7 @@ def get_config(self) -> Dict[str, Any]:
             "dimensions": self.dimensions,
             "embedding_type": self.embedding_type,
             "normalized": self.normalized,
+            "return_multivector": self.return_multivector,
             "query_config": self.query_config,
         }
 

chromadb/utils/embedding_functions/pylate_colbert_embedding_function.py

@@ -0,0 +1,110 @@
+from chromadb.api.types import Embeddings, Documents, EmbeddingFunction, Space
+from typing import List, Dict, Any
+from chromadb.utils.embedding_functions.schemas import validate_config_schema
+from chromadb.utils.muvera import create_fdes
+
+
+class PylateColBERTEmbeddingFunction(EmbeddingFunction[Documents]):
+    """
+    This class is used to get embeddings for a list of texts using the ColBERT API.
+    """
+
+    def __init__(
+        self,
+        model_name: str,
+    ):
+        """
+        Initialize the PylateColBERTEmbeddingFunction.
+
+        Args:
+            model_name (str): The name of the model to use for text embeddings.
+            Examples: "mixedbread-ai/mxbai-edge-colbert-v0-17m", "mixedbread-ai/mxbai-edge-colbert-v0-32m", "lightonai/colbertv2.0", "answerdotai/answerai-colbert-small-v1", "jinaai/jina-colbert-v2", "GTE-ModernColBERT-v1"
+        """
+        try:
+            from pylate import models
+        except ImportError:
+            raise ValueError(
+                "The pylate colbert python package is not installed. Please install it with `pip install pylate-colbert`"
+            )
+
+        self.model_name = model_name
+        self.model = models.ColBERT(model_name_or_path=model_name)
+
+    def __call__(self, input: Documents) -> Embeddings:
+        """
+        Get the embeddings for a list of texts.
+
+        Args:
+            input (Documents): A list of texts to get embeddings for.
+
+        Returns:
+            Embeddings: The embeddings for the texts.
+        """
+        multivec = self.model.encode(input, batch_size=32, is_query=False)
+        return create_fdes(
+            multivec,
+            dims=len(multivec[0][0]),
+            is_query=False,
+            fill_empty_partitions=True,
+        )
+
+    def embed_query(self, input: Documents) -> Embeddings:
+        """
+        Get the embeddings for a list of texts.
+
+        Args:
+            input (Documents): A list of texts to get embeddings for.
+
+        Returns:
+            Embeddings: The embeddings for the texts.
+        """
+        multivec = self.model.encode(input, batch_size=32, is_query=True)
+        return create_fdes(
+            multivec,
+            dims=len(multivec[0][0]),
+            is_query=True,
+            fill_empty_partitions=False,
+        )
+
+    @staticmethod
+    def name() -> str:
+        return "pylate_colbert"
+
+    def default_space(self) -> Space:
+        return "cosine"
+
+    def supported_spaces(self) -> List[Space]:
+        return ["cosine", "l2", "ip"]
+
+    @staticmethod
+    def build_from_config(config: Dict[str, Any]) -> "EmbeddingFunction[Documents]":
+        model_name = config.get("model_name")
+
+        if model_name is None:
+            assert False, "This code should not be reached"
+
+        return PylateColBERTEmbeddingFunction(model_name=model_name)
+
+    def get_config(self) -> Dict[str, Any]:
+        return {"model_name": self.model_name}
+
+    def validate_config_update(
+        self, old_config: Dict[str, Any], new_config: Dict[str, Any]
+    ) -> None:
+        if "model_name" in new_config:
+            raise ValueError(
+                "The model name cannot be changed after the embedding function has been initialized."
+            )
+
+    @staticmethod
+    def validate_config(config: Dict[str, Any]) -> None:
+        """
+        Validate the configuration using the JSON schema.
+
+        Args:
+            config: Configuration to validate
+
+        Raises:
+            ValidationError: If the configuration does not match the schema
+        """
+        validate_config_schema(config, "pylate_colbert")