Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Berkomunikasi dengan aliran Amazon Bedrock
**catatan**
Percakapan multi-putaran Amazon Bedrock Flows sedang dalam rilis pratinjau untuk Amazon Bedrock dan dapat berubah sewaktu-waktu.
Percakapan multi-putaran Amazon Bedrock Flows memungkinkan back-and-forth percakapan dinamis antara pengguna dan arus, mirip dengan dialog alami. Ketika node agen memerlukan klarifikasi atau konteks tambahan, node tersebut dapat dengan cerdas menjeda eksekusi flow dan meminta pengguna untuk informasi spesifik. Ini menciptakan pengalaman yang lebih interaktif dan sadar konteks, karena node dapat menyesuaikan perilakunya berdasarkan respons pengguna. Misalnya, jika kueri pengguna awal ambigu atau tidak lengkap, node dapat mengajukan pertanyaan tindak lanjut untuk mengumpulkan detail yang diperlukan. Setelah pengguna memberikan informasi yang diminta, alur melanjutkan eksekusi dengan mulus dengan input yang diperkaya, memastikan hasil yang lebih akurat dan relevan. Kemampuan ini sangat berharga untuk skenario kompleks di mana interaksi tunggal mungkin tidak cukup untuk sepenuhnya memahami dan memenuhi kebutuhan pengguna.
**Topics**
+ [Cara memproses percakapan multi-putaran dalam aliran](#flows-multi-turn-invocation-how)
+ [Membuat dan menjalankan alur contoh](#flows-multi-turn-invocation-example-flow)
## Cara memproses percakapan multi-putaran dalam aliran
Untuk menggunakan percakapan multi-putaran dalam alur, Anda memerlukan [simpul agen](flows-nodes.md#flows-nodes-agent) yang terhubung ke agen Amazon Bedrock. Ketika Anda menjalankan alur, percakapan multi-putaran terjadi ketika agen membutuhkan informasi lebih lanjut dari pengguna sebelum dapat melanjutkan. Bagian ini menjelaskan aliran yang menggunakan agen dengan instruksi berikut:
```
You are a playlist creator for a radio station.
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.
```
Untuk informasi tentang membuat agen, lihat[Otomatiskan tugas dalam aplikasi Anda menggunakan agen AI](agents.md).
### Langkah 1: Mulai aliran
Anda memulai aliran dengan memanggil [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)operasi. Anda menyertakan konten awal yang ingin Anda kirim ke alur. Dalam contoh berikut, `document` bidang berisi permintaan untuk *membuat daftar putar*. Setiap percakapan memiliki pengenal unik (*ID eksekusi*) yang mengidentifikasi percakapan dalam alur. Untuk mendapatkan ID eksekusi, Anda tidak mengirim `executionID` bidang dalam panggilan pertama Anda ke`InvokeFlow`. Tanggapan dari `InvokeFlow` menyertakan ID eksekusi. Dalam kode Anda, gunakan pengenal untuk melacak beberapa percakapan dan mengidentifikasi percakapan dalam panggilan lebih lanjut ke `InvokeFlow` operasi.
Berikut ini adalah contoh JSON untuk permintaan ke`InvokeFlow`.
```
{
"flowIdentifier": "XXXXXXXXXX",
"flowAliasIdentifier": "YYYYYYYYYY",
"inputs": [
{
"content": {
"document": "Create a playlist."
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
]
}
```
### Langkah 2: Ambil permintaan agen
Jika node agen dalam alur memutuskan bahwa ia membutuhkan informasi lebih lanjut dari pengguna, stream respons (`responseStream`) dari `InvokeFlow` menyertakan objek `FlowMultiTurnInputRequestEvent` peristiwa. Acara memiliki informasi yang diminta di bidang `content` (`FlowMultiTurnInputContent`). Dalam contoh berikut, permintaan di `document` lapangan adalah untuk informasi tentang jumlah lagu, genre musik, dan tema untuk daftar putar. Dalam kode Anda, Anda kemudian perlu mendapatkan informasi itu dari pengguna.
Berikut ini adalah contoh objek `FlowMultiTurnInputRequestEvent` JSON.
```
{
"nodeName": "AgentsNode_1",
"nodeType": "AgentNode",
"content": {
"document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
1. How many songs would you like in the playlist?
2. What genre of music do you prefer?
3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
}
}
```
Karena aliran tidak dapat berlanjut sampai lebih banyak input diterima, aliran juga memancarkan `FlowCompletionEvent` peristiwa. Aliran selalu memancarkan `FlowMultiTurnInputRequestEvent` sebelum. `FlowCompletionEvent` Jika nilai `completionReason` dalam `FlowCompletionEvent` acara tersebut`INPUT_REQUIRED`, aliran membutuhkan informasi lebih lanjut sebelum dapat dilanjutkan.
Berikut ini adalah contoh objek `FlowCompletionEvent` JSON.
```
{
"completionReason": "INPUT_REQUIRED"
}
```
### Langkah 3: Kirim respons pengguna ke aliran
Kirim respons pengguna kembali ke alur dengan memanggil `InvokeFlow` operasi lagi. Pastikan untuk memasukkan `executionId` untuk percakapan.
Berikut ini adalah contoh JSON untuk permintaan ke`InvokeFlow`. `document`Bidang berisi respons dari pengguna.
```
{
"flowIdentifier": "AUS7BMHXBE",
"flowAliasIdentifier": "4KUDB8VBEF",
"executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
"inputs": [
{
"content": {
"document": "1. 5 songs 2. Welsh rock music 3. Castles"
},
"nodeName": "AgentsNode_1",
"nodeInputName": "agentInputText"
}
]
}
```
Jika aliran membutuhkan lebih banyak informasi, aliran menciptakan `FlowMultiTurnInputRequestEvent` peristiwa lebih lanjut.
### Langkah 4: Akhiri aliran
Ketika tidak ada informasi lebih lanjut yang diperlukan, aliran memancarkan `FlowOutputEvent` peristiwa yang berisi respons akhir.
Berikut ini adalah contoh objek `FlowOutputEvent` JSON.
```
{
"nodeName": "FlowOutputNode",
"content": {
"document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles.
Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems
Description: A 5-song Welsh rock playlist featuring songs about castles
Songs:
1. Castell y Bere - Super Furry Animals
2. The Castle - Manic Street Preachers
3. Caerdydd (Cardiff Castle) - Stereophonics
4. Castell Coch - Catatonia
5. Chepstow Castle - Feeder
This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles.
Enjoy your castle-themed Welsh rock music experience!"
}
}
```
Aliran juga memancarkan suatu `FlowCompletionEvent` peristiwa. Nilai dari `completionReason` adalah `SUCCESS`.
Berikut ini adalah contoh objek `FlowCompletionEvent` JSON.
```
{
"completionReason": "SUCCESS"
}
```
Diagram urutan berikut menunjukkan langkah-langkah dalam aliran multi-putaran.
![\[Langkah-langkah alur untuk percakapan multi-putaran.\]](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png)
## Membuat dan menjalankan alur contoh
Dalam contoh ini, Anda membuat alur yang menggunakan agen untuk membuat daftar putar untuk stasiun radio. Agen mengajukan pertanyaan klarifikasi untuk menentukan jumlah lagu, genre musik, dan tema untuk daftar putar.
**Untuk membuat aliran**
1. Buat agen di konsol Amazon Bedrock dengan mengikuti petunjuk di[Buat dan konfigurasikan agen secara manual](agents-create.md).
+ Untuk langkah *2.d*, masukkan**You are a playlist creator for a radio station. When asked to create a playlist, ask for the number of songs, the genre of music, and a theme for the playlist.**.
+ Untuk langkah *2.e*, di **input Pengguna**, pilih **Diaktifkan**. Melakukan hal ini memungkinkan agen meminta informasi lebih lanjut, sesuai kebutuhan.
1. Buat alur dengan mengikuti instruksi di[Buat dan rancang alur di Amazon Bedrock](flows-create.md). Pastikan aliran memiliki simpul input, node agen, dan node keluaran.
1. Tautkan node agen ke agen yang Anda buat di langkah 1. Aliran akan terlihat seperti gambar berikut.
![\[Alur percakapan multi-putaran\]](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/images/flows/flows-multi-turn.png)
1. Jalankan aliran di konsol Amazon Bedrock. Untuk pengujian, Anda dapat melacak langkah-langkah yang dibuat oleh aliran. Untuk informasi selengkapnya, lihat [Menguji alur di Amazon Bedrock](flows-test.md).
Contoh kode Python berikut menunjukkan bagaimana menggunakan flow.
Untuk menjalankan kode, tentukan yang berikut ini:
+ `region_name`— AWS Wilayah di mana Anda menjalankan arus.
+ `FLOW_ID`— ID aliran.
+ `FLOW_ALIAS_ID`— ID alias aliran.
Untuk informasi tentang mendapatkan IDs, lihat[Melihat informasi tentang aliran di Amazon Bedrock](flows-view.md). Kode meminta permintaan awal untuk mengirim ke alur dan meminta lebih banyak input sesuai kebutuhan oleh aliran. Kode tidak mengelola permintaan lain dari agen, seperti permintaan untuk memanggil AWS Lambda fungsi. Untuk informasi selengkapnya, lihat [Bagaimana Amazon Bedrock Agents bekerja](agents-how.md). Saat berjalan, kode menghasilkan `FlowTraceEvent` objek yang dapat Anda gunakan untuk melacak jalur dari input ke respons yang dikembalikan aliran. Lihat informasi yang lebih lengkap di [Melacak setiap langkah dalam alur Anda dengan melihat jejaknya di Amazon BedrockLacak setiap langkah dalam alur Anda dengan melihat jejaknya](flows-trace.md).
```
"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.
"""
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'])
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
if __name__ == "__main__":
session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Replace these with your actual flow ID and alias ID
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
logger.info("Starting flow %s", FLOW_ID)
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)})
```