Add Hfresh index type

integration/test_collection_hfresh.py

@@ -0,0 +1,33 @@
+import pytest
+import weaviate
+import weaviate.exceptions
+from integration.conftest import CollectionFactory
+from weaviate.collections.classes.config import (
+    Configure,
+    VectorDistances,
+    VectorIndexType,
+    _VectorIndexConfigHFresh,
+)
+
+def test_collection_config_hfresh(collection_factory: CollectionFactory) -> None:
+    collection_dummy = collection_factory("dummy")
+    if collection_dummy._connection._weaviate_version.is_lower_than(1, 36, 0):
+        pytest.skip("Hfresh index is not supported in Weaviate versions lower than 1.36.0")
+
+    collection = collection_factory(
+        vector_index_config=Configure.VectorIndex.hfresh(
+            distance_metric=VectorDistances.COSINE,
+            max_posting_size_kb=1024,
+            replicas=2,
+            search_probe=50,
+        )
+    )
+
+    config = collection.config.get()
+
+    assert config.vector_index_type == VectorIndexType.HFRESH
+    assert isinstance(config.vector_index_config, _VectorIndexConfigHFresh)
+    assert config.vector_index_config.distance_metric == VectorDistances.COSINE
+    assert config.vector_index_config.max_posting_size_kb == 1024
+    assert config.vector_index_config.replicas == 2
+    assert config.vector_index_config.search_probe == 50

test/collection/test_config_methods.py

@@ -0,0 +1,73 @@
+
+import pytest
+from weaviate.collections.classes.config_methods import _collection_configs_simple_from_json
+
+def test_collection_config_simple_from_json_with_none_vectorizer_config() -> None:
+    """Test that _collection_configs_simple_from_json handles None vectorizer config."""
+    schema = {
+        "classes": [
+            {
+                "class": "TestCollection",
+                "vectorConfig": {
+                    "default": {
+                        "vectorizer": {
+                            "text2vec-transformers": None
+                        },
+                        "vectorIndexType": "hnsw",
+                        "vectorIndexConfig": {
+                            "skip": False,
+                            "cleanupIntervalSeconds": 300,
+                            "maxConnections": 64,
+                            "efConstruction": 128,
+                            "ef": -1,
+                            "dynamicEfMin": 100,
+                            "dynamicEfMax": 500,
+                            "dynamicEfFactor": 8,
+                            "vectorCacheMaxObjects": 1000000000000,
+                            "flatSearchCutoff": 40000,
+                            "distance": "cosine"
+                        }
+                    }
+                },
+                "properties": [],
+                "invertedIndexConfig": {
+                        "bm25": {"b": 0.75, "k1": 1.2},
+                        "cleanupIntervalSeconds": 60,
+                        "stopwords": {"preset": "en", "additions": None, "removals": None}
+                },
+                "replicationConfig": {"factor": 1, "deletionStrategy": "NoAutomatedResolution"},
+                "shardingConfig": {
+                    "virtualPerPhysical": 128,
+                    "desiredCount": 1,
+                    "actualCount": 1,
+                    "desiredVirtualCount": 128,
+                    "actualVirtualCount": 128,
+                    "key": "_id",
+                    "strategy": "hash",
+                    "function": "murmur3"
+                },
+                "vectorIndexType": "hnsw",
+                "vectorIndexConfig": {
+                    "skip": False,
+                    "cleanupIntervalSeconds": 300,
+                    "maxConnections": 64,
+                    "efConstruction": 128,
+                    "ef": -1,
+                    "dynamicEfMin": 100,
+                    "dynamicEfMax": 500,
+                    "dynamicEfFactor": 8,
+                    "vectorCacheMaxObjects": 1000000000000,
+                    "flatSearchCutoff": 40000,
+                    "distance": "cosine"
+                }
+            }
+        ]
+    }
+
+    configs = _collection_configs_simple_from_json(schema)
+    assert "TestCollection" in configs
+    vec_config = configs["TestCollection"].vector_config
+    assert vec_config is not None
+    assert "default" in vec_config
+    assert vec_config["default"].vectorizer.model == {}
+    assert vec_config["default"].vectorizer.source_properties is None

weaviate/collections/classes/config.py

@@ -52,6 +52,7 @@
     _VectorIndexConfigDynamicUpdate,
     _VectorIndexConfigFlatUpdate,
     _VectorIndexConfigHNSWUpdate,
+    _VectorIndexConfigHFreshUpdate,
     _VectorIndexConfigUpdate,
 )
 from weaviate.collections.classes.config_vector_index import (
@@ -1846,6 +1847,21 @@ def vector_index_type() -> str:
 VectorIndexConfigHNSW = _VectorIndexConfigHNSW
 
 
+@dataclass
+class _VectorIndexConfigHFresh(_VectorIndexConfig):
+    distance_metric: VectorDistances
+    max_posting_size_kb: int
+    replicas: int
+    search_probe: int
+
+    @staticmethod
+    def vector_index_type() -> str:
+        return VectorIndexType.HFRESH.value
+
+
+VectorIndexConfigHFresh = _VectorIndexConfigHFresh
+
+
 @dataclass
 class _VectorIndexConfigFlat(_VectorIndexConfig):
     distance_metric: VectorDistances
@@ -1919,7 +1935,10 @@ def to_dict(self) -> Dict[str, Any]:
 class _NamedVectorConfig(_ConfigBase):
     vectorizer: _NamedVectorizerConfig
     vector_index_config: Union[
-        VectorIndexConfigHNSW, VectorIndexConfigFlat, VectorIndexConfigDynamic
+        VectorIndexConfigHNSW,
+        VectorIndexConfigFlat,
+        VectorIndexConfigDynamic,
+        VectorIndexConfigHFresh,
     ]
 
     def to_dict(self) -> Dict:
@@ -1956,7 +1975,11 @@ class _CollectionConfig(_ConfigBase):
     reranker_config: Optional[RerankerConfig]
     sharding_config: Optional[ShardingConfig]
     vector_index_config: Union[
-        VectorIndexConfigHNSW, VectorIndexConfigFlat, VectorIndexConfigDynamic, None
+        VectorIndexConfigHNSW,
+        VectorIndexConfigFlat,
+        VectorIndexConfigDynamic,
+        VectorIndexConfigHFresh,
+        None,
     ]
     vector_index_type: Optional[VectorIndexType]
     vectorizer_config: Optional[VectorizerConfig]
@@ -2610,6 +2633,25 @@ def dynamic(
             quantizer=quantizer,
         )
 
+    @staticmethod
+    def hfresh(
+        max_posting_size_kb: Optional[int] = None,
+        search_probe: Optional[int] = None,
+        quantizer: Optional[_RQConfigUpdate] = None,
+    ) -> _VectorIndexConfigHFreshUpdate:
+        """Create an `_VectorIndexConfigHFreshUpdate` object to update the configuration of the HFresh vector index.
+
+        Use this method when defining the `vectorizer_config` argument in `collection.update()`.
+
+        Args:
+            See [the docs](https://weaviate.io/developers/weaviate/configuration/indexes#configure-the-inverted-index) for a more detailed view!
+        """  # noqa: D417 (missing argument descriptions in the docstring)
+        return _VectorIndexConfigHFreshUpdate(
+            maxPostingSizeKB=max_posting_size_kb,
+            searchProbe=search_probe,
+            quantizer=quantizer,
+        )
+
 
 class Reconfigure:
     """Use this factory class to generate the correct `xxxConfig` object for use when using the `collection.update()` method.

weaviate/collections/classes/config_methods.py

@@ -41,6 +41,7 @@
     _VectorIndexConfigDynamic,
     _VectorIndexConfigFlat,
     _VectorIndexConfigHNSW,
+    _VectorIndexConfigHFresh,
     _VectorizerConfig,
 )
 
@@ -213,6 +214,18 @@ def __get_hnsw_config(config: Dict[str, Any]) -> _VectorIndexConfigHNSW:
     )
 
 
+def __get_hfresh_config(config: Dict[str, Any]) -> _VectorIndexConfigHFresh:
+    quantizer = __get_quantizer_config(config)
+    return _VectorIndexConfigHFresh(
+        distance_metric=VectorDistances(config.get("distance")),
+        max_posting_size_kb=config["maxPostingSizeKB"],
+        replicas=config["replicas"],
+        search_probe=config["searchProbe"],
+        quantizer=quantizer,
+        multi_vector=None,
+    )
+
+
 def __get_flat_config(config: Dict[str, Any]) -> _VectorIndexConfigFlat:
     quantizer = __get_quantizer_config(config)
     return _VectorIndexConfigFlat(
@@ -225,7 +238,13 @@ def __get_flat_config(config: Dict[str, Any]) -> _VectorIndexConfigFlat:
 
 def __get_vector_index_config(
     schema: Dict[str, Any],
-) -> Union[_VectorIndexConfigHNSW, _VectorIndexConfigFlat, _VectorIndexConfigDynamic, None]:
+) -> Union[
+    _VectorIndexConfigHNSW,
+    _VectorIndexConfigFlat,
+    _VectorIndexConfigDynamic,
+    _VectorIndexConfigHFresh,
+    None,
+]:
     if "vectorIndexConfig" not in schema:
         return None
     if schema["vectorIndexType"] == "hnsw":
@@ -239,6 +258,8 @@ def __get_vector_index_config(
             hnsw=__get_hnsw_config(schema["vectorIndexConfig"]["hnsw"]),
             flat=__get_flat_config(schema["vectorIndexConfig"]["flat"]),
         )
+    elif schema["vectorIndexType"] == "hfresh":
+        return __get_hfresh_config(schema["vectorIndexConfig"])
     else:
         return None
 
@@ -256,6 +277,8 @@ def __get_vector_config(
 
             vectorizer_str: str = str(list(vectorizer)[0])
             vec_config: Dict[str, Any] = named_vector["vectorizer"][vectorizer_str]
+            if vec_config is None:
+                vec_config = {}
             props = vec_config.pop("properties", None)
 
             vector_index_config = __get_vector_index_config(named_vector)

weaviate/collections/classes/config_named_vectors.py

@@ -15,6 +15,7 @@
     _VectorIndexConfigDynamicUpdate,
     _VectorIndexConfigFlatUpdate,
     _VectorIndexConfigHNSWUpdate,
+    _VectorIndexConfigHFreshUpdate,
     _VectorIndexConfigUpdate,
 )
 from weaviate.collections.classes.config_vectorizers import (
@@ -1340,6 +1341,7 @@ def update(
         *,
         vector_index_config: Union[
             _VectorIndexConfigHNSWUpdate,
+            _VectorIndexConfigHFreshUpdate,
             _VectorIndexConfigFlatUpdate,
             _VectorIndexConfigDynamicUpdate,
         ],

weaviate/collections/classes/config_vector_index.py

@@ -34,11 +34,14 @@ class VectorIndexType(str, Enum):
     Attributes:
         HNSW: Hierarchical Navigable Small World (HNSW) index.
         FLAT: Flat index.
+        DYNAMIC: Dynamic index.
+        HFRESH: HFRESH index.
     """
 
     HNSW = "hnsw"
     FLAT = "flat"
     DYNAMIC = "dynamic"
+    HFRESH = "hfresh"
 
 
 class _MultiVectorConfigCreateBase(_ConfigCreateModel):
@@ -127,6 +130,16 @@ def vector_index_type() -> VectorIndexType:
         return VectorIndexType.HNSW
 
 
+class _VectorIndexConfigHFreshCreate(_VectorIndexConfigCreate):
+    maxPostingSizeKB: Optional[int]
+    replicas: Optional[int]
+    searchProbe: Optional[int]
+
+    @staticmethod
+    def vector_index_type() -> VectorIndexType:
+        return VectorIndexType.HFRESH
+
+
 class _VectorIndexConfigFlatCreate(_VectorIndexConfigCreate):
     vectorCacheMaxObjects: Optional[int]
 
@@ -149,6 +162,15 @@ def vector_index_type() -> VectorIndexType:
         return VectorIndexType.HNSW
 
 
+class _VectorIndexConfigHFreshUpdate(_VectorIndexConfigUpdate):
+    maxPostingSizeKB: Optional[int]
+    searchProbe: Optional[int]
+
+    @staticmethod
+    def vector_index_type() -> VectorIndexType:
+        return VectorIndexType.HFRESH
+
+
 class _VectorIndexConfigFlatUpdate(_VectorIndexConfigUpdate):
     vectorCacheMaxObjects: Optional[int]
 
@@ -564,6 +586,31 @@ def hnsw(
             multivector=multi_vector,
         )
 
+    @staticmethod
+    def hfresh(
+        distance_metric: Optional[VectorDistances] = None,
+        max_posting_size_kb: Optional[int] = None,
+        replicas: Optional[int] = None,
+        search_probe: Optional[int] = None,
+        quantizer: Optional[_QuantizerConfigCreate] = None,
+        multi_vector: Optional[_MultiVectorConfigCreate] = None,
+    ) -> _VectorIndexConfigHFreshCreate:
+        """Create a `_VectorIndexConfigHFreshCreate` object to be used when defining the HFresh vector index configuration of Weaviate.
+
+        Use this method when defining the `vector_index_config` argument in `collections.create()`.
+
+        Args:
+            See [the docs](https://weaviate.io/developers/weaviate/configuration/indexes#how-to-configure-hfresh) for a more detailed view!
+        """  # noqa: D417 (missing argument descriptions in the docstring)
+        return _VectorIndexConfigHFreshCreate(
+            distance=distance_metric,
+            maxPostingSizeKB=max_posting_size_kb,
+            replicas=replicas,
+            searchProbe=search_probe,
+            quantizer=quantizer,
+            multivector=multi_vector,
+        )
+
     @staticmethod
     def flat(
         distance_metric: Optional[VectorDistances] = None,

weaviate/collections/classes/config_vectors.py

@@ -20,6 +20,8 @@
     _VectorIndexConfigFlatUpdate,
     _VectorIndexConfigHNSWCreate,
     _VectorIndexConfigHNSWUpdate,
+    _VectorIndexConfigHFreshCreate,
+    _VectorIndexConfigHFreshUpdate,
     _VectorIndexConfigUpdate,
 )
 from weaviate.collections.classes.config_vectorizers import (
@@ -128,6 +130,17 @@ def __hnsw(
             multivector=multivector,
         )
 
+    @staticmethod
+    def __hfresh(*, quantizer: Optional[_QuantizerConfigCreate]) -> _VectorIndexConfigHFreshCreate:
+        return _VectorIndexConfigHFreshCreate(
+            maxPostingSizeKB=None,
+            replicas=None,
+            searchProbe=None,
+            quantizer=quantizer,
+            multivector=None,
+            distance=None,
+        )
+
     @staticmethod
     def __flat(*, quantizer: Optional[_QuantizerConfigCreate]) -> _VectorIndexConfigFlatCreate:
         return _VectorIndexConfigFlatCreate(
@@ -1804,6 +1817,7 @@ def update(
         name: Optional[str] = None,
         vector_index_config: Union[
             _VectorIndexConfigHNSWUpdate,
+            _VectorIndexConfigHFreshUpdate,
             _VectorIndexConfigFlatUpdate,
             _VectorIndexConfigDynamicUpdate,
         ],