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

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

@@ -1,5 +1,23 @@
 # Changelog
 
+## [integrations/chroma-v4.4.0] - 2026-07-24
+
+### 🚀 Features
+
+- Chroma - add sync closing methods (#3660)
+
+### 🐛 Bug Fixes
+
+- `ChromaDocumentStore` match `search_term` against metadata field value, not content (#3644)
+
+
+## [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/LICENSE → chroma_haystack-4.5.0/LICENSE.txt

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 deepset GmbH
+   Copyright 2023-present deepset GmbH
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

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

@@ -1,12 +1,12 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: chroma-haystack
-Version: 4.3.2
+Version: 4.5.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
 Author-email: deepset GmbH <info@deepset.ai>
 License-Expression: Apache-2.0
-License-File: LICENSE
+License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
@@ -36,5 +36,5 @@ Description-Content-Type: text/markdown
 
 Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
 
-To run integration tests locally, you need a Chroma server running.
-Start one with: `docker run -p 8000:8000 chromadb/chroma:latest`.
+To run integration tests locally, you need a Chroma server running on `localhost:8000`.
+You can start it with: `hatch run chroma run`.

{chroma_haystack-4.3.2 → chroma_haystack-4.5.0}/README.md

@@ -12,5 +12,5 @@
 
 Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
 
-To run integration tests locally, you need a Chroma server running.
-Start one with: `docker run -p 8000:8000 chromadb/chroma:latest`.
+To run integration tests locally, you need a Chroma server running on `localhost:8000`.
+You can start it with: `hatch run chroma run`.

{chroma_haystack-4.3.2 → chroma_haystack-4.5.0}/pyproject.toml

@@ -135,6 +135,7 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  "PLR0917",
   # Ignore unused params
   "ARG002",
   # Allow assertions

{chroma_haystack-4.3.2 → chroma_haystack-4.5.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.5.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]:
         """
@@ -350,16 +362,17 @@ class ChromaDocumentStore:
         search_term: str | None,
         from_: int,
         size: int,
-    ) -> tuple[list[str], int]:
+    ) -> tuple[list[Any], int]:
         """
         Computes paginated unique values for a metadata field from a Chroma get result.
 
         :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.
+        :returns: A tuple of the paginated unique values (in their original type) list and the total count.
         """
         metadatas = result.get("metadatas", [])
 
@@ -367,24 +380,35 @@ 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
 
-        unique_values = {
-            str(meta.get(field_name))
-            for meta in metadatas
-            if meta and field_name in meta and meta.get(field_name) is not None
-        }
+        # Values of different types can be equal in Python (`1 == True`, `1 == 1.0`), so a plain set
+        # would silently merge them. Dedupe by (type, value) instead to keep them distinct.
+        seen: set[tuple[type, Any]] = set()
+        unique_values: list[Any] = []
+        for meta in metadatas:
+            if not meta or field_name not in meta:
+                continue
+            value = meta.get(field_name)
+            if value is None:
+                continue
+            dedup_key = (type(value), value)
+            if dedup_key not in seen:
+                seen.add(dedup_key)
+                unique_values.append(value)
 
-        sorted_values = sorted(unique_values)
+        sorted_values = sorted(unique_values, key=str)
         total_count = len(sorted_values)
         end = from_ + size
         paginated_values = sorted_values[from_:end]
@@ -901,6 +925,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:
@@ -1292,27 +1317,27 @@ class ChromaDocumentStore:
         search_term: str | None = None,
         from_: int = 0,
         size: int = 10,
-    ) -> tuple[list[str], int]:
+        filters: dict[str, Any] | None = None,
+    ) -> tuple[list[Any], 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.
+        :param filters: Optional filters to restrict the documents considered.
+        :returns: A tuple containing list of unique values (in their original type) and total count of unique values.
         """
         self._ensure_initialized()
         assert self._collection is not None
 
         field_name = _normalize_metadata_field_name(metadata_field)
 
-        kwargs: dict[str, Any] = {"include": ["metadatas"]}
-        if search_term:
-            kwargs["include"] = ["metadatas", "documents"]
-
+        kwargs = ChromaDocumentStore._prepare_get_kwargs(filters)
+        kwargs["include"] = ["metadatas"]
         result = self._collection.get(**kwargs)
         return self._compute_field_unique_values(result, field_name, search_term, from_, size)
 
@@ -1322,29 +1347,29 @@ class ChromaDocumentStore:
         search_term: str | None = None,
         from_: int = 0,
         size: int = 10,
-    ) -> tuple[list[str], int]:
+        filters: dict[str, Any] | None = None,
+    ) -> tuple[list[Any], 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.
+        :param filters: Optional filters to restrict the documents considered.
+        :returns: A tuple containing list of unique values (in their original type) and total count of unique values.
         """
         await self._ensure_initialized_async()
         assert self._async_collection is not None
 
         field_name = _normalize_metadata_field_name(metadata_field)
 
-        kwargs: dict[str, Any] = {"include": ["metadatas"]}
-        if search_term:
-            kwargs["include"] = ["metadatas", "documents"]
-
+        kwargs = ChromaDocumentStore._prepare_get_kwargs(filters)
+        kwargs["include"] = ["metadatas"]
         result = await self._async_collection.get(**kwargs)
         return self._compute_field_unique_values(result, field_name, search_term, from_, size)
 

{chroma_haystack-4.3.2 → chroma_haystack-4.5.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
@@ -718,63 +752,6 @@ class TestMetadataOperations:
         assert min_max["min"] is None
         assert min_max["max"] is None
 
-    def test_get_metadata_field_unique_values_basic(self, populated_store):
-        """Test getting unique values for metadata field"""
-        values, total = populated_store.get_metadata_field_unique_values("category", from_=0, size=10)
-        assert sorted(values) == ["A", "B", "C"]
-        assert total == 3
-
-    def test_get_metadata_field_unique_values_pagination(self, populated_store):
-        """Test pagination of unique values"""
-        # First page
-        values_page1, total = populated_store.get_metadata_field_unique_values("category", from_=0, size=2)
-        assert len(values_page1) == 2
-        assert total == 3
-
-        # Second page
-        values_page2, total = populated_store.get_metadata_field_unique_values("category", from_=2, size=2)
-        assert len(values_page2) == 1
-        assert total == 3
-
-        # Check all values are returned across pages
-        all_values = values_page1 + values_page2
-        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"
-        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 total == 1
-
-    def test_get_metadata_field_unique_values_field_normalization(self, populated_store):
-        """Test field name normalization in unique values"""
-        # Test with "meta." prefix
-        values_with_prefix, total_with_prefix = populated_store.get_metadata_field_unique_values(
-            "meta.category", from_=0, size=10
-        )
-        # Test without "meta." prefix
-        values_without_prefix, total_without_prefix = populated_store.get_metadata_field_unique_values(
-            "category", from_=0, size=10
-        )
-
-        assert sorted(values_with_prefix) == sorted(values_without_prefix) == ["A", "B", "C"]
-        assert total_with_prefix == total_without_prefix == 3
-
-    def test_get_metadata_field_unique_values_missing_field(self, populated_store):
-        """Test getting unique values for non-existent field"""
-        values, total = populated_store.get_metadata_field_unique_values("nonexistent_field", from_=0, size=10)
-        assert values == []
-        assert total == 0
-
-    def test_get_metadata_field_unique_values_empty_collection(self, document_store):
-        """Test getting unique values from empty collection"""
-        values, total = document_store.get_metadata_field_unique_values("category", from_=0, size=10)
-        assert values == []
-        assert total == 0
-
     def test_get_metadata_field_unique_values_sorting(self, populated_store):
         """Test that unique values are sorted consistently"""
         values, total = populated_store.get_metadata_field_unique_values("status", from_=0, size=10)

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

@@ -123,7 +123,7 @@ class TestDocumentStoreAsync(
         assert store._async_client.get_settings().anonymized_telemetry is False
 
     async def test_search_async(self):
-        document_store = ChromaDocumentStore(host="localhost", port=8000, collection_name="my_custom_collection")
+        document_store = ChromaDocumentStore(host="localhost", port=8000, collection_name=f"{uuid.uuid1()}-search")
 
         documents = [
             Document(content="First document", meta={"author": "Author1"}),
@@ -205,13 +205,3 @@ class TestDocumentStoreAsync(
         min_max = await document_store.get_metadata_field_min_max_async("nonexistent_field")
         assert min_max["min"] is None
         assert min_max["max"] is None
-
-    async def test_get_metadata_field_unique_values_async_missing_field(self, document_store: ChromaDocumentStore):
-        """Chroma-specific: unique values for non-existent field returns empty."""
-        docs = [Document(content="Doc 1", meta={"category": "A"})]
-        await document_store.write_documents_async(docs)
-        values, total = await document_store.get_metadata_field_unique_values_async(
-            "nonexistent_field", from_=0, size=10
-        )
-        assert values == []
-        assert total == 0

{chroma_haystack-4.3.2 → chroma_haystack-4.5.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")]