Bagikan melalui

Menjelajahi Kernel Semantik BedrockAgent

Penting

Fitur agen tunggal, seperti BedrockAgent, saat ini dalam tahap eksperimental. Fitur-fitur ini sedang dalam pengembangan aktif dan dapat berubah sebelum mencapai ketersediaan umum.

Dokumentasi API terperinci yang terkait dengan diskusi ini tersedia di:

Dokumentasi API BedrockAgent segera hadir.

Dokumentasi API BedrockAgent segera hadir.

Fitur saat ini tidak tersedia di Java.

Apa itu BedrockAgent?

Bedrock Agent adalah agen AI khusus dalam Semantic Kernel yang dirancang untuk berintegrasi dengan layanan Agen Amazon Bedrock. Seperti agen OpenAI dan Azure AI, Bedrock Agent memungkinkan kemampuan percakapan multi-giliran tingkat lanjut dengan integrasi alat (tindakan) yang mulus, tetapi beroperasi sepenuhnya di ekosistem AWS. Ini mengotomatiskan pemanggilan fungsi/alat (disebut grup tindakan di Bedrock), sehingga Anda tidak perlu mengurai dan menjalankan tindakan secara manual, dan mengelola status percakapan di AWS dengan aman melalui sesi, mengurangi kebutuhan untuk mempertahankan riwayat obrolan di aplikasi Anda.

Agen Bedrock berbeda dari jenis agen lain dalam beberapa cara utama:

  • Eksekusi Terkelola AWS: Tidak seperti Asisten OpenAI yang menggunakan cloud OpenAI atau Agen Azure AI yang menggunakan layanan Foundry Azure, Bedrock Agent berjalan di Amazon Bedrock. Anda harus memiliki akun AWS dengan akses ke Bedrock (dan izin IAM yang sesuai) untuk menggunakannya. Siklus hidup agen (pembuatan, sesi, penghapusan) dan eksekusi alat tertentu dikelola oleh layanan AWS, sementara alat panggilan fungsi dijalankan secara lokal dalam lingkungan Anda.

  • Pemilihan Model Fondasi: Saat membuat Bedrock Agent, Anda menentukan model fondasi mana (misalnya Amazon Titan atau model mitra) yang harus digunakannya. Hanya model yang telah Anda berikan akses yang dapat digunakan. Ini berbeda dari agen Chat Completion (yang Anda buat dengan titik akhir model langsung) - dengan Bedrock, model dipilih saat pembuatan agen sebagai kemampuan bawaan agen.

  • Persyaratan Peran IAM: Agen Bedrock memerlukan ARN peran IAM yang harus diberikan saat pembuatan. Peran ini harus memiliki izin untuk memanggil model yang dipilih (dan alat terintegrasi apa pun) atas nama Anda. Ini memastikan agen memiliki hak istimewa yang diperlukan untuk melakukan tindakannya (misalnya, menjalankan kode atau mengakses layanan AWS lainnya) di bawah akun AWS Anda.

  • Alat Bawaan (Grup Tindakan): Bedrock mendukung "grup tindakan" (alat) bawaan yang dapat dilampirkan ke agen. Misalnya, Anda dapat mengaktifkan grup tindakan Penerjemah Kode untuk memungkinkan agen menjalankan kode Python, atau grup tindakan Input Pengguna untuk memungkinkan agen meminta klarifikasi. Kemampuan ini serupa dengan plugin Code Interpreter OpenAI atau fungsi pemanggilan, tetapi di AWS, mereka dikonfigurasi secara eksplisit pada agen. Agen Bedrock juga dapat diperluas dengan plugin Kernel Semantik kustom (fungsi) untuk alat khusus domain, mirip dengan agen lain.

  • Thread berbasis sesi: Percakapan dengan Bedrock Agent berlangsung di thread yang terkait dengan sesi Bedrock di AWS. Setiap utas (sesi) diidentifikasi oleh ID unik yang disediakan oleh layanan Bedrock, dan riwayat percakapan disimpan oleh layanan daripada di dalam proses. Ini berarti dialog multi-giliran dipertahankan di AWS, dan Anda memperoleh konteks melalui ID sesi. Kelas Semantic Kernel BedrockAgentThread mengabstraksi detail ini – saat Anda menggunakannya, kelas ini akan membuat atau melanjutkan sesi Bedrock secara otomatis di belakang layar untuk agen.

Singkatnya, BedrockAgent memungkinkan Anda memanfaatkan kerangka kerja agen dan alat Amazon Bedrock yang kuat melalui Semantic Kernel, menyediakan dialog yang diarahkan tujuan dengan model dan alat yang dihosting AWS. Ini mengotomatiskan seluk-beluk API Agen Bedrock (pembuatan agen, manajemen sesi, pemanggilan alat) sehingga Anda dapat berinteraksi dengannya dalam antarmuka SK lintas bahasa tingkat tinggi.

Menyiapkan lingkungan pengembangan Anda

Untuk mulai mengembangkan dengan BedrockAgent, siapkan lingkungan Anda dengan paket Kernel Semantik yang sesuai dan pastikan prasyarat AWS terpenuhi.

Petunjuk / Saran

Lihat dokumentasi AWS tentang mengonfigurasi lingkungan Anda untuk menggunakan API Bedrock.

Tambahkan paket Semantic Kernel Bedrock Agents ke proyek .NET Anda:

dotnet add package Microsoft.SemanticKernel.Agents.Bedrock --prerelease

Ini akan menghadirkan dukungan SDK Kernel Semantik untuk Bedrock, termasuk ketergantungan pada AWS SDK untuk Bedrock. Anda mungkin juga perlu mengonfigurasi kredensial AWS (misalnya melalui variabel lingkungan atau konfigurasi AWS default). AWS SDK akan menggunakan kredensial yang sudah Anda konfigurasi; pastikan Anda memiliki AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, dan wilayah default diatur di lingkungan atau profil AWS Anda. (Lihat dokumentasi AWS tentang konfigurasi kredensial untuk detail selengkapnya.)

Instal paket Semantic Kernel dengan ekstra AWS:

pip install semantic-kernel[aws]

Ini memastikan bahwa pustaka AWS yang diperlukan (misalnya boto3) diinstal bersama Kernel Semantik. Sebelum menggunakan Bedrock Agent di Python, pastikan info masuk dan wilayah AWS Anda dikonfigurasi dengan benar (misalnya, dengan mengatur variabel lingkungan atau menggunakan AWS CLI). Anda harus mengatur AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, dan AWS_DEFAULT_REGION (atau profil AWS) sehingga boto3 dapat mengautentikasi.

Fitur saat ini tidak tersedia di Java.

Membuat BedrockAgent

Membuat Bedrock Agent melibatkan dua langkah: pertama, menentukan agen dengan Amazon Bedrock (termasuk memilih model dan memberikan instruksi awal), lalu membuat instans objek agen Kernel Semantik untuk berinteraksi dengannya. Saat Anda membuat agen di AWS, agen dimulai dalam status tidak disiapkan, sehingga operasi "persiapan" tambahan dilakukan untuk menyiapkannya untuk digunakan.

using Amazon.Bedrock;
using Amazon.Bedrock.Model;
using Amazon.BedrockRuntime;
using Microsoft.SemanticKernel.Agents.Bedrock;

// 1. Define a new agent on the Amazon Bedrock service
IAmazonBedrock bedrockClient = new AmazonBedrockClient();  // uses default AWS credentials & region
var createRequest = new CreateAgentRequest 
{
    AgentName = "<foundation model ID>",          // e.g., "anthropic.claude-v2" or other model
    FoundationModel = "<foundation model ID>",    // the same model, or leave null if AgentName is the model
    AgentResourceArn = "<agent role ARN>",        // IAM role ARN with Bedrock permissions
    Instruction = "<agent instructions>"
};
CreateAgentResponse createResponse = await bedrockClient.CreateAgentAsync(createRequest);

// (Optional) Provide a description as needed:
// createRequest.Description = "<agent description>";

// After creation, the agent is in a "NOT_PREPARED" state.
// Prepare the agent to load tools and finalize setup:
await bedrockClient.PrepareAgentAsync(new PrepareAgentRequest 
{
    AgentId = createResponse.Agent.AgentId
});

// 2. Create a Semantic Kernel agent instance from the Bedrock agent definition
IAmazonBedrockRuntime runtimeClient = new AmazonBedrockRuntimeClient();
BedrockAgent agent = new BedrockAgent(createResponse.Agent, bedrockClient, runtimeClient);

Dalam kode di atas, pertama-tama kami menggunakan AWS SDK (AmazonBedrockClient) untuk membuat agen di Bedrock, menentukan model fondasi, nama, instruksi, dan ARN peran IAM yang harus diasumsikan agen. Layanan Bedrock merespons dengan definisi agen (termasuk AgentId yang unik). Kami kemudian memanggil PrepareAgentAsync untuk transisi agen ke status siap (agen akan berpindah dari status CREATING ke NOT_PREPARED, lalu ke SIAP setelah siap). Terakhir, kami membuat BedrockAgent objek menggunakan definisi yang dikembalikan dan klien AWS. Instans inilah BedrockAgent yang akan kita gunakan untuk mengirim pesan dan menerima respons.

import boto3
from semantic_kernel.agents import BedrockAgent

# 1. Define and prepare a new agent on Amazon Bedrock
agent = await BedrockAgent.create_and_prepare_agent(
    name="<agent name>", 
    instructions="<agent instructions>",
    foundation_model="<foundation model ID>",
    agent_resource_role_arn="<agent role ARN>"
)

Dalam contoh di atas, BedrockAgent.create_and_prepare_agent menangani alur pembuatan penuh: ia menggunakan konfigurasi AWS Anda (melalui boto3) untuk membuat agen di Bedrock dengan nama, model fondasi, dan instruksi yang diberikan, lalu secara otomatis menunggu agen mencapai status siap (melakukan langkah persiapan secara internal). Hasilnya adalah instans yang BedrockAgent siap digunakan. Secara internal, metode ini membuat klien AWS (untuk Bedrock dan Bedrock Runtime) dengan menggunakan kredensial bawaan Anda, sehingga pastikan lingkungan AWS Anda telah disiapkan dengan benar. Jika Anda memerlukan konfigurasi kustom, Anda juga dapat membangun klien AWS secara manual dan meneruskannya sebagai parameter (misalnya client= boto3.client("bedrock") dan runtime_client= boto3.client("bedrock-runtime")) ke create_and_prepare_agent panggilan.

Fitur saat ini tidak tersedia di Java.

Mengambil yang sudah ada BedrockAgent

Setelah agen dibuat di Bedrock, pengidentifikasi uniknya (ID Agen) dapat digunakan untuk mengambilnya nanti. Ini memungkinkan Anda untuk menginstansiasi kembali BedrockAgent di Kernel Semantik tanpa harus membuatnya dari awal lagi.

Untuk .NET, pengidentifikasi agen Bedrock adalah string yang dapat diakses melalui agent.Id. Untuk mengambil agen yang ada berdasarkan ID, gunakan klien AWS Bedrock dan kemudian buat BedrockAgent baru.

string existingAgentId = "<your agent ID>";
var getResponse = await bedrockClient.GetAgentAsync(new GetAgentRequest { AgentId = existingAgentId });
BedrockAgent agent = new BedrockAgent(getResponse.Agent, bedrockClient, runtimeClient);

Di sini kita memanggil GetAgentAsync pada klien IAmazonBedrock dengan ID yang diketahui, yang mengembalikan definisi agen (nama, model, instruksi, dll.). Kami kemudian menginisialisasi yang baru BedrockAgent dengan definisi tersebut dan klien yang sama. Instans agen yang satu ini akan ditautkan ke agen Bedrock yang ada.

Di Python, Anda juga dapat mengambil agen berdasarkan ID menggunakan klien BOTO3 AWS Bedrock, lalu membungkusnya dengan BedrockAgent:

import asyncio, boto3
from semantic_kernel.agents import BedrockAgent

agent_id = "<your agent ID>"
bedrock_client = boto3.client("bedrock")  # Bedrock service client
# Fetch the agent's definition from AWS
agent_info = await asyncio.to_thread(bedrock_client.get_agent, AgentId=agent_id)
# Create the BedrockAgent instance from the retrieved definition
agent = BedrockAgent(agent_model=agent_info["agent"])

Dalam cuplikan ini, kami menggunakan boto3 untuk memanggil get_agent layanan Bedrock (menjalankannya di utas melalui asyncio.to_thread karena boto3 memblokir). Yang dikembalikan agent_info["agent"] berisi detail agen (id, nama, status, dll.), yang kami teruskan ke konstruktor BedrockAgent. Karena kami tidak secara eksplisit menyediakan klien AWS ke BedrockAgent, itu akan secara internal membuat klien baru dengan pengaturan default. (Secara opsional, Anda dapat menyediakan client= dan runtime_client= untuk menggunakan kembali klien jika Anda memilikinya.)

Fitur saat ini tidak tersedia di Java.

Berinteraksi dengan BedrockAgent

Setelah Anda memiliki instans BedrockAgent, berinteraksi dengannya (mengirim pesan pengguna dan menerima respons AI) sangat mudah. Agen memakai thread untuk mengelola konteks percakapan. Untuk Agen Bedrock, utas sesuai dengan sesi AWS Bedrock. Kelas Kernel BedrockAgentThread Semantik menangani pembuatan dan pelacakan sesi: saat Anda memulai percakapan baru, sesi Bedrock baru dimulai, dan saat Anda mengirim pesan, Bedrock mempertahankan riwayat pesan pengguna/asisten alternatif. (Bedrock mengharuskan riwayat obrolan bergantian antara pesan pengguna dan asisten; Logika saluran Kernel Semantik akan menyisipkan placeholder jika perlu untuk menerapkan pola ini.) Anda dapat memanggil agen tanpa menentukan utas (dalam hal ini SK akan secara otomatis membuat BedrockAgentThread baru), atau Anda dapat secara eksplisit membuat atau memelihara utas jika Anda ingin melanjutkan percakapan di beberapa panggilan. Setiap pemanggilan mengembalikan satu atau beberapa respons, dan Anda dapat mengelola masa hidup utas (misalnya, menghapusnya ketika selesai untuk menyelesaikan sesi AWS).

Spesifikasi utas agen Bedrock diabstraksikan oleh kelas BedrockAgentThread (yang mengimplementasikan antarmuka umum AgentThread). BedrockAgent saat ini hanya mendukung utas jenis BedrockAgentThread.

BedrockAgent agent = /* (your BedrockAgent instance, as created above) */;

// Start a new conversation thread for the agent
AgentThread agentThread = new BedrockAgentThread(runtimeClient);
try
{
    // Send a user message and iterate over the response(s)
    var userMessage = new ChatMessageContent(AuthorRole.User, "<your user input>");
    await foreach (ChatMessageContent response in agent.InvokeAsync(userMessage, agentThread))
    {
        Console.WriteLine(response.Content);
    }
}
finally
{
    // Clean up the thread and (optionally) the agent when done
    await agentThread.DeleteAsync();
    await agent.Client.DeleteAgentAsync(new DeleteAgentRequest { AgentId = agent.Id });
}

Dalam contoh ini, kami menciptakan secara eksplisit BedrockAgentThread (meneruskan runtimeClient, yang digunakannya untuk berkomunikasi dengan layanan runtime Bedrock). Kami kemudian memanggil agent.InvokeAsync(...) dengan ChatMessageContent mewakili pesan pengguna. InvokeAsync mengembalikan aliran asinkron respons – dalam praktiknya, Agen Bedrock biasanya mengembalikan satu respons akhir per pemanggilan (karena tindakan alat perantara ditangani secara terpisah), sehingga Anda biasanya akan mendapatkan satu ChatMessageContent dari perulangan. Kami mencetak balasan asisten (response.Content). Di blok terakhir, kami menghapus utas, yang mengakhiri sesi Bedrock di AWS. Kami juga menghapus agen itu sendiri dalam hal ini (karena kami membuatnya hanya untuk contoh ini) - langkah ini bersifat opsional dan hanya diperlukan jika Anda tidak ingin menggunakan kembali agen lagi (lihat Menghapus BedrockAgent di bawah).

Anda dapat melanjutkan percakapan yang sudah ada dengan menggunakan kembali hal yang sama agentThread untuk panggilan berikutnya. Misalnya, Anda dapat berulang kali membaca input pengguna dan memanggil InvokeAsync setiap kali menggunakan utas yang sama untuk melakukan dialog multi-giliran. Anda juga dapat membuat BedrockAgentThread dengan ID sesi yang diketahui untuk melanjutkan percakapan yang disimpan sebelumnya:

string sessionId = "<existing Bedrock session ID>";
AgentThread thread = new BedrockAgentThread(runtimeClient, sessionId);
// Now `InvokeAsync` using this thread will continue the conversation from that session

Menggunakan Agen Bedrock di Python serupa, dengan BedrockAgentThread mengelola sesi. Anda dapat memulai utas baru atau meneruskan utas yang sudah ada untuk melanjutkan percakapan:

from semantic_kernel.agents import BedrockAgentThread

# Assume `agent` is your BedrockAgent instance
USER_INPUTS = ["Hello", "What's your name?"]

thread = BedrockAgentThread()  # start a new conversation thread (session)
try:
    for user_input in USER_INPUTS:
        response = await agent.get_response(messages=user_input, thread=thread)
        print(response)  # print the assistant's reply
        thread = response.thread  # update thread (BedrockAgentThread) for next turn
finally:
    await thread.delete() if thread else None

Dalam kode ini, kita mengulangi beberapa input pengguna. Pada setiap perulangan, kita panggil agent.get_response(...) dengan pesan pengguna dan utas yang sedang berlangsung. Panggilan pertama memulai sesi Bedrock dan mengembalikan AgentResponseItem (atau ChatMessageContent) yang berisi jawaban asisten. Kami mencetak respons, lalu mengambil response.thread—yang merupakan BedrockAgentThread yang sama tetapi telah diperbarui dengan konteks pesan baru—untuk digunakan pada giliran berikutnya. Setelah percakapan (dalam contoh ini, dua putaran), kami menghapus percakapan untuk mengakhiri sesi di AWS.

Jika Anda menghilangkan thread parameter dalam panggilan, agent.get_response atau agent.invoke akan secara otomatis membuat utas baru untuk pemanggilan tersebut dan menyertakannya dalam respons.

Secara opsional, Anda juga dapat mengirim batch pesan sekaligus dengan meneruskan daftar pesan ke get_response atau menggunakan pemanggilan streaming asinkron. Misalnya, untuk melakukan streaming respons asisten (token demi token) untuk satu perintah:

# Streaming a single response from the Bedrock agent
async for partial in agent.invoke_stream(messages="Tell me a joke.", thread=thread):
    print(partial.content, end="")

Metode invoke_stream(...) ini menghasilkan objek ChatMessageContent saat respons dihasilkan. Dengan melakukan iterasi di atasnya, Anda dapat menghasilkan jawaban asisten secara bertahap (di sini kita mencetak karakter tanpa garis baru untuk membentuk respons penuh).

Fitur saat ini tidak tersedia di Java.

Menghapus BedrockAgent

Agen Bedrock adalah sumber daya persisten di akun AWS Anda - mereka akan tetap ada (dan berpotensi dikenakan biaya atau dihitung terhadap batas layanan) hingga dihapus. Jika Anda tidak lagi memerlukan agen yang telah Anda buat, Anda harus menghapusnya melalui API layanan Bedrock.

Gunakan klien Bedrock untuk menghapus berdasarkan ID agen. Contohnya:

await bedrockAgent.Client.DeleteAgentAsync(new() { AgentId = bedrockAgent.Id });

Setelah panggilan ini, status agen akan berubah dan tidak akan lagi dapat digunakan. (Mencoba memanggil agen yang dihapus akan mengakibatkan kesalahan.)

Panggil metode penghapusan milik agen. Misalnya:

await agent.delete_agent()

Ini akan memanggil layanan Bedrock untuk menghapus agen (dan secara internal menandai BedrockAgent objek sebagai dihapus). Anda dapat memverifikasi dengan memeriksa agent.id atau bendera jika disediakan (misalnya, _is_deleted).

Nota: Menghapus agen Bedrock tidak secara otomatis mengakhiri sesi yang sedang berlangsung. Jika Anda memiliki sesi (utas) yang berjalan lama, Anda harus mengakhiri sesi tersebut dengan menghapus utas (yang memanggil EndSession dan DeleteSession Bedrock secara internal). Dalam praktiknya, menghapus utas (seperti yang ditunjukkan pada contoh di atas) mengakhiri sesi.

Fitur saat ini tidak tersedia di Java.

Menangani Pesan Perantara dengan BedrockAgent

Ketika Agen Bedrock memanggil alat (grup tindakan) untuk sampai pada jawaban, langkah-langkah perantara tersebut (panggilan fungsi dan hasil) secara default ditangani secara internal. Jawaban akhir agen akan mengacu pada hasil dari alat-alat tersebut tetapi tidak akan secara otomatis menyertakan detail yang terperinci langkah demi langkah. Namun, Semantic Kernel memungkinkan Anda untuk memanfaatkan pesan perantara tersebut untuk pengelogan atau penanganan kustom dengan memberikan panggilan balik.

Selama agent.invoke(...) atau agent.invoke_stream(...), Anda dapat menyediakan fungsi callback on_intermediate_message. Panggilan balik ini akan dipanggil untuk setiap pesan perantara yang dihasilkan dalam proses merumuskan respons akhir. Pesan menengah dapat mencakup FunctionCallContent (ketika agen memutuskan untuk memanggil fungsi/alat) dan FunctionResultContent (ketika alat mengembalikan hasil).

Misalnya, Bedrock Agent kami memiliki akses ke plugin sederhana (atau alat bawaan) untuk informasi menu, mirip dengan contoh yang digunakan dengan Asisten OpenAI:

from semantic_kernel.contents import ChatMessageContent, FunctionCallContent, FunctionResultContent
from semantic_kernel.functions import kernel_function

# Define a sample plugin with two functions
class MenuPlugin:
    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> str:
        return "Soup: Clam Chowder; Salad: Cobb Salad; Drink: Chai Tea"

    @kernel_function(description="Provides the price of a menu item.")
    def get_item_price(self, menu_item: str) -> str:
        return "$9.99"

# Callback to handle intermediate messages
async def handle_intermediate_steps(message: ChatMessageContent) -> None:
    for item in (message.items or []):
        if isinstance(item, FunctionCallContent):
            print(f"Function Call:> {item.name} with arguments: {item.arguments}")
        elif isinstance(item, FunctionResultContent):
            print(f"Function Result:> {item.result} for function: {item.name}")
        else:
            print(f"[Intermediate] {item}")

# Create the BedrockAgent with the plugin (assuming agent is not yet created above)
agent = await BedrockAgent.create_and_prepare_agent(
    name="MenuAgent",
    instructions="You are a restaurant assistant.",
    foundation_model="<model ID>",
    agent_resource_role_arn="<role ARN>",
    plugins=[MenuPlugin()]  # include our custom plugin
)

# Start a conversation with intermediate callback
thread = BedrockAgentThread()
user_queries = [
    "Hello!",
    "What are the specials today?",
    "What is the special drink?",
    "How much is that?"
]
try:
    for query in user_queries:
        print(f"# User: {query}")
        async for response in agent.invoke(messages=query, thread=thread, on_intermediate_message=handle_intermediate_steps):
            print(f"# Assistant: {response}")
            thread = response.thread
finally:
    await thread.delete() if thread else None
    await agent.delete_agent()

Dalam kode ini, setiap kali agen perlu memanggil fungsi dari MenuPlugin (misalnya, get_specials atau get_item_price), handle_intermediate_steps panggilan balik akan mencetak baris untuk panggilan fungsi dan yang lain untuk hasil fungsi. Respons asisten akhir untuk setiap kueri pengguna kemudian dicetak seperti biasa. Dengan mengamati konten perantara, Anda dapat melacak bagaimana agen tiba pada jawabannya (alat mana yang digunakan, apa yang dikembalikannya, dll.).

Misalnya, output mungkin terlihat seperti:

# User: Hello!
# Assistant: Hello! How can I assist you today?
# User: What are the specials today?
Function Call:> MenuPlugin-get_specials with arguments: {}
Function Result:> Soup: Clam Chowder; Salad: Cobb Salad; Drink: Chai Tea for function: MenuPlugin-get_specials
# Assistant: The specials today include Clam Chowder for the soup, Cobb Salad, and Chai Tea as a special drink.
# User: What is the special drink?
# Assistant: The special drink is Chai Tea.
# User: How much is that?
Function Call:> MenuPlugin-get_item_price with arguments: {"menu_item": "Chai Tea"}
Function Result:> $9.99 for function: MenuPlugin-get_item_price
# Assistant: The special drink (Chai Tea) costs $9.99.

Dalam interaksi di atas, hasil cetakan sementara menunjukkan bahwa agen berhasil memanggil MenuPlugin.get_specials dan MenuPlugin.get_item_price pada waktu yang tepat, dan memakai hasilnya untuk menjawab pengguna. Detail perantara ini dapat dicatat atau digunakan dalam logika aplikasi Anda sesuai kebutuhan (misalnya, untuk menampilkan langkah-langkah yang diambil agen).

Dukungan panggilan balik untuk pesan menengah di BedrockAgent (C#) mengikuti pola serupa, tetapi API yang tepat sedang dikembangkan. (Rilis mendatang akan memungkinkan mendaftarkan delegasi untuk menangani FunctionCallContent dan FunctionResultContent selama InvokeAsync.)

Fitur saat ini tidak tersedia di Java.

Menggunakan YAML Deklaratif untuk Menentukan Agen Bedrock

Kerangka kerja agen Semantic Kernel mendukung skema deklaratif untuk menentukan agen melalui YAML (atau JSON). Ini memungkinkan Anda menentukan konfigurasi agen - jenis, model, alat, dll. - dalam file dan kemudian memuat definisi agen tersebut pada runtime tanpa menulis kode imperatif untuk membangunnya.

Nota: Definisi agen berbasis YAML adalah fitur yang muncul dan mungkin bersifat eksperimental. Pastikan Anda menggunakan versi Kernel Semantik yang mendukung pemuatan agen YAML, dan lihat dokumen terbaru untuk perubahan format apa pun.

Menggunakan spesifikasi deklaratif dapat menyederhanakan konfigurasi, terutama jika Anda ingin dengan mudah beralih pengaturan agen atau menggunakan pendekatan file konfigurasi. Untuk Agen Bedrock, definisi YAML mungkin terlihat seperti:

type: bedrock_agent
name: MenuAgent
description: Agent that answers questions about a restaurant menu
instructions: You are a restaurant assistant that provides daily specials and prices.
model:
  id: anthropic.claude-v2
agent_resource_role_arn: arn:aws:iam::123456789012:role/BedrockAgentRole
tools:
  - type: code_interpreter
  - type: user_input
  - name: MenuPlugin
    type: kernel_function

Dalam YAML (hipotetis) ini, kami mendefinisikan agen jenis bedrock_agent, memberinya nama dan instruksi, menentukan model dasar berdasarkan ID, dan memberikan ARN peran yang harus digunakan. Kami juga mendeklarasikan beberapa alat: satu mengaktifkan Penerjemah Kode bawaan, yang lain yang mengaktifkan alat Input Pengguna bawaan, dan MenuPlugin kustom (yang akan didefinisikan secara terpisah dalam kode dan terdaftar sebagai fungsi kernel). File seperti itu merangkum pengaturan agen dalam bentuk yang dapat dibaca manusia.

Untuk menginstansiasi agen dari YAML, gunakan pemuat statis dengan faktori yang sesuai. Contohnya:

string yamlText = File.ReadAllText("bedrock-agent.yaml");
var factory = new BedrockAgentFactory();  // or an AggregatorAgentFactory if multiple types are used
Agent myAgent = await KernelAgentYaml.FromAgentYamlAsync(kernel, yamlText, factory);

Ini akan mengurai YAML dan menghasilkan BedrockAgent instance (atau tipe lain, berdasarkan bidang type) dengan kernel dan fabrik yang telah disediakan.

Pengelolaan Spesifikasi Deklaratif BedrockAgent akan segera tersedia.

Fitur saat ini tidak tersedia di Java.

Menggunakan skema deklaratif dapat sangat kuat untuk konfigurasi skenario dan pengujian, karena Anda dapat menukar model atau instruksi dengan mengedit file konfigurasi daripada mengubah kode. Perhatikan dokumentasi dan sampel Semantic Kernel untuk informasi selengkapnya tentang definisi agen YAML seiring berkembangnya fitur.

Sumber Daya Selengkapnya

  • Dokumentasi AWS Bedrock: Untuk mempelajari selengkapnya tentang kemampuan agen Amazon Bedrock, lihat Amazon Bedrock Agents dalam dokumentasi AWS (misalnya, cara mengonfigurasi akses model fondasi dan peran IAM). Memahami layanan yang mendasar akan membantu dalam mengatur izin yang benar dan memanfaatkan alat bawaan sebaik-baiknya.
  • Sampel Kernel Semantik: Repositori Kernel Semantik berisi sampel konsep untuk Bedrock Agents. Misalnya, sampel obrolan dasar Bedrock Agent dalam sampel Python menunjukkan Tanya Jawab sederhana dengan BedrockAgent, dan sampel Bedrock Agent dengan Penerjemah Kode menunjukkan cara mengaktifkan dan menggunakan alat Penerjemah Kode. Sampel ini bisa menjadi titik awal yang bagus untuk melihat BedrockAgent beraksi.

Dengan Amazon Bedrock Agent terintegrasi, Semantic Kernel memungkinkan solusi AI multi-platform yang benar-benar – baik Anda menggunakan OpenAI, Azure OpenAI, atau AWS Bedrock, Anda dapat membangun aplikasi percakapan yang kaya dengan integrasi alat menggunakan kerangka kerja yang konsisten. Memungkinkan terbukanya BedrockAgent agar dapat memanfaatkan model fondasi terbaru AWS dan konsep agen yang aman dan dapat diperluas dalam proyek Kernel Semantik Anda.

Langkah Selanjutnya

Menjelajahi Agen Penyelesaian Percakapan