amazon-bedrock-haystack 3.10.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

{amazon_bedrock_haystack-3.10.0.dist-info → amazon_bedrock_haystack-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 3.10.0
+Version: 4.0.0
 Summary: An integration of Amazon Bedrock as an AmazonBedrockGenerator component.
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/amazon_bedrock#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
 Requires-Dist: aioboto3>=14.0.0
 Requires-Dist: boto3>=1.28.57
-Requires-Dist: haystack-ai>=2.16.0
+Requires-Dist: haystack-ai>=2.17.1
 Description-Content-Type: text/markdown
 
 # amazon-bedrock-haystack
@@ -29,43 +29,19 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/amazon-bedrock-haystack.svg)](https://pypi.org/project/amazon-bedrock-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/amazon-bedrock-haystack.svg)](https://pypi.org/project/amazon-bedrock-haystack)
 
------
-
-**Table of Contents**
-
-- [Installation](#installation)
-- [Contributing](#contributing)
-- [License](#license)
-
-## Installation
-
-```console
-pip install amazon-bedrock-haystack
-```
+- [Integration page](https://haystack.deepset.ai/integrations/amazon-bedrock)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/amazon_bedrock/CHANGELOG.md)
+---
 
 ## Contributing
 
-`hatch` is the best way to interact with this project, to install it:
-```sh
-pip install hatch
-```
-
-With `hatch` installed, to run all the tests:
-```
-hatch run test:all
-```
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
 
-To format your code and perform linting using Ruff (with automatic fixes), run:
+To run integration tests locally, you need to authenticate with AWS.
+For example, you can do that by exporting the following environment variables:
 ```
-hatch run fmt
+export AWS_ACCESS_KEY_ID=...
+export AWS_SECRET_ACCESS_KEY=...
+export AWS_SESSION_TOKEN=...
+export AWS_DEFAULT_REGION=...
 ```
-
-To check for static type errors, run:
-
-```console
-$ hatch run test:types
-```
-
-## License
-
-`amazon-bedrock-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

{amazon_bedrock_haystack-3.10.0.dist-info → amazon_bedrock_haystack-4.0.0.dist-info}/RECORD

@@ -3,20 +3,21 @@ haystack_integrations/common/amazon_bedrock/__init__.py,sha256=6GZ8Y3Lw0rLOsOAqi
 haystack_integrations/common/amazon_bedrock/errors.py,sha256=ReheDbY7L3EJkWcUoih6lWHjbPHg2TlUs9SnXIKK7Gg,744
 haystack_integrations/common/amazon_bedrock/utils.py,sha256=ASAwEhInF9F6rhL4CbXFQUFU1pSdscWvG6jcrXkEUhc,2735
 haystack_integrations/components/embedders/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haystack_integrations/components/embedders/amazon_bedrock/__init__.py,sha256=CFqYmAVq2aavlMkZHYScKHOTwwETdRzRZITMqGhJ9Kw,298
-haystack_integrations/components/embedders/amazon_bedrock/document_embedder.py,sha256=YBVlFIo9t2qzVkNWaFKc-FNRo7R_pKfHmqNRkoMZ9K0,12952
-haystack_integrations/components/embedders/amazon_bedrock/text_embedder.py,sha256=KNvsUP-YZD17_zVBwMs42v0S2uuTE_ajMaj9bjt1XlE,9036
+haystack_integrations/components/embedders/amazon_bedrock/__init__.py,sha256=7GlhHJ4jFHCxq5QN5losGuGtrGNjvEx2dSQvEYD2yG0,408
+haystack_integrations/components/embedders/amazon_bedrock/document_embedder.py,sha256=DD34-HAGwGwTU7KWGqKXXlFdwIs21JavBRDHrBqC-m4,13060
+haystack_integrations/components/embedders/amazon_bedrock/document_image_embedder.py,sha256=CHNH0Dt7JQqYNbZi1lKsGvarnEhJn3UNGdghF0IhqWw,16163
+haystack_integrations/components/embedders/amazon_bedrock/text_embedder.py,sha256=3eSqt3XpH2thblTeOPf-ej1V2UbdG2z50d3jInq1bYc,9144
 haystack_integrations/components/generators/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haystack_integrations/components/generators/amazon_bedrock/__init__.py,sha256=lv4NouIVm78YavUssWQrHHP_81u-7j21qW8v1kZMJPQ,284
 haystack_integrations/components/generators/amazon_bedrock/adapters.py,sha256=yBC-3YwV6qAwSXMtdZiLSYh2lUpPQIDy7Efl7w-Cu-k,19640
-haystack_integrations/components/generators/amazon_bedrock/generator.py,sha256=c_saV5zxFYQVJT0Hzo80lKty46itL0Dp31VuDueYa3M,14716
+haystack_integrations/components/generators/amazon_bedrock/generator.py,sha256=Brzw0XvtPJhz2kR2I3liAqWHRmDR6p5HzJerEAPhoJU,14743
 haystack_integrations/components/generators/amazon_bedrock/chat/__init__.py,sha256=6GZ8Y3Lw0rLOsOAqi6Tu5mZC977UzQvgDxKpOWr8IQw,110
-haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py,sha256=iIaMsOOX9eYvR1GNgpxNKxaOli91ShrCv3MuBBK1NSs,24743
-haystack_integrations/components/generators/amazon_bedrock/chat/utils.py,sha256=g2SZV8LdLobaCZpwWCreBJn1BtS1V3-wQkpisStJrcY,29015
+haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py,sha256=_0dpBoZGY9kgK9zQOTskcjElcTifwhyBAixXDliK-vY,24918
+haystack_integrations/components/generators/amazon_bedrock/chat/utils.py,sha256=eF2wldu1IppL64f01N3PIa9_-BZEolQzEz9NjXvEFTQ,25810
 haystack_integrations/components/rankers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haystack_integrations/components/rankers/amazon_bedrock/__init__.py,sha256=Zrc3BSVkEaXYpliEi6hKG9bqW4J7DNk93p50SuoyT1Q,107
 haystack_integrations/components/rankers/amazon_bedrock/ranker.py,sha256=enAjf2QyDwfpidKkFCdLz954cx-Tjh9emrOS3vINJDg,12344
-amazon_bedrock_haystack-3.10.0.dist-info/METADATA,sha256=DZDchQY_Nsi4GsU4fZKTVkHxFcnn4cYuXNMjZ1VxlQg,2288
-amazon_bedrock_haystack-3.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-amazon_bedrock_haystack-3.10.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-amazon_bedrock_haystack-3.10.0.dist-info/RECORD,,
+amazon_bedrock_haystack-4.0.0.dist-info/METADATA,sha256=8iHYVwqO_nLLbLOh59yoqxwnskmfBiDupxxSTWiCvcc,2222
+amazon_bedrock_haystack-4.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+amazon_bedrock_haystack-4.0.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+amazon_bedrock_haystack-4.0.0.dist-info/RECORD,,

haystack_integrations/components/embedders/amazon_bedrock/__init__.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from .document_embedder import AmazonBedrockDocumentEmbedder
+from .document_image_embedder import AmazonBedrockDocumentImageEmbedder
 from .text_embedder import AmazonBedrockTextEmbedder
 
-__all__ = ["AmazonBedrockDocumentEmbedder", "AmazonBedrockTextEmbedder"]
+__all__ = ["AmazonBedrockDocumentEmbedder", "AmazonBedrockDocumentImageEmbedder", "AmazonBedrockTextEmbedder"]

haystack_integrations/components/embedders/amazon_bedrock/document_embedder.py

@@ -21,6 +21,7 @@ SUPPORTED_EMBEDDING_MODELS = [
     "cohere.embed-english-v3",
     "cohere.embed-multilingual-v3",
     "amazon.titan-embed-text-v2:0",
+    "amazon.titan-embed-image-v1",
 ]
 
 
@@ -38,7 +39,7 @@ class AmazonBedrockDocumentEmbedder:
 
     os.environ["AWS_ACCESS_KEY_ID"] = "..."
     os.environ["AWS_SECRET_ACCESS_KEY_ID"] = "..."
-    os.environ["AWS_REGION_NAME"] = "..."
+    os.environ["AWS_DEFAULT_REGION"] = "..."
 
     embedder = AmazonBedrockDocumentEmbedder(
         model="cohere.embed-english-v3",
@@ -61,6 +62,7 @@ class AmazonBedrockDocumentEmbedder:
             "cohere.embed-english-v3",
             "cohere.embed-multilingual-v3",
             "amazon.titan-embed-text-v2:0",
+            "amazon.titan-embed-image-v1",
         ],
         aws_access_key_id: Optional[Secret] = Secret.from_env_var("AWS_ACCESS_KEY_ID", strict=False),  # noqa: B008
         aws_secret_access_key: Optional[Secret] = Secret.from_env_var(  # noqa: B008
@@ -136,9 +138,9 @@ class AmazonBedrockDocumentEmbedder:
                 aws_region_name=resolve_secret(aws_region_name),
                 aws_profile_name=resolve_secret(aws_profile_name),
             )
-            config: Optional[Config] = None
-            if self.boto3_config:
-                config = Config(**self.boto3_config)
+            config = Config(
+                user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+            )
             self._client = session.client("bedrock-runtime", config=config)
         except Exception as exception:
             msg = (

haystack_integrations/components/embedders/amazon_bedrock/document_image_embedder.py

@@ -0,0 +1,365 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from dataclasses import replace
+from typing import Any, Dict, List, Literal, Optional, Tuple
+
+from botocore.config import Config
+from botocore.exceptions import ClientError
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.components.converters.image.image_utils import (
+    _batch_convert_pdf_pages_to_images,
+    _encode_image_to_base64,
+    _extract_image_sources_info,
+    _PDFPageInfo,
+)
+from haystack.dataclasses import ByteStream
+from haystack.utils.auth import Secret, deserialize_secrets_inplace
+from tqdm import tqdm
+
+from haystack_integrations.common.amazon_bedrock.errors import (
+    AmazonBedrockConfigurationError,
+    AmazonBedrockInferenceError,
+)
+from haystack_integrations.common.amazon_bedrock.utils import get_aws_session
+
+logger = logging.getLogger(__name__)
+
+SUPPORTED_EMBEDDING_MODELS = ["amazon.titan-embed-image-v1", "cohere.embed-english-v3", "cohere.embed-multilingual-v3"]
+
+
+@component
+class AmazonBedrockDocumentImageEmbedder:
+    """
+    A component for computing Document embeddings based on images using Amazon Bedrock models.
+
+    The embedding of each Document is stored in the `embedding` field of the Document.
+
+    ### Usage example
+    ```python
+    from haystack import Document
+    rom haystack_integrations.components.embedders.amazon_bedrock import AmazonBedrockDocumentImageEmbedder
+
+    os.environ["AWS_ACCESS_KEY_ID"] = "..."
+    os.environ["AWS_SECRET_ACCESS_KEY_ID"] = "..."
+    os.environ["AWS_DEFAULT_REGION"] = "..."
+
+    embedder = AmazonBedrockDocumentImageEmbedder(model="amazon.titan-embed-image-v1")
+
+    documents = [
+        Document(content="A photo of a cat", meta={"file_path": "cat.jpg"}),
+        Document(content="A photo of a dog", meta={"file_path": "dog.jpg"}),
+    ]
+
+    result = embedder.run(documents=documents)
+    documents_with_embeddings = result["documents"]
+    print(documents_with_embeddings)
+
+    # [Document(id=...,
+    #           content='A photo of a cat',
+    #           meta={'file_path': 'cat.jpg',
+    #                 'embedding_source': {'type': 'image', 'file_path_meta_field': 'file_path'}},
+    #           embedding=vector of size 512),
+    #  ...]
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        model: Literal["amazon.titan-embed-image-v1", "cohere.embed-english-v3", "cohere.embed-multilingual-v3"],
+        aws_access_key_id: Optional[Secret] = Secret.from_env_var("AWS_ACCESS_KEY_ID", strict=False),  # noqa: B008
+        aws_secret_access_key: Optional[Secret] = Secret.from_env_var(  # noqa: B008
+            "AWS_SECRET_ACCESS_KEY", strict=False
+        ),
+        aws_session_token: Optional[Secret] = Secret.from_env_var("AWS_SESSION_TOKEN", strict=False),  # noqa: B008
+        aws_region_name: Optional[Secret] = Secret.from_env_var("AWS_DEFAULT_REGION", strict=False),  # noqa: B008
+        aws_profile_name: Optional[Secret] = Secret.from_env_var("AWS_PROFILE", strict=False),  # noqa: B008
+        file_path_meta_field: str = "file_path",
+        root_path: Optional[str] = None,
+        image_size: Optional[Tuple[int, int]] = None,
+        progress_bar: bool = True,
+        boto3_config: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Creates a AmazonBedrockDocumentImageEmbedder component.
+
+        :param model:
+            The Bedrock model to use for calculating embeddings. Pass a valid model ID.
+            Supported models:
+            - "amazon.titan-embed-image-v1"
+            - "cohere.embed-english-v3"
+            - "cohere.embed-multilingual-v3"
+        :param aws_access_key_id: AWS access key ID.
+        :param aws_secret_access_key: AWS secret access key.
+        :param aws_session_token: AWS session token.
+        :param aws_region_name: AWS region name.
+        :param aws_profile_name: AWS profile name.
+        :param file_path_meta_field: The metadata field in the Document that contains the file path to the image or PDF.
+        :param root_path: The root directory path where document files are located. If provided, file paths in
+            document metadata will be resolved relative to this path. If None, file paths are treated as absolute paths.
+        :param image_size:
+            If provided, resizes the image to fit within the specified dimensions (width, height) while
+            maintaining aspect ratio. This reduces file size, memory usage, and processing time, which is beneficial
+            when working with models that have resolution constraints or when transmitting images to remote services.
+        :param progress_bar:
+            If `True`, shows a progress bar when embedding documents.
+        :param boto3_config: The configuration for the boto3 client.
+        :param kwargs: Additional parameters to pass for model inference.
+            For example, `embeddingConfig` for Amazon Titan models and
+            `embedding_types` for Cohere models.
+        :raises ValueError: If the model is not supported.
+        :raises AmazonBedrockConfigurationError: If the AWS environment is not configured correctly.
+        """
+        if not model or model not in SUPPORTED_EMBEDDING_MODELS:
+            msg = "Please provide a valid model from the list of supported models: " + ", ".join(
+                SUPPORTED_EMBEDDING_MODELS
+            )
+            raise ValueError(msg)
+
+        self.file_path_meta_field = file_path_meta_field
+        self.root_path = root_path or ""
+        self.model = model
+        self.boto3_config = boto3_config
+
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_session_token = aws_session_token
+        self.aws_region_name = aws_region_name
+        self.aws_profile_name = aws_profile_name
+        self.image_size = image_size
+        self.progress_bar = progress_bar
+        self.kwargs = kwargs
+        self.embedding_types = None
+
+        if emmbedding_types := self.kwargs.get("embedding_types"):
+            if len(emmbedding_types) > 1:
+                msg = (
+                    "You have provided multiple embedding_types for Cohere model. "
+                    "AmazonBedrockDocumentImageEmbedder only supports one embedding_type at a time."
+                )
+                raise ValueError(msg)
+            self.embedding_types = emmbedding_types
+
+        def resolve_secret(secret: Optional[Secret]) -> Optional[str]:
+            return secret.resolve_value() if secret else None
+
+        try:
+            session = get_aws_session(
+                aws_access_key_id=resolve_secret(aws_access_key_id),
+                aws_secret_access_key=resolve_secret(aws_secret_access_key),
+                aws_session_token=resolve_secret(aws_session_token),
+                aws_region_name=resolve_secret(aws_region_name),
+                aws_profile_name=resolve_secret(aws_profile_name),
+            )
+            config = Config(
+                user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+            )
+            self._client = session.client("bedrock-runtime", config=config)
+        except Exception as exception:
+            msg = (
+                "Could not connect to Amazon Bedrock. Make sure the AWS environment is configured correctly. "
+                "See https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#configuration"
+            )
+            raise AmazonBedrockConfigurationError(msg) from exception
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self,
+            file_path_meta_field=self.file_path_meta_field,
+            root_path=self.root_path,
+            model=self.model,
+            aws_access_key_id=self.aws_access_key_id.to_dict() if self.aws_access_key_id else None,
+            aws_secret_access_key=self.aws_secret_access_key.to_dict() if self.aws_secret_access_key else None,
+            aws_session_token=self.aws_session_token.to_dict() if self.aws_session_token else None,
+            aws_region_name=self.aws_region_name.to_dict() if self.aws_region_name else None,
+            aws_profile_name=self.aws_profile_name.to_dict() if self.aws_profile_name else None,
+            progress_bar=self.progress_bar,
+            boto3_config=self.boto3_config,
+            image_size=self.image_size,
+            **self.kwargs,
+        )
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "AmazonBedrockDocumentImageEmbedder":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        init_params = data["init_parameters"]
+        deserialize_secrets_inplace(
+            init_params,
+            keys=[
+                "aws_access_key_id",
+                "aws_secret_access_key",
+                "aws_session_token",
+                "aws_region_name",
+                "aws_profile_name",
+            ],
+        )
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=list[Document])
+    def run(self, documents: list[Document]) -> dict[str, list[Document]]:
+        """
+        Embed a list of images.
+
+        :param documents:
+            Documents to embed.
+
+        :returns:
+            A dictionary with the following keys:
+            - `documents`: Documents with embeddings.
+        """
+        if not isinstance(documents, list) or (documents and not isinstance(documents[0], Document)):
+            msg = (
+                "AmazonBedrockDocumentImageEmbedder expects a list of Documents as input. "
+                "In case you want to embed a string, please use the AmazonBedrockTextEmbedder."
+            )
+            raise TypeError(msg)
+        images_source_info = _extract_image_sources_info(
+            documents=documents, file_path_meta_field=self.file_path_meta_field, root_path=self.root_path
+        )
+
+        images_to_embed: list = [None] * len(documents)
+        pdf_page_infos: list[_PDFPageInfo] = []
+
+        for doc_idx, image_source_info in enumerate(images_source_info):
+            if image_source_info["mime_type"] == "application/pdf":
+                # Store PDF documents for later processing
+                page_number = image_source_info.get("page_number")
+
+                pdf_page_info: _PDFPageInfo = {
+                    "doc_idx": doc_idx,
+                    "path": image_source_info["path"],
+                    # page_number is added but mypy doesn't know that
+                    "page_number": page_number,  # type: ignore[typeddict-item]
+                }
+                pdf_page_infos.append(pdf_page_info)
+            else:
+                # Process images directly
+                image_byte_stream = ByteStream.from_file_path(
+                    filepath=image_source_info["path"], mime_type=image_source_info["mime_type"]
+                )
+                mime_type, base64_image = _encode_image_to_base64(bytestream=image_byte_stream, size=self.image_size)
+                if "cohere" in self.model:
+                    images_to_embed[doc_idx] = f"data:{mime_type};base64,{base64_image}"
+                else:
+                    images_to_embed[doc_idx] = base64_image
+
+        pdf_images_by_doc_idx = _batch_convert_pdf_pages_to_images(
+            pdf_page_infos=pdf_page_infos, return_base64=True, size=self.image_size
+        )
+
+        # the pdf_images_by_doc_idx has base64 images but mypy cant detect that
+        for doc_idx, base64_image in pdf_images_by_doc_idx.items():  # type: ignore[assignment]
+            pdf_image_uri = f"data:application/pdf;base64,{base64_image}" if "cohere" in self.model else base64_image
+            images_to_embed[doc_idx] = pdf_image_uri
+
+        none_images_doc_ids = [documents[doc_idx].id for doc_idx, image in enumerate(images_to_embed) if image is None]
+        if none_images_doc_ids:
+            msg = f"Conversion failed for some documents. Document IDs: {none_images_doc_ids}."
+            raise RuntimeError(msg)
+
+        if "cohere" in self.model:
+            embeddings = self._embed_cohere(image_uris=images_to_embed)
+        elif "titan" in self.model:
+            embeddings = self._embed_titan(images=images_to_embed)
+        else:
+            msg = f"Model {self.model} is not supported. Supported models are: {', '.join(SUPPORTED_EMBEDDING_MODELS)}."
+            raise ValueError(msg)
+
+        docs_with_embeddings = []
+
+        for doc, emb in zip(documents, embeddings):
+            # we store this information for later inspection
+            new_meta = {
+                **doc.meta,
+                "embedding_source": {"type": "image", "file_path_meta_field": self.file_path_meta_field},
+            }
+            new_doc = replace(doc, meta=new_meta, embedding=emb)
+            docs_with_embeddings.append(new_doc)
+
+        return {"documents": docs_with_embeddings}
+
+    def _embed_titan(self, images: List[str]) -> List[List[float]]:
+        """
+        Internal method to embed base64 images using Amazon Titan models.
+
+        :param images: List of base64 images.
+        :return: List of embeddings.
+        """
+
+        titan_body = {}
+        if embedding_config := self.kwargs.get("embeddingConfig"):
+            titan_body["embeddingConfig"] = embedding_config  # optional parameter for Amazon Titan models
+
+        all_embeddings = []
+
+        for image in tqdm(images, disable=not self.progress_bar, desc="Creating embeddings"):
+            body = {"inputImage": image, **titan_body}
+            try:
+                response = self._client.invoke_model(
+                    body=json.dumps(body), modelId=self.model, accept="*/*", contentType="application/json"
+                )
+            except ClientError as exception:
+                msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
+                raise AmazonBedrockInferenceError(msg) from exception
+
+            response_body = json.loads(response.get("body").read())
+            embedding = response_body["embedding"]
+            all_embeddings.append(embedding)
+
+        return all_embeddings
+
+    def _embed_cohere(self, image_uris: List[str]) -> List[List[float]]:
+        """
+        Internal method to embed base64 images using Cohere models.
+
+        :param image_uris: List of image uris containing the base64 image and the mime type.
+        :return: List of embeddings.
+        """
+
+        cohere_body = {"input_type": "image"}
+        if self.embedding_types:
+            cohere_body["embedding_types"] = self.embedding_types
+
+        all_embeddings = []
+
+        for image in tqdm(image_uris, disable=not self.progress_bar, desc="Creating embeddings"):
+            body = {"images": [image], **cohere_body}
+            try:
+                response = self._client.invoke_model(
+                    body=json.dumps(body), modelId=self.model, accept="*/*", contentType="application/json"
+                )
+            except ClientError as exception:
+                msg = f"Could not perform inference for Amazon Bedrock model {self.model} due to:\n{exception}"
+                raise AmazonBedrockInferenceError(msg) from exception
+
+            response_body = json.loads(response.get("body").read())
+            embeddings = response_body["embeddings"]
+
+            # if embedding_types is specified, cohere returns a dict with the embedding types as keys
+            if isinstance(embeddings, dict):
+                for embedding in embeddings.values():
+                    all_embeddings.append(embedding[0])
+            else:
+                # if embedding_types is not specified, cohere returns
+                # a nested list of float embeddings
+                all_embeddings.append(embeddings[0])
+
+        return all_embeddings

haystack_integrations/components/embedders/amazon_bedrock/text_embedder.py

@@ -19,6 +19,7 @@ SUPPORTED_EMBEDDING_MODELS = [
     "cohere.embed-english-v3",
     "cohere.embed-multilingual-v3",
     "amazon.titan-embed-text-v2:0",
+    "amazon.titan-embed-image-v1",
 ]
 
 
@@ -34,7 +35,7 @@ class AmazonBedrockTextEmbedder:
 
     os.environ["AWS_ACCESS_KEY_ID"] = "..."
     os.environ["AWS_SECRET_ACCESS_KEY_ID"] = "..."
-    os.environ["AWS_REGION_NAME"] = "..."
+    os.environ["AWS_DEFAULT_REGION"] = "..."
 
     embedder = AmazonBedrockTextEmbedder(
         model="cohere.embed-english-v3",
@@ -54,6 +55,7 @@ class AmazonBedrockTextEmbedder:
             "cohere.embed-english-v3",
             "cohere.embed-multilingual-v3",
             "amazon.titan-embed-text-v2:0",
+            "amazon.titan-embed-image-v1",
         ],
         aws_access_key_id: Optional[Secret] = Secret.from_env_var("AWS_ACCESS_KEY_ID", strict=False),  # noqa: B008
         aws_secret_access_key: Optional[Secret] = Secret.from_env_var(  # noqa: B008
@@ -114,9 +116,9 @@ class AmazonBedrockTextEmbedder:
                 aws_region_name=resolve_secret(aws_region_name),
                 aws_profile_name=resolve_secret(aws_profile_name),
             )
-            config: Optional[Config] = None
-            if self.boto3_config:
-                config = Config(**self.boto3_config)
+            config = Config(
+                user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+            )
             self._client = session.client("bedrock-runtime", config=config)
         except Exception as exception:
             msg = (

haystack_integrations/components/generators/amazon_bedrock/chat/chat_generator.py

@@ -213,9 +213,9 @@ class AmazonBedrockChatGenerator:
         def resolve_secret(secret: Optional[Secret]) -> Optional[str]:
             return secret.resolve_value() if secret else None
 
-        config: Optional[Config] = None
-        if self.boto3_config:
-            config = Config(**self.boto3_config)
+        config = Config(
+            user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+        )
 
         try:
             # sync session
@@ -226,6 +226,7 @@ class AmazonBedrockChatGenerator:
                 aws_region_name=resolve_secret(aws_region_name),
                 aws_profile_name=resolve_secret(aws_profile_name),
             )
+
             self.client = session.client("bedrock-runtime", config=config)
 
         except Exception as exception:
@@ -498,7 +499,10 @@ class AmazonBedrockChatGenerator:
             session = self._get_async_session()
             # Note: https://aioboto3.readthedocs.io/en/latest/usage.html
             # we need to create a new client for each request
-            async with session.client("bedrock-runtime", config=self.boto3_config) as async_client:
+            config = Config(
+                user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+            )
+            async with session.client("bedrock-runtime", config=config) as async_client:
                 if callback:
                     response = await async_client.converse_stream(**params)
                     response_stream: EventStream = response.get("stream")

haystack_integrations/components/generators/amazon_bedrock/chat/utils.py

@@ -5,16 +5,20 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from botocore.eventstream import EventStream
 from haystack import logging
+from haystack.components.generators.utils import _convert_streaming_chunks_to_chat_message
 from haystack.dataclasses import (
     AsyncStreamingCallbackT,
     ChatMessage,
     ChatRole,
     ComponentInfo,
+    FinishReason,
     ImageContent,
+    ReasoningContent,
     StreamingChunk,
     SyncStreamingCallbackT,
     TextContent,
     ToolCall,
+    ToolCallDelta,
 )
 from haystack.tools import Tool
 
@@ -24,6 +28,16 @@ logger = logging.getLogger(__name__)
 # see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html for supported formats
 IMAGE_SUPPORTED_FORMATS = ["png", "jpeg", "gif", "webp"]
 
+# see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html
+FINISH_REASON_MAPPING: Dict[str, FinishReason] = {
+    "end_turn": "stop",
+    "stop_sequence": "stop",
+    "max_tokens": "length",
+    "guardrail_intervened": "content_filter",
+    "content_filtered": "content_filter",
+    "tool_use": "tool_calls",
+}
+
 
 # Haystack to Bedrock util methods
 def _format_tools(tools: Optional[List[Tool]] = None) -> Optional[Dict[str, Any]]:
@@ -57,8 +71,8 @@ def _format_tool_call_message(tool_call_message: ChatMessage) -> Dict[str, Any]:
     content: List[Dict[str, Any]] = []
 
     # tool call messages can contain reasoning content
-    if reasoning_contents := tool_call_message.meta.get("reasoning_contents"):
-        content.extend(_format_reasoning_contents(reasoning_contents=reasoning_contents))
+    if reasoning_content := tool_call_message.reasoning:
+        content.extend(_format_reasoning_content(reasoning_content=reasoning_content))
 
     # Tool call message can contain text
     if tool_call_message.text:
@@ -162,16 +176,16 @@ def _repair_tool_result_messages(bedrock_formatted_messages: List[Dict[str, Any]
     return [msg for _, msg in repaired_bedrock_formatted_messages]
 
 
-def _format_reasoning_contents(reasoning_contents: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+def _format_reasoning_content(reasoning_content: ReasoningContent) -> List[Dict[str, Any]]:
     """
-    Format reasoning contents to match Bedrock's expected structure.
+    Format ReasoningContent to match Bedrock's expected structure.
 
-    :param reasoning_contents: List of reasoning content dictionaries from Haystack ChatMessage metadata.
+    :param reasoning_content: ReasoningContent object containing reasoning contents to format.
     :returns: List of formatted reasoning content dictionaries for Bedrock.
     """
     formatted_contents = []
-    for reasoning_content in reasoning_contents:
-        formatted_content = {"reasoningContent": reasoning_content["reasoning_content"]}
+    for content in reasoning_content.extra.get("reasoning_contents", []):
+        formatted_content = {"reasoningContent": content["reasoning_content"]}
         if reasoning_text := formatted_content["reasoningContent"].pop("reasoning_text", None):
             formatted_content["reasoningContent"]["reasoningText"] = reasoning_text
         if redacted_content := formatted_content["reasoningContent"].pop("redacted_content", None):
@@ -192,8 +206,8 @@ def _format_text_image_message(message: ChatMessage) -> Dict[str, Any]:
 
     bedrock_content_blocks: List[Dict[str, Any]] = []
     # Add reasoning content if available as the first content block
-    if message.meta.get("reasoning_contents"):
-        bedrock_content_blocks.extend(_format_reasoning_contents(reasoning_contents=message.meta["reasoning_contents"]))
+    if message.reasoning:
+        bedrock_content_blocks.extend(_format_reasoning_content(reasoning_content=message.reasoning))
 
     for part in content_parts:
         if isinstance(part, TextContent):
@@ -269,7 +283,7 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
             base_meta = {
                 "model": model,
                 "index": 0,
-                "finish_reason": response_body.get("stopReason"),
+                "finish_reason": FINISH_REASON_MAPPING.get(response_body.get("stopReason", "")),
                 "usage": {
                     # OpenAI's format for usage for cross ChatGenerator compatibility
                     "prompt_tokens": response_body.get("usage", {}).get("inputTokens", 0),
@@ -303,11 +317,26 @@ def _parse_completion_response(response_body: Dict[str, Any], model: str) -> Lis
                         reasoning_content["redacted_content"] = reasoning_content.pop("redactedContent")
                     reasoning_contents.append({"reasoning_content": reasoning_content})
 
-            # If reasoning contents were found, add them to the base meta
-            base_meta.update({"reasoning_contents": reasoning_contents})
+            reasoning_text = ""
+            for content in reasoning_contents:
+                if "reasoning_text" in content["reasoning_content"]:
+                    reasoning_text += content["reasoning_content"]["reasoning_text"]["text"]
+                elif "redacted_content" in content["reasoning_content"]:
+                    reasoning_text += "[REDACTED]"
 
             # Create a single ChatMessage with combined text and tool calls
-            replies.append(ChatMessage.from_assistant(" ".join(text_content), tool_calls=tool_calls, meta=base_meta))
+            replies.append(
+                ChatMessage.from_assistant(
+                    " ".join(text_content),
+                    tool_calls=tool_calls,
+                    meta=base_meta,
+                    reasoning=ReasoningContent(
+                        reasoning_text=reasoning_text, extra={"reasoning_contents": reasoning_contents}
+                    )
+                    if reasoning_contents
+                    else None,
+                )
+            )
 
     return replies
 
@@ -328,9 +357,8 @@ def _convert_event_to_streaming_chunk(
     """
     # Initialize an empty StreamingChunk to return if no relevant event is found
     # (e.g. for messageStart and contentBlockStop)
-    streaming_chunk = StreamingChunk(
-        content="", meta={"model": model, "received_at": datetime.now(timezone.utc).isoformat()}
-    )
+    base_meta = {"model": model, "received_at": datetime.now(timezone.utc).isoformat()}
+    streaming_chunk = StreamingChunk(content="", meta=base_meta)
 
     if "contentBlockStart" in event:
         # contentBlockStart always has the key "contentBlockIndex"
@@ -340,26 +368,15 @@ def _convert_event_to_streaming_chunk(
             tool_start = block_start["start"]["toolUse"]
             streaming_chunk = StreamingChunk(
                 content="",
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    # We follow the same format used in the OpenAIChatGenerator
-                    "tool_calls": [  # Optional[List[ChoiceDeltaToolCall]]
-                        {
-                            "index": block_idx,  # int
-                            "id": tool_start["toolUseId"],  # Optional[str]
-                            "function": {  # Optional[ChoiceDeltaToolCallFunction]
-                                # Will accumulate deltas as string
-                                "arguments": "",  # Optional[str]
-                                "name": tool_start["name"],  # Optional[str]
-                            },
-                            "type": "function",  # Optional[Literal["function"]]
-                        }
-                    ],
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                tool_calls=[
+                    ToolCallDelta(
+                        index=block_idx,
+                        id=tool_start["toolUseId"],
+                        tool_name=tool_start["name"],
+                    )
+                ],
+                meta=base_meta,
             )
 
     elif "contentBlockDelta" in event:
@@ -370,39 +387,22 @@ def _convert_event_to_streaming_chunk(
         if "text" in delta:
             streaming_chunk = StreamingChunk(
                 content=delta["text"],
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    "tool_calls": None,
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                meta=base_meta,
             )
         # This only occurs when accumulating the arguments for a toolUse
         # The content_block for this tool should already exist at this point
         elif "toolUse" in delta:
             streaming_chunk = StreamingChunk(
                 content="",
-                meta={
-                    "model": model,
-                    # This is always 0 b/c it represents the choice index
-                    "index": 0,
-                    "tool_calls": [  # Optional[List[ChoiceDeltaToolCall]]
-                        {
-                            "index": block_idx,  # int
-                            "id": None,  # Optional[str]
-                            "function": {  # Optional[ChoiceDeltaToolCallFunction]
-                                # Will accumulate deltas as string
-                                "arguments": delta["toolUse"].get("input", ""),  # Optional[str]
-                                "name": None,  # Optional[str]
-                            },
-                            "type": "function",  # Optional[Literal["function"]]
-                        }
-                    ],
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
-                },
+                index=block_idx,
+                tool_calls=[
+                    ToolCallDelta(
+                        index=block_idx,
+                        arguments=delta["toolUse"].get("input", ""),
+                    )
+                ],
+                meta=base_meta,
             )
         # This is for accumulating reasoning content deltas
         elif "reasoningContent" in delta:
@@ -411,28 +411,19 @@ def _convert_event_to_streaming_chunk(
                 reasoning_content["redacted_content"] = reasoning_content.pop("redactedContent")
             streaming_chunk = StreamingChunk(
                 content="",
+                index=block_idx,
                 meta={
-                    "model": model,
-                    "index": 0,
-                    "tool_calls": None,
-                    "finish_reason": None,
-                    "received_at": datetime.now(timezone.utc).isoformat(),
+                    **base_meta,
                     "reasoning_contents": [{"index": block_idx, "reasoning_content": reasoning_content}],
                 },
             )
 
     elif "messageStop" in event:
-        finish_reason = event["messageStop"].get("stopReason")
+        finish_reason = FINISH_REASON_MAPPING.get(event["messageStop"].get("stopReason"))
         streaming_chunk = StreamingChunk(
             content="",
-            meta={
-                "model": model,
-                # This is always 0 b/c it represents the choice index
-                "index": 0,
-                "tool_calls": None,
-                "finish_reason": finish_reason,
-                "received_at": datetime.now(timezone.utc).isoformat(),
-            },
+            finish_reason=finish_reason,
+            meta=base_meta,
         )
 
     elif "metadata" in event and "usage" in event["metadata"]:
@@ -440,12 +431,7 @@ def _convert_event_to_streaming_chunk(
         streaming_chunk = StreamingChunk(
             content="",
             meta={
-                "model": model,
-                # This is always 0 b/c it represents the choice index
-                "index": 0,
-                "tool_calls": None,
-                "finish_reason": None,
-                "received_at": datetime.now(timezone.utc).isoformat(),
+                **base_meta,
                 "usage": {
                     "prompt_tokens": metadata["usage"].get("inputTokens", 0),
                     "completion_tokens": metadata["usage"].get("outputTokens", 0),
@@ -459,7 +445,7 @@ def _convert_event_to_streaming_chunk(
     return streaming_chunk
 
 
-def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str, Any]]:
+def _process_reasoning_contents(chunks: List[StreamingChunk]) -> Optional[ReasoningContent]:
     """
     Process reasoning contents from a list of StreamingChunk objects into the Bedrock expected format.
 
@@ -491,6 +477,8 @@ def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str,
                     )
                 if redacted_content:
                     formatted_reasoning_contents.append({"reasoning_content": {"redacted_content": redacted_content}})
+
+                # Reset accumulators for new group
                 reasoning_text = ""
                 reasoning_signature = None
                 redacted_content = None
@@ -516,85 +504,22 @@ def _process_reasoning_contents(chunks: List[StreamingChunk]) -> List[Dict[str,
         if redacted_content:
             formatted_reasoning_contents.append({"reasoning_content": {"redacted_content": redacted_content}})
 
-    return formatted_reasoning_contents
-
-
-def _convert_streaming_chunks_to_chat_message(chunks: List[StreamingChunk]) -> ChatMessage:
-    """
-    Converts a list of streaming chunks into a ChatMessage object.
-
-    The function processes streaming chunks to build a ChatMessage object, including extracting and constructing
-    tool calls, managing metadata such as model type, finish reason, and usage information.
-    The tool call processing handles accumulating data across the chunks and attempts to parse JSON-formatted
-    arguments for tool calls.
-
-    :param chunks: A list of StreamingChunk objects representing parts of the assistant's response.
-
-    :returns:
-        A ChatMessage object constructed from the streaming chunks, containing the aggregated text, processed tool
-        calls, and metadata.
-    """
-    # Join all text content from the chunks
-    text = "".join([chunk.content for chunk in chunks])
-
-    # If reasoning content is present in any chunk, accumulate it
-    reasoning_contents = _process_reasoning_contents(chunks=chunks)
-
-    # Process tool calls if present in any chunk
-    tool_calls = []
-    tool_call_data: Dict[int, Dict[str, str]] = {}  # Track tool calls by index
-    for chunk_payload in chunks:
-        tool_calls_meta = chunk_payload.meta.get("tool_calls")
-        if tool_calls_meta is not None:
-            for delta in tool_calls_meta:
-                # We use the index of the tool call to track it across chunks since the ID is not always provided
-                if delta["index"] not in tool_call_data:
-                    tool_call_data[delta["index"]] = {"id": "", "name": "", "arguments": ""}
-
-                # Save the ID if present
-                if delta.get("id"):
-                    tool_call_data[delta["index"]]["id"] = delta["id"]
-
-                if delta.get("function"):
-                    if delta["function"].get("name"):
-                        tool_call_data[delta["index"]]["name"] += delta["function"]["name"]
-                    if delta["function"].get("arguments"):
-                        tool_call_data[delta["index"]]["arguments"] += delta["function"]["arguments"]
-
-    # Convert accumulated tool call data into ToolCall objects
-    for call_data in tool_call_data.values():
-        try:
-            arguments = json.loads(call_data.get("arguments", "{}")) if call_data.get("arguments") else {}
-            tool_calls.append(ToolCall(id=call_data["id"], tool_name=call_data["name"], arguments=arguments))
-        except json.JSONDecodeError:
-            logger.warning(
-                "Amazon Bedrock returned a malformed JSON string for tool call arguments. This tool call will be "
-                "skipped. Tool call ID: {tool_id}, Tool name: {tool_name}, Arguments: {tool_arguments}",
-                tool_id=call_data["id"],
-                tool_name=call_data["name"],
-                tool_arguments=call_data["arguments"],
-            )
-
-    # finish_reason can appear in different places so we look for the last one
-    finish_reasons = [
-        chunk.meta.get("finish_reason") for chunk in chunks if chunk.meta.get("finish_reason") is not None
-    ]
-    finish_reason = finish_reasons[-1] if finish_reasons else None
-
-    # usage is usually last but we look for it as well
-    usages = [chunk.meta.get("usage") for chunk in chunks if chunk.meta.get("usage") is not None]
-    usage = usages[-1] if usages else None
-
-    meta = {
-        "model": chunks[-1].meta["model"],
-        "index": 0,
-        "finish_reason": finish_reason,
-        "completion_start_time": chunks[0].meta.get("received_at"),  # first chunk received
-        "usage": usage,
-        "reasoning_contents": reasoning_contents,
-    }
-
-    return ChatMessage.from_assistant(text=text or None, tool_calls=tool_calls, meta=meta)
+    # Combine all reasoning texts into a single string for the main reasoning_text field
+    final_reasoning_text = ""
+    for content in formatted_reasoning_contents:
+        if "reasoning_text" in content["reasoning_content"]:
+            # mypy somehow thinks that content["reasoning_content"]["reasoning_text"]["text"] can be of type None
+            final_reasoning_text += content["reasoning_content"]["reasoning_text"]["text"]  # type: ignore[operator]
+        elif "redacted_content" in content["reasoning_content"]:
+            final_reasoning_text += "[REDACTED]"
+
+    return (
+        ReasoningContent(
+            reasoning_text=final_reasoning_text, extra={"reasoning_contents": formatted_reasoning_contents}
+        )
+        if formatted_reasoning_contents
+        else None
+    )
 
 
 def _parse_streaming_response(
@@ -612,13 +537,26 @@ def _parse_streaming_response(
     :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
+    content_block_idxs = set()
     chunks: List[StreamingChunk] = []
     for event in response_stream:
         streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
+        content_block_idx = streaming_chunk.index
+        if content_block_idx is not None and content_block_idx not in content_block_idxs:
+            streaming_chunk.start = True
+            content_block_idxs.add(content_block_idx)
         streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
-    replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
-    return replies
+    reply = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+    reasoning_content = _process_reasoning_contents(chunks=chunks)
+    reply = ChatMessage.from_assistant(
+        text=reply.text,
+        meta=reply.meta,
+        name=reply.name,
+        tool_calls=reply.tool_calls,
+        reasoning=reasoning_content,
+    )
+    return [reply]
 
 
 async def _parse_streaming_response_async(
@@ -636,10 +574,23 @@ async def _parse_streaming_response_async(
     :param component_info: ComponentInfo object
     :return: List of ChatMessage objects
     """
+    content_block_idxs = set()
     chunks: List[StreamingChunk] = []
     async for event in response_stream:
         streaming_chunk = _convert_event_to_streaming_chunk(event=event, model=model, component_info=component_info)
+        content_block_idx = streaming_chunk.index
+        if content_block_idx is not None and content_block_idx not in content_block_idxs:
+            streaming_chunk.start = True
+            content_block_idxs.add(content_block_idx)
         await streaming_callback(streaming_chunk)
         chunks.append(streaming_chunk)
-    replies = [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
-    return replies
+    reply = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+    reasoning_content = _process_reasoning_contents(chunks=chunks)
+    reply = ChatMessage.from_assistant(
+        text=reply.text,
+        meta=reply.meta,
+        name=reply.name,
+        tool_calls=reply.tool_calls,
+        reasoning=reasoning_content,
+    )
+    return [reply]

haystack_integrations/components/generators/amazon_bedrock/generator.py

@@ -167,9 +167,9 @@ class AmazonBedrockGenerator:
                 aws_region_name=resolve_secret(aws_region_name),
                 aws_profile_name=resolve_secret(aws_profile_name),
             )
-            config: Optional[Config] = None
-            if self.boto3_config:
-                config = Config(**self.boto3_config)
+            config = Config(
+                user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+            )
             self.client = session.client("bedrock-runtime", config=config)
         except Exception as exception:
             msg = (