Introduction

Bedrock is an innovative AI platform developed by Amazon that enables developers to build and deploy machine learning models with ease. With Bedrock, developers can leverage pre-trained models for various tasks, including image generation, natural language processing, and more. In this blog post, we’ll explore how to use the Bedrock Titan model with Spring Boot to generate image variations.

What is Bedrock?

Bedrock is a cloud-based AI platform that provides a suite of pre-trained models for various AI tasks. These models are optimized for performance and can be easily integrated into applications using the Bedrock SDK. Bedrock supports multiple model types, including:

• Titan: A text-to-image model capable of generating high-quality images from text prompts.
• Luna: A conversational AI model for natural language processing tasks.
• Aurora: An image classification model for computer vision tasks.

Using Bedrock with Spring Boot

To use Bedrock with Spring Boot, we’ll need to add the following dependencies to our pom.xml file:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>bedrock</artifactId>
    <version>2.27.17</version>
</dependency>
<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>bedrockruntime</artifactId>
    <version>2.27.17</version>
</dependency>

Note: Before using the Bedrock Titan model, ensure that it is activated in your AWS account.

Next, we’ll create a configuration bean to set up the Bedrock Runtime client:

@Bean
public BedrockRuntimeClient bedrockRuntimeClient() {
    return BedrockRuntimeClient.builder()
            .region(Region.of("us-east-1"))
            .credentialsProvider(awsCredentialsProvider())
            .build();
}

private AwsCredentialsProvider awsCredentialsProvider() {
    return create(AwsBasicCredentials.create("awsAccessKey", "awssecretKey"));
}

Image Variation with Bedrock Titan Model

To generate image variations using the Bedrock Titan model, we’ll create a service method that takes an ImageCreateRequestDto object as input:

    /**
     * Generates an AI image based on the provided prompt.
     *
     * @param imageCreateRequestDto Contains the request details for generating the AI image.
     * @return A JSON string containing the generated image data.
     */
    public String generateAiImage(ImageCreateRequestDto imageCreateRequestDto) {
        log.info("Request received to generate AI image for prompt: {}", imageCreateRequestDto.getPrompt());

        // Define the model ID for the AI image generator
        var modelId = "amazon.titan-image-generator-v2:0";

        // Create a native Bedrock request from the input DTO
        var nativeRequest = createNativeBedrockRequest(imageCreateRequestDto);

        try {
            log.info("Sending Bedrock request prompt");

            // Invoke the Bedrock model with the encoded request
            var response = bedrockRuntimeClient.invokeModel(request -> request
                    .body(SdkBytes.fromUtf8String(nativeRequest))
                    .modelId(modelId)
            );

            log.info("Bedrock response received");

            // Decode the response body
            var responseBody = new JSONObject(response.body().asUtf8String());

            // Extract and format the generated image data
            var responseJsonObject = new JSONObject();
            for (int i = 1; i <= 4; i++) {
                responseJsonObject.put("image" + i, new JSONPointer("/images/" + (i - 1)).queryFrom(responseBody).toString());
            }

            // Return the formatted image data as a JSON string
            return responseJsonObject.toString();
        } catch (Exception e) {
            log.error("ERROR: Can't invoke {}. Reason: {}", modelId, e.getMessage(), e);
            return "";
        }
    }

/**
 * Creates a native Bedrock request from the provided AI image creation request DTO.
 *
 * @param imageCreateRequestDto Contains the request details for generating the AI image.
 * @return A JSON string representing the native Bedrock request.
 */
private String createNativeBedrockRequest(ImageCreateRequestDto imageCreateRequestDto) {
    // Define the native Bedrock request template
    var nativeRequestTemplate = """
        {
            "taskType": "IMAGE_VARIATION",
            "imageVariationParams": {
                "text": "{{PROMPT}}",
                "negativeText": "{{NEGATIVE_PROMPT}}",
                "images": ["{{BASE64_ENCODED_FIRST_IMAGE}}"],
                "similarityStrength": 0.8
            },
            "imageGenerationConfig": {
                "numberOfImages": 4,
                "height": 512,
                "width": 512,
                "cfgScale": 8
            }
        }
    """;

    // Replace placeholders with actual values
    return nativeRequestTemplate
            .replace("{{BASE64_ENCODED_FIRST_IMAGE}}", Optional.ofNullable(firstImageBase64Data).orElse(""))
            .replace("{{NEGATIVE_PROMPT}}", Optional.ofNullable(negativePrompt).orElse("no nudity"))
            .replace("{{PROMPT}}", imageCreateRequestDto.getPrompt());
}

Pros and Cons of Using Bedrock

Pros

1. Pre-trained models: Bedrock provides pre-trained models for various AI tasks, saving development time.
2. Scalability: Bedrock is designed for cloud-scale deployments, ensuring high performance and reliability.
3. Easy integration: Bedrock’s SDKs and APIs simplify integration with existing applications.
4. Cost-effective: Bedrock’s pricing model is competitive, especially for large-scale deployments.
5. Security: Bedrock ensures secure data processing and storage.

Cons

1. Limited customization: Pre-trained models may not be fully customizable for specific use cases.
2. Dependence on Amazon: Bedrock is tightly coupled with Amazon Web Services, limiting flexibility.
3. Cost complexity: Pricing can be complex, leading to unexpected costs.
4. Limited support: Community support and documentation may be limited compared to other platforms.
5. Vendor lock-in: Dependence on Bedrock may limit migration to alternative platforms.

Conclusion

Bedrock offers a compelling solution for developers seeking to integrate pre-trained AI models into their applications. While it has limitations, its scalability, ease of integration, and cost-effectiveness make it an attractive choice. When evaluating Bedrock versus Singularity, consider factors like model customization, platform flexibility, and community support.