Refactor InvokeModel and add Converse

Author: DennisTraub

kotlin/services/bedrock-runtime/build.gradle.kts

@@ -1,54 +1,40 @@
 plugins {
     kotlin("jvm") version "2.1.10"
-    id("org.jetbrains.kotlin.plugin.serialization") version "2.1.10"
-    id("org.jlleitschuh.gradle.ktlint") version "11.3.1" apply true
+    kotlin("plugin.serialization") version "2.1.10"
+    id("org.jlleitschuh.gradle.ktlint") version "12.1.1"
     application
 }
 
 group = "com.example.bedrockruntime"
 version = "1.0-SNAPSHOT"
 
+val awsSdkVersion = "1.4.27"
+val junitVersion = "5.12.0"
+
 repositories {
     mavenCentral()
 }
 
-buildscript {
-    repositories {
-        maven("https://plugins.gradle.org/m2/")
-    }
-    dependencies {
-        classpath("org.jlleitschuh.gradle:ktlint-gradle:11.3.1")
-    }
-}
-
 dependencies {
-    implementation("aws.sdk.kotlin:bedrockruntime:1.4.11")
+    implementation("aws.sdk.kotlin:bedrockruntime:$awsSdkVersion")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json-jvm:1.8.0")
-    testImplementation("org.junit.jupiter:junit-jupiter:5.11.4")
-}
 
-application {
-    mainClass.set("com.example.bedrockruntime.InvokeModelKt")
+    testImplementation("org.junit.jupiter:junit-jupiter:$junitVersion")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
-// Java and Kotlin configuration
 kotlin {
     jvmToolchain(21)
 }
 
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(21)
-    }
-}
-
 tasks.test {
     useJUnitPlatform()
     testLogging {
         events("passed", "skipped", "failed")
     }
-
-    // Define the test source set
-    testClassesDirs += files("build/classes/kotlin/test")
-    classpath += files("build/classes/kotlin/main", "build/resources/main")
 }
+
+application {
+    mainClass.set("com.example.bedrockruntime.InvokeModelKt")
+}

kotlin/services/bedrock-runtime/src/main/kotlin/com/example/bedrockruntime/InvokeModel.kt

@@ -0,0 +1,81 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.example.bedrockruntime.models.amazon.nova.text
+
+// snippet-start:[bedrock-runtime.kotlin.Converse_AmazonNovaText]
+
+import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
+import aws.sdk.kotlin.services.bedrockruntime.model.ContentBlock
+import aws.sdk.kotlin.services.bedrockruntime.model.ConversationRole
+import aws.sdk.kotlin.services.bedrockruntime.model.ConverseRequest
+import aws.sdk.kotlin.services.bedrockruntime.model.Message
+
+/**
+ * This example demonstrates how to use the Amazon Nova foundation models to generate text.
+ * It shows how to:
+ * - Set up the Amazon Bedrock runtime client
+ * - Create a message
+ * - Configure and send a request
+ * - Process the response
+ *
+ * @throws RuntimeException if the model invocation fails
+ */
+suspend fun main() {
+    converse().also { println(it) }
+}
+
+suspend fun converse(): String {
+    // Step 1: Create the Amazon Bedrock runtime client
+    // The runtime client handles the communication with AI models on Amazon Bedrock
+    BedrockRuntimeClient { region = "us-east-1" }.use { client ->
+
+        // Step 2: Specify which model to use
+        // Available Amazon Nova models and their characteristics:
+        // - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
+        // - Amazon Nova Lite:  Fast, low-cost multimodal model for image, video, and text
+        // - Amazon Nova Pro:   Advanced multimodal model balancing accuracy, speed, and cost
+        //
+        // For the latest available models, see:
+        // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+        val modelId = "amazon.nova-lite-v1:0"
+
+        // Step 3: Create the message
+        // The message includes the text prompt and specifies that it comes from the user
+        val inputText = "Describe the purpose of a 'hello world' program in one line."
+        val message = Message {
+            role = ConversationRole.User
+            content = listOf(ContentBlock.Text(inputText))
+        }
+
+        // Step 4: Configure the request
+        // Optional parameters to control the model's response:
+        // - maxTokens: maximum number of tokens to generate
+        // - temperature: randomness (max: 1.0, default: 0.7)
+        //   OR
+        // - topP: diversity of word choice (max: 1.0, default: 0.9)
+        // Note: Use either temperature OR topP, but not both
+        val request = ConverseRequest {
+            this.modelId = modelId
+            messages = listOf(message)
+            inferenceConfig {
+                maxTokens = 500     // The maximum response length
+                temperature = 0.5F  // Using temperature for randomness control
+                // topP = 0.8F      // Alternative: use topP instead of temperature
+            }
+        }
+
+        // Step 5: Send and process the request
+        // - Send the request to the model
+        // - Extract and return the generated text
+        runCatching {
+            val response = client.converse(request)
+            return response.output!!.asMessage().content.first().asText()
+
+        }.getOrElse { error ->
+            error.message?.let { e -> System.err.println("ERROR: Can't invoke '$modelId'. Reason: $e") }
+            throw RuntimeException("Failed to generate text with model $modelId", error)
+        }
+    }
+}
+// snippet-end:[bedrock-runtime.kotlin.Converse_AmazonNovaText]

kotlin/services/bedrock-runtime/src/main/kotlin/com/example/bedrockruntime/models/amazon/nova/text/Converse.kt

@@ -0,0 +1,101 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.example.bedrockruntime.models.amazon.titan.text
+
+// snippet-start:[bedrock-runtime.kotlin.InvokeModel_AmazonTitanText]
+
+import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
+import aws.sdk.kotlin.services.bedrockruntime.model.InvokeModelRequest
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+/**
+ * This example demonstrates how to use the Amazon Titan foundation models to generate text.
+ * It shows how to:
+ * - Set up the Amazon Bedrock runtime client
+ * - Create a request payload
+ * - Configure and send a request
+ * - Process the response
+ *
+ * @throws RuntimeException if the model invocation fails
+ */
+suspend fun main() {
+    invokeModel().also { println(it) }
+}
+
+// Initialize JSON parser with relaxed configuration
+private val json = Json { ignoreUnknownKeys = true }
+
+suspend fun invokeModel(): String {
+    // Step 1: Create the Amazon Bedrock runtime client
+    // The runtime client handles the communication with AI models on Amazon Bedrock
+    BedrockRuntimeClient { region = "us-east-1" }.use { client ->
+
+        // Step 2: Specify which model to use
+        // Available Amazon Titan models and their characteristics:
+        // - Titan Text Lite: Fast, cost-effective text generation
+        // - Titan Text Express: Balanced performance and cost
+        // - Titan Text Large: Advanced capabilities for complex tasks
+        //
+        // For the latest available models, see:
+        // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
+        val modelId = "amazon.titan-text-lite-v1"
+
+        // Step 3: Create the request payload
+        // Optional parameters to control the model's response:
+        // - maxTokenCount: maximum number of tokens to generate
+        // - temperature: randomness (max: 1.0, default: 0.7)
+        //   OR
+        // - topP: diversity of word choice (max: 1.0, default: 0.9)
+        // Note: Use either temperature OR topP, but not both
+        //
+        // For detailed parameter descriptions, see:
+        // https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-text.html
+        val prompt = "Describe the purpose of a 'hello world' program in one line."
+        val request = """
+            {
+                "inputText": "$prompt",
+                "textGenerationConfig": {
+                    "maxTokenCount": 500,
+                    "temperature": 0.5
+                }
+            }
+        """.trimIndent()
+
+        // Step 4: Send and process the request
+        // - Send the request to the model
+        // - Parse the JSON response
+        // - Extract and return the generated text
+        runCatching {
+            // Send the request to the model
+            val response = client.invokeModel(InvokeModelRequest {
+                this.modelId = modelId
+                body = request.toByteArray()
+            })
+
+            // Convert the response bytes to a JSON string
+            val jsonResponse = response.body.toString(Charsets.UTF_8)
+
+            // Parse the JSON into a Kotlin object
+            val parsedResponse = json.decodeFromString<BedrockResponse>(jsonResponse)
+
+            // Extract and return the generated text
+            return parsedResponse.results.firstOrNull()!!.outputText
+
+        }.getOrElse { error ->
+            error.message?.let { msg ->
+                System.err.println("ERROR: Can't invoke '$modelId'. Reason: $msg")
+            }
+            throw RuntimeException("Failed to generate text with model $modelId", error)
+        }
+    }
+}
+
+@Serializable
+private data class BedrockResponse(val results: List<Result>)
+
+@Serializable
+private data class Result(val outputText: String)
+
+// snippet-end:[bedrock-runtime.kotlin.InvokeModel_AmazonTitanText]