chroma-haystack 3.1.0__tar.gz → 3.3.0__tar.gz

{chroma_haystack-3.1.0 → chroma_haystack-3.3.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [integrations/chroma-v3.2.0] - 2025-06-06
+
+### 🚀 Features
+
+- Add async support for Chroma + improve typing (#1697)
+
+
+### 🧹 Chores
+
+- Align core-integrations Hatch scripts (#1898)
+
+
 ## [integrations/chroma-v2.0.3] - 2025-04-04
 
 ### 🐛 Bug Fixes

{chroma_haystack-3.1.0 → chroma_haystack-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chroma-haystack
-Version: 3.1.0
+Version: 3.3.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-3.1.0 → chroma_haystack-3.3.0}/pyproject.toml

@@ -43,37 +43,36 @@ git_describe_command = 'git describe --tags --match="integrations/chroma-v[0-9]*
 
 [tool.hatch.envs.default]
 installer = "uv"
-dependencies = [
-  "coverage[toml]>=6.5",
-  "pytest",
-  "pytest-rerunfailures",
-  "haystack-pydoc-tools",
-  "databind-core<4.5.0",  # FIXME: the latest 4.5.0 causes loops in pip resolver
-]
+dependencies = ["haystack-pydoc-tools", "ruff"]
+
 [tool.hatch.envs.default.scripts]
-test = "pytest {args:tests}"
-test-cov = "coverage run -m pytest {args:tests}"
-test-cov-retry = "test-cov --reruns 3 --reruns-delay 30 -x"
-cov-report = ["- coverage combine", "coverage report"]
-cov = ["test-cov", "cov-report"]
-cov-retry = ["test-cov-retry", "cov-report"]
 docs = ["pydoc-markdown pydoc/config.yml"]
+fmt = "ruff check --fix {args} && ruff format {args}"
+fmt-check = "ruff check {args} && ruff format --check {args}"
 
-[tool.hatch.envs.lint]
-installer = "uv"
-detached = true
+[tool.hatch.envs.test]
 dependencies = [
-  "pip", 
-  "black>=23.1.0",
-  "mypy>=1.0.0",
-  "ruff>=0.0.243",
-  "numpy",         # we need the stubs from the main package
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-rerunfailures",
+    "mypy",
+    "pip"
 ]
-[tool.hatch.envs.lint.scripts]
-typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
-style = ["ruff check {args:.}", "black --check --diff {args:.}"]
-fmt = ["black {args:.}", "ruff check --fix {args:.}", "style"]
-all = ["style", "typing"]
+
+[tool.hatch.envs.test.scripts]
+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'
+
+types = "mypy -p haystack_integrations.components.retrievers.chroma -p haystack_integrations.document_stores.chroma {args}"
+
+[tool.mypy]
+install_types = true
+non_interactive = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
 
 [tool.hatch.metadata]
 allow-direct-references = true
@@ -166,14 +165,4 @@ exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"
-markers = ["unit: unit tests", "integration: integration tests"]
-
-[[tool.mypy.overrides]]
-module = [
-  "chromadb.*",
-  "haystack.*",
-  "haystack_integrations.*",
-  "pytest.*",
-  "numpy.*",
-]
-ignore_missing_imports = true
+markers = ["integration: integration tests"]

{chroma_haystack-3.1.0 → chroma_haystack-3.3.0}/src/haystack_integrations/components/retrievers/chroma/retriever.py

@@ -71,7 +71,7 @@ class ChromaQueryTextRetriever:
         query: str,
         filters: Optional[Dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ):
+    ) -> Dict[str, Any]:
         """
         Run the retriever on the given input data.
 
@@ -90,6 +90,33 @@ class ChromaQueryTextRetriever:
         top_k = top_k or self.top_k
         return {"documents": self.document_store.search([query], top_k, filters)[0]}
 
+    @component.output_types(documents=List[Document])
+    async def run_async(
+        self,
+        query: str,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Asynchronously run the retriever on the given input data.
+
+        Asynchronous methods are only supported for HTTP connections.
+
+        :param query: The input data for the retriever. In this case, a plain-text query.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
+        :param top_k: The maximum number of documents to retrieve.
+            If not specified, the default value from the constructor is used.
+        :returns: A dictionary with the following keys:
+            - `documents`: List of documents returned by the search engine.
+
+        :raises ValueError: If the specified document store is not found or is not a MemoryDocumentStore instance.
+        """
+        filters = apply_filter_policy(self.filter_policy, self.filters, filters)
+        top_k = top_k or self.top_k
+        return {"documents": (await self.document_store.search_async([query], top_k, filters))[0]}
+
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "ChromaQueryTextRetriever":
         """
@@ -126,18 +153,38 @@ class ChromaQueryTextRetriever:
 
 
 @component
-class ChromaEmbeddingRetriever(ChromaQueryTextRetriever):
+class ChromaEmbeddingRetriever:
     """
     A component for retrieving documents from a [Chroma database](https://docs.trychroma.com/) using embeddings.
     """
 
+    def __init__(
+        self,
+        document_store: ChromaDocumentStore,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+    ):
+        """
+        :param document_store: an instance of `ChromaDocumentStore`.
+        :param filters: filters to narrow down the search space.
+        :param top_k: the maximum number of documents to retrieve.
+        :param filter_policy: Policy to determine how filters are applied.
+        """
+        self.filters = filters or {}
+        self.top_k = top_k
+        self.document_store = document_store
+        self.filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+
     @component.output_types(documents=List[Document])
     def run(
         self,
         query_embedding: List[float],
         filters: Optional[Dict[str, Any]] = None,
         top_k: Optional[int] = None,
-    ):
+    ) -> Dict[str, Any]:
         """
         Run the retriever on the given input data.
 
@@ -157,3 +204,66 @@ class ChromaEmbeddingRetriever(ChromaQueryTextRetriever):
 
         query_embeddings = [query_embedding]
         return {"documents": self.document_store.search_embeddings(query_embeddings, top_k, filters)[0]}
+
+    @component.output_types(documents=List[Document])
+    async def run_async(
+        self,
+        query_embedding: List[float],
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Asynchronously run the retriever on the given input data.
+
+        Asynchronous methods are only supported for HTTP connections.
+
+        :param query_embedding: the query embeddings.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
+        :param top_k: the maximum number of documents to retrieve.
+            If not specified, the default value from the constructor is used.
+
+        :returns: a dictionary with the following keys:
+            - `documents`: List of documents returned by the search engine.
+        """
+        filters = apply_filter_policy(self.filter_policy, self.filters, filters)
+
+        top_k = top_k or self.top_k
+
+        query_embeddings = [query_embedding]
+        return {"documents": (await self.document_store.search_embeddings_async(query_embeddings, top_k, filters))[0]}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ChromaEmbeddingRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        document_store = ChromaDocumentStore.from_dict(data["init_parameters"]["document_store"])
+        data["init_parameters"]["document_store"] = document_store
+        # Pipelines serialized with old versions of the component might not
+        # have the filter_policy field.
+        if filter_policy := data["init_parameters"].get("filter_policy"):
+            data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
+
+        return default_from_dict(cls, data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            filters=self.filters,
+            top_k=self.top_k,
+            filter_policy=self.filter_policy.value,
+            document_store=self.document_store.to_dict(),
+        )