chroma-haystack 4.3.2__tar.gz → 4.4.0__tar.gz

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [integrations/chroma-v4.3.2] - 2026-07-17
+
+### 🐛 Bug Fixes
+
+- *(chroma)* Raise a clear error for id filters with a non-'==' operator (#3587)
+
+
 ## [integrations/chroma-v4.3.1] - 2026-06-29
 
 ### 🐛 Bug Fixes

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chroma-haystack
-Version: 4.3.2
+Version: 4.4.0
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/chroma#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/chroma

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/src/haystack_integrations/components/retrievers/chroma/retriever.py

@@ -119,6 +119,12 @@ class ChromaQueryTextRetriever:
         top_k = top_k or self.top_k
         return {"documents": (await self.document_store.search_async([query], top_k, filters))[0]}
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self.document_store.close()
+
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "ChromaQueryTextRetriever":
         """
@@ -238,6 +244,12 @@ class ChromaEmbeddingRetriever:
         query_embeddings = [query_embedding]
         return {"documents": (await self.document_store.search_embeddings_async(query_embeddings, top_k, filters))[0]}
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self.document_store.close()
+
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> "ChromaEmbeddingRetriever":
         """

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/src/haystack_integrations/document_stores/chroma/document_store.py

@@ -3,9 +3,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import Sequence
+from contextlib import suppress
 from typing import Any, Literal, cast
 
 import chromadb
+from chromadb.api import ClientAPI
 from chromadb.api.models.AsyncCollection import AsyncCollection
 from chromadb.api.types import GetResult, Metadata, OneOrMany, QueryResult
 from chromadb.config import Settings
@@ -101,6 +103,7 @@ class ChromaDocumentStore:
         self._host = host
         self._port = port
 
+        self._client: ClientAPI | None = None
         self._collection: chromadb.Collection | None = None
         self._async_collection: AsyncCollection | None = None
 
@@ -138,7 +141,7 @@ class ChromaDocumentStore:
                 # Local persistent storage
                 client = chromadb.PersistentClient(path=self._persist_path, **client_kwargs)
 
-            self._client = client  # store client for potential future use
+            self._client = client
 
             # Build the collection metadata locally so `self._metadata` stays exactly as the user passed it.
             # This keeps `to_dict()` deterministic and avoids mutating a user-supplied dict in place.
@@ -213,6 +216,15 @@ class ChromaDocumentStore:
                     embedding_function=self._embedding_func,
                 )
 
+    def close(self) -> None:
+        """Release the associated synchronous resources."""
+        if self._client is not None:
+            with suppress(Exception):
+                # `close` is not declared on the `ClientAPI` interface, but the concrete Chroma clients implement it
+                self._client.close()  # type: ignore[attr-defined]
+            self._client = None
+            self._collection = None
+
     @staticmethod
     def _prepare_get_kwargs(filters: dict[str, Any] | None = None) -> dict[str, Any]:
         """
@@ -356,7 +368,8 @@ class ChromaDocumentStore:
 
         :param result: The full GetResult from a Chroma collection get operation.
         :param field_name: The metadata field name to collect unique values for.
-        :param search_term: Optional search term to filter documents by content.
+        :param search_term: Optional search term to filter by, matched as a case-insensitive
+            substring against the value of `field_name`.
         :param from_: The offset to start returning values from.
         :param size: The maximum number of unique values to return.
         :returns: A tuple of the paginated unique values list and the total count.
@@ -367,13 +380,15 @@ class ChromaDocumentStore:
             return [], 0
 
         if search_term:
-            documents = result.get("documents")
-            if documents is None:
-                documents = []
-            filtered_metadatas = [
-                metadatas[i] for i in range(len(documents)) if documents[i] and search_term in documents[i]
+            search_term_lower = search_term.lower()
+            metadatas = [
+                meta
+                for meta in metadatas
+                if meta
+                and field_name in meta
+                and meta.get(field_name) is not None
+                and search_term_lower in str(meta.get(field_name)).lower()
             ]
-            metadatas = filtered_metadatas
 
         if not metadatas:
             return [], 0
@@ -901,6 +916,7 @@ class ChromaDocumentStore:
         """
         self._ensure_initialized()  # _ensure_initialized ensures _client is not None and a collection exists
         assert self._collection is not None
+        assert self._client is not None
 
         try:
             if recreate_index:
@@ -1294,12 +1310,12 @@ class ChromaDocumentStore:
         size: int = 10,
     ) -> tuple[list[str], int]:
         """
-        Return unique metadata field values, optionally filtered by a content search term, with pagination.
+        Return unique metadata field values, optionally filtered by a search term, with pagination.
 
         :param metadata_field: The metadata field to get unique values for.
             Can include or omit the "meta." prefix.
-        :param search_term: Optional search term to filter documents by matching
-            in the content field.
+        :param search_term: Optional search term to filter values, matched as a
+            case-insensitive substring against the metadata field's value.
         :param from_: The offset to start returning values from (for pagination).
         :param size: The maximum number of unique values to return.
         :returns: A tuple containing list of unique values and total count of unique values.
@@ -1309,11 +1325,7 @@ class ChromaDocumentStore:
 
         field_name = _normalize_metadata_field_name(metadata_field)
 
-        kwargs: dict[str, Any] = {"include": ["metadatas"]}
-        if search_term:
-            kwargs["include"] = ["metadatas", "documents"]
-
-        result = self._collection.get(**kwargs)
+        result = self._collection.get(include=["metadatas"])
         return self._compute_field_unique_values(result, field_name, search_term, from_, size)
 
     async def get_metadata_field_unique_values_async(
@@ -1324,14 +1336,14 @@ class ChromaDocumentStore:
         size: int = 10,
     ) -> tuple[list[str], int]:
         """
-        Asynchronously return unique metadata field values, optionally filtered by content, with pagination.
+        Asynchronously return unique metadata field values, optionally filtered by a search term, with pagination.
 
         Asynchronous methods are only supported for HTTP connections.
 
         :param metadata_field: The metadata field to get unique values for.
             Can include or omit the "meta." prefix.
-        :param search_term: Optional search term to filter documents by matching
-            in the content field.
+        :param search_term: Optional search term to filter values, matched as a
+            case-insensitive substring against the metadata field's value.
         :param from_: The offset to start returning values from (for pagination).
         :param size: The maximum number of unique values to return.
         :returns: A tuple containing list of unique values and total count of unique values.
@@ -1341,11 +1353,7 @@ class ChromaDocumentStore:
 
         field_name = _normalize_metadata_field_name(metadata_field)
 
-        kwargs: dict[str, Any] = {"include": ["metadatas"]}
-        if search_term:
-            kwargs["include"] = ["metadatas", "documents"]
-
-        result = await self._async_collection.get(**kwargs)
+        result = await self._async_collection.get(include=["metadatas"])
         return self._compute_field_unique_values(result, field_name, search_term, from_, size)
 
     @classmethod

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/tests/test_document_store.py

@@ -180,6 +180,29 @@ class TestDocumentStoreUnit:
             with pytest.raises(ValueError, match="Invalid client_settings"):
                 store._ensure_initialized()
 
+    def test_close(self):
+        store = ChromaDocumentStore()
+        client = mock.Mock()
+        store._client = client
+
+        store.close()
+
+        client.close.assert_called_once()
+        assert store._client is None
+
+        store.close()
+        client.close.assert_called_once()
+
+    def test_close_is_exception_safe(self):
+        store = ChromaDocumentStore()
+        client = mock.Mock()
+        client.close.side_effect = RuntimeError("boom")
+        store._client = client
+
+        store.close()
+
+        assert store._client is None
+
     def test_infer_type_from_value_fallback_for_unknown_type(self):
         assert ChromaDocumentStore._infer_type_from_value(None) == "keyword"
         assert ChromaDocumentStore._infer_type_from_value(["a", "b"]) == "keyword"
@@ -196,10 +219,11 @@ class TestDocumentStoreUnit:
     @pytest.mark.parametrize(
         "result",
         [
-            {"ids": ["1"], "documents": None, "metadatas": [{"cat": "A"}]},
-            {"ids": ["1"], "documents": ["hello world"], "metadatas": [{"cat": "A"}]},
+            {"ids": ["1"], "metadatas": [{"cat": "A"}]},
+            {"ids": ["1"], "metadatas": [None]},
+            {"ids": ["1"], "metadatas": [{"other": "A"}]},
         ],
-        ids=["documents_none", "no_matches"],
+        ids=["no_match", "metadata_none", "field_missing"],
     )
     def test_compute_field_unique_values_with_search_term_edge_cases(self, result):
         values, total = ChromaDocumentStore._compute_field_unique_values(result, "cat", "absent", 0, 10)
@@ -377,6 +401,16 @@ class TestDocumentStore(
         assert store._collection.metadata["hnsw:space"] == "ip"
         assert new_store._collection.metadata["hnsw:space"] == "ip"
 
+    def test_close_and_reopen(self, tmp_path):
+        store = ChromaDocumentStore(collection_name="test_close_and_reopen", persist_path=str(tmp_path))
+        store.write_documents([Document(content="doc", embedding=TEST_EMBEDDING_1)])
+        assert store.count_documents() == 1
+
+        store.close()
+        assert store._client is None
+
+        assert store.count_documents() == 1
+
     def test_delete_empty(self, document_store: ChromaDocumentStore):
         """
         Deleting a non-existing document should not raise with Chroma
@@ -741,12 +775,57 @@ class TestMetadataOperations:
         assert sorted(all_values) == ["A", "B", "C"]
 
     def test_get_metadata_field_unique_values_with_search_term(self, populated_store):
-        """Test getting unique values filtered by search term"""
-        # Search for documents containing "Doc 1"
+        """Test getting unique values filtered by search term.
+
+        The search term is matched against the metadata field's own value, not document
+        content. "Doc 1" is content for one document (category "A"), but it is not a
+        substring of any "category" value, so no values should match.
+        """
         values, total = populated_store.get_metadata_field_unique_values(
             "category", search_term="Doc 1", from_=0, size=10
         )
-        assert values == ["A"]  # Only Doc 1 has category A
+        assert values == []
+        assert total == 0
+
+    def test_get_metadata_field_unique_values_search_term_matches_field_value(self, populated_store):
+        """Search term matches when it's a case-insensitive substring of the field's value."""
+        values, total = populated_store.get_metadata_field_unique_values("status", search_term="ACT", from_=0, size=10)
+        # "ACT" is a substring of both "active" and "inactive" (case-insensitive)
+        assert sorted(values) == ["active", "inactive"]
+        assert total == 2
+
+        values, total = populated_store.get_metadata_field_unique_values("status", search_term="ina", from_=0, size=10)
+        assert values == ["inactive"]
+        assert total == 1
+
+    def test_get_metadata_field_unique_values_search_term_excludes_content_only_match(self, document_store):
+        """A search term present only in document content (not in the metadata field value)
+        must not match, proving search_term no longer filters on content."""
+        docs = [
+            Document(content="unique-marker-xyz", meta={"category": "A"}),
+            Document(content="plain content", meta={"category": "B"}),
+        ]
+        document_store.write_documents(docs)
+
+        values, total = document_store.get_metadata_field_unique_values(
+            "category", search_term="unique-marker-xyz", from_=0, size=10
+        )
+        assert values == []
+        assert total == 0
+
+    def test_get_metadata_field_unique_values_search_term_matches_field_value_not_content(self, document_store):
+        """A search term present in the metadata field's value but absent from the content
+        must match, proving search_term filters on the metadata field's value."""
+        docs = [
+            Document(content="Nothing special here", meta={"category": "special-value"}),
+            Document(content="Nothing special here either", meta={"category": "other"}),
+        ]
+        document_store.write_documents(docs)
+
+        values, total = document_store.get_metadata_field_unique_values(
+            "category", search_term="SPECIAL", from_=0, size=10
+        )
+        assert values == ["special-value"]
         assert total == 1
 
     def test_get_metadata_field_unique_values_field_normalization(self, populated_store):

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/tests/test_document_store_async.py

@@ -215,3 +215,37 @@ class TestDocumentStoreAsync(
         )
         assert values == []
         assert total == 0
+
+    async def test_get_metadata_field_unique_values_async_search_term_excludes_content_only_match(
+        self, document_store: ChromaDocumentStore
+    ):
+        """A search term present only in document content (not in the metadata field value)
+        must not match, proving search_term no longer filters on content."""
+        docs = [
+            Document(content="unique-marker-xyz", meta={"category": "A"}),
+            Document(content="plain content", meta={"category": "B"}),
+        ]
+        await document_store.write_documents_async(docs)
+
+        values, total = await document_store.get_metadata_field_unique_values_async(
+            "category", search_term="unique-marker-xyz", from_=0, size=10
+        )
+        assert values == []
+        assert total == 0
+
+    async def test_get_metadata_field_unique_values_async_search_term_matches_field_value(
+        self, document_store: ChromaDocumentStore
+    ):
+        """A search term present in the metadata field's value but absent from the content
+        must match, proving search_term filters on the metadata field's value (case-insensitively)."""
+        docs = [
+            Document(content="Nothing special here", meta={"category": "special-value"}),
+            Document(content="Nothing special here either", meta={"category": "other"}),
+        ]
+        await document_store.write_documents_async(docs)
+
+        values, total = await document_store.get_metadata_field_unique_values_async(
+            "category", search_term="SPECIAL", from_=0, size=10
+        )
+        assert values == ["special-value"]
+        assert total == 1

{chroma_haystack-4.3.2 → chroma_haystack-4.4.0}/tests/test_retriever.py

@@ -106,6 +106,15 @@ class TestChromaQueryTextRetriever:
         assert retriever.top_k == 42
         assert retriever.filter_policy == FilterPolicy.REPLACE  # default even if not specified
 
+    def test_close(self):
+        ds = mock.Mock(spec=ChromaDocumentStore)
+        retriever = ChromaQueryTextRetriever(ds)
+
+        retriever.close()
+
+        ds.close.assert_called_once()
+        assert retriever.document_store is ds
+
     def test_run_delegates_to_document_store_search(self):
         ds = mock.Mock(spec=ChromaDocumentStore)
         expected = [Document(content="hit")]
@@ -215,6 +224,15 @@ class TestChromaEmbeddingRetriever:
         retriever = ChromaEmbeddingRetriever.from_dict(data)
         assert retriever.filter_policy == FilterPolicy.REPLACE
 
+    def test_close(self):
+        ds = mock.Mock(spec=ChromaDocumentStore)
+        retriever = ChromaEmbeddingRetriever(ds)
+
+        retriever.close()
+
+        ds.close.assert_called_once()
+        assert retriever.document_store is ds
+
     def test_run_delegates_to_document_store_search_embeddings(self):
         ds = mock.Mock(spec=ChromaDocumentStore)
         expected = [Document(content="hit")]