Ada lebih banyak contoh AWS SDK yang tersedia di repo Contoh [SDK AWS Doc](https://github.com/awsdocs/aws-doc-sdk-examples). GitHub
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh dasar untuk Amazon Bedrock Agents Runtime menggunakan AWS SDKs
Contoh kode berikut menunjukkan cara menggunakan dasar-dasar Amazon Bedrock Agents Runtime dengan. AWS SDKs
**Contents**
+ [Pelajari dasar-dasarnya](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Tindakan](bedrock-agent-runtime_code_examples_actions.md)
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
# Berkomunikasi dengan aliran Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan InvokeFlow untuk berkomunikasi dengan aliran Amazon Bedrock yang menyertakan node agen.
Untuk informasi selengkapnya, [lihat Berbicara dengan alur Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/flows-multi-turn-invocation.html).
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
```
"""
Shows how to run an Amazon Bedrock flow with InvokeFlow and handle muli-turn interaction
for a single conversation.
For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-multi-turn-invocation.html.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to invoke.
flow_alias_id: The alias ID of the flow.
input_data: Input data for the flow.
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
# Log trace events.
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
def converse_with_flow(bedrock_agent_client, flow_id, flow_alias_id):
"""
Run a conversation with the supplied flow.
Args:
bedrock_agent_client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to run.
flow_alias_id: The alias ID of the flow.
"""
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
# Use prompt to create input data.
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, flow_id, flow_alias_id, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", flow_id)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", flow_id)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
def main():
"""
Main entry point for the script.
"""
# Replace these with your actual flow ID and flow alias ID.
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
logger.info("Starting conversation with FLOW: %s ID: %s",
FLOW_ID, FLOW_ALIAS_ID)
# Get the Bedrock agent runtime client.
session = boto3.Session(profile_name='default')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Start the conversation.
converse_with_flow(bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID)
logger.info("Conversation with FLOW: %s ID: %s finished",
FLOW_ID, FLOW_ALIAS_ID)
if __name__ == "__main__":
main()
```
+ Untuk detail API, lihat [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Tindakan untuk Amazon Bedrock Agents Runtime menggunakan AWS SDKs
Contoh kode berikut menunjukkan cara melakukan tindakan Runtime Amazon Bedrock Agents individual dengan. AWS SDKs Setiap contoh menyertakan tautan ke GitHub, di mana Anda dapat menemukan instruksi untuk mengatur dan menjalankan kode.
Kutipan ini memanggil Amazon Bedrock Agents Runtime API dan merupakan kutipan kode dari program yang lebih besar yang harus dijalankan dalam konteks. Anda dapat melihat tindakan dalam konteks di[Skenario untuk Amazon Bedrock Agents Runtime menggunakan AWS SDKs](bedrock-agent-runtime_code_examples_scenarios.md).
Contoh berikut hanya mencakup tindakan yang paling umum digunakan. Untuk daftar lengkapnya, lihat Referensi [API Amazon Bedrock Agents Runtime](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_Operations_Agents_for_Amazon_Bedrock_Runtime.html).
**Topics**
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
# Gunakan `InvokeAgent` dengan AWS SDK
Contoh kode berikut menunjukkan cara menggunakan`InvokeAgent`.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples).
```
import {
BedrockAgentRuntimeClient,
InvokeAgentCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";
/**
* @typedef {Object} ResponseBody
* @property {string} completion
*/
/**
* Invokes a Bedrock agent to run an inference using the input
* provided in the request body.
*
* @param {string} prompt - The prompt that you want the Agent to complete.
* @param {string} sessionId - An arbitrary identifier for the session.
*/
export const invokeBedrockAgent = async (prompt, sessionId) => {
const client = new BedrockAgentRuntimeClient({ region: "us-east-1" });
// const client = new BedrockAgentRuntimeClient({
// region: "us-east-1",
// credentials: {
// accessKeyId: "accessKeyId", // permission to invoke agent
// secretAccessKey: "accessKeySecret",
// },
// });
const agentId = "AJBHXXILZN";
const agentAliasId = "AVKP1ITZAA";
const command = new InvokeAgentCommand({
agentId,
agentAliasId,
sessionId,
inputText: prompt,
});
try {
let completion = "";
const response = await client.send(command);
if (response.completion === undefined) {
throw new Error("Completion is undefined");
}
for await (const chunkEvent of response.completion) {
const chunk = chunkEvent.chunk;
console.log(chunk);
const decodedResponse = new TextDecoder("utf-8").decode(chunk.bytes);
completion += decodedResponse;
}
return { sessionId: sessionId, completion };
} catch (err) {
console.error(err);
}
};
// Call function if run directly
import { fileURLToPath } from "node:url";
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const result = await invokeBedrockAgent("I need help.", "123");
console.log(result);
}
```
+ Untuk detail API, lihat [InvokeAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeAgentCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
Meminta agen.
```
def invoke_agent(self, agent_id, agent_alias_id, session_id, prompt):
"""
Sends a prompt for the agent to process and respond to.
:param agent_id: The unique identifier of the agent to use.
:param agent_alias_id: The alias of the agent to use.
:param session_id: The unique identifier of the session. Use the same value across requests
to continue the same conversation.
:param prompt: The prompt that you want Claude to complete.
:return: Inference response from the model.
"""
try:
# Note: The execution time depends on the foundation model, complexity of the agent,
# and the length of the prompt. In some cases, it can take up to a minute or more to
# generate a response.
response = self.agents_runtime_client.invoke_agent(
agentId=agent_id,
agentAliasId=agent_alias_id,
sessionId=session_id,
inputText=prompt,
)
completion = ""
for event in response.get("completion"):
chunk = event["chunk"]
completion = completion + chunk["bytes"].decode()
except ClientError as e:
logger.error(f"Couldn't invoke agent. {e}")
raise
return completion
```
+ Untuk detail API, lihat [InvokeAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeAgent)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Rust ]
**SDK for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-agent-runtime#code-examples).
```
use aws_config::{BehaviorVersion, SdkConfig};
use aws_sdk_bedrockagentruntime::{
self as bedrockagentruntime,
types::{error::ResponseStreamError, ResponseStream},
};
#[allow(unused_imports)]
use mockall::automock;
const BEDROCK_AGENT_ID: &str = "AJBHXXILZN";
const BEDROCK_AGENT_ALIAS_ID: &str = "AVKP1ITZAA";
const BEDROCK_AGENT_REGION: &str = "us-east-1";
#[cfg(not(test))]
pub use EventReceiverImpl as EventReceiver;
#[cfg(test)]
pub use MockEventReceiverImpl as EventReceiver;
pub struct EventReceiverImpl {
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
}
#[cfg_attr(test, automock)]
impl EventReceiverImpl {
#[allow(dead_code)]
pub fn new(
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
) -> Self {
Self { inner }
}
pub async fn recv(
&mut self,
) -> Result<
Option,
aws_sdk_bedrockagentruntime::error::SdkError<
ResponseStreamError,
aws_smithy_types::event_stream::RawMessage,
>,
> {
self.inner.recv().await
}
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let result = invoke_bedrock_agent("I need help.".to_string(), "123".to_string()).await?;
println!("{}", result);
Ok(())
}
async fn invoke_bedrock_agent(
prompt: String,
session_id: String,
) -> Result {
let sdk_config: SdkConfig = aws_config::defaults(BehaviorVersion::latest())
.region(BEDROCK_AGENT_REGION)
.load()
.await;
let bedrock_client = bedrockagentruntime::Client::new(&sdk_config);
let command_builder = bedrock_client
.invoke_agent()
.agent_id(BEDROCK_AGENT_ID)
.agent_alias_id(BEDROCK_AGENT_ALIAS_ID)
.session_id(session_id)
.input_text(prompt);
let response = command_builder.send().await?;
let response_stream = response.completion;
let event_receiver = EventReceiver::new(response_stream);
process_agent_response_stream(event_receiver).await
}
async fn process_agent_response_stream(
mut event_receiver: EventReceiver,
) -> Result {
let mut full_agent_text_response = String::new();
while let Some(event_result) = event_receiver.recv().await? {
match event_result {
ResponseStream::Chunk(chunk) => {
if let Some(bytes) = chunk.bytes {
match String::from_utf8(bytes.into_inner()) {
Ok(text_chunk) => {
full_agent_text_response.push_str(&text_chunk);
}
Err(e) => {
eprintln!("UTF-8 decoding error for chunk: {}", e);
}
}
}
}
_ => {
panic!("received an unhandled event type from Bedrock stream",);
}
}
}
Ok(full_agent_text_response)
}
#[cfg(test)]
mod test {
use super::*;
#[tokio::test]
async fn test_process_agent_response_stream() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Chunk(
aws_sdk_bedrockagentruntime::types::PayloadPart::builder()
.set_bytes(Some(aws_smithy_types::Blob::new(vec![
116, 101, 115, 116, 32, 99, 111, 109, 112, 108, 101, 116, 105, 111, 110,
])))
.build(),
),
))
});
// end the stream
mock.expect_recv().times(1).returning(|| Ok(None));
let response = process_agent_response_stream(mock).await.unwrap();
assert_eq!("test completion", response);
}
#[tokio::test]
#[should_panic(expected = "received an unhandled event type from Bedrock stream")]
async fn test_process_agent_response_stream_error() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Trace(
aws_sdk_bedrockagentruntime::types::TracePart::builder().build(),
),
))
});
let _ = process_agent_response_stream(mock).await.unwrap();
}
}
```
+ Untuk detail API, lihat [InvokeAgent](https://docs.rs/aws-sdk-bedrockagentruntime/latest/aws_sdk_bedrockagentruntime/client/struct.Client.html#method.invoke_agent)*referensi AWS SDK for Rust API*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdz#code-examples).
```
DATA(lo_result) = lo_bdz->invokeagent(
iv_agentid = iv_agentid
iv_agentaliasid = iv_agentaliasid
iv_enabletrace = abap_true
iv_sessionid = CONV #( cl_system_uuid=>create_uuid_c26_static( ) )
iv_inputtext = |Let's play "rock, paper, scissors". I choose rock.| ).
DATA(lo_stream) = lo_result->get_completion( ).
TRY.
" loop while there are still events in the stream
WHILE lo_stream->/aws1/if_rt_stream_reader~data_available( ) = abap_true.
DATA(lo_evt) = lo_stream->read( ).
" each /AWS1/CL_BDZRESPONSESTREAM_EV event contains exactly one member
" all others are INITIAL. For each event, process the non-initial
" member if desired
IF lo_evt->get_chunk( ) IS NOT INITIAL.
" Process a Chunk event
DATA(lv_xstr) = lo_evt->get_chunk( )->get_bytes( ).
DATA(lv_answer) = /aws1/cl_rt_util=>xstring_to_string( lv_xstr ).
" the answer says something like "I chose paper, so you lost"
ELSEIF lo_evt->get_files( ) IS NOT INITIAL.
" process a Files event if desired
ELSEIF lo_evt->get_returncontrol( ) IS NOT INITIAL.
" process a ReturnControl event if desired
ELSEIF lo_evt->get_trace( ) IS NOT INITIAL.
" process a Trace event if desired
ENDIF.
ENDWHILE.
" the stream of events can possibly contain an exception
" which will be raised to break the loop
" catch /AWS1/CX_BDZACCESSDENIEDEX.
" catch /AWS1/CX_BDZINTERNALSERVEREX.
" catch /AWS1/CX_BDZMODELNOTREADYEX.
" catch /AWS1/CX_BDZVALIDATIONEX.
" catch /AWS1/CX_BDZTHROTTLINGEX.
" catch /AWS1/CX_BDZDEPENDENCYFAILEDEX.
" catch /AWS1/CX_BDZBADGATEWAYEX.
" catch /AWS1/CX_BDZRESOURCENOTFOUNDEX.
" catch /AWS1/CX_BDZSERVICEQUOTAEXCDEX.
" catch /AWS1/CX_BDZCONFLICTEXCEPTION.
ENDTRY.
```
+ Untuk detail API, lihat [InvokeAgent](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)di *AWS SDK untuk referensi SAP ABAP* API.
------
# Gunakan `InvokeFlow` dengan AWS SDK
Contoh kode berikut menunjukkan cara menggunakan`InvokeFlow`.
Contoh tindakan adalah kutipan kode dari program yang lebih besar dan harus dijalankan dalam konteks. Anda dapat melihat tindakan ini dalam konteks dalam contoh kode berikut:
+ [Pelajari dasar-dasarnya](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Buat dan panggil alur](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples).
```
import { fileURLToPath } from "node:url";
import {
BedrockAgentRuntimeClient,
InvokeFlowCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";
/**
* Invokes an alias of a flow to run the inputs that you specify and return
* the output of each node as a stream.
*
* @param {{
* flowIdentifier: string,
* flowAliasIdentifier: string,
* prompt?: string,
* region?: string
* }} options
* @returns {Promise} An object containing information about the output from flow invocation.
*/
export const invokeBedrockFlow = async ({
flowIdentifier,
flowAliasIdentifier,
prompt = "Hi, how are you?",
region = "us-east-1",
}) => {
const client = new BedrockAgentRuntimeClient({ region });
const command = new InvokeFlowCommand({
flowIdentifier,
flowAliasIdentifier,
inputs: [
{
content: {
document: prompt,
},
nodeName: "FlowInputNode",
nodeOutputName: "document",
},
],
});
let flowResponse = {};
const response = await client.send(command);
for await (const chunkEvent of response.responseStream) {
const { flowOutputEvent, flowCompletionEvent } = chunkEvent;
if (flowOutputEvent) {
flowResponse = { ...flowResponse, ...flowOutputEvent };
console.log("Flow output event:", flowOutputEvent);
} else if (flowCompletionEvent) {
flowResponse = { ...flowResponse, ...flowCompletionEvent };
console.log("Flow completion event:", flowCompletionEvent);
}
}
return flowResponse;
};
// Call function if run directly
import { parseArgs } from "node:util";
import {
isMain,
validateArgs,
} from "@aws-doc-sdk-examples/lib/utils/util-node.js";
const loadArgs = () => {
const options = {
flowIdentifier: {
type: "string",
required: true,
},
flowAliasIdentifier: {
type: "string",
required: true,
},
prompt: {
type: "string",
},
region: {
type: "string",
},
};
const results = parseArgs({ options });
const { errors } = validateArgs({ options }, results);
return { errors, results };
};
if (isMain(import.meta.url)) {
const { errors, results } = loadArgs();
if (!errors) {
invokeBedrockFlow(results.values);
} else {
console.error(errors.join("\n"));
}
}
```
+ Untuk detail API, lihat [InvokeFlow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeFlowCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
Memanggil aliran.
```
def invoke_flow(self, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
param flow_id: The ID of the flow to invoke.
param flow_alias_id: The alias ID of the flow.
param input_data: Input data for the flow.
param execution_id: Execution ID for continuing a flow. Use the value None on first run.
Return: Response from the flow.
"""
try:
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": input_data,
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": input_data,
"enableTrace": True
}
response = self.agents_runtime_client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
result = ""
# Get the streaming response
for event in response['responseStream']:
result = result + str(event) + '\n'
print(result)
except ClientError as e:
logger.error("Couldn't invoke flow %s.", {e})
raise
return result
```
+ Untuk detail API, lihat [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)di *AWS SDK for Python (Boto3) Referensi* API.
------