fix: ChromaDocumentStore match search_term against metadata field value, not content (#3644)

Author: davidsbatista

integrations/chroma/src/haystack_integrations/document_stores/chroma/document_store.py

@@ -356,7 +356,8 @@ def _compute_field_unique_values(
 
         :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 +368,15 @@ def _compute_field_unique_values(
             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
@@ -1294,12 +1297,12 @@ def get_metadata_field_unique_values(
         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 +1312,7 @@ def get_metadata_field_unique_values(
 
         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 +1323,14 @@ async def get_metadata_field_unique_values_async(
         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 +1340,7 @@ async def get_metadata_field_unique_values_async(
 
         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

integrations/chroma/tests/test_document_store.py

@@ -196,10 +196,11 @@ def test_compute_field_min_max_skips_non_scalar_values(self):
     @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)
@@ -741,12 +742,57 @@ def test_get_metadata_field_unique_values_pagination(self, populated_store):
         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):

integrations/chroma/tests/test_document_store_async.py

@@ -215,3 +215,37 @@ async def test_get_metadata_field_unique_values_async_missing_field(self, docume
         )
         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