De semantische kernel BedrockAgent verkennen

Belangrijk

Functies van één agent, zoals BedrockAgent, bevinden zich momenteel in de experimentele fase. Deze functies worden actief ontwikkeld en kunnen veranderen voordat de algemene beschikbaarheid wordt bereikt.

Gedetailleerde API-documentatie met betrekking tot deze discussie is beschikbaar op:

BedrockAgent API-documentatie komt binnenkort beschikbaar.

BedrockAgent API-documentatie binnenkort beschikbaar.

Functie is momenteel niet beschikbaar in Java.

Wat is een BedrockAgent?

De Bedrock Agent is een gespecialiseerde AI-agent binnen Semantic Kernel die is ontworpen om te integreren met de agentservice van Amazon Bedrock. Net als de OpenAI- en Azure AI-agents biedt een Bedrock Agent geavanceerde gespreksmogelijkheden met naadloze integratie van hulpprogramma's (actie), maar werkt deze volledig in het AWS-ecosysteem. Het automatiseert het aanroepen van functies/hulpprogramma's (actiegroepen genoemd in Bedrock), dus u hoeft niet handmatig acties te parseren en uit te voeren, en beheert de gespreksstatus op AWS veilig via sessies, waardoor u de chatgeschiedenis in uw toepassing minder hoeft te onderhouden.

Een Bedrock Agent verschilt van andere agenttypen op een aantal belangrijke manieren:

• Door AWS beheerde uitvoering: In tegenstelling tot de OpenAI-assistent die gebruikmaakt van de cloud van OpenAI of de Azure AI-agent die gebruikmaakt van de Foundry-service van Azure, wordt de Bedrock-agent uitgevoerd op Amazon Bedrock. U moet een AWS-account hebben met toegang tot Bedrock (en de juiste IAM-machtigingen) om dit te kunnen gebruiken. De levenscyclus van de agent (maken, sessies, verwijderen) en bepaalde uitvoeringen van hulpprogramma's worden beheerd door AWS-services, terwijl hulpprogramma's voor het aanroepen van functies lokaal in uw omgeving worden uitgevoerd.

• Basismodelselectie: Bij het maken van een Bedrock Agent geeft u op welk basismodel (bijvoorbeeld een Amazon Titan- of partnermodel) het moet worden gebruikt. Alleen modellen waaraan u toegang hebt, kunnen worden gebruikt. Dit verschilt van chatvoltooiingsagenten (die u instantieert met een direct model-eindpunt) - met Bedrock wordt het model gekozen tijdens het maken van de agent als standaardfunctionaliteit voor de agent.

• IAM-rolvereiste: Bedrock-agents vereisen dat een IAM-rol ARN tijdens de creatie wordt geleverd. Deze rol moet namens u machtigingen hebben om het gekozen model (en alle geïntegreerde hulpprogramma's) aan te roepen. Dit zorgt ervoor dat de agent over de benodigde bevoegdheden beschikt om de acties uit te voeren (bijvoorbeeld code uit te voeren of toegang te krijgen tot andere AWS-services) onder uw AWS-account.

• Ingebouwde hulpprogramma's (actiegroepen): Bedrock ondersteunt ingebouwde "actiegroepen" (hulpprogramma's) die aan een agent kunnen worden gekoppeld. U kunt bijvoorbeeld een codeinterpreteractiegroep inschakelen om de agent toe te staan Python-code uit te voeren of een actiegroep Gebruikersinvoer om de agent toestemming te geven om uitleg te vragen. Deze mogelijkheden zijn vergelijkbaar met de invoegtoepassing code-interpreter van OpenAI of functieaanroepen, maar in AWS worden ze expliciet geconfigureerd op de agent. Een Bedrock Agent kan ook worden uitgebreid met aangepaste Semantische Kernel-invoegtoepassingen (functies) voor domeinspecifieke hulpprogramma's, vergelijkbaar met andere agents.

• Op sessies gebaseerde threads: Gesprekken met een Bedrock Agent vinden plaats in threads die zijn gekoppeld aan Bedrock-sessies op AWS. Elke thread (sessie) wordt geïdentificeerd door een unieke id die wordt geleverd door de Bedrock-service en de gespreksgeschiedenis wordt opgeslagen door de service in plaats van in verwerking. Dit betekent dat dialogen met meerdere beurten behouden blijven op AWS en dat u context ophaalt via de sessie-id. De Semantische Kernel-klasse BedrockAgentThread abstraheert dit detail: wanneer u deze gebruikt, wordt er achter de schermen een Bedrock-sessie voor de agent gemaakt of voortgezet.

Kortom, BedrockAgent kunt u gebruikmaken van het krachtige agent-and-tools framework van Amazon Bedrock via Semantic Kernel, waardoor doelgerichte dialoog met door AWS gehoste modellen en hulpprogramma's wordt geboden. Het automatiseert de complexiteit van de Agent-API van Bedrock (agent maken, sessiebeheer, aanroepen van hulpprogramma's), zodat u ermee kunt communiceren in een geavanceerde, cross-language SK-interface.

Uw ontwikkelomgeving voorbereiden

Als u wilt beginnen met ontwikkelen met een BedrockAgent, stelt u uw omgeving in met de juiste Semantische Kernel-pakketten en zorgt u ervoor dat aan DE VEREISTEN van AWS wordt voldaan.

Aanbeveling

Bekijk de AWS-documentatie over het configureren van uw omgeving voor het gebruik van de Bedrock-API.

Voeg het Semantic Kernel Bedrock Agents-pakket toe aan uw .NET-project:

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

Hiermee wordt de Semantic Kernel SDK-ondersteuning voor Bedrock, inclusief afhankelijkheden van de AWS SDK voor Bedrock, opgenomen. Mogelijk moet u ook AWS-referenties configureren (bijvoorbeeld via omgevingsvariabelen of de standaard-AWS-configuratie). De AWS SDK gebruikt uw geconfigureerde referenties; zorg ervoor dat uw AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEYen de standaardregio zijn ingesteld in uw omgeving of AWS-profiel. (Zie de documentatie van AWS over referentieconfiguratie voor meer informatie.)

Installeer het Semantic Kernel-pakket met de AWS-extra's:

pip install semantic-kernel[aws]

Dit zorgt ervoor dat de benodigde AWS-bibliotheken (bijvoorbeeld boto3) naast Semantische kernel worden geïnstalleerd. Voordat u een Bedrock Agent in Python gebruikt, moet u ervoor zorgen dat uw AWS-referenties en -regio correct zijn geconfigureerd (bijvoorbeeld door omgevingsvariabelen in te stellen of de AWS CLI te gebruiken). U moet AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY en AWS_DEFAULT_REGION (of een AWS-profiel) instellen zodat boto3 kan authenticeren.

Functie is momenteel niet beschikbaar in Java.

Een BedrockAgent maken

Het maken van een Bedrock-agent omvat twee stappen: eerst het definiëren van de agent met Amazon Bedrock (inclusief het selecteren van een model en het verstrekken van initiële instructies) en vervolgens het Semantische Kernel-agentobject instantiëren om ermee te communiceren. Wanneer u de agent in AWS maakt, wordt deze gestart in een niet-voorbereide status, zodat er een extra 'prepare'-bewerking wordt uitgevoerd om deze gereed te maken voor gebruik.

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

In de bovenstaande code gebruiken we eerst de AWS SDK (AmazonBedrockClient) om een agent op Bedrock te maken, waarbij het basismodel, een naam, de instructies en de ARN van de IAM-rol worden opgegeven die de agent moet aannemen. De Bedrock-service reageert met een agentdefinitie (inclusief een unieke AgentId). Vervolgens wordt PrepareAgentAsync aangeroepen om de agent naar een gereedstatus over te zetten (de agent wordt verplaatst van de status CREATING naar NOT_PREPARED en vervolgens naar PREPARED zodra deze gereed is). Ten slotte maken we een BedrockAgent object met behulp van de geretourneerde definitie en de AWS-clients. Dit BedrockAgent exemplaar wordt gebruikt om berichten te verzenden en antwoorden te ontvangen.

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

In het bovenstaande voorbeeld verzorgt BedrockAgent.create_and_prepare_agent de volledige aanmaakstroom: het maakt gebruik van uw AWS-configuratie (via boto3) om een agent op Bedrock te maken met de opgegeven naam, het foundation model en de instructies. Vervolgens wacht het automatisch totdat de agent de status Gereed heeft bereikt (de voorbereidingsstap intern uitvoeren). Het resultaat is een BedrockAgent instantie die gereed is voor gebruik. Onder de schermen maakt deze methode AWS-clients (voor Bedrock en Bedrock Runtime) met behulp van uw standaardreferenties, dus zorg ervoor dat uw AWS-omgeving is ingesteld. Als u een aangepaste configuratie nodig hebt, kunt u de AWS-clients ook handmatig samenstellen en deze doorgeven als parameters (bijvoorbeeld client= boto3.client("bedrock") en runtime_client= boto3.client("bedrock-runtime")) aan de create_and_prepare_agent aanroep.

Functie is momenteel niet beschikbaar in Java.

Het bestaande BedrockAgent ophalen

Zodra een agent is gemaakt op Bedrock, kan de unieke id (agent-id) worden gebruikt om deze later op te halen. Hierdoor kunt u een nieuwe instantie van een BedrockAgent in Semantic Kernel maken zonder dat u deze helemaal opnieuw hoeft te maken.

Voor .NET is de id van de Bedrock-agent een tekenreeks die toegankelijk is via agent.Id. Als u een bestaande agent op id wilt ophalen, gebruikt u de AWS Bedrock-client en maakt u vervolgens een nieuwe BedrockAgent:

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

Hier roepen GetAgentAsync we de IAmazonBedrock client aan met de bekende id, die de definitie van de agent retourneert (naam, model, instructies, enzovoort). Vervolgens initialiseren we een nieuwe BedrockAgent met die definitie en dezelfde clients. Dit agentexemplaar zal worden gekoppeld aan de bestaande Bedrock-agent.

In Python kunt u op dezelfde manier een agent ophalen met behulp van de AWS Bedrock boto3-client en deze vervolgens verpakken in een 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"])

In dit fragment gebruiken we boto3 om de Bedrock-service aan te roepen get_agent (het uitvoeren in een thread via asyncio.to_thread omdat boto3 wordt geblokkeerd). Het geretourneerde agent_info["agent"] bestand bevat de details van de agent (id, naam, status, enzovoort), die we doorgeven aan de constructor BedrockAgent. Omdat we geen AWS-klanten expliciet aan BedrockAgent hebben opgegeven, worden er intern nieuwe klanten met standaardinstellingen gemaakt. (Desgewenst kunt u client= en runtime_client= opgeven om clients opnieuw te gebruiken als u ze hebt.)

Functie is momenteel niet beschikbaar in Java.

Interactie met een BedrockAgent

Zodra u een BedrockAgent-exemplaar hebt, kunt u er eenvoudig mee communiceren (gebruikersberichten verzenden en AI-antwoorden ontvangen). De agent gebruikt threads om de gesprekscontext te beheren. Voor een Bedrock Agent komt een thread overeen met een AWS Bedrock-sessie. De Semantische Kernel-klasse BedrockAgentThread verwerkt het maken en bijhouden van sessies: wanneer u een nieuw gesprek start, wordt een nieuwe Bedrock-sessie gestart en terwijl u berichten verzendt, houdt Bedrock de afwisselende berichtengeschiedenis van de gebruiker/assistent bij. (Bedrock vereist dat chatgeschiedenis wisselt tussen gebruikers- en assistentberichten; Met de kanaallogica van semantische kernel worden indien nodig tijdelijke aanduidingen ingevoegd om dit patroon af te dwingen.) U kunt de agent aanroepen zonder een thread op te geven (in dat geval maakt SK automatisch een nieuwe BedrockAgentThread thread) of kunt u expliciet een thread maken/onderhouden als u een gesprek wilt voortzetten tussen meerdere oproepen. Elke aanroep retourneert een of meer antwoorden en u kunt de levensduur van de thread beheren (bijvoorbeeld verwijderen wanneer u klaar bent om de AWS-sessie te beëindigen).

De details van de Bedrock-agentthread worden geabstraheerd door de BedrockAgentThread klasse (die de gemeenschappelijke AgentThread interface implementeert). De BedrockAgent ondersteunt momenteel alleen threads van het type 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 dit voorbeeld maken we expliciet een BedrockAgentThread (waarbij we de runtimeClient doorgeven, die gebruikt wordt om te communiceren met de Bedrock Runtime-service). We roepen vervolgens agent.InvokeAsync(...) aan met een ChatMessageContent dat het bericht van een gebruiker vertegenwoordigt. InvokeAsync retourneert een asynchrone stroom antwoorden: in de praktijk retourneert een Bedrock-agent meestal één laatste antwoord per aanroep (omdat tussenliggende hulpprogrammaacties afzonderlijk worden verwerkt), zodat u meestal één keer ChatMessageContent uit de lus krijgt. We drukken het antwoord van de assistent af (response.Content). In het laatste blok verwijderen we de thread, waardoor de Bedrock-sessie op AWS wordt beëindigd. In dit geval verwijderen we ook de agent zelf (omdat we deze net voor dit voorbeeld hebben gemaakt). Deze stap is optioneel en alleen nodig als u de agent niet opnieuw wilt gebruiken (zie Hieronder een BedrockAgent verwijderen).

U kunt een bestaand gesprek voortzetten door hetzelfde agentThread te hergebruiken voor volgende oproepen. U kunt bijvoorbeeld het lezen van gebruikersinvoer herhalen en InvokeAsync elke keer aanroepen met dezelfde thread om een meer-staps dialoog uit te voeren. U kunt ook een BedrockAgentThread maken met een bekende sessie-id om een gesprek te hervatten dat eerder is opgeslagen:

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

Het gebruik van een Bedrock Agent in Python is vergelijkbaar met het BedrockAgentThread beheren van de sessie. U kunt een nieuwe thread starten of een bestaande thread doorgeven om door te gaan met een gesprek:

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 deze code doorlopen we een aantal gebruikersinvoer. Bij elke iteratie roepen we agent.get_response(...) aan met het gebruikersbericht en de huidige thread. De eerste oproep start de Bedrock-sessie en retourneert een AgentResponseItem (of ChatMessageContent) met het antwoord van de assistent. We printen de reactie, waarna we het response.thread pakken – dat hetzelfde BedrockAgentThread is, bijgewerkt met de nieuwe berichtcontext – om te gebruiken voor de volgende beurt. Na het gesprek (in dit voorbeeld twee beurten), verwijderen we de thread om de sessie op AWS te beëindigen.

Als u de thread parameter weglaat in de aanroep, dan zullen agent.get_response of agent.invoke automatisch een nieuwe thread voor die aanroep maken en deze in het antwoord opnemen.

U kunt desgewenst ook een batch berichten tegelijk verzenden door een lijst met berichten door te geven aan get_response of met behulp van de asynchrone streamingaanroep. Als u bijvoorbeeld het antwoord van de assistent (token per token) wilt streamen voor één prompt:

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

De invoke_stream(...) methode levert objecten op ChatMessageContent wanneer het antwoord wordt gegenereerd. Door deze te herhalen, kunt u het antwoord van de assistent incrementeel uitvoeren (hier drukken we tekens af zonder een nieuwe regel om het volledige antwoord te vormen).

Functie is momenteel niet beschikbaar in Java.

Het verwijderen van een BedrockAgent

Bedrock Agents zijn permanente resources in uw AWS-account – ze blijven aanwezig (en kunnen mogelijk kosten veroorzaken of meetellen voor servicelimieten) totdat ze worden verwijderd. Als u geen agent meer nodig hebt die u hebt gemaakt, moet u deze verwijderen via de Api van de Bedrock-service.

Gebruik de Bedrock-client om te verwijderen op Agent-ID. Voorbeeld:

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

Na deze aanroep wordt de status van de agent gewijzigd en kan deze niet meer worden gebruikt. (Als u een verwijderde agent probeert aan te roepen, treedt er een fout op.)

Roep de verwijderingsmethode van de agent aan. Bijvoorbeeld:

await agent.delete_agent()

Hiermee wordt de Bedrock-service aangeroepen om de agent te verwijderen (en het object intern te markeren BedrockAgent als verwijderd). U kunt dit verifiëren door agent.id te controleren of een markering indien opgegeven (bijvoorbeeld _is_deleted).

Notitie: Als u een Bedrock-agent verwijdert, worden de lopende sessies niet automatisch beëindigd. Als u langlopende sessies (threads) hebt, moet u deze beëindigen door de threads te verwijderen (wat achter de schermen Bedrock's EndSession en DeleteSession aanroept). In de praktijk eindigt het verwijderen van een thread (zoals in de bovenstaande voorbeelden) de sessie.

Functie is momenteel niet beschikbaar in Java.

Tussenliggende berichten verwerken met een BedrockAgent

Wanneer een Bedrock-agent hulpprogramma's (actiegroepen) aanroept om een antwoord te krijgen, worden deze tussenliggende stappen (functieaanroepen en resultaten) standaard intern verwerkt. Het uiteindelijke antwoord van de agent verwijst naar het resultaat van deze hulpprogramma's, maar bevat niet automatisch uitgebreide stapsgewijze details. Met Semantische kernel kunt u echter gebruikmaken van deze tussenliggende berichten voor logboekregistratie of aangepaste verwerking door een callback te bieden.

Tijdens agent.invoke(...) of agent.invoke_stream(...)kunt u een on_intermediate_message callback-functie opgeven. Deze callback wordt aangeroepen voor elk tussenliggend bericht dat wordt gegenereerd tijdens het opstellen van het uiteindelijke antwoord. Tussenliggende berichten kunnen zijn FunctionCallContent (wanneer de agent besluit een functie/hulpprogramma aan te roepen) en FunctionResultContent (wanneer een hulpprogramma een resultaat retourneert).

Stel dat onze Bedrock Agent toegang heeft tot een eenvoudige invoegtoepassing (of ingebouwd hulpprogramma) voor menugegevens, vergelijkbaar met de voorbeelden die worden gebruikt met OpenAI Assistant:

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

Wanneer de agent in deze code een functie MenuPlugin moet aanroepen (bijvoorbeeld get_specials of get_item_price), wordt met de handle_intermediate_steps callback een regel voor de functieaanroep afgedrukt en een andere regel voor het functieresultaat. Het uiteindelijke antwoord van de assistent voor elke gebruikersquery wordt vervolgens als normaal afgedrukt. Door de tussenliggende inhoud te observeren, kunt u traceren hoe de agent bij het antwoord is aangekomen (welk hulpprogramma is gebruikt, wat er is geretourneerd, enzovoort).

De uitvoer kan er bijvoorbeeld als volgt uitzien:

# 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 de bovenstaande interactie tonen de tussenliggende afdrukken aan dat de agent MenuPlugin.get_specials en MenuPlugin.get_item_price op de juiste momenten heeft aangeroepen en hun resultaten heeft gebruikt om de gebruiker te beantwoorden. Deze tussenliggende gegevens kunnen indien nodig in uw toepassingslogica worden geregistreerd of gebruikt (bijvoorbeeld om de stappen weer te geven die de agent heeft uitgevoerd).

Callback-ondersteuning voor tussenliggende berichten in BedrockAgent (C#) volgt een vergelijkbaar patroon, maar de exacte API is in ontwikkeling. (Toekomstige releases zullen toestaan dat een gemachtigde wordt geregistreerd om FunctionCallContent en FunctionResultContent te verwerken tijdens InvokeAsync.)

Functie is momenteel niet beschikbaar in Java.

Declaratieve YAML gebruiken om een Bedrock-agent te definiëren

Het agentframework van Semantic Kernel ondersteunt een declaratief schema voor het definiëren van agents via YAML (of JSON). Hiermee kunt u de configuratie van een agent , het type, de modellen, hulpprogramma's, enzovoort, opgeven in een bestand en die agentdefinitie vervolgens tijdens runtime laden zonder dat u imperatieve code hoeft te schrijven om deze samen te stellen.

Notitie: Op YAML gebaseerde agentdefinities zijn een opkomende functie en kunnen experimenteel zijn. Zorg ervoor dat u een Semantische kernelversie gebruikt die ondersteuning biedt voor het laden van YAML-agent en raadpleeg de meest recente documenten voor eventuele indelingswijzigingen.

Als u een declaratieve specificatie gebruikt, kunt u de configuratie vereenvoudigen, met name als u eenvoudig van agentinstallatie wilt wisselen of een configuratiebestandsbenadering wilt gebruiken. Voor een Bedrock-agent kan een YAML-definitie er als volgt uitzien:

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 deze (hypothetische) YAML definiëren we een agent van het type bedrock_agent, geven we deze een naam en instructies, geven we het basismodel op basis van id op en geven we de ARN op van de rol die moet worden gebruikt. We declareren ook een aantal hulpprogramma's: een die de ingebouwde code-interpreter inschakelt, een andere die het ingebouwde hulpprogramma voor gebruikersinvoer inschakelt en een aangepast MenuPlugin (die afzonderlijk in code wordt gedefinieerd en geregistreerd als een kernelfunctie). Een dergelijk bestand bevat de installatie van de agent in een door mensen leesbare vorm.

Als u een agent uit YAML wilt instantiëren, gebruikt u de statische loader met een geschikte factory-methode. Voorbeeld:

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

Hiermee parseert u de YAML en produceert u een BedrockAgent exemplaar (of een ander type op basis van het type veld) met behulp van de opgegeven kernel en factory.

BedrockAgent Declarative Spec handling is binnenkort beschikbaar.

Functie is momenteel niet beschikbaar in Java.

Het gebruik van een declaratief schema kan bijzonder krachtig zijn voor het configureren en testen van scenario's, omdat u modellen of instructies kunt wisselen door een configuratiebestand te bewerken in plaats van code te wijzigen. Houd de documentatie en voorbeelden van Semantic Kernel in de gaten voor meer informatie over YAML-agentdefinities naarmate de functie zich ontwikkelt.

Overige resources

• Documentatie voor AWS Bedrock: Voor meer informatie over de agentmogelijkheden van Amazon Bedrock raadpleegt u Amazon Bedrock Agents in de AWS-documentatie (bijvoorbeeld het configureren van basismodeltoegang en IAM-rollen). Als u de onderliggende service begrijpt, kunt u de juiste machtigingen instellen en optimaal profiteren van de ingebouwde hulpprogramma's.
• Semantische kernelvoorbeelden: de Semantische kernelopslagplaats bevat conceptvoorbeelden voor Bedrock Agents. Het basischatvoorbeeld van Bedrock Agent in de Python-voorbeelden demonstreert bijvoorbeeld eenvoudige Q&A met een BedrockAgent, en het voorbeeld van de Bedrock Agent met Code Interpreter laat zien hoe u het hulpprogramma Code Interpreter inschakelt en gebruikt. Deze voorbeelden kunnen een goed uitgangspunt zijn om BedrockAgent in actie te zien.

Met de geïntegreerde Amazon Bedrock Agent maakt Semantic Kernel echte AI-oplossingen met meerdere platforms mogelijk, ongeacht of u OpenAI, Azure OpenAI of AWS Bedrock gebruikt, kunt u uitgebreide gesprekstoepassingen bouwen met hulpprogramma-integratie met behulp van een consistent framework. Hiermee BedrockAgent opent u de deur voor het gebruik van de nieuwste basismodellen van AWS en het veilige, uitbreidbare agentparadigma binnen uw Semantische Kernel-projecten.

Volgende stappen

De chatvoltooiingsagent verkennen