pgvector-haystack 5.4.0__tar.gz → 6.0.0__tar.gz

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [integrations/pgvector-v5.5.0] - 2026-01-02
+
+### 🚀 Features
+
+- Adding `update_by_filter` and `delete_by_filter` to PgVector document store (#2647)
+
+
+## [integrations/pgvector-v5.4.0] - 2025-12-05
+
+### 📚 Documentation
+
+- Add pydoc configurations for Docusaurus (#2411)
+
+### ⚙️ CI
+
+- Change pytest command (#2475)
+
+### 🧹 Chores
+
+- Remove Readme API CI workflow and configs (#2573)
+- Pgvector - document expected connection string and raise informative error (#2583)
+
+### 🌀 Miscellaneous
+
+- Enhancement: Adopt PEP 585 type hinting (part 5) (#2528)
+
 ## [integrations/pgvector-v5.3.0] - 2025-10-17
 
 ### 🚀 Features

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 5.4.0
+Version: 6.0.0
 Summary: An integration of pgvector (vector search extension for Postgres) 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/pgvector/README.md
@@ -11,15 +11,14 @@ 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.9
 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 :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
-Requires-Dist: haystack-ai>=2.11.0
+Requires-Python: >=3.10
+Requires-Dist: haystack-ai>=2.22.0
 Requires-Dist: pgvector>=0.3.0
 Requires-Dist: psycopg[binary]
 Description-Content-Type: text/markdown

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "pgvector-haystack"
 dynamic = ["version"]
 description = "An integration of pgvector (vector search extension for Postgres) with Haystack"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 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.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
@@ -23,7 +22,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.11.0", "pgvector>=0.3.0", "psycopg[binary]"]
+dependencies = ["haystack-ai>=2.22.0", "pgvector>=0.3.0", "psycopg[binary]"]
 
 [project.urls]
 Source = "https://github.com/deepset-ai/haystack-core-integrations"
@@ -47,7 +46,7 @@ dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
 docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
-fmt = "ruff check --fix {args} && ruff format {args}"
+fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
 [tool.hatch.envs.test]
@@ -83,7 +82,6 @@ ignore_missing_imports = true
 
 
 [tool.ruff]
-target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]
@@ -134,10 +132,6 @@ ignore = [
   # ignore assertions
   "S101",
 ]
-unfixable = [
-  # Don't touch unused imports
-  "F401",
-]
 
 [tool.ruff.lint.isort]
 known-first-party = ["haystack_integrations"]

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -62,10 +62,10 @@ class PgvectorEmbeddingRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
     ):
         """
         :param document_store: An instance of `PgvectorDocumentStore`.
@@ -137,9 +137,9 @@ class PgvectorEmbeddingRetriever:
     def run(
         self,
         query_embedding: list[float],
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
@@ -170,9 +170,9 @@ class PgvectorEmbeddingRetriever:
     async def run_async(
         self,
         query_embedding: list[float],
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Optional, Union
+from typing import Any
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -52,9 +52,9 @@ class PgvectorKeywordRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        filter_policy: str | FilterPolicy = FilterPolicy.REPLACE,
     ):
         """
         :param document_store: An instance of `PgvectorDocumentStore`.
@@ -111,8 +111,8 @@ class PgvectorKeywordRetriever:
     def run(
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
     ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
@@ -141,8 +141,8 @@ class PgvectorKeywordRetriever:
     async def run_async(
         self,
         query: str,
-        filters: Optional[dict[str, Any]] = None,
-        top_k: Optional[int] = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int | None = None,
     ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on keywords.

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -1,7 +1,8 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from typing import Any, Literal, Optional, Union, overload
+
+from typing import Any, Literal, overload
 
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses.document import Document
@@ -13,6 +14,7 @@ from psycopg.cursor_async import AsyncCursor
 from psycopg.rows import DictRow, dict_row
 from psycopg.sql import SQL, Composed, Identifier
 from psycopg.sql import Literal as SQLLiteral
+from psycopg.types.json import Jsonb
 
 from pgvector.psycopg import register_vector, register_vector_async
 
@@ -90,9 +92,9 @@ class PgvectorDocumentStore:
         recreate_table: bool = False,
         search_strategy: Literal["exact_nearest_neighbor", "hnsw"] = "exact_nearest_neighbor",
         hnsw_recreate_index_if_exists: bool = False,
-        hnsw_index_creation_kwargs: Optional[dict[str, int]] = None,
+        hnsw_index_creation_kwargs: dict[str, int] | None = None,
         hnsw_index_name: str = "haystack_hnsw_index",
-        hnsw_ef_search: Optional[int] = None,
+        hnsw_ef_search: int | None = None,
         keyword_index_name: str = "haystack_keyword_index",
     ):
         """
@@ -173,12 +175,12 @@ class PgvectorDocumentStore:
         self.keyword_index_name = keyword_index_name
         self.language = language
 
-        self._connection: Optional[Connection] = None
-        self._async_connection: Optional[AsyncConnection] = None
-        self._cursor: Optional[Cursor] = None
-        self._async_cursor: Optional[AsyncCursor] = None
-        self._dict_cursor: Optional[Cursor[DictRow]] = None
-        self._async_dict_cursor: Optional[AsyncCursor[DictRow]] = None
+        self._connection: Connection | None = None
+        self._async_connection: AsyncConnection | None = None
+        self._cursor: Cursor | None = None
+        self._async_cursor: AsyncCursor | None = None
+        self._dict_cursor: Cursor[DictRow] | None = None
+        self._async_dict_cursor: AsyncCursor[DictRow] | None = None
         self._table_initialized = False
 
     def to_dict(self) -> dict[str, Any]:
@@ -248,21 +250,21 @@ class PgvectorDocumentStore:
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor, sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: Cursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor: ...
 
     @overload
     def _execute_sql(
-        self, cursor: Cursor[DictRow], sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: Cursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> Cursor[DictRow]: ...
 
     def _execute_sql(
         self,
-        cursor: Union[Cursor, Cursor[DictRow]],
+        cursor: Cursor | Cursor[DictRow],
         sql_query: Composed,
-        params: Optional[tuple] = None,
+        params: tuple | None = None,
         error_msg: str = "",
-    ) -> Union[Cursor, Cursor[DictRow]]:
+    ) -> Cursor | Cursor[DictRow]:
         """
         Internal method to execute SQL statements and handle exceptions.
 
@@ -297,21 +299,21 @@ class PgvectorDocumentStore:
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor, sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: AsyncCursor, sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor: ...
 
     @overload
     async def _execute_sql_async(
-        self, cursor: AsyncCursor[DictRow], sql_query: Composed, params: Optional[tuple] = None, error_msg: str = ""
+        self, cursor: AsyncCursor[DictRow], sql_query: Composed, params: tuple | None = None, error_msg: str = ""
     ) -> AsyncCursor[DictRow]: ...
 
     async def _execute_sql_async(
         self,
-        cursor: Union[AsyncCursor, AsyncCursor[DictRow]],
+        cursor: AsyncCursor | AsyncCursor[DictRow],
         sql_query: Composed,
-        params: Optional[tuple] = None,
+        params: tuple | None = None,
         error_msg: str = "",
-    ) -> Union[AsyncCursor, AsyncCursor[DictRow]]:
+    ) -> AsyncCursor | AsyncCursor[DictRow]:
         """
         Internal method to asynchronously execute SQL statements and handle exceptions.
 
@@ -757,12 +759,12 @@ class PgvectorDocumentStore:
             return result[0]
         return 0
 
-    def filter_documents(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
+    def filter_documents(self, filters: dict[str, Any] | None = None) -> list[Document]:
         """
         Returns the documents that match the filters provided.
 
         For a detailed specification of the filters,
-        refer to the [documentation](https://docs.haystack.deepset.ai/v2.0/docs/metadata-filtering)
+        refer to the [documentation](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :param filters: The filters to apply to the document list.
         :raises TypeError: If `filters` is not a dictionary.
@@ -794,12 +796,12 @@ class PgvectorDocumentStore:
         docs = _from_pg_to_haystack_documents(records)
         return docs
 
-    async def filter_documents_async(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
+    async def filter_documents_async(self, filters: dict[str, Any] | None = None) -> list[Document]:
         """
         Asynchronously returns the documents that match the filters provided.
 
         For a detailed specification of the filters,
-        refer to the [documentation](https://docs.haystack.deepset.ai/v2.0/docs/metadata-filtering)
+        refer to the [documentation](https://docs.haystack.deepset.ai/docs/metadata-filtering)
 
         :param filters: The filters to apply to the document list.
 
@@ -1036,8 +1038,192 @@ class PgvectorDocumentStore:
             error_msg="Could not delete all documents from PgvectorDocumentStore",
         )
 
+    def delete_by_filter(self, filters: dict[str, Any]) -> int:
+        """
+        Deletes all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for deletion.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :returns: The number of documents deleted.
+        """
+        _validate_filters(filters)
+
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            delete_sql += sql_where_clause
+
+        self._ensure_db_setup()
+        assert self._cursor is not None
+
+        try:
+            self._execute_sql(
+                cursor=self._cursor,
+                sql_query=delete_sql,
+                params=params,
+                error_msg="Could not delete documents by filter from PgvectorDocumentStore",
+            )
+            deleted_count = self._cursor.rowcount
+            logger.info(
+                "Deleted {n_docs} documents from table '{schema}.{table}' using filters.",
+                n_docs=deleted_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return deleted_count
+        except Error as e:
+            msg = f"Failed to delete documents by filter from PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    async def delete_by_filter_async(self, filters: dict[str, Any]) -> int:
+        """
+        Asynchronously deletes all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for deletion.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :returns: The number of documents deleted.
+        """
+        _validate_filters(filters)
+
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            delete_sql += sql_where_clause
+
+        await self._ensure_db_setup_async()
+        assert self._async_cursor is not None
+
+        try:
+            await self._execute_sql_async(
+                cursor=self._async_cursor,
+                sql_query=delete_sql,
+                params=params,
+                error_msg="Could not delete documents by filter from PgvectorDocumentStore",
+            )
+            deleted_count = self._async_cursor.rowcount
+            logger.info(
+                "Deleted {n_docs} documents from table '{schema}.{table}' using filters.",
+                n_docs=deleted_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return deleted_count
+        except Error as e:
+            msg = f"Failed to delete documents by filter from PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    def update_by_filter(self, filters: dict[str, Any], meta: dict[str, Any]) -> int:
+        """
+        Updates the metadata of all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for updating.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :param meta: The metadata fields to update.
+        :returns: The number of documents updated.
+        """
+        _validate_filters(filters)
+
+        if not meta:
+            msg = "meta must be a non-empty dictionary"
+            raise ValueError(msg)
+
+        update_sql = SQL(
+            "UPDATE {schema_name}.{table_name} SET meta = COALESCE(meta, '{{}}'::jsonb) || %s::jsonb"
+        ).format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params: tuple[Any, ...] = (Jsonb(meta),)
+        if filters:
+            sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(filters)
+            update_sql += sql_where_clause
+            params = params + where_params
+
+        self._ensure_db_setup()
+        assert self._cursor is not None
+
+        try:
+            self._execute_sql(
+                cursor=self._cursor,
+                sql_query=update_sql,
+                params=params,
+                error_msg="Could not update documents by filter from PgvectorDocumentStore",
+            )
+            updated_count = self._cursor.rowcount
+            logger.info(
+                "Updated {n_docs} documents in table '{schema}.{table}' using filters.",
+                n_docs=updated_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return updated_count
+        except Error as e:
+            msg = f"Failed to update documents by filter in PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
+    async def update_by_filter_async(self, filters: dict[str, Any], meta: dict[str, Any]) -> int:
+        """
+        Asynchronously updates the metadata of all documents that match the provided filters.
+
+        :param filters: The filters to apply to select documents for updating.
+            For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+        :param meta: The metadata fields to update.
+        :returns: The number of documents updated.
+        """
+        _validate_filters(filters)
+
+        if not meta:
+            msg = "meta must be a non-empty dictionary"
+            raise ValueError(msg)
+
+        update_sql = SQL(
+            "UPDATE {schema_name}.{table_name} SET meta = COALESCE(meta, '{{}}'::jsonb) || %s::jsonb"
+        ).format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+        )
+
+        params: tuple[Any, ...] = (Jsonb(meta),)
+        if filters:
+            sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(filters)
+            update_sql += sql_where_clause
+            params = params + where_params
+
+        await self._ensure_db_setup_async()
+        assert self._async_cursor is not None
+
+        try:
+            await self._execute_sql_async(
+                cursor=self._async_cursor,
+                sql_query=update_sql,
+                params=params,
+                error_msg="Could not update documents by filter from PgvectorDocumentStore",
+            )
+            updated_count = self._async_cursor.rowcount
+            logger.info(
+                "Updated {n_docs} documents in table '{schema}.{table}' using filters.",
+                n_docs=updated_count,
+                schema=self.schema_name,
+                table=self.table_name,
+            )
+            return updated_count
+        except Error as e:
+            msg = f"Failed to update documents by filter in PgvectorDocumentStore: {e!s}"
+            raise DocumentStoreError(msg) from e
+
     def _build_keyword_retrieval_query(
-        self, query: str, top_k: int, filters: Optional[dict[str, Any]] = None
+        self, query: str, top_k: int, filters: dict[str, Any] | None = None
     ) -> tuple[Composed, tuple]:
         """
         Builds the SQL query and the where parameters for keyword retrieval.
@@ -1050,7 +1236,7 @@ class PgvectorDocumentStore:
         )
 
         where_params = ()
-        sql_where_clause: Union[Composed, SQL] = SQL("")
+        sql_where_clause: Composed | SQL = SQL("")
         if filters:
             sql_where_clause, where_params = _convert_filters_to_where_clause_and_params(
                 filters=filters, operator="AND"
@@ -1066,7 +1252,7 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
     ) -> list[Document]:
         """
@@ -1101,7 +1287,7 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
     ) -> list[Document]:
         """
@@ -1129,9 +1315,9 @@ class PgvectorDocumentStore:
     def _check_and_build_embedding_retrieval_query(
         self,
         query_embedding: list[float],
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]],
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None,
         top_k: int,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
     ) -> tuple[Composed, tuple]:
         """
         Performs checks and builds the SQL query and the where parameters for embedding retrieval.
@@ -1171,7 +1357,7 @@ class PgvectorDocumentStore:
             score=SQL(score_definition),
         )
 
-        sql_where_clause: Union[Composed, SQL] = SQL("")
+        sql_where_clause: Composed | SQL = SQL("")
         params = ()
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
@@ -1193,9 +1379,9 @@ class PgvectorDocumentStore:
         self,
         query_embedding: list[float],
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query embedding using a vector similarity metric.
@@ -1227,9 +1413,9 @@ class PgvectorDocumentStore:
         self,
         query_embedding: list[float],
         *,
-        filters: Optional[dict[str, Any]] = None,
+        filters: dict[str, Any] | None = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+        vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] | None = None,
     ) -> list[Document]:
         """
         Asynchronously retrieves documents that are most similar to the query embedding using a

{pgvector_haystack-5.4.0 → pgvector_haystack-6.0.0}/src/haystack_integrations/document_stores/pgvector/filters.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from datetime import datetime
 from itertools import chain
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 from haystack.errors import FilterError
 from psycopg.sql import SQL, Composed
@@ -21,7 +21,7 @@ PYTHON_TYPES_TO_PG_TYPES = {
 NO_VALUE = "no_value"
 
 
-def _validate_filters(filters: Optional[dict[str, Any]] = None) -> None:
+def _validate_filters(filters: dict[str, Any] | None = None) -> None:
     """
     Validates the filters provided.
     """