Udostępnij przez

Eksplorowanie jądra semantycznego BedrockAgent

Ważne

Funkcje pojedynczego agenta, takie jak BedrockAgent, są obecnie na etapie eksperymentalnym. Te funkcje są aktywnie opracowywane i mogą ulec zmianie przed osiągnięciem ogólnej dostępności.

Szczegółowa dokumentacja interfejsu API związana z tą dyskusją jest dostępna pod adresem:

Dokumentacja interfejsu API BedrockAgent będzie dostępna wkrótce.

Dokumentacja interfejsu API BedrockAgent będzie dostępna wkrótce.

Funkcja jest obecnie niedostępna w języku Java.

Co to jest BedrockAgent?

Agent Bedrock to specjalistyczny agent sztucznej inteligencji w Semantic Kernel zaprojektowany do integracji z usługą Agent usługi Amazon Bedrock. Podobnie jak agenci OpenAI i Azure AI, agent Bedrock umożliwia zaawansowane funkcje konwersacyjne obejmujące wielokrotne wymiany zdań dzięki płynnej integracji z narzędziami (akcjami), ale działa całkowicie w ekosystemie AWS. Automatyzuje wywołanie funkcji/narzędzia (nazywane grupami akcji w narzędziu Bedrock), dzięki czemu nie trzeba ręcznie analizować i wykonywać akcji, a także bezpiecznie zarządza stanem konwersacji na platformie AWS za pośrednictwem sesji, co zmniejsza konieczność utrzymania historii czatów w aplikacji.

Agent Bedrock różni się od innych typów agentów na kilka kluczowych sposobów:

  • Wykonywanie zarządzane platformy AWS: W przeciwieństwie do asystenta OpenAI korzystającego z chmury openAI lub agenta usługi Azure AI korzystającego z usługi Foundry platformy Azure, agent Bedrock działa w usłudze Amazon Bedrock. Aby z niego korzystać, musisz mieć konto AWS z dostępem do Bedrock (i odpowiednimi uprawnieniami IAM). Cykl życia agenta (tworzenie, sesje, usuwanie) i niektóre wykonania narzędzi są zarządzane przez usługi AWS, a narzędzia wywołujące funkcje są wykonywane lokalnie w danym środowisku.

  • Wybór modelu podstawowego: Podczas tworzenia agenta Bedrock należy określić, który model podstawowy (np. model Amazon Titan lub model partnera) powinien być używany. Można używać tylko modeli, do których udzielono dostępu. Różni się to od agentów uzupełniania czatów (które są tworzone przy użyciu bezpośredniego punktu końcowego modelu) — w przypadku narzędzia Bedrock model jest wybierany w czasie tworzenia agenta jako domyślna funkcja agenta.

  • Wymaganie roli IAM: Agenci Bedrock wymagają podania ARN roli IAM przy tworzeniu. Ta rola musi mieć uprawnienia do wywoływania wybranego modelu (i wszystkich zintegrowanych narzędzi) w Twoim imieniu. Gwarantuje to, że agent ma niezbędne uprawnienia do wykonywania swoich akcji (na przykład uruchamiania kodu lub uzyskiwania dostępu do innych usług AWS) na koncie platformy AWS.

  • Wbudowane narzędzia (grupy akcji): Bedrock obsługuje wbudowane „grupy akcji” (narzędzia), które można dołączyć do agenta. Można na przykład włączyć grupę akcji Interpreter kodu, aby umożliwić agentowi wykonywanie kodu w języku Python lub grupę akcji Wprowadzania danych przez użytkownika, aby umożliwić agentowi wywoływanie monitu o doprecyzowanie. Te możliwości są analogiczne do wtyczki lub wywołania funkcji interpretera kodu OpenAI, ale w usługach AWS są one konfigurowane jawnie na agencie. Agent typu Bedrock można również rozszerzyć za pomocą niestandardowych wtyczek jądra semantycznego (funkcji) dla narzędzi specyficznych dla domeny, podobnie jak inne agenty.

  • Wątki oparte na sesji: Rozmowy z agentem Bedrock występują w wątkach związanych z sesjami Bedrock na PLATFORMIE AWS. Każdy wątek (sesja) jest identyfikowany przez unikatowy identyfikator dostarczony przez usługę Bedrock, a historia konwersacji jest przechowywana przez usługę, a nie w procesie. Oznacza to, że dialogi wieloetapowe są utrwalane na platformie AWS, a kontekst jest pobierany za pośrednictwem identyfikatora sesji. Klasa Semantic Kernel BedrockAgentThread abstrahuje ten szczegół – gdy jej używasz, tworzy lub kontynuuje sesję Bedrock w tle dla agenta.

Podsumowując, BedrockAgent pozwala wykorzystać zaawansowaną strukturę agentów i narzędzi firmy Amazon Bedrock za pośrednictwem semantycznego jądra, zapewniając ukierunkowany na cel dialog z modelami i narzędziami hostowanymi przez platformę AWS. Automatyzuje zawiłości interfejsu API agenta Bedrock (tworzenie agenta, zarządzanie sesjami, uruchamianie narzędzi), dzięki czemu można wchodzić w interakcję z systemem za pomocą interfejsu SK o wysokim poziomie abstrakcji.

Przygotowywanie środowiska projektowego

Aby rozpocząć programowanie z BedrockAgent, skonfiguruj swoje środowisko za pomocą odpowiednich pakietów Semantic Kernel i upewnij się, że są spełnione wymagania wstępne platformy AWS.

Wskazówka

Zapoznaj się z dokumentacją platformy AWS dotyczącą konfigurowania środowiska do korzystania z interfejsu API Bedrock.

Dodaj pakiet Semantic Kernel Bedrock Agents do projektu platformy .NET:

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

Spowoduje to włączenie obsługi zestawu SDK jądra semantycznego dla narzędzia Bedrock, w tym zależności od zestawu AWS SDK for Bedrock. Może być również konieczne skonfigurowanie poświadczeń platformy AWS (np. za pomocą zmiennych środowiskowych lub domyślnej konfiguracji platformy AWS). AWS SDK będzie używał skonfigurowanych poświadczeń; upewnij się, że masz ustawiony AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY i domyślny region w swoim środowisku lub profilu AWS. (Aby uzyskać więcej informacji, zobacz dokumentację platformy AWS dotyczącą konfiguracji poświadczeń).

Zainstaluj pakiet semantycznego jądra przy użyciu dodatków platformy AWS:

pip install semantic-kernel[aws]

Gwarantuje to zainstalowanie niezbędnych bibliotek platformy AWS (np. boto3) wraz z semantycznym jądrem. Przed użyciem agenta Bedrock w języku Python upewnij się, że poświadczenia i region platformy AWS są prawidłowo skonfigurowane (na przykład przez ustawienie zmiennych środowiskowych lub użycie interfejsu wiersza polecenia platformy AWS). Należy ustawić AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY i AWS_DEFAULT_REGION (lub profil AWS), aby boto3 mógł się uwierzytelnić.

Funkcja jest obecnie niedostępna w języku Java.

Tworzenie BedrockAgent

Utworzenie agenta Bedrock obejmuje dwa kroki: najpierw zdefiniowanie agenta za pomocą narzędzia Amazon Bedrock (w tym wybranie modelu i podanie początkowych instrukcji), a następnie utworzenie wystąpienia obiektu agenta jądra semantycznego w celu interakcji z nim. Po utworzeniu agenta na platformie AWS rozpoczyna się on w stanie nieprzygotowym, więc jest wykonywana dodatkowa operacja "prepare", aby przygotować ją do użycia.

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

W powyższym kodzie najpierw użyjemy zestawu AWS SDK (AmazonBedrockClient), aby utworzyć agenta w usłudze Bedrock, określając model podstawowy, nazwę, instrukcje i nazwę ARN roli IAM, jaką powinien przyjąć agent. Usługa Bedrock odpowiada za pomocą definicji agenta (w tym unikatowego identyfikatora AgentId). Następnie wywołujemy PrepareAgentAsync, aby przejść agenta do stanu GOTOWOŚCI (agent przejdzie ze stanu TWORZENIE do NOT_PRZYGOTOWANY, a następnie do PRZYGOTOWANY, gdy będzie gotowy). Na koniec skonstruujemy BedrockAgent obiekt przy użyciu zwróconej definicji i klientów platformy AWS. To BedrockAgent wystąpienie służy do wysyłania komunikatów i odbierania odpowiedzi.

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

W przykładzie powyżej BedrockAgent.create_and_prepare_agent zarządza pełnym procesem tworzenia: używa konfiguracji platformy AWS (za pośrednictwem boto3) do utworzenia agenta na Bedrock z daną nazwą, modelem bazowym i instrukcjami, a następnie automatycznie czeka, aż agent osiągnie stan gotowości (wewnętrznie wykonując krok przygotowawczy). Wynikiem jest BedrockAgent instancja gotowa do użycia. Ta metoda polega na tworzeniu klientów platformy AWS (dla środowiska Bedrock i Bedrock Runtime) przy użyciu poświadczeń domyślnych, dlatego upewnij się, że środowisko AWS jest skonfigurowane. Jeśli potrzebujesz konfiguracji niestandardowej, możesz również ręcznie skonstruować klientów platformy AWS i przekazać je jako parametry (np. client= boto3.client("bedrock") i runtime_client= boto3.client("bedrock-runtime")) do wywołania create_and_prepare_agent .

Funkcja jest obecnie niedostępna w języku Java.

Pobieranie istniejącej BedrockAgent

Po utworzeniu agenta w usłudze Bedrock można użyć jego identyfikatora (identyfikatora agenta), aby później go odzyskać. Dzięki temu można ponownie utworzyć wystąpienie BedrockAgent w semantycznym jądrze bez ponownego utworzenia go od podstaw.

W przypadku platformy .NET identyfikator agenta Bedrock jest ciągiem dostępnym za pośrednictwem agent.Id. Aby pobrać istniejącego agenta według identyfikatora, użyj klienta AWS Bedrock, a następnie skonstruuj nowy element BedrockAgent:

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

W tym miejscu wywołujemy GetAgentAsync na kliencie IAmazonBedrock o znanym identyfikatorze, co zwraca definicję agenta (nazwę, model, instrukcje itp.). Następnie zainicjujemy nową BedrockAgent przy użyciu tej definicji i tych samych klientów. Wystąpienie tego agenta zostanie połączone z istniejącym agentem Bedrock.

W języku Python możesz podobnie pobrać agenta za pomocą identyfikatora używając klienta AWS Bedrock boto3, a następnie opakować go w 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"])

W tym fragmencie używamy boto3 do wywołania get_agent na usłudze Bedrock (uruchamiając ją w wątku za pośrednictwem asyncio.to_thread, ponieważ boto3 jest blokujący). Zwrócony agent_info["agent"] element zawiera szczegóły agenta (identyfikator, nazwa, stan itp.), które przekazujemy do konstruktora BedrockAgent. Ponieważ nie dostarczyliśmy jawnie klientów AWS do BedrockAgent, zostaną one utworzone wewnętrznie z domyślnymi ustawieniami. (Opcjonalnie możesz podać client= i runtime_client=, aby ponownie wykorzystać klientów, jeśli je masz).

Funkcja jest obecnie niedostępna w języku Java.

Interakcja z BedrockAgent

Po utworzeniu wystąpienia BedrockAgent interakcja z nim (wysyłanie komunikatów użytkowników i odbieranie odpowiedzi sztucznej inteligencji) jest prosta. Agent używa wątków do zarządzania kontekstem konwersacji. Dla Agenta Bedrock, wątek odpowiada sesji AWS Bedrock. Jądro Semantyczne BedrockAgentThread obsługuje rozpoczynanie sesji i ich śledzenie: po rozpoczęciu nowej konwersacji uruchamiana jest nowa sesja Bedrock, a gdy wysyłasz wiadomości, Bedrock utrzymuje historię wiadomości użytkownika i asystenta naprzemiennie. (Bedrock wymaga, aby historia czatów naprzemiennie obejmowała wiadomości użytkownika i asystenta. Logika kanałów Semantic Kernel wstawi symbole zastępcze w razie konieczności, aby wymusić ten wzorzec). Można wywołać agenta bez określania wątku (wówczas SK utworzy nową BedrockAgentThread automatycznie) lub można jawnie utworzyć/zachować wątek, jeśli chcesz kontynuować konwersację przez wiele wywołań. Każde wywołanie zwraca co najmniej jedną odpowiedź i można zarządzać okresem istnienia wątku (np. usunięciem go po zakończeniu sesji platformy AWS).

Szczegóły wątku agenta Bedrock są abstrakcjonowane przez klasę BedrockAgentThread (która implementuje wspólny interfejs AgentThread). Obecnie BedrockAgent obsługuje tylko wątki typu 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 });
}

W tym przykładzie jawnie tworzymy BedrockAgentThread (przekazując runtimeClient, który jest używany do komunikacji z serwisem środowiska uruchomieniowego Bedrock). Następnie wywołujemy agent.InvokeAsync(...) z ChatMessageContent, które reprezentuje komunikat użytkownika. InvokeAsync Zwraca asynchroniczny strumień odpowiedzi — w praktyce agent Bedrock zwykle zwraca jedną ostateczną odpowiedź na wywołanie (ponieważ akcje narzędzia pośredniego są obsługiwane oddzielnie), więc zwykle otrzymasz pojedynczą odpowiedź ChatMessageContent z pętli. Wyświetlamy odpowiedź asystenta (response.Content). W końcu bloku usuniemy wątek, który kończy sesję Bedrock na platformie AWS. Usuwamy również samego agenta w tym przypadku (ponieważ utworzyliśmy go tylko w tym przykładzie) — ten krok jest opcjonalny i wymagany tylko wtedy, gdy nie zamierzasz ponownie używać agenta (zobacz Usuwanie narzędzia BedrockAgent poniżej).

Możesz kontynuować istniejącą konwersację, ponownie używając tego samego agentThread dla kolejnych połączeń. Na przykład możesz zapętlić proces odczytywania danych wejściowych użytkownika i wywoływanie InvokeAsync każdorazowo na tym samym wątku, aby kontynuować dialog wielotaktowy. Możesz również utworzyć element BedrockAgentThread ze znanym identyfikatorem sesji, aby wznowić konwersację, która została zapisana wcześniej:

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

Użycie agenta Bedrock w Pythonie jest podobne, ponieważ BedrockAgentThread zarządza sesją. Możesz uruchomić nowy wątek lub przekazać istniejący, aby kontynuować konwersację:

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

W tym kodzie iterujemy przez kilka danych wejściowych użytkownika. W każdej iteracji wywołujemy agent.get_response(...) z komunikatem użytkownika i bieżącym wątkiem. Pierwsze wywołanie uruchamia sesję Bedrock i zwraca wartość AgentResponseItem (lub ChatMessageContent) zawierającą odpowiedź asystenta. Wyświetlamy odpowiedź, a następnie pobieramy response.thread — który jest taki sam jak BedrockAgentThread, ale z zaktualizowanym kontekstem wiadomości — do użycia w następnym kroku. Po konwersacji (w tym przykładzie dwie kolei) usuniemy wątek, aby zakończyć sesję na platformie AWS.

Jeśli pominiesz parametr thread w wywołaniu, agent.get_response lub agent.invoke automatycznie utworzy nowy wątek dla tego wywołania i dołączy go do odpowiedzi.

Opcjonalnie możesz również wysłać partię komunikatów jednocześnie, przekazując listę komunikatów do get_response lub używając wywołania asynchronicznego przesyłania strumieniowego. Na przykład, aby przesyłać strumieniowo odpowiedzi asystenta (każdy token z osobna) dla pojedynczego zapytania:

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

Metoda invoke_stream(...) zwraca ChatMessageContent obiekty podczas generowania odpowiedzi. Iterując nad nim, możesz wyświetlić odpowiedź asystenta przyrostowo (tutaj drukujemy znaki bez nowego wiersza, aby utworzyć pełną odpowiedź).

Funkcja jest obecnie niedostępna w języku Java.

Usuwanie BedrockAgent

Agenci Bedrock są trwałymi zasobami na koncie platformy AWS — pozostaną (i potencjalnie będą ponosić koszty lub zliczać limity usług) do momentu usunięcia. Jeśli nie potrzebujesz już utworzonego agenta, usuń go za pośrednictwem interfejsu API usługi Bedrock.

Użyj klienta Bedrock do usunięcia według identyfikatora agenta. Przykład:

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

Po tym wywołaniu stan agenta zmieni się i nie będzie już można go używać. (Próba wywołania usuniętego agenta spowoduje wystąpienie błędu).

Wywołaj metodę usuwania agenta. Przykład:

await agent.delete_agent()

Spowoduje to wywołanie usługi Bedrock, aby usunąć agenta (i wewnętrznie oznaczyć BedrockAgent obiekt jako usunięty). Możesz sprawdzić, sprawdzając agent.id lub flagę, jeśli podano (np. _is_deleted).

Uwaga: Usunięcie agenta Bedrock nie powoduje automatycznego zakończenia trwających sesji. Jeśli masz długotrwałe sesje (wątki), należy je zakończyć, usuwając wątki (co wywołuje EndSession Bedrock i DeleteSession pod maską). W praktyce usunięcie wątku (jak pokazano w powyższych przykładach) kończy sesję.

Funkcja jest obecnie niedostępna w języku Java.

Obsługa komunikatów pośrednich za pomocą BedrockAgent

Gdy agent Bedrock wywołuje narzędzia (grupy akcji), aby uzyskać odpowiedź, te pośrednie kroki (wywołania funkcji i wyniki) są domyślnie obsługiwane wewnętrznie. Ostateczna odpowiedź agenta będzie odwoływać się do wyniku tych narzędzi, ale nie będzie automatycznie zawierać szczegółowych instrukcji krok po kroku. Jednak semantyczne jądro umożliwia korzystanie z tych komunikatów pośrednich na potrzeby rejestrowania lub obsługi niestandardowej, umożliwiając wywołanie zwrotne.

W trakcie agent.invoke(...) lub agent.invoke_stream(...)można podać funkcję wywołania zwrotnego on_intermediate_message . To wywołanie zwrotne będzie wywoływane dla każdego komunikatu pośredniego wygenerowanego w procesie formułowania ostatecznej odpowiedzi. Komunikaty pośrednie mogą zawierać FunctionCallContent (gdy agent zdecyduje się wywołać funkcję/narzędzie) i FunctionResultContent (gdy narzędzie zwraca wynik).

Załóżmy na przykład, że nasz agent Bedrock ma dostęp do prostej wtyczki (lub wbudowanego narzędzia) w celu uzyskania informacji o menu, podobnie jak w przypadku przykładów używanych z Asystentem 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()

W tym kodzie, za każdym razem, gdy agent musi wywołać funkcję z MenuPlugin (na przykład get_specials lub get_item_price), funkcja zwrotna handle_intermediate_steps wyświetli wiersz dla wywołania funkcji i inny wiersz dla wyniku funkcji. Ostateczna odpowiedź asystenta dla każdego zapytania użytkownika jest następnie drukowana normalnie. Obserwując zawartość pośrednią, możesz śledzić sposób, w jaki agent dotarł do odpowiedzi (jakie narzędzie zostało użyte, co zostało zwrócone itd.).

Na przykład dane wyjściowe mogą wyglądać następująco:

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

W powyższej interakcji pośrednie wydruki pokazują, że agent pomyślnie wywołał MenuPlugin.get_specials i MenuPlugin.get_item_price w odpowiednim czasie oraz użył ich wyników, aby odpowiedzieć użytkownikowi. Te szczegóły pośrednie mogą być rejestrowane lub używane w logice aplikacji zgodnie z potrzebami (na przykład w celu wyświetlenia kroków, które podjął agent).

Obsługa wywołań zwrotnych dla komunikatów pośrednich w narzędziu BedrockAgent (C#) jest zgodna z podobnym wzorcem, ale dokładny interfejs API jest opracowywany. (Przyszłe wersje umożliwią zarejestrowanie pełnomocnika do obsługi FunctionCallContent i FunctionResultContent w trakcie wykonywania operacji InvokeAsync).

Funkcja jest obecnie niedostępna w języku Java.

Definiowanie agenta Bedrock przy użyciu deklaratywnego kodu YAML

Struktura agenta jądra semantycznego obsługuje schemat deklaratywny do definiowania agentów za pośrednictwem kodu YAML (lub JSON). Dzięki temu można określić konfigurację agenta — jego typ, modele, narzędzia itp. — w pliku, a następnie załadować tę definicję agenta w czasie wykonywania bez konieczności pisania kodu imperatywnego, aby go skonstruować.

Nuta: Definicje agentów oparte na języku YAML są nową funkcją i mogą być eksperymentalne. Upewnij się, że używasz wersji jądra semantycznego, która obsługuje ładowanie agenta YAML, i zapoznaj się z najnowszymi dokumentami dotyczącymi wszelkich zmian w formacie.

Użycie specyfikacji deklaratywnej może uprościć konfigurację, zwłaszcza jeśli chcesz łatwo przełączyć konfigurację agenta lub użyć podejścia do pliku konfiguracji. W przypadku agenta Bedrock definicja YAML może wyglądać następująco:

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

W tym (hipotetycznym) YAML definiujemy agenta typu bedrock_agent, nadaj mu nazwę i instrukcje, określ model podstawy według identyfikatora i podaj nazwę ARN roli, która powinna być używana. Deklarujemy również kilka narzędzi: jedno włączenie wbudowanego interpretera kodu, drugie włączenie wbudowanego narzędzia do wprowadzania danych użytkownika i niestandardowe menuPlugin (które byłoby zdefiniowane oddzielnie w kodzie i zarejestrowane jako funkcja jądra). Taki plik ujmuje konfigurację agenta w postaci czytelnej dla człowieka.

Aby utworzyć wystąpienie agenta z poziomu YAML, użyj statycznego modułu ładującego z użyciem odpowiedniej fabryki. Przykład:

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

Spowoduje przeanalizowanie YAML i utworzenie wystąpienia BedrockAgent (lub innego typu na podstawie pola type) przy użyciu dostarczonego jądra i fabryki.

Obsługa specyfikacji deklaratywnej BedrockAgent będzie wkrótce dostępna.

Funkcja jest obecnie niedostępna w języku Java.

Użycie schematu deklaratywnego może być szczególnie zaawansowane w przypadku konfiguracji scenariusza i testowania, ponieważ można zamienić modele lub instrukcje, edytując plik konfiguracji, a nie zmieniając kodu. Zapoznaj się z dokumentacją i przykładami semantycznego jądra, aby uzyskać więcej informacji na temat definicji agenta YAML w miarę rozwoju funkcji.

Dodatkowe zasoby

  • Dokumentacja platformy AWS Bedrock: Aby dowiedzieć się więcej na temat możliwości agenta firmy Amazon Bedrock, zobacz Amazon Bedrock Agents (Agenci Amazon Bedrock ) w dokumentacji platformy AWS (np. jak skonfigurować dostęp do modelu podstawowego i role IAM). Zrozumienie działania usługi pomoże w poprawnym ustawieniu uprawnień i wykorzystaniu w pełni wbudowanych narzędzi.
  • Przykłady semantycznego kernela: repozytorium semantycznego kernela zawiera przykłady pojęć dla agentów Bedrock. Na przykład podstawowy przykład czatu w narzędziu Bedrock Agent w przykładach języka Python demonstruje proste pytania i odpowiedzi z BedrockAgent, a przykładowy agent Bedrock z interpreterem kodu pokazuje, jak włączyć i używać narzędzie Interpreter kodu. Te przykłady mogą być doskonałym punktem wyjścia, aby zobaczyć BedrockAgent w działaniu.

Dzięki zintegrowanemu agentowi Amazon Bedrock Jądro semantyczne umożliwia naprawdę wieloplatformowe rozwiązania sztucznej inteligencji — niezależnie od tego, czy używasz rozwiązań OpenAI, Azure OpenAI, czy AWS Bedrock, możesz tworzyć rozbudowane aplikacje konwersacyjne z integracją narzędzi przy użyciu spójnej struktury. Otwiera BedrockAgent drzwi do korzystania z najnowszych modeli fundamentów AWS i bezpiecznego, rozszerzalnego paradygmatu agenta w projektach Jądra Semantycznego.

Dalsze kroki

Eksplorowanie agenta uzupełniania czatu

  • Last updated on