SDK for Kotlin을 사용한 Amazon Bedrock 런타임 예제

다음 코드 예제에서는 Amazon Bedrock 런타임과 함께 AWS SDK for Kotlin을 사용하여 작업을 수행하고 일반적인 시나리오를 구현하는 방법을 보여줍니다.

각 예시에는 전체 소스 코드에 대한 링크가 포함되어 있으며, 여기에서 컨텍스트에 맞춰 코드를 설정하고 실행하는 방법에 대한 지침을 찾을 수 있습니다.

Amazon Nova

Converse

다음 코드 예제에서는 Bedrock의 Converse API를 사용하여 Amazon Nova로 텍스트 메시지를 전송하는 방법을 보여줍니다.

SDK for Kotlin

참고

GitHub에 더 많은 내용이 있습니다. AWS 코드 예제 리포지토리에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.

Bedrock의 Converse API를 사용하여 Amazon Nova로 텍스트 메시지를 전송합니다.

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
 */
suspend fun main() {
    converse().also { println(it) }
}

suspend fun converse(): String {
    // Create and configure the Bedrock runtime client
    BedrockRuntimeClient { region = "us-east-1" }.use { client ->

        // Specify the model ID. For the latest available models, see:
        // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
        val modelId = "amazon.nova-lite-v1:0"

        // Create the message with the user's prompt
        val prompt = "Describe the purpose of a 'hello world' program in one line."
        val message = Message {
            role = ConversationRole.User
            content = listOf(ContentBlock.Text(prompt))
        }

        // Configure the request with optional model parameters
        val request = ConverseRequest {
            this.modelId = modelId
            messages = listOf(message)
            inferenceConfig {
                maxTokens = 500 // Maximum response length
                temperature = 0.5F // Lower values: more focused output
                // topP = 0.8F // Alternative to temperature
            }
        }

        // Send the request and process the model's response
        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)
        }
    }
}

• API 세부 정보는 AWS SDK for Kotlin API 참조의 Converse를 참조하세요.

ConverseStream

다음 코드 예제에서는 Bedrock의 Converse API를 사용하여 Amazon Nova에 텍스트 메시지를 전송하고 응답 스트림을 실시간으로 처리하는 방법을 보여줍니다.

SDK for Kotlin

참고

GitHub에 더 많은 내용이 있습니다. AWS 코드 예제 리포지토리에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.

Bedrock의 Converse API를 사용하여 Amazon Nova로 텍스트 메시지를 전송하고 응답 스트림을 실시간으로 처리합니다.

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.ConverseStreamOutput
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseStreamRequest
import aws.sdk.kotlin.services.bedrockruntime.model.Message

/**
 * This example demonstrates how to use the Amazon Nova foundation models
 * to generate streaming text responses.
 * It shows how to:
 * - Set up the Amazon Bedrock runtime client
 * - Create a message with a prompt
 * - Configure a streaming request with parameters
 * - Process the response stream in real time
 */
suspend fun main() {
    converseStream()
}

suspend fun converseStream(): String {
    // A buffer to collect the complete response
    val completeResponseBuffer = StringBuilder()

    // Create and configure the Bedrock runtime client
    BedrockRuntimeClient { region = "us-east-1" }.use { client ->

        // Specify the model ID. For the latest available models, see:
        // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
        val modelId = "amazon.nova-lite-v1:0"

        // Create the message with the user's prompt
        val prompt = "Describe the purpose of a 'hello world' program in a paragraph."
        val message = Message {
            role = ConversationRole.User
            content = listOf(ContentBlock.Text(prompt))
        }

        // Configure the request with optional model parameters
        val request = ConverseStreamRequest {
            this.modelId = modelId
            messages = listOf(message)
            inferenceConfig {
                maxTokens = 500 // Maximum response length
                temperature = 0.5F // Lower values: more focused output
                // topP = 0.8F // Alternative to temperature
            }
        }

        // Process the streaming response
        runCatching {
            client.converseStream(request) { response ->
                response.stream?.collect { chunk ->
                    when (chunk) {
                        is ConverseStreamOutput.ContentBlockDelta -> {
                            // Process each text chunk as it arrives
                            chunk.value.delta?.asText()?.let { text ->
                                print(text)
                                System.out.flush() // Ensure immediate output
                                completeResponseBuffer.append(text)
                            }
                        }
                        else -> {} // Other output block types can be handled as needed
                    }
                }
            }
        }.onFailure { 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", error)
        }
    }

    return completeResponseBuffer.toString()
}

• API 세부 정보는 AWS SDK for Kotlin API 참조의 ConverseStream을 참조하세요.

Amazon Titan Text

InvokeModel

다음 코드 예제에서는 Invoke Model API를 사용하여 Amazon Titan Text에 텍스트 메시지를 보내는 방법을 보여줍니다.

SDK for Kotlin

참고

GitHub에 더 많은 내용이 있습니다. AWS 코드 예제 리포지토리에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.

Invoke Model API를 사용하여 짧은 스토리를 생성합니다.

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
 */
suspend fun main() {
    invokeModel().also { println(it) }
}

// Data class for parsing the model's response
@Serializable
private data class BedrockResponse(val results: List<Result>) {
    @Serializable
    data class Result(
        val outputText: String,
    )
}

// Initialize JSON parser with relaxed configuration
private val json = Json { ignoreUnknownKeys = true }

suspend fun invokeModel(): String {
    // Create and configure the Bedrock runtime client
    BedrockRuntimeClient { region = "us-east-1" }.use { client ->

        // Specify the model ID. For the latest available models, see:
        // https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
        val modelId = "amazon.titan-text-lite-v1"

        // Create the request payload with optional configuration parameters
        // 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()

        // Send the request and process the model's response
        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)
        }
    }
}

• API 세부 정보는 AWS SDK for Kotlin API 참조의 InvokeModel을 참조하세요.