Erforschung des semantischen Kerns BedrockAgent

Von Bedeutung

Einzelagenten-Funktionen, wie z. B. BedrockAgent, befinden sich derzeit in der experimentellen Phase. Diese Features befinden sich in der aktiven Entwicklung und können sich ändern, bevor sie die allgemeine Verfügbarkeit erreichen.

Detaillierte API-Dokumentation zu dieser Diskussion finden Sie unter:

BedrockAgent API-Dokumentation in Kürze verfügbar.

BedrockAgent API-Dokumentation in Kürze verfügbar.

Das Feature ist derzeit in Java nicht verfügbar.

Was ist ein BedrockAgent?

Der Bedrock Agent ist ein spezialisierter KI-Agent innerhalb von Semantic Kernel, der für die Integration in den Agent-Service von Amazon Bedrock entwickelt wurde. Wie die OpenAI- und Azure AI-Agenten ermöglicht ein Bedrock-Agent erweiterte Multi-Turn-Gesprächsfunktionen mit nahtloser Toolintegration, operiert jedoch vollständig im AWS-Ökosystem. Es automatisiert Funktions-/Toolaufrufe (als Aktionsgruppen in Bedrock bezeichnet), sodass Sie Aktionen nicht manuell analysieren und ausführen müssen, und es verwaltet den Unterhaltungsstatus auf AWS über Sitzungen sicher und reduziert die Notwendigkeit, den Chatverlauf in Ihrer Anwendung zu verwalten.

Ein Bedrock Agent unterscheidet sich von anderen Agenttypen auf verschiedene Arten:

• AWS Managed Execution: Im Gegensatz zum OpenAI-Assistenten, der die Cloud von OpenAI oder den Azure AI-Agent verwendet, der den Findry-Dienst von Azure verwendet, wird der Bedrock Agent auf Amazon Bedrock ausgeführt. Sie müssen über ein AWS-Konto mit Zugriff auf Bedrock (und entsprechende IAM-Berechtigungen) verfügen, um es zu verwenden. Der Lebenszyklus des Agents (Erstellung, Sitzungen, Löschung) und bestimmte Toolausführungen werden von AWS-Diensten verwaltet, während Funktionsaufruftools lokal in Ihrer Umgebung ausgeführt werden.

• Foundation Model Selection: Beim Erstellen eines Bedrock-Agents geben Sie an, welches Foundation-Modell (z. B. ein Amazon Titan oder Partnermodell) verwendet werden soll. Es können nur Modelle verwendet werden, auf die Sie Zugriff haben. Dies unterscheidet sich von Chat-Vervollständigungs-Agenten (die Sie mit einem direkten Modellendpunkt instanziieren) – mit Bedrock wird das Modell bei der Erstellung des Agenten als Standardfunktion des Agenten ausgewählt.

• IAM-Rollenanforderung: Bedrock Agents erfordern eine IAM-Rollen-ARN, die bei der Erstellung bereitzustellen ist. Diese Rolle muss über Berechtigungen verfügen, um das ausgewählte Modell (und alle integrierten Tools) in Ihrem Auftrag aufzurufen. Dadurch wird sichergestellt, dass der Agent über die erforderlichen Berechtigungen verfügt, um seine Aktionen auszuführen (z. B. Code ausführen oder auf andere AWS-Dienste zuzugreifen) unter Ihrem AWS-Konto.

• Integrierte Tools (Aktionsgruppen): Bedrock unterstützt integrierte "Aktionsgruppen" (Tools), die an einen Agenten angefügt werden können. Sie können z. B. eine Codedolmetscher-Aktionsgruppe aktivieren, um dem Agent das Ausführen von Python-Code oder eine Benutzereingabeaktionsgruppe zu ermöglichen, damit der Agent zur Klärung aufgefordert wird. Diese Funktionen sind analog zum Code-Interpreter-Plug-In oder Funktionsaufruf von OpenAI, aber in AWS werden sie explizit für den Agent konfiguriert. Ein Bedrock Agent kann auch mit benutzerdefinierten semantischen Kernel-Plug-Ins (Funktionen) für domänenspezifische Tools erweitert werden, ähnlich wie andere Agents.

• Sitzungsbasierte Threads: Unterhaltungen mit einem Bedrock-Agent treten in Threads auf, die an Bedrock-Sitzungen auf AWS gebunden sind. Jeder Thread (Sitzung) wird durch eine eindeutige ID identifiziert, die vom Bedrock-Dienst bereitgestellt wird, und der Unterhaltungsverlauf wird vom Dienst und nicht vom In-Process-Prozess gespeichert. Dies bedeutet, dass Multi-Turn-Dialoge auf AWS gespeichert werden und Sie über die Sitzungs-ID den Kontext abrufen. Die Semantik kernel-Klasse BedrockAgentThread abstrahiert dieses Detail – wenn Sie sie verwenden, wird hinter den Kulissen eine Bedrock-Sitzung für den Agent erstellt oder fortgesetzt.

Zusammenfassend können Sie über Semantic Kernel das leistungsstarke Agent-and-Tools-Framework von Amazon Bedrock nutzen und einen zielorientierten Dialog mit von AWS gehosteten Modellen und Tools erhalten. Es automatisiert die Komplexität der Agent-API von Bedrock (Agent-Erstellung, Sitzungsverwaltung, Toolaufrufe), sodass Sie über eine allgemeine, sprachübergreifende Schnittstelle interagieren können.

So bereiten Sie Ihre Entwicklungsumgebung vor

Um mit einer BedrockAgentEntwicklung zu beginnen, richten Sie Ihre Umgebung mit den entsprechenden Semantic Kernel-Paketen ein, und stellen Sie sicher, dass AWS-Voraussetzungen erfüllt sind.

Tipp

Schauen Sie sich die AWS-Dokumentation zum Konfigurieren Ihrer Umgebung für die Verwendung der Bedrock-API an.

Fügen Sie ihrem .NET-Projekt das Paket "Semantic Kernel Bedrock Agents" hinzu:

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

Dadurch wird die Unterstützung des semantischen Kernel-SDK für Bedrock bereitgestellt, einschließlich Abhängigkeiten vom AWS SDK für Bedrock. Möglicherweise müssen Sie auch AWS-Anmeldeinformationen konfigurieren (z. B. über Umgebungsvariablen oder die Standard-AWS-Konfiguration). Das AWS SDK verwendet Ihre konfigurierten Anmeldeinformationen; Stellen Sie sicher, dass Ihre AWS_ACCESS_KEY_ID und AWS_SECRET_ACCESS_KEY sowie Ihre Standardregion in Ihrer Umgebung oder in Ihrem AWS-Profil festgelegt sind. (Weitere Informationen finden Sie in der Dokumentation von AWS zur Konfiguration von Anmeldeinformationen.)

Installieren Sie das Semantic Kernel-Paket mit den AWS-Extras:

pip install semantic-kernel[aws]

Dadurch wird sichergestellt, dass die erforderlichen AWS-Bibliotheken (z. B. Boto3) zusammen mit semantic Kernel installiert werden. Bevor Sie einen Bedrock-Agent in Python verwenden, stellen Sie sicher, dass Ihre AWS-Anmeldeinformationen und -Region ordnungsgemäß konfiguriert sind (z. B. durch Festlegen von Umgebungsvariablen oder Verwenden der AWS CLI). Sie sollten AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY und AWS_DEFAULT_REGION (oder AWS-Profil) so festgelegt haben, dass boto3 sich authentifizieren kann.

Das Feature ist derzeit in Java nicht verfügbar.

Erstellen eines BedrockAgent

Das Erstellen eines Bedrock-Agents umfasst zwei Schritte: Zuerst definieren Sie den Agent mit Amazon Bedrock (einschließlich Auswahl eines Modells und Bereitstellung anfänglicher Anweisungen), und dann instanziieren Sie das Semantik-Kernel-Agent-Objekt, um mit ihm zu interagieren. Wenn Sie den Agent auf AWS erstellen, beginnt er in einem nicht vorbereiteten Zustand, sodass ein zusätzlicher "Vorbereiten"-Vorgang ausgeführt wird, um ihn für die Verwendung vorzubereiten.

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);

Im obigen Code verwenden wir zuerst das AWS SDK (AmazonBedrockClient), um einen Agent auf Bedrock zu erstellen, wobei das Foundation-Modell, ein Name, die Anweisungen und der ARN der IAM-Rolle, die der Agent annehmen sollte, angegeben wird. Der Bedrock-Dienst antwortet mit einer Agentdefinition (einschließlich einer eindeutigen AgentId). Anschließend rufen wir PrepareAgentAsync auf, um den Agenten in einen bereiten Zustand zu versetzen (der Agent wechselt von einem CREATING-Status zu NOT_PREPARED und dann zu PREPARED, sobald er bereit ist). Schließlich erstellen wir ein BedrockAgent Objekt mit der zurückgegebenen Definition und den AWS-Clients. Diese BedrockAgent Instanz wird verwendet, um Nachrichten zu senden und Antworten zu empfangen.

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>"
)

Im obigen BedrockAgent.create_and_prepare_agent Beispiel wird der vollständige Erstellungsfluss behandelt: Es verwendet Ihre AWS-Konfiguration (über Boto3), um einen Agent auf Bedrock mit dem angegebenen Namen, dem Foundation-Modell und den Anweisungen zu erstellen, und wartet dann automatisch, bis der Agent einen bereiten Zustand erreicht (den Vorbereitungsschritt intern ausführen). Das Ergebnis ist eine BedrockAgent Instanz, die zur Verwendung bereit ist. Unter der Haube erstellt diese Methode AWS-Clients (für Bedrock und Bedrock Runtime) mit Ihren Standardanmeldeinformationen. Stellen Sie daher sicher, dass Ihre AWS-Umgebung eingerichtet ist. Wenn Sie eine benutzerdefinierte Konfiguration benötigen, können Sie die AWS-Clients auch manuell konstruieren und als Parameter (z. B. client= boto3.client("bedrock") und runtime_client= boto3.client("bedrock-runtime")) an den create_and_prepare_agent Aufruf übergeben.

Das Feature ist derzeit in Java nicht verfügbar.

Abrufen einer vorhandenen BedrockAgent

Nachdem ein Agent auf Bedrock erstellt wurde, kann dessen eindeutiger Bezeichner (Agent-ID) verwendet werden, um ihn später abzurufen. Auf diese Weise können Sie einen BedrockAgent semantischen Kernel erneut instanziieren, ohne ihn von Grund auf neu zu erstellen.

Bei .NET ist der Bezeichner des Bedrock-Agents eine Zeichenfolge, auf die über agent.Id zugegriffen werden kann. Um einen vorhandenen Agent anhand der ID abzurufen, verwenden Sie den AWS Bedrock-Client, und erstellen Sie dann ein neues BedrockAgent:

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

Hier rufen GetAgentAsync wir den IAmazonBedrock Client mit der bekannten ID auf, die die Definition des Agents (Name, Modell, Anweisungen usw.) zurückgibt. Anschließend initialisieren wir ein neues BedrockAgent mit dieser Definition und denselben Clients. Diese Agentinstanz wird mit dem vorhandenen Bedrock-Agent verknüpft.

In Python können Sie ähnlich einen Agenten anhand der ID mit dem AWS Bedrock-Boto3-Client abrufen und ihn dann in ein BedrockAgent einfügen.

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"])

In diesem Codeausschnitt verwenden wir boto3, um den Bedrock-Dienst get_agent aufzurufen (wir führen ihn in einem Thread über asyncio.to_thread aus, da boto3 blockierend ist). Die zurückgegebene agent_info["agent"] Enthält die Details des Agents (ID, Name, Status usw.), die wir an den BedrockAgent-Konstruktor übergeben. Da wir keine AWS-Clients explizit an BedrockAgent bereitstellen, werden intern neue Clients mit Standardeinstellungen erstellt. (Optional können Sie, wenn sie vorhanden sind, Clients bereitstellen client= und runtime_client= wiederzuverwenden.)

Das Feature ist derzeit in Java nicht verfügbar.

Interagieren mit einem BedrockAgent

Sobald Sie über eine BedrockAgent-Instanz verfügen, ist die Interaktion mit dieser Instanz (Senden von Benutzernachrichten und Empfangen von KI-Antworten) einfach. Der Agent verwendet Threads zum Verwalten des Unterhaltungskontexts. Bei einem Bedrock-Agent entspricht ein Thread einer AWS Bedrock-Sitzung. Die Semantic Kernel-Klasse BedrockAgentThread behandelt die Sitzungserstellung und -verfolgung: Wenn Sie eine neue Unterhaltung starten, wird eine neue Bedrock-Sitzung gestartet, und während Sie Nachrichten senden, verwaltet Bedrock den abwechselnden Nachrichtenverlauf des Benutzers/Assistenten. (Bedrock erfordert, dass der Chatverlauf zwischen Benutzer- und Assistentennachrichten wechselt; Die Kanallogik des semantischen Kernels fügt Platzhalter ein, falls erforderlich, um dieses Muster zu erzwingen.) Sie können den Agent aufrufen, ohne einen Thread anzugeben (in diesem Fall erstellt SK automatisch eine neue BedrockAgentThread ), oder Sie können einen Thread explizit erstellen/verwalten, wenn Sie eine Unterhaltung über mehrere Anrufe hinweg fortsetzen möchten. Jeder Aufruf gibt eine oder mehrere Antworten zurück, und Sie können die Threadlebensdauer verwalten (z. B. löschen, wenn Sie die AWS-Sitzung beendet haben).

Die Besonderheiten des Bedrock-Agentthreads werden von der BedrockAgentThread Klasse abstrahiert (die die gemeinsame AgentThread Schnittstelle implementiert). Die BedrockAgent unterstützt derzeit nur Threads vom Typ 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 });
}

In diesem Beispiel erstellen wir explizit ein BedrockAgentThread, wobei wir runtimeClient übergeben, das zur Kommunikation mit dem Bedrock-Laufzeitdienst verwendet wird. Anschließend rufen wir agent.InvokeAsync(...) mit einer ChatMessageContent Darstellung der Nachricht eines Benutzers auf. InvokeAsync gibt einen asynchronen Antwortstrom zurück – in der Praxis gibt ein Bedrock-Agent in der Regel eine endgültige Antwort per Aufruf zurück (da Zwischentoolaktionen separat behandelt werden), sodass Sie in der Regel eine einzelne ChatMessageContent aus der Schleife erhalten. Wir drucken die Antwort des Assistenten aus (response.Content). Im letzten Block löschen wir den Thread, der die Bedrock-Sitzung auf AWS beendet. Außerdem löschen wir den Agent selbst in diesem Fall (da wir ihn nur für dieses Beispiel erstellt haben) – dieser Schritt ist optional und nur erforderlich, wenn Sie nicht beabsichtigen, den Agent erneut wiederzuverwenden (siehe Löschen eines BedrockAgent unten).

Sie können eine vorhandene Unterhaltung fortsetzen, indem Sie die gleiche agentThread für nachfolgende Anrufe wiederverwenden. Sie können beispielsweise das Lesen von Benutzereingaben und das Aufrufen InvokeAsync jedes Mal mit demselben Thread durchlaufen, um einen mehrstufigen Dialog auszuführen. Sie können auch ein BedrockAgentThread mit einer bekannten Sitzungs-ID erstellen, um eine zuvor gespeicherte Unterhaltung fortzusetzen:

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

Die Verwendung eines Bedrock-Agents in Python ist ähnlich, wobei die BedrockAgentThread die Sitzungsverwaltung übernimmt. Sie können einen neuen Thread starten oder einen vorhandenen Thread übergeben, um eine Unterhaltung fortzusetzen:

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

In diesem Code durchlaufen wir einige Benutzereingaben. Bei jeder Iteration rufen agent.get_response(...) wir mit der Benutzernachricht und dem aktuellen Thread auf. Der erste Anruf startet die Bedrock-Sitzung und gibt eine AgentResponseItem (oder ChatMessageContent) zurück, die die Antwort des Assistenten enthält. Wir drucken die Antwort und greifen dann auf response.thread zu – derselbe BedrockAgentThread Kontext, der mit der neuen Nachricht aktualisiert wurde –, um ihn im nächsten Schritt zu verwenden. Nach der Unterhaltung (in diesem Beispiel zwei Runden) löschen wir die Unterhaltung, um die Sitzung auf AWS zu beenden.

Wenn Sie den thread Parameter im Aufruf weglassen, wird agent.get_response oder agent.invoke automatisch einen neuen Thread für diesen Aufruf erstellen und ihn in die Antwort einschließen.

Optional können Sie auch einen Batch von Nachrichten gleichzeitig senden, indem Sie eine Liste von Nachrichten an get_response oder mithilfe des asynchronen Streamingaufrufs übergeben. Um beispielsweise die Antwort des Assistenten (Token nach Token) für eine einzelne Eingabeaufforderung zu streamen:

# 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="")

Die invoke_stream(...) Methode liefert ChatMessageContent Objekte, während die Antwort generiert wird. Indem Sie über die Antwort des Assistenten iterieren, können Sie diese schrittweise ausgeben (hier drucken wir Zeichen ohne Zeilenumbruch, um die vollständige Antwort zu bilden).

Das Feature ist derzeit in Java nicht verfügbar.

Löschen eines BedrockAgent

Bedrock Agents sind persistente Ressourcen in Ihrem AWS-Konto – sie bleiben (und verursachen möglicherweise Kosten oder zählen gegen Servicelimits), bis sie gelöscht werden. Wenn Sie keinen Agent mehr benötigen, den Sie erstellt haben, sollten Sie ihn über die Bedrock-Dienst-API löschen.

Verwenden Sie den Bedrock-Client, um nach Agent-ID zu löschen. Beispiel:

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

Nach diesem Aufruf ändert sich der Status des Agents, und er kann nicht mehr verwendet werden. (Der Versuch, einen gelöschten Agent aufzurufen, führt zu einem Fehler.)

Rufen Sie die Löschmethode des Agenten auf. Beispiel:

await agent.delete_agent()

Dadurch wird der Bedrock-Dienst aufgerufen, um den Agent zu löschen (und das BedrockAgent Objekt intern als gelöscht zu markieren). Sie können überprüfen, indem Sie agent.id oder eine Flagge prüfen, falls vorhanden (z. B. _is_deleted).

Anmerkung: Durch das Löschen eines Bedrock-Agents werden die laufenden Sitzungen nicht automatisch beendet. Wenn Sie über lange laufende Sitzungen (Threads) verfügen, sollten Sie diese beenden, indem Sie die Threads löschen (die Bedrocks EndSession und DeleteSession unter der Haube aufrufen). In der Praxis endet das Löschen eines Threads (wie in den obigen Beispielen gezeigt) die Sitzung.

Das Feature ist derzeit in Java nicht verfügbar.

Verarbeiten von Zwischennachrichten mit einem BedrockAgent

Wenn ein Bedrock-Agent Tools (Aktionsgruppen) aufruft, um zu einer Antwort zu gelangen, werden diese Zwischenschritte (Funktionsaufrufe und Ergebnisse) standardmäßig intern behandelt. Die endgültige Antwort des Agents verweist auf das Ergebnis dieser Tools, enthält jedoch nicht automatisch ausführliche Details. Der semantische Kernel ermöglicht es Ihnen jedoch, diese Zwischenmeldungen für die Protokollierung oder benutzerdefinierte Verarbeitung durch Bereitstellen eines Rückrufs zu nutzen.

Während agent.invoke(...) oder agent.invoke_stream(...) können Sie eine on_intermediate_message Rückruffunktion bereitstellen. Dieser Rückruf wird für jede zwischengeschaltete Nachricht aufgerufen, die beim Erstellen der endgültigen Antwort generiert wird. Zwischenmeldungen können FunctionCallContent (wenn der Agent entscheidet, eine Funktion/ein Tool aufzurufen) und FunctionResultContent (wenn ein Tool ein Ergebnis zurückgibt) enthalten.

Angenommen, unser Bedrock Agent hat Zugriff auf ein einfaches Plug-In (oder integriertes Tool) für Menüinformationen, ähnlich den Beispielen, die mit dem OpenAI-Assistenten verwendet werden:

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()

In diesem Code ruft der Agent immer dann eine Funktion von MenuPlugin auf (z. B. get_specials oder get_item_price), wenn der handle_intermediate_steps Rückruf eine Zeile für den Funktionsaufruf und eine andere für das Funktionsergebnis ausgibt. Die endgültige Assistentenantwort für jede Benutzerabfrage wird dann normal gedruckt. Indem Sie den Zwischeninhalt beobachten, können Sie verfolgen, wie der Agent zu seiner Antwort gelangt ist (welches Tool verwendet wurde, was er zurückgegeben hat usw.).

Beispielsweise könnte die Ausgabe wie folgt aussehen:

# 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.

In der obigen Interaktion zeigen die Zwischenergebnisse, dass der Agent erfolgreich MenuPlugin.get_specials und MenuPlugin.get_item_price zu den entsprechenden Zeiten aufgerufen und ihre Ergebnisse genutzt hat, um den Benutzer zu beantworten. Diese Zwischendetails können bei Bedarf in Ihrer Anwendungslogik protokolliert oder verwendet werden (z. B. um die schritte anzuzeigen, die der Agent ausgeführt hat).

Die Rückrufunterstützung für Zwischennachrichten in BedrockAgent (C#) folgt einem ähnlichen Muster, aber die genaue API wird entwickelt. (Zukünftige Versionen werden es ermöglichen, einen Delegierten zu registrieren, um FunctionCallContent und FunctionResultContent während InvokeAsync zu verarbeiten.)

Das Feature ist derzeit in Java nicht verfügbar.

Verwenden von deklarativem YAML zum Definieren eines Bedrock-Agents

Das Agentframework des semantischen Kernels unterstützt ein deklaratives Schema zum Definieren von Agents über YAML (oder JSON). Auf diese Weise können Sie die Konfiguration eines Agents – seinen Typ, Modelle, Tools usw. – in einer Datei angeben und diese Agentdefinition dann zur Laufzeit laden, ohne imperativen Code zum Erstellen zu schreiben.

Anmerkung: YAML-basierte Agentdefinitionen sind ein aufstrebendes Feature und können experimentell sein. Stellen Sie sicher, dass Sie eine semantische Kernelversion verwenden, die das Laden von YAML-Agents unterstützt, und verweisen Sie auf die neuesten Dokumente für alle Formatänderungen.

Die Verwendung einer deklarativen Spezifikation kann die Konfiguration vereinfachen, insbesondere, wenn Sie die Agent-Setups ganz einfach wechseln oder einen Konfigurationsdateiansatz verwenden möchten. Bei einem Bedrock-Agent könnte eine YAML-Definition wie folgt aussehen:

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

In diesem (hypothetischen) YAML definieren wir einen Agent vom Typ bedrock_agent, geben ihm einen Namen und Anweisungen, geben das Foundation-Modell anhand der ID an und stellen den ARN der Rolle bereit, die verwendet werden soll. Außerdem deklarieren wir ein paar Tools: eine, die den integrierten Codedolmetscher ermöglicht, ein anderes, das integrierte Benutzereingabetool und ein benutzerdefiniertes MenuPlugin (das separat im Code definiert und als Kernelfunktion registriert wird). Eine solche Datei fasst die Einrichtung des Agenten in einer für Menschen lesbaren Form zusammen.

Verwenden Sie zum Instanziieren eines Agenten aus YAML den statischen Lader mit einer geeigneten Factory. Beispiel:

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);

Dadurch wird das YAML analysiert und eine BedrockAgent Instanz (oder einen anderen Typ gemäß dem type Feld) mithilfe des bereitgestellten Kernels und Erzeugers erzeugt.

BedrockAgent Declarative Spec Handling ist in Kürze verfügbar.

Das Feature ist derzeit in Java nicht verfügbar.

Die Verwendung eines deklarativen Schemas kann für die Szenariokonfiguration und -tests besonders leistungsfähig sein, da Sie Modelle oder Anweisungen austauschen können, indem Sie eine Konfigurationsdatei bearbeiten, anstatt Code zu ändern. Behalten Sie die Dokumentation und Beispiele für semantischen Kernel im Auge, um mehr über YAML-Agentdefinitionen zu erfahren, während sich das Feature weiterentwickelt.

Weitere Ressourcen

• AWS Bedrock-Dokumentation: Weitere Informationen zu den Agent-Funktionen von Amazon Bedrock finden Sie in der AWS-Dokumentation unter Amazon Bedrock Agents (z. B. wie man Foundation-Modellzugriff und IAM-Rollen konfiguriert). Wenn Sie den zugrunde liegenden Dienst verstehen, können Sie die richtigen Berechtigungen festlegen und die integrierten Tools optimal nutzen.
• Semantische Kernelbeispiele: Das Repository für semantische Kernel enthält Konzeptbeispiele für Bedrock Agents. Das Bedrock-Agent-Beispiel für einen einfachen Chat in den Python-Beispielen veranschaulicht einfache Fragen und Antworten mit einem BedrockAgent, und das Bedrock-Agent-Beispiel mit Code-Interpreter zeigt, wie das Code-Interpreter-Tool aktiviert und genutzt wird. Diese Beispiele können ein guter Ausgangspunkt sein, um zu sehen, wie BedrockAgent in Aktion ist.

Mit dem integrierten Amazon Bedrock Agent ermöglicht Semantic Kernel wirklich multiplattformbasierte KI-Lösungen – unabhängig davon, ob Sie OpenAI, Azure OpenAI oder AWS Bedrock verwenden, können Sie umfangreiche Unterhaltungsanwendungen mit Toolintegration mit einem konsistenten Framework erstellen. Die BedrockAgent öffnet die Tür zur Nutzung der neuesten Grundlagenmodelle von AWS und des sicheren, erweiterbaren Agentenparadigmas in Ihren Semantic-Kernel-Projekten.

Nächste Schritte

Entdecken Sie den Chat-Completion-Agent