weaviate-haystack 7.8.0__tar.gz → 8.0.0__tar.gz

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [integrations/weaviate-v7.9.0] - 2026-09-21
+
+### 🚀 Features
+
+- Send X-Weaviate-Client-Integration telemetry header (#3954)
+
+### ⚙️ CI
+
+- Improve changelog generation; fix existing changelogs (#3883)
+
+### 🧹 Chores
+
+- Raise weaviate-client floor and test against Weaviate 1.39 (#3956)
+
+
+## [integrations/weaviate-v7.8.0] - 2026-09-01
+
+### 🐛 Bug Fixes
+
+- `Weaviate` match `search_term` against metadata field value, not content + default size value set to 10 (#3643)
+- Fix new issues raised by ruff 0.16.0 (#3670)
+- `WeaviateDocumentStore` get_metadata_field_unique_values setting list of values to return to `Any` (#3708)
+- Weaviate adding optional parameter `filters` to `get_metadata_field_unique_values()` (#3741)
+- Standardize license files (#3771)
+
+### 🧪 Testing
+
+- `WeaviateDocumentStore` removing duplicated tests already covered by haystack Mixin tests (#3787)
+
+
 ## [integrations/weaviate-v7.7.0] - 2026-07-22
 
 ### 🚜 Refactor
@@ -207,21 +237,20 @@
 
 ### 🧹 Chores
 
-- Weaviate - remove legacy filter support (#1070)
 - Update changelog after removing legacy filters (#1083)
 - Update ruff linting scripts and settings (#1105)
 
+## [integrations/weaviate-v3.0.0] - 2024-09-12
 
-## [integrations/weaviate-v2.2.1] - 2024-09-07
+### 🧹 Chores
 
-### 🚀 Features
+- Weaviate - remove legacy filter support (#1070)
 
-- Add filter_policy to weaviate integration (#824)
+
+## [integrations/weaviate-v2.2.1] - 2024-09-07
 
 ### 🐛 Bug Fixes
 
-- Weaviate filter error (#811)
-- Fix connection to Weaviate Cloud Service (#624)
 - Pin weaviate-client (#1046)
 - Weaviate - fix connection issues with some WCS URLs (#1058)
 
@@ -229,9 +258,27 @@
 
 - Do not retry tests in `hatch run test` command (#954)
 
-### ⚙️ CI
+### 🌀 Miscellaneous
 
-- Retry tests to reduce flakyness (#836)
+- Chore: weaviate - ruff update, don't ruff tests (#986)
+
+## [integrations/weaviate-v2.2.0] - 2024-08-02
+
+### 🌀 Miscellaneous
+
+- Fix: Weaviate: Use collections.list_all instead of collections._get_all (#921)
+
+## [integrations/weaviate-v2.1.3] - 2024-07-17
+
+### 🌀 Miscellaneous
+
+- Fix: `weaviate` - Fallback to default filter policy when deserializing retrievers without the init parameter  (#903)
+
+## [integrations/weaviate-v2.1.2] - 2024-07-15
+
+### 🚀 Features
+
+- Add filter_policy to weaviate integration (#824)
 
 ### 🧹 Chores
 
@@ -239,15 +286,24 @@
 
 ### 🌀 Miscellaneous
 
+- Chore: Minor retriever pydoc fix (#884)
+
+## [integrations/weaviate-v2.1.1] - 2024-06-25
+
+### 🐛 Bug Fixes
+
+- Weaviate filter error (#811)
+- Fix connection to Weaviate Cloud Service (#624)
+
+### ⚙️ CI
+
+- Retry tests to reduce flakyness (#836)
+
+### 🌀 Miscellaneous
+
 - Handle connection to WCS and add tests
 - Revert "Handle connection to WCS and add tests"
-
-This reverts commit f48802b2ce612896fd06a13cf33dffd9f77a8859.
 - Ci: install `pytest-rerunfailures` where needed; add retry config to `test-cov` script (#845)
-- Chore: Minor retriever pydoc fix (#884)
-- Fix: `weaviate` - Fallback to default filter policy when deserializing retrievers without the init parameter  (#903)
-- Fix: Weaviate: Use collections.list_all instead of collections._get_all (#921)
-- Chore: weaviate - ruff update, don't ruff tests (#986)
 
 ## [integrations/weaviate-v2.1.0] - 2024-06-10
 

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: weaviate-haystack
-Version: 7.8.0
+Version: 8.0.0
 Summary: An integration of Weaviate vector database with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/weaviate/README.md
@@ -11,17 +11,16 @@ License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai>=2.28.0
 Requires-Dist: python-dateutil>=2.7.0
-Requires-Dist: weaviate-client>=4.20
+Requires-Dist: weaviate-client>=4.23.0
 Description-Content-Type: text/markdown
 
 # weaviate-haystack

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/docker-compose.yml

@@ -7,7 +7,7 @@ services:
     - '8080'
     - --scheme
     - http
-    image: semitechnologies/weaviate:1.36.2
+    image: cr.weaviate.io/semitechnologies/weaviate:1.39.4
     ports:
     - 8080:8080
     - 50051:50051
@@ -18,4 +18,16 @@ services:
       PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
       DEFAULT_VECTORIZER_MODULE: 'none'
       ENABLE_MODULES: ''
-      CLUSTER_HOSTNAME: 'node1'
+      CLUSTER_HOSTNAME: 'node1'
+    healthcheck:
+      test:
+      - CMD
+      - busybox
+      - wget
+      - -q
+      - -O
+      - '-'
+      - http://127.0.0.1:8080/v1/.well-known/ready
+      interval: 5s
+      timeout: 3s
+      retries: 20

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "weaviate-haystack"
 dynamic = ["version"]
 description = "An integration of Weaviate vector database with Haystack"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
@@ -15,7 +15,6 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -25,7 +24,7 @@ classifiers = [
 ]
 dependencies = [
   "haystack-ai>=2.28.0",
-  "weaviate-client>=4.20",
+  "weaviate-client>=4.23.0",
   "python-dateutil>=2.7.0",
 ]
 

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/components/retrievers/weaviate/embedding_retriever.py

@@ -143,8 +143,8 @@ class WeaviateEmbeddingRetriever:
         filters = apply_filter_policy(self._filter_policy, self._filters, filters)
         top_k = top_k or self._top_k
 
-        distance = distance or self._distance
-        certainty = certainty or self._certainty
+        distance = self._distance if distance is None else distance
+        certainty = self._certainty if certainty is None else certainty
         if distance is not None and certainty is not None:
             msg = f"Can't use 'distance' ({distance}) and 'certainty' ({certainty}) parameters together"
             raise ValueError(msg)
@@ -191,8 +191,8 @@ class WeaviateEmbeddingRetriever:
         filters = apply_filter_policy(self._filter_policy, self._filters, filters)
         top_k = top_k or self._top_k
 
-        distance = distance or self._distance
-        certainty = certainty or self._certainty
+        distance = self._distance if distance is None else distance
+        certainty = self._certainty if certainty is None else certainty
         if distance is not None and certainty is not None:
             msg = f"Can't use 'distance' ({distance}) and 'certainty' ({certainty}) parameters together"
             raise ValueError(msg)

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/document_stores/weaviate/_filters.py

@@ -33,6 +33,10 @@ def convert_filters(filters: dict[str, Any]) -> FilterReturn:
     Note: The ``contains`` operator performs substring matching and is
     **case-sensitive**. For case-insensitive matching, normalize the value
     (e.g., lowercase) before building the filter.
+
+    Note: ``NOT`` is applied client-side by inverting its conditions (De Morgan), so it works
+    on any Weaviate version. The only exception is ``NOT`` over ``contains``, which has no
+    invertible counterpart and uses Weaviate's native ``NOT`` operator (Weaviate 1.33 or later).
     """
     if not isinstance(filters, dict):
         msg = "Filters must be a dictionary"
@@ -43,7 +47,13 @@ def convert_filters(filters: dict[str, Any]) -> FilterReturn:
     return _parse_logical_condition(filters)
 
 
-OPERATOR_INVERSE = {
+LOGICAL_OPERATORS = {
+    "AND": Filter.all_of,
+    "OR": Filter.any_of,
+}
+
+
+COMPARISON_INVERSE = {
     "==": "!=",
     "!=": "==",
     ">": "<=",
@@ -52,38 +62,10 @@ OPERATOR_INVERSE = {
     "<=": ">",
     "in": "not in",
     "not in": "in",
-    "AND": "OR",
-    "OR": "AND",
-    "NOT": "OR",
-}
-
-
-def _invert_condition(filters: dict[str, Any]) -> dict[str, Any]:
-    """
-    Invert condition recursively.
-
-    Weaviate doesn't support NOT filters so we need to invert them ourselves.
-    """
-    inverted_condition = filters.copy()
-    if "operator" not in filters:
-        # Let's not handle this stuff in here, we'll fail later on anyway.
-        return inverted_condition
-    inverted_condition["operator"] = OPERATOR_INVERSE[filters["operator"]]
-    if "conditions" in filters:
-        inverted_condition["conditions"] = []
-        for condition in filters["conditions"]:
-            inverted_condition["conditions"].append(_invert_condition(condition))
-
-    return inverted_condition
-
-
-LOGICAL_OPERATORS = {
-    "AND": Filter.all_of,
-    "OR": Filter.any_of,
 }
 
 
-def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
+def _validate_logical_condition(condition: dict[str, Any]) -> None:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
         raise FilterError(msg)
@@ -91,23 +73,55 @@ def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
         msg = f"'conditions' key missing in {condition}"
         raise FilterError(msg)
 
+
+def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
+    _validate_logical_condition(condition)
+
     operator = condition["operator"]
     if operator in ["AND", "OR"]:
-        operands = []
-        for c in condition["conditions"]:
-            if "field" not in c:
-                operands.append(_parse_logical_condition(c))
-            else:
-                operands.append(_parse_comparison_condition(c))
-        return LOGICAL_OPERATORS[operator](operands)
+        return LOGICAL_OPERATORS[operator](_parse_operands(condition["conditions"]))
+    elif operator == "NOT":
+        # A NOT node negates the conjunction of its conditions: NOT(a AND b) == NOT(a) OR NOT(b).
+        return Filter.any_of([_negate(c) for c in condition["conditions"]])
+    else:
+        msg = f"Unknown logical operator '{operator}'"
+        raise FilterError(msg)
+
+
+def _negate(condition: dict[str, Any]) -> FilterReturn:
+    """
+    Build the negation of a condition by applying De Morgan's laws.
+
+    Negation is done client-side so that it works on Weaviate versions without a native NOT operator.
+    """
+    if "field" in condition:
+        operator = condition.get("operator")
+        if operator in COMPARISON_INVERSE:
+            return _parse_comparison_condition({**condition, "operator": COMPARISON_INVERSE[operator]})
+        # Operators like `contains` have no invertible counterpart, so we fall back to Weaviate's
+        # native NOT, which requires Weaviate 1.33 or later.
+        # Unknown operators raise a FilterError while parsing the condition.
+        return Filter.not_(_parse_comparison_condition(condition))
+
+    _validate_logical_condition(condition)
+    operator = condition["operator"]
+    conditions = condition["conditions"]
+    if operator == "AND":
+        return Filter.any_of([_negate(c) for c in conditions])
+    elif operator == "OR":
+        return Filter.all_of([_negate(c) for c in conditions])
     elif operator == "NOT":
-        inverted_conditions = _invert_condition(condition)
-        return _parse_logical_condition(inverted_conditions)
+        # The two negations cancel out, leaving the conjunction of the conditions.
+        return Filter.all_of(_parse_operands(conditions))
     else:
         msg = f"Unknown logical operator '{operator}'"
         raise FilterError(msg)
 
 
+def _parse_operands(conditions: list[dict[str, Any]]) -> list[FilterReturn]:
+    return [_parse_comparison_condition(c) if "field" in c else _parse_logical_condition(c) for c in conditions]
+
+
 def _handle_date(value: Any) -> str:
     if isinstance(value, str):
         try:
@@ -282,6 +296,10 @@ def _parse_comparison_condition(condition: dict[str, Any]) -> FilterReturn:
     operator: str = condition["operator"]
     value: Any = condition["value"]
 
+    if operator not in COMPARISON_OPERATORS:
+        msg = f"Unknown comparison operator '{operator}'. Valid operators are: {list(COMPARISON_OPERATORS.keys())}"
+        raise FilterError(msg)
+
     return COMPARISON_OPERATORS[operator](field, value)
 
 

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/document_stores/weaviate/document_store.py

@@ -3,7 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import base64
-import datetime
+import datetime as dt
+import importlib.metadata
 import json
 from contextlib import suppress
 from dataclasses import asdict
@@ -38,6 +39,27 @@ from .auth import AuthCredentials
 
 logger = logging.getLogger(__name__)
 
+# Weaviate tracks which framework integrations talk to it through this header, so that adoption of
+# weaviate-haystack shows up in Weaviate's own telemetry. See https://github.com/weaviate/weaviate/pull/10535.
+_INTEGRATION_HEADER = "X-Weaviate-Client-Integration"
+_INTEGRATION_NAME = "haystack-python"
+_PACKAGE_NAME = "weaviate-haystack"
+
+
+def _integration_header_value() -> str:
+    """
+    Builds the value of the Weaviate client integration header.
+
+    :returns:
+        A `<name>/<version>` string. The version falls back to `unknown` when the package metadata is
+        unavailable, for example when running from a source checkout that was never installed.
+    """
+    try:
+        version = importlib.metadata.version(_PACKAGE_NAME)
+    except importlib.metadata.PackageNotFoundError:
+        version = "unknown"
+    return f"{_INTEGRATION_NAME}/{version}"
+
 
 # This is the default collection properties for Weaviate.
 # It's a list of properties that will be created on the collection.
@@ -144,6 +166,9 @@ class WeaviateDocumentStore:
             ```
             {"X-OpenAI-Api-Key": "<THE-KEY>"}, {"X-HuggingFace-Api-Key": "<THE-KEY>"}
             ```
+            Every connection also carries `X-Weaviate-Client-Integration: haystack-python/<version>`, which
+            identifies this integration in Weaviate's telemetry. Supplying that header here, in any casing,
+            overrides it.
         :param embedded_options:
             If set, create an embedded Weaviate cluster inside the client. For a full list of options see
             `weaviate.embedded.EmbeddedOptions`.
@@ -183,6 +208,26 @@ class WeaviateDocumentStore:
             "properties", DOCUMENT_COLLECTION_PROPERTIES
         )
 
+    def _connection_headers(self) -> dict[str, Any]:
+        """
+        Builds the headers passed to the Weaviate client.
+
+        Merges the integration identification header into the user supplied `additional_headers`. A user
+        supplied value for the same header wins, so the header can be overridden or suppressed. The merged
+        headers are deliberately not stored on the instance: `to_dict()` must keep serializing only the
+        headers the user actually passed, so that a serialized pipeline does not bake in the version of
+        `weaviate-haystack` that happened to write it.
+
+        :returns:
+            The headers to pass to the Weaviate client.
+        """
+        headers: dict[str, Any] = dict(self._additional_headers) if self._additional_headers else {}
+        # The comparison is case insensitive because gRPC metadata keys are case sensitive: a user supplied
+        # "x-weaviate-client-integration" would otherwise end up alongside our own spelling of the header.
+        if not any(key.lower() == _INTEGRATION_HEADER.lower() for key in headers):
+            headers[_INTEGRATION_HEADER] = _integration_header_value()
+        return headers
+
     @property
     def client(self) -> weaviate.WeaviateClient:
         """Return the synchronous Weaviate client, creating and connecting it if necessary."""
@@ -199,7 +244,7 @@ class WeaviateDocumentStore:
             self._client = weaviate.connect_to_weaviate_cloud(
                 self._url,
                 auth_credentials=self._auth_client_secret.resolve_value(),
-                headers=self._additional_headers,
+                headers=self._connection_headers(),
                 additional_config=self._additional_config,
             )
         else:
@@ -216,7 +261,7 @@ class WeaviateDocumentStore:
                 ),
                 auth_client_secret=self._auth_client_secret.resolve_value() if self._auth_client_secret else None,
                 additional_config=self._additional_config,
-                additional_headers=self._additional_headers,
+                additional_headers=self._connection_headers(),
                 embedded_options=self._embedded_options,
                 skip_init_checks=False,
             )
@@ -244,7 +289,7 @@ class WeaviateDocumentStore:
             self._async_client = weaviate.use_async_with_weaviate_cloud(
                 self._url,
                 auth_credentials=self._auth_client_secret.resolve_value(),
-                headers=self._additional_headers,
+                headers=self._connection_headers(),
                 additional_config=self._additional_config,
             )
         else:
@@ -261,7 +306,7 @@ class WeaviateDocumentStore:
                 ),
                 auth_client_secret=self._auth_client_secret.resolve_value() if self._auth_client_secret else None,
                 additional_config=self._additional_config,
-                additional_headers=self._additional_headers,
+                additional_headers=self._connection_headers(),
                 embedded_options=self._embedded_options,
                 skip_init_checks=False,
             )
@@ -831,7 +876,7 @@ class WeaviateDocumentStore:
         document_data.pop("blob_mime_type", None)
 
         for key, value in document_data.items():
-            if isinstance(value, datetime.datetime):
+            if isinstance(value, dt.datetime):
                 document_data[key] = value.strftime("%Y-%m-%dT%H:%M:%SZ")
 
         if weaviate_meta := getattr(data, "metadata", None):
@@ -938,6 +983,9 @@ class WeaviateDocumentStore:
         matching). For case-insensitive matching, normalize the value before
         building the filter.
 
+        Note: ``NOT`` over the ``contains`` operator is translated to Weaviate's
+        native ``NOT``, which requires Weaviate 1.33 or later.
+
         :param filters: The filters to apply to the document list.
         :returns: A list of Documents that match the given filters.
         """
@@ -961,6 +1009,9 @@ class WeaviateDocumentStore:
         matching). For case-insensitive matching, normalize the value before
         building the filter.
 
+        Note: ``NOT`` over the ``contains`` operator is translated to Weaviate's
+        native ``NOT``, which requires Weaviate 1.33 or later.
+
         :param filters: The filters to apply to the document list.
         :returns: A list of Documents that match the given filters.
         """

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/tests/test_bm25_retriever.py

@@ -2,9 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import Mock, patch
+from unittest.mock import create_autospec, patch
 
 import pytest
+from haystack import Pipeline
 from haystack.document_stores.types import FilterPolicy
 
 from haystack_integrations.components.retrievers.weaviate import WeaviateBM25Retriever
@@ -12,7 +13,7 @@ from haystack_integrations.document_stores.weaviate import WeaviateDocumentStore
 
 
 def test_close():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
 
     retriever.close()
@@ -22,7 +23,7 @@ def test_close():
 
 
 def test_init_default():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
     assert retriever._document_store == mock_document_store
     assert retriever._filters == {}
@@ -153,10 +154,24 @@ def test_from_dict_no_filter_policy(_mock_weaviate):
     assert retriever._filter_policy == FilterPolicy.REPLACE
 
 
-@patch("haystack_integrations.components.retrievers.weaviate.bm25_retriever.WeaviateDocumentStore")
-def test_run(mock_document_store):
+def test_run():
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
     query = "some query"
     filters = {"field": "content", "operator": "==", "value": "Some text"}
     retriever.run(query=query, filters=filters, top_k=5)
     mock_document_store._bm25_retrieval.assert_called_once_with(query=query, filters=filters, top_k=5)
+
+
+def test_pipeline_serde():
+    """A pipeline holding the retriever must survive a dumps/loads round trip, nested store included."""
+    document_store = WeaviateDocumentStore(url="http://localhost:8080")
+    pipeline = Pipeline()
+    pipeline.add_component("retriever", WeaviateBM25Retriever(document_store=document_store, top_k=3))
+
+    reloaded = Pipeline.loads(pipeline.dumps()).get_component("retriever")
+
+    assert isinstance(reloaded, WeaviateBM25Retriever)
+    assert isinstance(reloaded._document_store, WeaviateDocumentStore)
+    assert reloaded._document_store.to_dict() == document_store.to_dict()
+    assert reloaded._top_k == 3

{weaviate_haystack-7.8.0 → weaviate_haystack-8.0.0}/tests/test_bm25_retriever_async.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import create_autospec
 
 import pytest
 
@@ -12,8 +12,7 @@ from haystack_integrations.document_stores.weaviate import WeaviateDocumentStore
 
 @pytest.mark.asyncio
 async def test_close_async():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
-    mock_document_store.close_async = AsyncMock()
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
 
     await retriever.close_async()
@@ -24,8 +23,8 @@ async def test_close_async():
 
 @pytest.mark.asyncio
 async def test_run_async_calls_async_retrieval():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
-    mock_document_store._bm25_retrieval_async = AsyncMock(return_value=[])
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
+    mock_document_store._bm25_retrieval_async.return_value = []
 
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)