pgvector-haystack 6.3.1__tar.gz → 6.4.1__tar.gz

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [integrations/pgvector-v6.4.0] - 2026-07-23
+
+### 🚀 Features
+
+- Pgvector - add closing methods (#3650)
+
+### 🐛 Bug Fixes
+
+- *(pgvector)* NO_VALUE sentinel collides with the literal string 'no_value' (#3593)
+
+### 📚 Documentation
+
+- Replace old haystack core imports with haystack_integrations paths (#3545)
+
+
+## [integrations/pgvector-v6.3.1] - 2026-06-01
+
+### 🐛 Bug Fixes
+
+- Replace in place dataclass mutations for pgvector #11087 (#3142)
+- *(pgvector)* Order retrieval by distance operator (#3370)
+
+### 🚜 Refactor
+
+- *(pgvector)* Use async DocumentStore mixin tests (#3094)
+
+### 🧪 Testing
+
+- `PGVectorDocumentStore`e use Mixin tests (#3003)
+- Test compatible integrations with python 3.14; update pyproject (#3001)
+- Track test coverage for all integrations (#3065)
+- Add tests for pgvector document store (#3156)
+
+### 🧹 Chores
+
+- Add ANN ruff ruleset to optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake (#2992)
+- Enforce ruff docstring rules in integrations 31-40 (openrouter, opensearch, optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake) (#3011)
+
+
 ## [integrations/pgvector-v6.3.0] - 2026-03-17
 
 ### 🐛 Bug Fixes

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 6.3.1
+Version: 6.4.1
 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-6.3.1 → pgvector_haystack-6.4.1}/examples/embedding_retrieval.py

@@ -14,10 +14,13 @@ import glob
 
 from haystack import Pipeline
 from haystack.components.converters import MarkdownToDocument
-from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
 from haystack.components.preprocessors import DocumentSplitter
 from haystack.components.writers import DocumentWriter
 
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+    SentenceTransformersTextEmbedder,
+)
 from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
 

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/examples/hybrid_retrieval.py

@@ -14,11 +14,14 @@ import glob
 
 from haystack import Pipeline
 from haystack.components.converters import MarkdownToDocument
-from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
 from haystack.components.joiners import DocumentJoiner
 from haystack.components.preprocessors import DocumentSplitter
 from haystack.components.writers import DocumentWriter
 
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+    SentenceTransformersTextEmbedder,
+)
 from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever, PgvectorKeywordRetriever
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
 

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py

@@ -21,7 +21,9 @@ class PgvectorEmbeddingRetriever:
     ```python
     from haystack.document_stores import DuplicatePolicy
     from haystack import Document, Pipeline
-    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+    # Requires: pip install sentence-transformers-haystack
+    from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersTextEmbedder
+    from haystack_integrations.components.embedders.sentence_transformers import SentenceTransformersDocumentEmbedder
 
     from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
     from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever
@@ -40,7 +42,6 @@ class PgvectorEmbeddingRetriever:
                  Document(content="In certain places, you can witness the phenomenon of bioluminescent waves.")]
 
     document_embedder = SentenceTransformersDocumentEmbedder()
-    document_embedder.warm_up()
     documents_with_embeddings = document_embedder.run(documents)
 
     document_store.write_documents(documents_with_embeddings.get("documents"), policy=DuplicatePolicy.OVERWRITE)
@@ -135,6 +136,18 @@ class PgvectorEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self.document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self.document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py

@@ -109,6 +109,18 @@ class PgvectorKeywordRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self.document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self.document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/src/haystack_integrations/document_stores/pgvector/document_store.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from contextlib import suppress
 from typing import Any, Literal, overload
 
 from haystack import default_from_dict, default_to_dict, logging
@@ -223,6 +224,28 @@ class PgvectorDocumentStore:
         deserialize_secrets_inplace(data["init_parameters"], ["connection_string"])
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the associated synchronous resources.
+        """
+        if self._connection is not None:
+            with suppress(Exception):
+                self._connection.close()
+            self._connection = None
+            self._cursor = None
+            self._dict_cursor = None
+
+    async def close_async(self) -> None:
+        """
+        Release the associated asynchronous resources.
+        """
+        if self._async_connection is not None:
+            with suppress(Exception):
+                await self._async_connection.close()
+            self._async_connection = None
+            self._async_cursor = None
+            self._async_dict_cursor = None
+
     @staticmethod
     def _connection_is_valid(connection: Connection) -> bool:
         """
@@ -1909,7 +1932,8 @@ class PgvectorDocumentStore:
         Builds SQL queries for getting unique metadata field values.
 
         :param normalized_field: The normalized metadata field name.
-        :param search_term: Optional search term to filter documents by content.
+        :param search_term: Optional search term to filter unique values by a case-insensitive substring match
+            against the metadata field's own value.
         :param from_: The offset for pagination (0-based).
         :param size: The number of unique values to return.
         :returns: A tuple containing (count_query, select_query, params).
@@ -1925,11 +1949,9 @@ class PgvectorDocumentStore:
 
         params: tuple = ()
         if search_term:
-            # Use full-text search with word boundaries (similar to keyword retrieval)
-            sql_where += SQL(" AND to_tsvector({language}, content) @@ plainto_tsquery({language}, %s)").format(
-                language=SQLLiteral(self.language)
-            )
-            params = (search_term,)
+            # Case-insensitive substring match against the metadata field's own value.
+            sql_where += SQL(" AND meta->>{} ILIKE %s").format(field_literal)
+            params = (f"%{search_term}%",)
 
         # count query
         sql_count = SQL("SELECT COUNT(DISTINCT meta->>{} ) AS total").format(field_literal)
@@ -1959,14 +1981,14 @@ class PgvectorDocumentStore:
         return unique_values, total_count
 
     def get_metadata_field_unique_values(
-        self, metadata_field: str, search_term: str | None, from_: int, size: int
+        self, metadata_field: str, search_term: str | None = None, from_: int = 0, size: int = 10
     ) -> tuple[list[str], int]:
         """
         Returns unique values for a given metadata field, optionally filtered by a search term.
 
         :param metadata_field: The name of the metadata field. Can include or omit the "meta." prefix.
-        :param search_term: Optional search term to filter documents by content before extracting unique values.
-            If None, all documents are considered.
+        :param search_term: Optional search term to filter unique values by a case-insensitive substring
+            match against the metadata field's own value. If None, all values are considered.
         :param from_: The offset for pagination (0-based).
         :param size: The number of unique values to return.
         :returns: A tuple containing:
@@ -1997,14 +2019,14 @@ class PgvectorDocumentStore:
         return PgvectorDocumentStore._process_unique_values_result(count_result, records)
 
     async def get_metadata_field_unique_values_async(
-        self, metadata_field: str, search_term: str | None, from_: int, size: int
+        self, metadata_field: str, search_term: str | None = None, from_: int = 0, size: int = 10
     ) -> tuple[list[str], int]:
         """
         Asynchronously returns unique values for a given metadata field, optionally filtered by a search term.
 
         :param metadata_field: The name of the metadata field. Can include or omit the "meta." prefix.
-        :param search_term: Optional search term to filter documents by content before extracting unique values.
-            If None, all documents are considered.
+        :param search_term: Optional search term to filter unique values by a case-insensitive substring
+            match against the metadata field's own value. If None, all values are considered.
         :param from_: The offset for pagination (0-based).
         :param size: The number of unique values to return.
         :returns: A tuple containing:

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/src/haystack_integrations/document_stores/pgvector/filters.py

@@ -20,7 +20,7 @@ PYTHON_TYPES_TO_PG_TYPES = {
     bool: "boolean",
 }
 
-NO_VALUE = "no_value"
+NO_VALUE = object()  # unique sentinel; can never equal a user-supplied filter value
 
 
 def _validate_filters(filters: dict[str, Any] | None = None) -> None:
@@ -48,7 +48,7 @@ def _convert_filters_to_where_clause_and_params(
         query, values = _parse_logical_condition(filters)
 
     where_clause = SQL(f" {operator} ") + query
-    params = tuple(value for value in values if value != NO_VALUE)
+    params = tuple(value for value in values if value is not NO_VALUE)
 
     return where_clause, params
 
@@ -227,14 +227,14 @@ def _less_than_equal(field: Composable, value: Any) -> tuple[Composed, Any]:
 
 def _not_in(field: Composable, value: Any) -> tuple[Composed, list]:
     if not isinstance(value, list):
-        msg = f"{field}'s value must be a list when using 'not in' comparator in Pinecone"
+        msg = f"{field}'s value must be a list when using 'not in' comparator in PgVector"
         raise FilterError(msg)
-    return SQL("{} IS NULL OR {} != ALL(%s)").format(field, field), [value]
+    return SQL("({} IS NULL OR {} != ALL(%s))").format(field, field), [value]
 
 
 def _in(field: Composable, value: Any) -> tuple[Composed, list]:
     if not isinstance(value, list):
-        msg = f"{field}'s value must be a list when using 'in' comparator in Pinecone"
+        msg = f"{field}'s value must be a list when using 'in' comparator in PgVector"
         raise FilterError(msg)
 
     # see https://www.psycopg.org/psycopg3/docs/basic/adapt.html#lists-adaptation

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/tests/test_document_store.py

@@ -103,6 +103,18 @@ class TestDocumentStore(
             document_store._ensure_db_setup()
         assert "Failed to connect to PostgreSQL database" in str(e)
 
+    def test_close_and_reopen(self, document_store: PgvectorDocumentStore):
+        assert document_store.count_documents() == 0
+        assert document_store._connection is not None
+
+        document_store.close()
+        assert document_store._connection is None
+        assert document_store._cursor is None
+        assert document_store._dict_cursor is None
+
+        assert document_store.count_documents() == 0
+        assert document_store._connection is not None
+
 
 @pytest.mark.usefixtures("patches_for_unit_tests")
 def test_init(monkeypatch):
@@ -353,6 +365,33 @@ def test_process_count_unique_metadata_result_uses_zero_for_missing_keys():
     assert counts == {"category": 5, "language": 0}
 
 
+def test_close(mock_store):
+    mock_connection = Mock(spec=Connection)
+    mock_store._connection = mock_connection
+    mock_store._cursor = Mock(spec=Cursor)
+    mock_store._dict_cursor = Mock(spec=Cursor)
+
+    mock_store.close()
+
+    mock_connection.close.assert_called_once()
+    assert mock_store._connection is None
+    assert mock_store._cursor is None
+    assert mock_store._dict_cursor is None
+
+    mock_store.close()
+    mock_connection.close.assert_called_once()
+
+
+def test_close_is_exception_safe(mock_store):
+    mock_connection = Mock(spec=Connection)
+    mock_connection.close.side_effect = RuntimeError("boom")
+    mock_store._connection = mock_connection
+
+    mock_store.close()
+
+    assert mock_store._connection is None
+
+
 @pytest.mark.integration
 def test_halfvec_hnsw_write_documents(document_store_w_halfvec_hnsw_index: PgvectorDocumentStore):
     documents = [
@@ -623,17 +662,30 @@ def test_get_metadata_field_unique_values(document_store: PgvectorDocumentStore)
     # All three pages should be different
     assert len(set(unique_values_single1 + unique_values_single2 + unique_values_single3)) == 3
 
-    # Test with search term - filter by content matching "Python"
+    # Test with search term - case-insensitive substring match against the metadata field's OWN value
+    # (not against document content).
     unique_values_filtered, total_filtered = document_store.get_metadata_field_unique_values(
-        "meta.category", "Python", 0, 10
+        "meta.language", "Python", 0, 10
     )
-    assert set(unique_values_filtered) == {"A"}  # Only category A has documents with "Python" in content
+    assert set(unique_values_filtered) == {"Python"}
     assert total_filtered == 1
 
-    # Test with search term - filter by content matching "Java"
-    unique_values_java, total_java = document_store.get_metadata_field_unique_values("meta.category", "Java", 0, 10)
-    assert set(unique_values_java) == {"B"}  # Only category B has documents with "Java" in content
-    assert total_java == 1
+    # Case-insensitivity: lowercase search term should still match "Python"
+    unique_values_lower, total_lower = document_store.get_metadata_field_unique_values("meta.language", "python", 0, 10)
+    assert set(unique_values_lower) == {"Python"}
+    assert total_lower == 1
+
+    # Substring matching: "Java" is a substring of both "Java" and "JavaScript"
+    unique_values_java, total_java = document_store.get_metadata_field_unique_values("meta.language", "Java", 0, 10)
+    assert set(unique_values_java) == {"Java", "JavaScript"}
+    assert total_java == 2
+
+    # Substring matching in the middle/end of a value
+    unique_values_script, total_script = document_store.get_metadata_field_unique_values(
+        "meta.language", "Script", 0, 10
+    )
+    assert set(unique_values_script) == {"JavaScript"}
+    assert total_script == 1
 
     # Test pagination with search term
     unique_values_search_page1, total_search = document_store.get_metadata_field_unique_values(
@@ -650,6 +702,17 @@ def test_get_metadata_field_unique_values(document_store: PgvectorDocumentStore)
     assert len(unique_values_search_empty) == 0
     assert total_search_empty == 1
 
+    # Test that search_term matches metadata VALUE, not content
+    content_vs_metadata_docs = [
+        Document(content="This document mentions Python explicitly", meta={"topic": "cooking"}),
+        Document(content="Unrelated content about recipes", meta={"topic": "python-tutorial"}),
+    ]
+    document_store.write_documents(content_vs_metadata_docs)
+
+    unique_topics, total_topics = document_store.get_metadata_field_unique_values("meta.topic", "python", 0, 10)
+    assert set(unique_topics) == {"python-tutorial"}
+    assert total_topics == 1
+
     # Test with integer values
     int_docs = [
         Document(content="Doc 1", meta={"priority": 1}),
@@ -662,9 +725,42 @@ def test_get_metadata_field_unique_values(document_store: PgvectorDocumentStore)
     assert set(unique_priorities) == {"1", "2", "3"}
     assert total_priorities == 3
 
-    # Test with search term on integer field
+    # Test with search term on integer field - substring match against the field's own (stringified)
+    # value, e.g. "Doc 1" (content) no longer matches; "1" (the value itself) does.
     unique_priorities_filtered, total_priorities_filtered = document_store.get_metadata_field_unique_values(
-        "meta.priority", "Doc 1", 0, 10
+        "meta.priority", "1", 0, 10
     )
     assert set(unique_priorities_filtered) == {"1"}
     assert total_priorities_filtered == 1
+
+
+@pytest.mark.integration
+def test_get_metadata_field_unique_values_no_search_term(document_store: PgvectorDocumentStore):
+    docs = [
+        Document(content="mentions tsvector and content in the body", meta={"category": "A"}),
+        Document(content="another document", meta={"category": "B"}),
+    ]
+    document_store.write_documents(docs)
+
+    values, total = document_store.get_metadata_field_unique_values("meta.category")
+
+    assert set(values) == {"A", "B"}
+    assert total == 2
+
+
+@pytest.mark.integration
+def test_get_metadata_field_unique_values_search_term_matches_field_value_not_content(
+    document_store: PgvectorDocumentStore,
+):
+    docs = [
+        # "python" appears in the content but NOT in the category value -> must be EXCLUDED
+        Document(content="Python programming guide", meta={"category": "Backend"}),
+        # "python" appears in the category value but NOT in the content -> must be INCLUDED
+        Document(content="General purpose scripting language", meta={"category": "Python-based"}),
+    ]
+    document_store.write_documents(docs)
+
+    values, total = document_store.get_metadata_field_unique_values("meta.category", search_term="python")
+
+    assert values == ["Python-based"]
+    assert total == 1

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/tests/test_document_store_async.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import Mock, patch
+from unittest.mock import AsyncMock, Mock, patch
 
 import psycopg
 import pytest
@@ -131,6 +131,18 @@ class TestDocumentStoreAsync(
         """
         await document_store.delete_table_async()  # if throw error, test fails
 
+    async def test_close_async_and_reopen(self, document_store: PgvectorDocumentStore):
+        assert await document_store.count_documents_async() == 0
+        assert document_store._async_connection is not None
+
+        await document_store.close_async()
+        assert document_store._async_connection is None
+        assert document_store._async_cursor is None
+        assert document_store._async_dict_cursor is None
+
+        assert await document_store.count_documents_async() == 0
+        assert document_store._async_connection is not None
+
 
 @pytest.mark.integration
 @pytest.mark.asyncio
@@ -302,3 +314,33 @@ async def test_write_documents_async_rejects_non_document_items(mock_store):
 async def test_count_unique_metadata_by_filter_async_rejects_empty_fields(mock_store):
     with pytest.raises(ValueError, match="metadata_fields must be a non-empty list"):
         await mock_store.count_unique_metadata_by_filter_async(filters={}, metadata_fields=[])
+
+
+@pytest.mark.asyncio
+async def test_close_async(mock_store):
+    mock_connection = Mock(spec=AsyncConnection)
+    mock_connection.close = AsyncMock()
+    mock_store._async_connection = mock_connection
+    mock_store._async_cursor = Mock(spec=AsyncCursor)
+    mock_store._async_dict_cursor = Mock(spec=AsyncCursor)
+
+    await mock_store.close_async()
+
+    mock_connection.close.assert_awaited_once()
+    assert mock_store._async_connection is None
+    assert mock_store._async_cursor is None
+    assert mock_store._async_dict_cursor is None
+
+    await mock_store.close_async()
+    mock_connection.close.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_close_async_is_exception_safe(mock_store):
+    mock_connection = Mock(spec=AsyncConnection)
+    mock_connection.close = AsyncMock(side_effect=RuntimeError("boom"))
+    mock_store._async_connection = mock_connection
+
+    await mock_store.close_async()
+
+    assert mock_store._async_connection is None

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/tests/test_filters.py

@@ -183,6 +183,14 @@ def test_comparison_condition_unknown_operator():
         _parse_comparison_condition(condition)
 
 
+@pytest.mark.parametrize("operator", ["like", "not like"])
+def test_comparison_condition_like_operator_requires_str_value(operator):
+    # pgvector-specific: LIKE / NOT LIKE require a string operand.
+    condition = {"field": "meta.name", "operator": operator, "value": 123}
+    with pytest.raises(FilterError, match="must be a str when using 'LIKE'"):
+        _parse_comparison_condition(condition)
+
+
 def test_logical_condition_missing_operator():
     condition = {"conditions": []}
     with pytest.raises(FilterError):
@@ -228,13 +236,32 @@ def test_logical_condition_nested():
         "("
         "(meta->>'domain' IS DISTINCT FROM %s OR meta->>'chapter' = ANY(%s))"
         " AND "
-        "((meta->>'number')::integer >= %s OR meta->>'author' IS NULL OR meta->>'author' != ALL(%s))"
+        "((meta->>'number')::integer >= %s OR (meta->>'author' IS NULL OR meta->>'author' != ALL(%s)))"
         ")"
     )
     assert _render(query) == expected_sql
     assert values == ["science", [["intro", "conclusion"]], 90, [["John", "Jane"]]]
 
 
+def test_logical_condition_not_in_is_parenthesized_when_and_combined():
+    # `not in` renders an internal `OR` (`IS NULL OR != ALL`). Without surrounding
+    # parentheses that `OR` escapes an enclosing `AND` (AND binds tighter than OR in
+    # SQL), so an AND-combined `not in` would wrongly match documents.
+    condition = {
+        "operator": "AND",
+        "conditions": [
+            {"field": "meta.number", "operator": "==", "value": 5},
+            {"field": "meta.author", "operator": "not in", "value": ["John", "Jane"]},
+        ],
+    }
+    query, values = _parse_logical_condition(condition)
+    assert isinstance(query, Composed)
+
+    expected_sql = "((meta->>'number')::integer = %s AND (meta->>'author' IS NULL OR meta->>'author' != ALL(%s)))"
+    assert _render(query) == expected_sql
+    assert values == [5, [["John", "Jane"]]]
+
+
 def test_convert_filters_to_where_clause_and_params():
     filters = {
         "operator": "AND",
@@ -265,6 +292,18 @@ def test_convert_filters_to_where_clause_and_params_handle_null():
     assert params == ("intro",)
 
 
+def test_convert_filters_to_where_clause_and_params_value_equal_to_no_value_sentinel():
+    """A legitimate equality filter whose value is the literal string the internal
+    NO_VALUE sentinel used to be ("no_value") must not be dropped from params --
+    the query still has a placeholder for it."""
+    filters = {"field": "meta.tag", "operator": "==", "value": "no_value"}
+    where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+
+    expected_sql = " WHERE meta->>'tag' = %s"
+    assert _render(where_clause) == expected_sql
+    assert params == ("no_value",)
+
+
 def test_validate_filters():
     filters = {"field": "meta.number", "operator": "==", "value": 100}
     _validate_filters(filters)

{pgvector_haystack-6.3.1 → pgvector_haystack-6.4.1}/tests/test_retrievers.py

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
-from unittest.mock import Mock
+from unittest.mock import AsyncMock, Mock
 
 import pytest
 from haystack.dataclasses import Document
@@ -126,6 +126,26 @@ class TestEmbeddingRetriever:
         assert retriever.filter_policy == FilterPolicy.REPLACE
         assert retriever.vector_function == "l2_distance"
 
+    def test_close(self):
+        mock_store = Mock(spec=PgvectorDocumentStore)
+        retriever = PgvectorEmbeddingRetriever(document_store=mock_store, vector_function="l2_distance")
+
+        retriever.close()
+
+        mock_store.close.assert_called_once()
+        assert retriever.document_store is mock_store
+
+    @pytest.mark.asyncio
+    async def test_close_async(self):
+        mock_store = Mock(spec=PgvectorDocumentStore)
+        mock_store.close_async = AsyncMock()
+        retriever = PgvectorEmbeddingRetriever(document_store=mock_store, vector_function="l2_distance")
+
+        await retriever.close_async()
+
+        mock_store.close_async.assert_awaited_once()
+        assert retriever.document_store is mock_store
+
     def test_run(self):
         mock_store = Mock(spec=PgvectorDocumentStore)
         doc = Document(content="Test doc", embedding=[0.1, 0.2])
@@ -315,6 +335,26 @@ class TestKeywordRetriever:
         assert retriever.filter_policy == FilterPolicy.REPLACE  # defaults to REPLACE
         assert retriever.top_k == 5
 
+    def test_close(self):
+        mock_store = Mock(spec=PgvectorDocumentStore)
+        retriever = PgvectorKeywordRetriever(document_store=mock_store)
+
+        retriever.close()
+
+        mock_store.close.assert_called_once()
+        assert retriever.document_store is mock_store
+
+    @pytest.mark.asyncio
+    async def test_close_async(self):
+        mock_store = Mock(spec=PgvectorDocumentStore)
+        mock_store.close_async = AsyncMock()
+        retriever = PgvectorKeywordRetriever(document_store=mock_store)
+
+        await retriever.close_async()
+
+        mock_store.close_async.assert_awaited_once()
+        assert retriever.document_store is mock_store
+
     def test_run(self):
         mock_store = Mock(spec=PgvectorDocumentStore)
         doc = Document(content="Test doc", embedding=[0.1, 0.2])