cohere-haystack 9.5.0__tar.gz → 10.0.1__tar.gz

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/CHANGELOG.md

@@ -1,6 +1,30 @@
 # Changelog
 
-## [unreleased]
+## [integrations/cohere-v10.0.0] - 2026-09-04
+
+### 🚜 Refactor
+
+- [**breaking**] Cohere - create clients in warm up methods (#3911)
+
+### ⚙️ CI
+
+- Improve changelog generation; fix existing changelogs (#3883)
+
+### 🧹 Chores
+
+- Clarify how generation_kwargs passed in run are handled (#3805)
+- [**breaking**] Remove deprecated `CohereGenerator` (use `CohereChatGenerator` instead) (#3885)
+
+
+## [integrations/cohere-v9.5.0] - 2026-08-11
+
+### 🐛 Bug Fixes
+
+- Fix new issues raised by ruff 0.16.0 (#3670)
+- CohereRanker reordered the top_k fallback to happen after validation (#3747)
+
+
+## [integrations/cohere-v9.4.1] - 2026-07-22
 
 
 ## [integrations/cohere-v9.4.0] - 2026-07-22
@@ -111,7 +135,7 @@
 - [**breaking**] Cohere - drop Python 3.9 and use X|Y typing (#2696)
 
 
-## [integrations/cohere-v6.3.0] - 2025-11-26
+## [integrations/cohere-v6.2.0] - 2025-11-26
 
 ### ⚙️ CI
 
@@ -320,8 +344,6 @@
 
 ### 🚀 Features
 
-- Update Anthropic/Cohere for tools use (#790)
-- Update Cohere default LLMs, add examples and update unit tests (#838)
 - Cohere LLM - adjust token counting meta to match OpenAI format (#1086)
 
 ### 🐛 Bug Fixes
@@ -332,10 +354,6 @@
 
 - Do not retry tests in `hatch run test` command (#954)
 
-### ⚙️ CI
-
-- Retry tests to reduce flakyness (#836)
-
 ### 🧹 Chores
 
 - Update ruff invocation to include check parameter (#853)
@@ -346,6 +364,24 @@
 - Update CohereChatGenerator docstrings (#958)
 - Update CohereGenerator docstrings (#960)
 
+## [integrations/cohere-v1.1.3] - 2024-06-21
+
+### 🚀 Features
+
+- Update Cohere default LLMs, add examples and update unit tests (#838)
+
+### ⚙️ CI
+
+- Retry tests to reduce flakyness (#836)
+
+
+## [integrations/cohere-v1.1.2] - 2024-06-18
+
+### 🚀 Features
+
+- Update Anthropic/Cohere for tools use (#790)
+
+
 ## [integrations/cohere-v1.1.1] - 2024-06-12
 
 ### 🌀 Miscellaneous
@@ -418,11 +454,6 @@
 
 ## [integrations/cohere-v0.4.0] - 2024-02-12
 
-### 🐛 Bug Fixes
-
-- Fix Cohere tests (#337)
-- Cohere inconsistent embeddings and documents lengths (#284)
-
 ### 🚜 Refactor
 
 - [**breaking**] Use `Secret` for API keys in Cohere components (#386)
@@ -431,6 +462,13 @@
 
 - Fix failing `TestCohereChatGenerator.test_from_dict_fail_wo_env_var` test (#393)
 
+## [integrations/cohere-v0.3.1] - 2024-02-08
+
+### 🐛 Bug Fixes
+
+- Fix Cohere tests (#337)
+- Cohere inconsistent embeddings and documents lengths (#284)
+
 ### 🌀 Miscellaneous
 
 - Cohere: generate api docs (#321)

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: cohere-haystack
-Version: 9.5.0
+Version: 10.0.1
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/cohere#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/cohere
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Requires-Dist: cohere>=5.17.0
-Requires-Dist: haystack-ai>=2.30.0
+Requires-Dist: haystack-ai>=3.0.0
 Requires-Dist: pydantic>=2.12.0
 Description-Content-Type: text/markdown
 

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/pydoc/config_docusaurus.yml

@@ -4,7 +4,6 @@ loaders:
       - haystack_integrations.components.embedders.cohere.document_image_embedder
       - haystack_integrations.components.embedders.cohere.text_embedder
       - haystack_integrations.components.embedders.cohere.utils
-      - haystack_integrations.components.generators.cohere.generator
       - haystack_integrations.components.generators.cohere.chat.chat_generator
       - haystack_integrations.components.rankers.cohere.ranker
     search_path: [../src]

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.30.0", "cohere>=5.17.0", "pydantic>=2.12.0"]
+dependencies = ["haystack-ai>=3.0.0", "cohere>=5.17.0", "pydantic>=2.12.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/cohere#readme"

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/embedders/cohere/document_embedder.py

@@ -95,18 +95,28 @@ class CohereDocumentEmbedder:
         self.embedding_separator = embedding_separator
         self.embedding_type = embedding_type or EmbeddingTypes.FLOAT
 
-        self._client = ClientV2(
-            api_key=self.api_key.resolve_value(),
-            base_url=self.api_base_url,
-            timeout=self.timeout,
-            client_name="haystack",
-        )
-        self._async_client = AsyncClientV2(
-            api_key=self.api_key.resolve_value(),
-            base_url=self.api_base_url,
-            timeout=self.timeout,
-            client_name="haystack",
-        )
+        self._client: ClientV2 | None = None
+        self._async_client: AsyncClientV2 | None = None
+
+    def warm_up(self) -> None:
+        """Create the synchronous Cohere client."""
+        if self._client is None:
+            self._client = ClientV2(
+                api_key=self.api_key.resolve_value(),
+                base_url=self.api_base_url,
+                timeout=self.timeout,
+                client_name="haystack",
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous Cohere client."""
+        if self._async_client is None:
+            self._async_client = AsyncClientV2(
+                api_key=self.api_key.resolve_value(),
+                base_url=self.api_base_url,
+                timeout=self.timeout,
+                client_name="haystack",
+            )
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -191,6 +201,8 @@ class CohereDocumentEmbedder:
         if not documents:
             return {"documents": [], "meta": {}}
 
+        self.warm_up()
+        assert self._client is not None
         texts_to_embed = self._prepare_texts_to_embed(documents)
 
         all_embeddings, metadata = get_response(
@@ -227,6 +239,8 @@ class CohereDocumentEmbedder:
         if not documents:
             return {"documents": [], "meta": {}}
 
+        await self.warm_up_async()
+        assert self._async_client is not None
         texts_to_embed = self._prepare_texts_to_embed(documents)
 
         all_embeddings, metadata = await get_async_response(
@@ -235,6 +249,8 @@ class CohereDocumentEmbedder:
             model_name=self.model,
             input_type=self.input_type,
             truncate=self.truncate,
+            batch_size=self.batch_size,
+            progress_bar=self.progress_bar,
             embedding_type=self.embedding_type,
         )
 

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/embedders/cohere/document_image_embedder.py

@@ -128,18 +128,28 @@ class CohereDocumentImageEmbedder:
         self._api_base_url = api_base_url
         self._timeout = timeout
 
-        self._client = ClientV2(
-            api_key=self._api_key.resolve_value(),
-            base_url=self._api_base_url,
-            timeout=self._timeout,
-            client_name="haystack",
-        )
-        self._async_client = AsyncClientV2(
-            api_key=self._api_key.resolve_value(),
-            base_url=self._api_base_url,
-            timeout=self._timeout,
-            client_name="haystack",
-        )
+        self._client: ClientV2 | None = None
+        self._async_client: AsyncClientV2 | None = None
+
+    def warm_up(self) -> None:
+        """Create the synchronous Cohere client."""
+        if self._client is None:
+            self._client = ClientV2(
+                api_key=self._api_key.resolve_value(),
+                base_url=self._api_base_url,
+                timeout=self._timeout,
+                client_name="haystack",
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous Cohere client."""
+        if self._async_client is None:
+            self._async_client = AsyncClientV2(
+                api_key=self._api_key.resolve_value(),
+                base_url=self._api_base_url,
+                timeout=self._timeout,
+                client_name="haystack",
+            )
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -264,6 +274,8 @@ class CohereDocumentImageEmbedder:
             - `documents`: Documents with embeddings.
         """
 
+        self.warm_up()
+        assert self._client is not None
         images_to_embed = self._extract_images_to_embed(documents)
 
         embeddings = []
@@ -312,6 +324,8 @@ class CohereDocumentImageEmbedder:
             - `documents`: Documents with embeddings.
         """
 
+        await self.warm_up_async()
+        assert self._async_client is not None
         images_to_embed = self._extract_images_to_embed(documents)
 
         embeddings = []

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/embedders/cohere/text_embedder.py

@@ -78,19 +78,28 @@ class CohereTextEmbedder:
         self.timeout = timeout
         self.embedding_type = embedding_type or EmbeddingTypes.FLOAT
 
-        self._client = ClientV2(
-            api_key=self.api_key.resolve_value(),
-            base_url=self.api_base_url,
-            timeout=self.timeout,
-            client_name="haystack",
-        )
+        self._client: ClientV2 | None = None
+        self._async_client: AsyncClientV2 | None = None
+
+    def warm_up(self) -> None:
+        """Create the synchronous Cohere client."""
+        if self._client is None:
+            self._client = ClientV2(
+                api_key=self.api_key.resolve_value(),
+                base_url=self.api_base_url,
+                timeout=self.timeout,
+                client_name="haystack",
+            )
 
-        self._async_client = AsyncClientV2(
-            api_key=self.api_key.resolve_value(),
-            base_url=self.api_base_url,
-            timeout=self.timeout,
-            client_name="haystack",
-        )
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous Cohere client."""
+        if self._async_client is None:
+            self._async_client = AsyncClientV2(
+                api_key=self.api_key.resolve_value(),
+                base_url=self.api_base_url,
+                timeout=self.timeout,
+                client_name="haystack",
+            )
 
     def _validate_input(self, text: str) -> None:
         if not isinstance(text, str):
@@ -155,6 +164,8 @@ class CohereTextEmbedder:
             If the input is not a string.
         """
         self._validate_input(text=text)
+        self.warm_up()
+        assert self._client is not None
 
         embedding, metadata = get_response(
             cohere_client=self._client,
@@ -187,6 +198,8 @@ class CohereTextEmbedder:
             If the input is not a string.
         """
         self._validate_input(text=text)
+        await self.warm_up_async()
+        assert self._async_client is not None
 
         embedding, metadata = await get_async_response(
             cohere_async_client=self._async_client,

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/embedders/cohere/utils.py

@@ -16,6 +16,8 @@ async def get_async_response(
     model_name: str,
     input_type: str,
     truncate: str,
+    batch_size: int = 32,
+    progress_bar: bool = False,
     embedding_type: EmbeddingTypes | None = None,
 ) -> tuple[list[list[float]], dict[str, Any]]:
     """
@@ -27,6 +29,9 @@ async def get_async_response(
     :param input_type: one of "classification", "clustering", "search_document", "search_query".
         The type of input text provided to embed.
     :param truncate: one of "NONE", "START", "END". How the API handles text longer than the maximum token length.
+    :param batch_size: the batch size to use. The Cohere embed endpoint caps the number of texts per call, so the
+        texts are sent in batches just like the synchronous path.
+    :param progress_bar: if `True`, show a progress bar
     :param embedding_type: the type of embeddings to return. Defaults to float embeddings.
 
     :returns: A tuple of the embeddings and metadata.
@@ -35,24 +40,28 @@ async def get_async_response(
     """
     all_embeddings: list[list[float]] = []
     metadata: dict[str, Any] = {}
-
     embedding_type = embedding_type or EmbeddingTypes.FLOAT
-    response = await cohere_async_client.embed(
-        texts=texts,
-        model=model_name,
-        input_type=input_type,
-        truncate=truncate,
-        embedding_types=[embedding_type.value],
-    )
-    if response.meta is not None:
-        metadata = response.meta.model_dump()
-    for emb_tuple in response.embeddings:
-        # emb_tuple[0] is a str denoting the embedding type (e.g. "float", "int8", etc.)
-        if emb_tuple[1] is not None:
-            # ok we have embeddings for this type, let's take all
-            # the embeddings (a list of embeddings) and break the loop
-            all_embeddings.extend(emb_tuple[1])
-            break
+
+    for i in tqdm(
+        range(0, len(texts), batch_size),
+        disable=not progress_bar,
+        desc="Calculating embeddings",
+    ):
+        batch = texts[i : i + batch_size]
+        response = await cohere_async_client.embed(
+            texts=batch,
+            model=model_name,
+            input_type=input_type,
+            truncate=truncate,
+            embedding_types=[embedding_type.value],
+        )
+        for emb_tuple in response.embeddings:
+            # emb_tuple[0] is a str denoting the embedding type (e.g. "float", "int8", etc.)
+            if emb_tuple[1] is not None:
+                # ok we have embeddings for this type, let's take all the embeddings (a list of embeddings)
+                all_embeddings.extend(emb_tuple[1])
+        if response.meta is not None:
+            metadata = response.meta.model_dump()
 
     return all_embeddings, metadata
 

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/generators/cohere/__init__.py

@@ -2,6 +2,5 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from .chat.chat_generator import CohereChatGenerator
-from .generator import CohereGenerator
 
-__all__ = ["CohereChatGenerator", "CohereGenerator"]
+__all__ = ["CohereChatGenerator"]

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/generators/cohere/chat/chat_generator.py

@@ -579,22 +579,35 @@ class CohereChatGenerator:
         self.timeout = timeout
         self.max_retries = max_retries
 
+        self.client: ClientV2 | None = None
+        self.async_client: AsyncClientV2 | None = None
+
+    def _client_kwargs(self, *, async_client: bool) -> dict[str, Any]:
+        """Build the keyword arguments used to create a Cohere client."""
         client_kwargs: dict[str, Any] = {
             "api_key": self.api_key.resolve_value(),
             "base_url": self.api_base_url,
             "client_name": "haystack",
         }
-        if timeout is not None:
-            client_kwargs["timeout"] = timeout
-
-        sync_kwargs = {**client_kwargs}
-        async_kwargs = {**client_kwargs}
-        if max_retries is not None:
-            sync_kwargs["httpx_client"] = HTTPXClient(transport=HTTPTransport(retries=max_retries))
-            async_kwargs["httpx_client"] = AsyncHTTPXClient(transport=AsyncHTTPTransport(retries=max_retries))
-
-        self.client = ClientV2(**sync_kwargs)
-        self.async_client = AsyncClientV2(**async_kwargs)
+        if self.timeout is not None:
+            client_kwargs["timeout"] = self.timeout
+
+        if self.max_retries is not None:
+            if async_client:
+                client_kwargs["httpx_client"] = AsyncHTTPXClient(transport=AsyncHTTPTransport(retries=self.max_retries))
+            else:
+                client_kwargs["httpx_client"] = HTTPXClient(transport=HTTPTransport(retries=self.max_retries))
+        return client_kwargs
+
+    def warm_up(self) -> None:
+        """Create the synchronous Cohere client."""
+        if self.client is None:
+            self.client = ClientV2(**self._client_kwargs(async_client=False))
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous Cohere client."""
+        if self.async_client is None:
+            self.async_client = AsyncClientV2(**self._client_kwargs(async_client=True))
 
     def _get_telemetry_data(self) -> dict[str, Any]:
         """
@@ -652,8 +665,9 @@ class CohereChatGenerator:
 
         :param messages: list of `ChatMessage` instances representing the input messages.
             If a string is provided, it is converted to a list containing a ChatMessage with user role.
-        :param generation_kwargs: additional keyword arguments for chat generation. These parameters will
-            potentially override the parameters passed in the __init__ method.
+        :param generation_kwargs: additional keyword arguments for chat generation. These are merged per key
+            with the `generation_kwargs` passed at initialization: keys provided here take precedence, keys set
+            only at initialization are kept.
             For more details on the parameters supported by the Cohere API, refer to the
             Cohere [documentation](https://docs.cohere.com/reference/chat).
         :param tools: A list of Tool and/or Toolset objects, or a single Toolset for which the model can prepare calls.
@@ -664,6 +678,8 @@ class CohereChatGenerator:
         :returns: A dictionary with the following keys:
             - `replies`: a list of `ChatMessage` instances representing the generated responses.
         """
+        self.warm_up()
+        assert self.client is not None
         messages = _normalize_messages(messages)
 
         # update generation kwargs by merging with the generation kwargs passed to the run method
@@ -720,8 +736,9 @@ class CohereChatGenerator:
 
         :param messages: list of `ChatMessage` instances representing the input messages.
             If a string is provided, it is converted to a list containing a ChatMessage with user role.
-        :param generation_kwargs: additional keyword arguments for chat generation. These parameters will
-            potentially override the parameters passed in the __init__ method.
+        :param generation_kwargs: additional keyword arguments for chat generation. These are merged per key
+            with the `generation_kwargs` passed at initialization: keys provided here take precedence, keys set
+            only at initialization are kept.
             For more details on the parameters supported by the Cohere API, refer to the
             Cohere [documentation](https://docs.cohere.com/reference/chat).
         :param tools: A list of Tool and/or Toolset objects, or a single Toolset for which the model can prepare calls.
@@ -730,6 +747,8 @@ class CohereChatGenerator:
         :returns: A dictionary with the following keys:
             - `replies`: a list of `ChatMessage` instances representing the generated responses.
         """
+        await self.warm_up_async()
+        assert self.async_client is not None
         messages = _normalize_messages(messages)
 
         # update generation kwargs by merging with the generation kwargs passed to the run method

{cohere_haystack-9.5.0 → cohere_haystack-10.0.1}/src/haystack_integrations/components/rankers/cohere/ranker.py

@@ -69,12 +69,22 @@ class CohereRanker:
         self.meta_data_separator = meta_data_separator
         self.max_tokens_per_doc = max_tokens_per_doc
 
-        self._cohere_client = ClientV2(
-            api_key=self.api_key.resolve_value(), base_url=self.api_base_url, client_name="haystack"
-        )
-        self._cohere_async_client = AsyncClientV2(
-            api_key=self.api_key.resolve_value(), base_url=self.api_base_url, client_name="haystack"
-        )
+        self._cohere_client: ClientV2 | None = None
+        self._cohere_async_client: AsyncClientV2 | None = None
+
+    def warm_up(self) -> None:
+        """Create the synchronous Cohere client."""
+        if self._cohere_client is None:
+            self._cohere_client = ClientV2(
+                api_key=self.api_key.resolve_value(), base_url=self.api_base_url, client_name="haystack"
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous Cohere client."""
+        if self._cohere_async_client is None:
+            self._cohere_async_client = AsyncClientV2(
+                api_key=self.api_key.resolve_value(), base_url=self.api_base_url, client_name="haystack"
+            )
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -172,6 +182,8 @@ class CohereRanker:
 
         :raises ValueError: If `top_k` is not > 0.
         """
+        self.warm_up()
+        assert self._cohere_client is not None
         cohere_input_docs, top_k = self._prepare_cohere_input_docs(documents, top_k)
 
         response = self._cohere_client.rerank(
@@ -205,6 +217,8 @@ class CohereRanker:
 
         :raises ValueError: If `top_k` is not > 0.
         """
+        await self.warm_up_async()
+        assert self._cohere_async_client is not None
         cohere_input_docs, top_k = self._prepare_cohere_input_docs(documents, top_k)
 
         response = await self._cohere_async_client.rerank(