pgvector-haystack 5.3.0__tar.gz → 5.5.0__tar.gz

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.0}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [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
+
+- `PgvectorDocumentStore` now supports `delete_all_documents` and  `delete_all_documents_async` (#2394)
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
+
 ## [integrations/pgvector-v5.2.1] - 2025-07-03
 
 ### 🐛 Bug Fixes

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 5.3.0
+Version: 5.5.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

pgvector_haystack-5.5.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,30 @@
+loaders:
+- ignore_when_discovered:
+  - __init__
+  modules:
+  - haystack_integrations.components.retrievers.pgvector.embedding_retriever
+  - haystack_integrations.components.retrievers.pgvector.keyword_retriever
+  - haystack_integrations.document_stores.pgvector.document_store
+  search_path:
+  - ../src
+  type: haystack_pydoc_tools.loaders.CustomPythonLoader
+processors:
+- do_not_filter_modules: false
+  documented_only: true
+  expression: null
+  skip_empty_modules: true
+  type: filter
+- type: smart
+- type: crossref
+renderer:
+  description: Pgvector integration for Haystack
+  id: integrations-pgvector
+  markdown:
+    add_member_class_prefix: false
+    add_method_class_prefix: true
+    classdef_code_block: false
+    descriptive_class_title: false
+    descriptive_module_title: true
+    filename: pgvector.md
+  title: Pgvector
+  type: haystack_pydoc_tools.renderers.DocusaurusRenderer

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.0}/pyproject.toml

@@ -46,7 +46,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config.yml"]
+docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args} && ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -64,7 +64,7 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
 
 types = "mypy -p haystack_integrations.document_stores.pgvector -p haystack_integrations.components.retrievers.pgvector {args}"
 
@@ -83,7 +83,7 @@ ignore_missing_imports = true
 
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.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, Dict, List, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -62,7 +62,7 @@ class PgvectorEmbeddingRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
         filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
@@ -99,7 +99,7 @@ class PgvectorEmbeddingRetriever:
             filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -116,7 +116,7 @@ class PgvectorEmbeddingRetriever:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorEmbeddingRetriever":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorEmbeddingRetriever":
         """
         Deserializes the component from a dictionary.
 
@@ -133,14 +133,14 @@ class PgvectorEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     def run(
         self,
-        query_embedding: List[float],
-        filters: Optional[Dict[str, Any]] = None,
+        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,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
 
@@ -166,14 +166,14 @@ class PgvectorEmbeddingRetriever:
         )
         return {"documents": docs}
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     async def run_async(
         self,
-        query_embedding: List[float],
-        filters: Optional[Dict[str, Any]] = None,
+        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,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.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, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import Document
@@ -52,7 +52,7 @@ class PgvectorKeywordRetriever:
         self,
         *,
         document_store: PgvectorDocumentStore,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
     ):
@@ -74,7 +74,7 @@ class PgvectorKeywordRetriever:
             filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -90,7 +90,7 @@ class PgvectorKeywordRetriever:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorKeywordRetriever":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorKeywordRetriever":
         """
         Deserializes the component from a dictionary.
 
@@ -107,13 +107,13 @@ class PgvectorKeywordRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     def run(
         self,
         query: str,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 
@@ -137,13 +137,13 @@ class PgvectorKeywordRetriever:
         )
         return {"documents": docs}
 
-    @component.output_types(documents=List[Document])
+    @component.output_types(documents=list[Document])
     async def run_async(
         self,
         query: str,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ) -> Dict[str, List[Document]]:
+    ) -> dict[str, list[Document]]:
         """
         Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.0}/src/haystack_integrations/document_stores/pgvector/converters.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 from haystack import logging
 from haystack.dataclasses import ByteStream, Document
@@ -7,7 +7,7 @@ from psycopg.types.json import Jsonb
 logger = logging.getLogger(__name__)
 
 
-def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str, Any]]:
+def _from_haystack_to_pg_documents(documents: list[Document]) -> list[dict[str, Any]]:
     """
     Internal method to convert a list of Haystack Documents to a list of dictionaries that can be used to insert
     documents into the PgvectorDocumentStore.
@@ -38,7 +38,7 @@ def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str,
     return db_documents
 
 
-def _from_pg_to_haystack_documents(documents: List[Dict[str, Any]]) -> List[Document]:
+def _from_pg_to_haystack_documents(documents: list[dict[str, Any]]) -> list[Document]:
     """
     Internal method to convert a list of dictionaries from pgvector to a list of Haystack Documents.
     """

{pgvector_haystack-5.3.0 → pgvector_haystack-5.5.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, Dict, List, Literal, Optional, Tuple, Union, overload
+
+from typing import Any, Literal, Optional, Union, 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,7 +92,7 @@ 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: Optional[dict[str, int]] = None,
         hnsw_index_name: str = "haystack_hnsw_index",
         hnsw_ef_search: Optional[int] = None,
         keyword_index_name: str = "haystack_keyword_index",
@@ -101,9 +103,10 @@ class PgvectorDocumentStore:
         A specific table to store Haystack documents will be created if it doesn't exist yet.
 
         :param connection_string: The connection string to use to connect to the PostgreSQL database, defined as an
-            environment variable. It can be provided in either URI format
-            e.g.: `PG_CONN_STR="postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"`, or keyword/value format
-            e.g.: `PG_CONN_STR="host=HOST port=PORT dbname=DBNAME user=USER password=PASSWORD"`
+            environment variable. Supported formats:
+            - URI, e.g. `PG_CONN_STR="postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"` (use percent-encoding for special
+                characters)
+            - keyword/value format, e.g. `PG_CONN_STR="host=HOST port=PORT dbname=DBNAME user=USER password=PASSWORD"`
             See [PostgreSQL Documentation](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING)
             for more details.
         :param create_extension: Whether to create the pgvector extension if it doesn't exist.
@@ -180,7 +183,7 @@ class PgvectorDocumentStore:
         self._async_dict_cursor: Optional[AsyncCursor[DictRow]] = None
         self._table_initialized = False
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serializes the component to a dictionary.
 
@@ -207,7 +210,7 @@ class PgvectorDocumentStore:
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorDocumentStore":
+    def from_dict(cls, data: dict[str, Any]) -> "PgvectorDocumentStore":
         """
         Deserializes the component from a dictionary.
 
@@ -360,7 +363,15 @@ class PgvectorDocumentStore:
                 logger.debug("Failed to close connection: {e}", e=str(e))
 
         conn_str = self.connection_string.resolve_value() or ""
-        connection = Connection.connect(conn_str)
+        try:
+            connection = Connection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
         connection.autocommit = True
         if self.create_extension:
             connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -394,7 +405,15 @@ class PgvectorDocumentStore:
             await self._async_connection.close()
 
         conn_str = self.connection_string.resolve_value() or ""
-        async_connection = await AsyncConnection.connect(conn_str)
+        try:
+            async_connection = await AsyncConnection.connect(conn_str)
+        except Error as e:
+            msg = (
+                "Failed to connect to PostgreSQL database.  Ensure the connection string follows the "
+                "PostgreSQL connection specification: "
+                "https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING."
+            )
+            raise DocumentStoreError(msg) from e
         await async_connection.set_autocommit(True)
         if self.create_extension:
             await async_connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
@@ -740,7 +759,7 @@ class PgvectorDocumentStore:
             return result[0]
         return 0
 
-    def filter_documents(self, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    def filter_documents(self, filters: Optional[dict[str, Any]] = None) -> list[Document]:
         """
         Returns the documents that match the filters provided.
 
@@ -777,7 +796,7 @@ 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: Optional[dict[str, Any]] = None) -> list[Document]:
         """
         Asynchronously returns the documents that match the filters provided.
 
@@ -832,7 +851,7 @@ class PgvectorDocumentStore:
 
         return sql_insert
 
-    def write_documents(self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int:
+    def write_documents(self, documents: list[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int:
         """
         Writes documents to the document store.
 
@@ -888,7 +907,7 @@ class PgvectorDocumentStore:
         return written_docs
 
     async def write_documents_async(
-        self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE
+        self, documents: list[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE
     ) -> int:
         """
         Asynchronously writes documents to the document store.
@@ -939,7 +958,7 @@ class PgvectorDocumentStore:
 
         return written_docs
 
-    def delete_documents(self, document_ids: List[str]) -> None:
+    def delete_documents(self, document_ids: list[str]) -> None:
         """
         Deletes documents that match the provided `document_ids` from the document store.
 
@@ -962,7 +981,7 @@ class PgvectorDocumentStore:
             cursor=self._cursor, sql_query=delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore"
         )
 
-    async def delete_documents_async(self, document_ids: List[str]) -> None:
+    async def delete_documents_async(self, document_ids: list[str]) -> None:
         """
         Asynchronously deletes documents that match the provided `document_ids` from the document store.
 
@@ -1019,9 +1038,193 @@ 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
-    ) -> Tuple[Composed, tuple]:
+        self, query: str, top_k: int, filters: Optional[dict[str, Any]] = None
+    ) -> tuple[Composed, tuple]:
         """
         Builds the SQL query and the where parameters for keyword retrieval.
         """
@@ -1049,9 +1252,9 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search.
 
@@ -1084,9 +1287,9 @@ class PgvectorDocumentStore:
         self,
         query: str,
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search asynchronously.
         """
@@ -1111,11 +1314,11 @@ class PgvectorDocumentStore:
 
     def _check_and_build_embedding_retrieval_query(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]],
         top_k: int,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[Composed, tuple]:
+        filters: Optional[dict[str, Any]] = None,
+    ) -> tuple[Composed, tuple]:
         """
         Performs checks and builds the SQL query and the where parameters for embedding retrieval.
         """
@@ -1174,12 +1377,12 @@ class PgvectorDocumentStore:
 
     def _embedding_retrieval(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Retrieves documents that are most similar to the query embedding using a vector similarity metric.
 
@@ -1208,12 +1411,12 @@ class PgvectorDocumentStore:
 
     async def _embedding_retrieval_async(
         self,
-        query_embedding: List[float],
+        query_embedding: list[float],
         *,
-        filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[dict[str, Any]] = None,
         top_k: int = 10,
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
-    ) -> List[Document]:
+    ) -> list[Document]:
         """
         Asynchronously retrieves documents that are most similar to the query embedding using a
         vector similarity metric.