amazon-bedrock-haystack 4.0.0__tar.gz → 4.2.0__tar.gz

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/CHANGELOG.md

@@ -1,11 +1,43 @@
 # Changelog
 
+## [integrations/amazon_bedrock-v4.1.0] - 2025-09-19
+
+### 🚀 Features
+
+- Support AWS Bedrock Guardrails in `AmazonBedrockChatGenerator` (#2284)
+
+### 🧹 Chores
+
+- Bedrock - remove unused `stop_words` init parameter (#2275)
+
+### 🌀 Miscellaneous
+
+- Chore: Fix linting aws bedrock (#2249)
+
+## [integrations/amazon_bedrock-v4.0.0] - 2025-08-29
+
+### 🚀 Features
+
+- [**breaking**] Update AmazonBedrockChatGenerator to use the new fields in `StreamingChunk` (#2216)
+- [**breaking**] Use `ReasoningContent` to store reasoning content in `ChatMessage` instead of `ChatMessage.meta` (#2226)
+
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
 ## [integrations/amazon_bedrock-v3.11.0] - 2025-08-21
 
 ### 🚀 Features
 
 - Add `AmazonBedrockDocumentImageEmbedder` component (#2185)
 
+### 🧹 Chores
+
+- Add framework name into UserAgent header for bedrock integration (#2168)
+- Standardize readmes - part 1 (#2202)
+
+
 ## [integrations/amazon_bedrock-v3.10.0] - 2025-08-06
 
 ### 🚀 Features

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: amazon-bedrock-haystack
-Version: 4.0.0
-Summary: An integration of Amazon Bedrock as an AmazonBedrockGenerator component.
+Version: 4.2.0
+Summary: An integration of AWS S3 and Bedrock as a Downloader and Generator components.
 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
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/amazon_bedrock

amazon_bedrock_haystack-4.2.0/examples/s3_downloader_example.py

@@ -0,0 +1,83 @@
+# To run this example, you will need to
+# 1) set `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` and `AWS_DEFAULT_REGION` environment variables
+# 2) enabled access to the selected S3 bucket
+# 3) `S3_DOWNLOADER_BUCKET` environment variable should be set to the name of the S3 bucket.
+
+# The example shows how to use the S3Downloader component in a query pipeline to download files from an S3 bucket.
+# To run this example, set the file_name in docs to your files in the S3 bucket.
+# The files are then downloaded, converted to images and used to answer a question.
+
+
+from pathlib import Path
+from uuid import uuid4
+
+from haystack import Pipeline
+from haystack.components.builders import ChatPromptBuilder
+from haystack.components.converters.image import DocumentToImageContent
+from haystack.components.routers import DocumentTypeRouter
+from haystack.dataclasses import Document
+
+from haystack_integrations.components.downloaders.s3.s3_downloader import S3Downloader
+from haystack_integrations.components.generators.amazon_bedrock import AmazonBedrockChatGenerator
+
+docs = [
+    Document(meta={"file_id": str(uuid4()), "file_name": "text-sample.txt"}),
+    Document(meta={"file_id": str(uuid4()), "file_name": "document-sample.pdf", "page_number": 1}),
+]
+
+chat_prompt_builder = ChatPromptBuilder(
+    required_variables=["question"],
+    template="""{% message role="system" %}
+You are a friendly assistant that answers questions based on provided documents and images.
+{% endmessage %}
+
+{%- message role="user" -%}
+Only provide an answer to the question using the images and text passages provided.
+
+These are the text-only documents:
+{%- if documents|length > 0 %}
+{%- for doc in documents %}
+Text Document [{{ loop.index }}] :
+{{ doc.content }}
+{% endfor -%}
+{%- else %}
+No relevant text documents were found.
+{% endif %}
+End of text documents.
+
+Question: {{ question }}
+Answer:
+
+Images:
+{%- if image_contents|length > 0 %}
+{%- for img in image_contents -%}
+  {{ img | templatize_part }}
+{%- endfor -%}
+{% endif %}
+{%- endmessage -%}
+""",
+)
+
+pipe = Pipeline()
+pipe.add_component(
+    "s3_downloader", S3Downloader(file_root_path=str(Path.cwd() / "s3_downloads"), file_extensions=[".pdf"])
+)
+pipe.add_component(
+    "doc_type_router", DocumentTypeRouter(file_path_meta_field="file_path", mime_types=["application/pdf"])
+)
+pipe.add_component("doc_to_image", DocumentToImageContent(detail="auto"))
+pipe.add_component("chat_prompt_builder", chat_prompt_builder)
+pipe.add_component("llm", AmazonBedrockChatGenerator(model="anthropic.claude-3-haiku-20240307-v1:0"))
+
+pipe.connect("s3_downloader.documents", "doc_type_router.documents")
+pipe.connect("doc_type_router.application/pdf", "doc_to_image.documents")
+pipe.connect("doc_to_image.image_contents", "chat_prompt_builder.image_contents")
+pipe.connect("s3_downloader.documents", "chat_prompt_builder.documents")
+pipe.connect("chat_prompt_builder.prompt", "llm.messages")
+
+result = pipe.run(
+    data={
+        "s3_downloader": {"documents": docs},
+        "chat_prompt_builder": {"question": "What is the main topic of the document?"},
+    }
+)

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/pydoc/config.yml

@@ -11,6 +11,9 @@ loaders:
       "haystack_integrations.common.amazon_bedrock.errors",
       "haystack_integrations.components.generators.amazon_bedrock.chat.chat_generator",
       "haystack_integrations.components.rankers.amazon_bedrock.ranker",
+      "haystack_integrations.components.downloaders.s3.s3_downloader",
+      "haystack_integrations.common.s3.utils",
+      "haystack_integrations.common.s3.errors",
     ]
     ignore_when_discovered: ["__init__"]
 processors:

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "amazon-bedrock-haystack"
 dynamic = ["version"]
-description = 'An integration of Amazon Bedrock as an AmazonBedrockGenerator component.'
+description = 'An integration of AWS S3 and Bedrock as a Downloader and Generator components.'
 readme = "README.md"
 requires-python = ">=3.9"
 license = "Apache-2.0"
@@ -71,7 +71,10 @@ cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
 types = """mypy -p haystack_integrations.common.amazon_bedrock \
 -p haystack_integrations.components.embedders.amazon_bedrock \
 -p haystack_integrations.components.generators.amazon_bedrock \
--p haystack_integrations.components.rankers.amazon_bedrock {args}"""
+-p haystack_integrations.components.rankers.amazon_bedrock \
+-p haystack_integrations.components.downloaders.s3 \
+-p haystack_integrations.common.s3 {args}"""
+
 
 [tool.mypy]
 install_types = true

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/src/haystack_integrations/common/amazon_bedrock/errors.py

@@ -1,3 +1,8 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
 class AmazonBedrockError(Exception):
     """
     Any error generated by the Amazon Bedrock integration.

{amazon_bedrock_haystack-4.0.0 → amazon_bedrock_haystack-4.2.0}/src/haystack_integrations/common/amazon_bedrock/utils.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any, Optional, Union
 
 import aioboto3

amazon_bedrock_haystack-4.2.0/src/haystack_integrations/common/s3/errors.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+class S3Error(Exception):
+    """Exception for issues that occur in the S3 based components"""
+
+
+class S3ConfigurationError(S3Error):
+    """Exception raised when AmazonS3 node is not configured correctly"""
+
+
+class S3StorageError(S3Error):
+    """This exception is raised when an error occurs while interacting with a S3Storage object."""

amazon_bedrock_haystack-4.2.0/src/haystack_integrations/common/s3/utils.py

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from dataclasses import dataclass
+from http import HTTPStatus
+from pathlib import Path
+from typing import Optional
+
+from boto3.session import Session
+from botocore.config import Config
+from botocore.exceptions import ClientError, NoCredentialsError, PartialCredentialsError
+
+from haystack_integrations.common.s3.errors import S3ConfigurationError, S3StorageError
+
+
+@dataclass
+class S3Storage:
+    """This class provides a storage class for downloading files from an AWS S3 bucket."""
+
+    def __init__(
+        self,
+        s3_bucket: str,
+        session: Session,
+        s3_prefix: Optional[str] = None,
+        endpoint_url: Optional[str] = None,
+        config: Optional[Config] = None,
+    ) -> None:
+        """
+        Initializes the S3Storage object with the provided parameters.
+
+        :param s3_bucket: The name of the S3 bucket to download files from.
+        :param session: The session to use for the S3 client.
+        :param s3_prefix: The optional prefix of the files in the S3 bucket.
+        Can be used to specify folder or naming structure.
+            For example, if the file is in the folder "folder/subfolder/file.txt",
+            the s3_prefix should be "folder/subfolder/". If the file is in the root of the S3 bucket,
+            the s3_prefix should be None.
+        :param endpoint_url: The endpoint URL of the S3 bucket to download files from.
+        :param config: The configuration to use for the S3 client.
+        """
+
+        self.s3_bucket = s3_bucket
+        self.s3_prefix = s3_prefix
+        self.endpoint_url = endpoint_url
+        self.session = session
+        self.config = config
+
+        try:
+            self._client = self.session.client("s3", endpoint_url=self.endpoint_url, config=self.config)
+        except Exception as e:
+            msg = f"Failed to create S3 session client: {e}"
+            raise S3ConfigurationError(msg) from e
+
+    def download(self, key: str, local_file_path: Path) -> None:
+        """Download a file from S3.
+
+        :param key: The key of the file to download.
+        :param local_file_path: The folder path to download the file to.
+        It will be created if it does not exist. The file will be downloaded to
+        the folder with the same name as the key.
+        :raises S3ConfigurationError: If the S3 session client cannot be created.
+        :raises S3StorageError: If the file does not exist in the S3 bucket
+        or the file cannot be downloaded.
+        """
+
+        if self.s3_prefix:
+            s3_key = f"{self.s3_prefix}{key}"
+        else:
+            s3_key = key
+
+        try:
+            self._client.download_file(self.s3_bucket, s3_key, str(local_file_path))
+
+        except (NoCredentialsError, PartialCredentialsError) as e:
+            msg = (
+                f"Missing AWS credentials. Please check your AWS credentials (access key, secret key, region)."
+                f"Error: {e}"
+            )
+            raise S3ConfigurationError(msg) from e
+
+        except ClientError as e:
+            error_code = int(e.response["Error"]["Code"])
+
+            if error_code == HTTPStatus.FORBIDDEN:
+                msg = (
+                    f"Failed to access S3 bucket {self.s3_bucket!r}. "
+                    f"Please check your AWS credentials (access key, secret key, region) and ensure "
+                    f"they have the necessary S3 permissions. "
+                    f"Error: {e}"
+                )
+                raise S3ConfigurationError(msg) from e
+
+            elif error_code == HTTPStatus.NOT_FOUND:
+                msg = f"The object {s3_key!r} does not exist in the S3 bucket {self.s3_bucket!r}. \n Error: {e}"
+                raise S3StorageError(msg) from e
+            else:
+                msg = f"Failed to download file {s3_key!r} from S3. Error: {e}"
+                raise S3StorageError(msg) from e
+
+    @classmethod
+    def from_env(cls, *, session: Session, config: Config) -> "S3Storage":
+        """Create a S3Storage object from environment variables."""
+        s3_bucket = os.getenv("S3_DOWNLOADER_BUCKET")
+        if not s3_bucket:
+            msg = (
+                "Missing environment variable S3_DOWNLOADER_BUCKET."
+                "Please set it to the name of the S3 bucket to download files from."
+            )
+            raise ValueError(msg)
+        s3_prefix = os.getenv("S3_DOWNLOADER_PREFIX") or None
+        endpoint_url = os.getenv("AWS_ENDPOINT_URL") or None
+        return cls(
+            s3_bucket=s3_bucket,
+            s3_prefix=s3_prefix,
+            endpoint_url=endpoint_url,
+            session=session,
+            config=config,
+        )

amazon_bedrock_haystack-4.2.0/src/haystack_integrations/components/downloaders/s3/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .s3_downloader import S3Downloader
+
+__all__ = ["S3Downloader"]

amazon_bedrock_haystack-4.2.0/src/haystack_integrations/components/downloaders/s3/s3_downloader.py

@@ -0,0 +1,246 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from botocore.config import Config
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.dataclasses import Document
+from haystack.utils.auth import Secret, deserialize_secrets_inplace
+
+from haystack_integrations.common.amazon_bedrock.utils import get_aws_session
+from haystack_integrations.common.s3.utils import S3Storage
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class S3Downloader:
+    """
+    A component for downloading files from AWS S3 Buckets to local filesystem.
+    Supports filtering by file extensions.
+    """
+
+    def __init__(
+        self,
+        *,
+        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
+        boto3_config: Optional[Dict[str, Any]] = None,
+        file_root_path: Optional[str] = None,
+        file_extensions: Optional[List[str]] = None,
+        file_name_meta_key: str = "file_name",
+        max_workers: int = 32,
+        max_cache_size: int = 100,
+    ) -> None:
+        """
+        Initializes the `S3Downloader` with the provided parameters.
+
+        Note that the AWS credentials are not required if the AWS environment is configured correctly. These are loaded
+        automatically from the environment or the AWS configuration file and do not need to be provided explicitly via
+        the constructor. If the AWS environment is not configured users need to provide the AWS credentials via the
+        constructor. Three required parameters are `aws_access_key_id`, `aws_secret_access_key`,
+        and `aws_region_name`.
+
+        :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 boto3_config: The configuration for the boto3 client.
+        :param file_root_path: The path where the file will be downloaded.
+            Can be set through this parameter or the `FILE_ROOT_PATH` environment variable.
+            If none of them is set, a `ValueError` is raised.
+        :param file_extensions: The file extensions that are permitted to be downloaded.
+            By default, all file extensions are allowed.
+        :param max_workers: The maximum number of workers to use for concurrent downloads.
+        :param max_cache_size: The maximum number of files to cache.
+        :param file_name_meta_key: The name of the meta key that contains the file name to download.
+            By default, the `Document.meta["file_name"]` is used. If you want to use a
+            different key in `Document.meta`, you can set it here.
+        :raises ValueError: If the `file_root_path` is not set through
+            the constructor or the `FILE_ROOT_PATH` environment variable.
+
+        """
+
+        # Set up download directory
+        file_root_path = file_root_path or os.getenv("FILE_ROOT_PATH")
+
+        if file_root_path is None:
+            msg = (
+                "The path where files will be downloaded is not set. Please set the "
+                "`file_root_path` init parameter or the `FILE_ROOT_PATH` environment variable."
+            )
+            raise ValueError(msg)
+
+        self.file_root_path = Path(file_root_path)
+
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_region_name = aws_region_name
+        self.aws_session_token = aws_session_token
+        self.aws_profile_name = aws_profile_name
+        self.boto3_config = boto3_config
+        self.file_extensions = [e.lower() for e in file_extensions] if file_extensions else None
+        self.max_workers = max_workers
+        self.max_cache_size = max_cache_size
+        self.file_name_meta_key = file_name_meta_key
+
+        self._storage: Optional[S3Storage] = None
+
+        def resolve_secret(secret: Optional[Secret]) -> Optional[str]:
+            return secret.resolve_value() if secret else None
+
+        self._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),
+        )
+        self._config = Config(
+            user_agent_extra="x-client-framework:haystack", **(self.boto3_config if self.boto3_config else {})
+        )
+
+    def warm_up(self) -> None:
+        """Warm up the component by initializing the settings and storage."""
+        if self._storage is None:
+            self.file_root_path.mkdir(parents=True, exist_ok=True)
+            self._storage = S3Storage.from_env(session=self._session, config=self._config)
+
+    @component.output_types(documents=List[Document])
+    def run(
+        self,
+        documents: List[Document],
+    ) -> Dict[str, List[Document]]:
+        """Download files from AWS S3 Buckets to local filesystem.
+
+        Return enriched `Document`s with the path of the downloaded file.
+        :param documents: Document containing the name of the file to download in the meta field.
+        :returns: A dictionary with:
+            - `documents`: The downloaded `Document`s; each has `meta['file_path']`.
+        :raises S3Error: If a download attempt fails or the file does not exist in the S3 bucket.
+        :raises ValueError: If the path where files will be downloaded is not set.
+        """
+
+        if self._storage is None:
+            msg = f"The component {self.__class__.__name__} was not warmed up. Call 'warm_up()' before calling run()."
+            raise RuntimeError(msg)
+
+        filtered_documents = self._filter_documents_by_extensions(documents) if self.file_extensions else documents
+
+        if not filtered_documents:
+            return {"documents": []}
+
+        try:
+            max_workers = min(self.max_workers, len(filtered_documents) if filtered_documents else self.max_workers)
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                iterable = executor.map(self._download_file, filtered_documents)
+        finally:
+            self._cleanup_cache(filtered_documents)
+
+        downloaded_documents = [d for d in iterable if d is not None]
+        return {"documents": downloaded_documents}
+
+    def _filter_documents_by_extensions(self, documents: List[Document]) -> List[Document]:
+        """Filter documents by file extensions."""
+        if not self.file_extensions:
+            return documents
+        return [
+            doc
+            for doc in documents
+            if Path(doc.meta.get(self.file_name_meta_key, "")).suffix.lower() in self.file_extensions
+        ]
+
+    def _download_file(self, document: Document) -> Optional[Document]:
+        """
+        Download a single file from AWS S3 Bucket to local filesystem.
+
+        :param document: `Document` with the name of the file to download in the meta field.
+        :returns:
+            The same `Document` with `meta` containing the `file_path` of the
+            downloaded file.
+        :raises S3Error: If the download or head request fails or the file does not exist in the S3 bucket.
+        """
+
+        file_name = document.meta.get(self.file_name_meta_key)
+        if not file_name:
+            logger.warning(
+                f"Document missing required file name metadata key '{self.file_name_meta_key}'. Skipping download."
+            )
+            return None
+
+        file_path = self.file_root_path / Path(file_name)
+
+        if file_path.is_file():
+            # set access and modification time to now without redownloading the file
+            file_path.touch()
+
+        else:
+            # we know that _storage is not None after warm_up() is called, but mypy does not know that
+            self._storage.download(key=file_name, local_file_path=file_path)  # type: ignore[union-attr]
+
+        document.meta["file_path"] = str(file_path)
+        return document
+
+    def _cleanup_cache(self, documents: List[Document]) -> None:
+        """
+        Remove least-recently-accessed cache files when cache exceeds `max_cache_size`.
+
+        :param documents: List of Document objects being used containing `cache_id` metadata.
+        """
+        requested_ids = {
+            str(abs(hash(str(doc.meta.get("cache_id", ""))))) for doc in documents if doc.meta.get("cache_id")
+        }
+
+        all_files = [p for p in self.file_root_path.iterdir() if p.is_file()]
+        misses = [p for p in all_files if p.stem not in requested_ids]
+
+        overflow = len(misses) + len(requested_ids) - self.max_cache_size
+        if overflow > 0:
+            misses.sort(key=lambda p: p.stat().st_atime)
+            for p in misses[:overflow]:
+                try:
+                    p.unlink()
+                except Exception as error:
+                    logger.warning("Failed to remove cache file at {path} with error: {e}", path=p, e=error)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize the component to a dictionary."""
+        return default_to_dict(
+            self,
+            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,
+            file_root_path=str(self.file_root_path),
+            max_workers=self.max_workers,
+            max_cache_size=self.max_cache_size,
+            file_extensions=self.file_extensions,
+            file_name_meta_key=self.file_name_meta_key,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "S3Downloader":
+        """
+        Deserializes the component from a dictionary.
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        deserialize_secrets_inplace(
+            data["init_parameters"],
+            ["aws_access_key_id", "aws_secret_access_key", "aws_session_token", "aws_region_name", "aws_profile_name"],
+        )
+        return default_from_dict(cls, data)