Skip to main content
Feedback

Amazon Bedrock connector

The Amazon Bedrock connector provides you a seamless, secure, and robust integration point between the Boomi integration platform and the Amazon Bedrock API. It allows you to build processes that leverage powerful generative AI capabilities without managing the complexities of REST API calls, request signing, and authentication from scratch.

The Amazon Bedrock connector enables Boomi processes to interact with supported generative AI models on Amazon Bedrock. You can:

  • Generate text
  • Create images
  • Produce vector embeddings
  • Converse (runs conversational exchanges using message history)
  • Call Amazon Bedrock agents using an Invoke Agent operation

by invoking Bedrock Runtime with model-specific JSON payloads.

The connector dynamically discovers models available to your AWS account and region, and provides streamlined configuration aligned with Boomi best practices.

When you use an Invoke Agent operation to call Amazon Bedrock agents from a Boomi process, you can do the following:

  • Route inbound requests (for example, a JSON payload from an API or message queue) to an Agent.
  • Maintain conversational state across multiple invocations using a sessionId.
  • Select the target Agent and Agent Alias either from browse-time discovery or dynamically at runtime.

For more information, refer What is Amazon Bedrock? - Amazon Bedrock

Benefits

  • Simplified access to multiple Bedrock model families (foundation and custom) through a single connector
  • Dynamic browsing of available models filtered by output modality (Text, Image, Embedding)
  • Secure AWS SigV4 request signing with support for Access Keys and IAM Roles Anywhere
  • Consistent request/response handling with JSON profiles aligned to model schemas
  • Per-document invocation model for easy scaling and process control

Prerequisites

Runtime Environment
  • A Boomi Runtime (basic runtime, runtime cluster, or runtime cloud) is installed and running.
AWS Account Requirements
  • An AWS account with access to Amazon Bedrock in the target AWS Region.
  • Amazon Bedrock is enabled for the selected Region.
Credentials
  • Configure one of the following authentication methods in the connector connection:
  • AWS Access Key ID and Secret Access Key
  • IAM Roles Anywhere profile with a client certificate and private key
IAM Permissions
  • The AWS IAM user or role used by the connector must have sufficient permissions to access Amazon Bedrock APIs.
    • Users with full Amazon Bedrock access (for example, using the AmazonBedrockFullAccess managed policy or an equivalent custom policy) require no additional configuration.
    • Users with restricted or limited Bedrock permissions (for example, using the AmazonBedrockLimitedAccess managed policy or an equivalent custom policy) must be explicitly granted access to all Bedrock APIs used by the connector.
note

If the IAM principal does not have permission to invoke Bedrock Agents (bedrock:InvokeAgent), Agent-based operations will fail with an HTTP 403 Forbidden error.

Required IAM Policy for Bedrock Agent Access

For accounts with restricted Bedrock permissions, attach an inline IAM policy that allows invoking Bedrock Agents. Paste the following JSON policy:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "AllowBoomiToInvokeAgent",
            "Effect": "Allow",
            "Action": "bedrock:InvokeAgent",
            "Resource": [
                "arn:aws:bedrock:::agent/*",
                "arn:aws:bedrock:::agent-alias/*"
            ]
        }
    ]
}

After adding the policy:

  1. Proceed to the next step in the policy editor.
  2. Provide a policy name (for example, BoomiBedrockAgentAccess).
  3. Create and attach the policy to the IAM user or role used by the connector.

Connector configuration

To configure the connector, create these reusable components and then add them to your process:

  • Amazon Bedrock connection
  • Amazon Bedrock operations (Generate, Converse)

After you build the connection and operation, place the connector step in your process and map the request/response as required by your use case.

Supported versions and SDKs

  • Boomi Connector SDK: 2.25.0
  • Java: 8
  • Uses Boomi AWS utilities for AWS SigV4 signing

Video: Using Amazon Bedrock Connector

This video provides a step-by-step overview of generating a Shopify order summary using the Amazon Bedrock connector.

Business Use Cases Supported

  • Generate high-quality product descriptions, marketing copies, emails, chat responses, or support message drafts from business input text.
  • Automatically summarize long documents (contracts, reports, emails, tickets) into concise insights using text-generation models.
  • Create product visuals, marketing banners, concept designs, and rapid UI/UX prototypes using AI-generated images.
  • Produce semantic embeddings from documents, products, or knowledge-base content to enable intelligent search, similarity matching, and recommendations.
  • Build intelligent chatbots and virtual assistants that maintain conversation context for HR, IT helpdesk, support, onboarding, and workflow guidance.
  • Enable interactive data-driven assistants for multi-turn interactions in CRM, ERP, and enterprise applications to help users query, explore information, and take guided actions.

Known Limitations

  • Latency: The performance of the Invoke Model operation is primarily dependent on the latency of the Amazon Bedrock service and the complexity of the request. Response times can range from milliseconds to several seconds.
  • Rate Limiting: All calls are subject to AWS Bedrock's API rate limits. If a process exceeds these limits, the API will return an HTTP 429 Too Many Requests error. The connector will report this as an exception.
  • Resource Limits: Subject to AWS Bedrock service quotas (e.g., tokens per request, requests per second per model).
  • Memory: The connector processes request and response payloads in memory. Very large payloads (megabytes) could impact the memory usage of the Boomi Atom.
  • Payload Size: Limited by Bedrock API payload size limits for both request and response bodies.
  • Streaming: Streaming outputs are handled as a single response payload; very large outputs may require Atom resource tuning.
  • Application Inference profile: Not supported.
  • Provisioned throughput models: Not supported.

Best Practices

Performance Optimization

  • Select the appropriate foundation model based on the use case (lighter models for simple tasks, larger models for complex reasoning).
  • Configure inference parameters (such as max tokens, temperature, and top-p) to control response size, quality, and latency.
  • Reuse agent sessions for multi-turn interactions instead of creating a new session for each request.
  • Delegate orchestration and reasoning to Amazon Bedrock Agents to reduce complexity within Boomi processes.
  • Generate a single image per request, as generating multiple images in a single operation may impact Runtime memory utilization.

Cost Management

  • Monitor token usage and inference metrics using Amazon CloudWatch.
  • Use lower-cost models during development and testing.
  • Limit context size by sending only the data required for the request.
  • Implement caching for repeated queries.
  • Configure AWS budgets and cost alerts to track Amazon Bedrock usage.

Security

  • Use IAM roles with least-privilege permissions to access Amazon Bedrock.
  • Store AWS credentials securely using Boomi Platform credential management.
  • Validate and sanitize all inputs before invoking models or agents.
  • Avoid logging prompts or model responses that may contain sensitive data.
  • Apply Bedrock Agent guardrails (if configured) to enforce safety and compliance requirements.

Error Handling

  • Always implement retry logic for transient errors.
  • Use exponential backoff for throttling and rate-limit errors.
  • Log errors with request IDs and error codes for troubleshooting.
  • Configure appropriate timeouts based on expected response size and complexity.
  • Handle empty or partial responses gracefully in downstream processing.

When to Use the Invoke Agent Operation

Use Invoke Agent when:

  • You have configured an Amazon Bedrock Agent (with instructions, knowledge bases, tools, etc.) and want Boomi to delegate orchestration or decision-making to that Agent.
  • You need conversation/session continuity (for example, multi-turn workflows) handled by the Agent rather than by your Boomi process.
  • You want runtime flexibility to change which Agent or alias is invoked using Dynamic Operation Properties.

Best Practices for Using Invoke Agent

Design clear responsibilities

  • Let the Agent handle orchestration and reasoning.
  • Let Boomi handle integration, routing, and data transformation.

Manage sessions explicitly

  • Persist sessionId from the outbound document.
  • Reuse for multi-turn workflows.
  • Create a new session to reset context.
On this Page