Изучение семантического ядра BedrockAgent

Это важно

Функции одного агента, такие как BedrockAgent, в настоящее время находятся на экспериментальном этапе. Эти функции находятся в активной разработке и могут измениться, прежде чем достичь общедоступной доступности.

Подробная документация по API, связанная с этим обсуждением, доступна по адресу:

Документация по API BedrockAgent будет в ближайшее время.

Документация по API BedrockAgent будет в ближайшее время.

Функция в настоящее время недоступна в Java.

Что такое BedrockAgent?

Агент Bedrock — это специализированный агент ИИ в семантическом ядре, предназначенный для интеграции со службой агента Amazon Bedrock. Как и агенты OpenAI и Azure AI, агент Bedrock обеспечивает расширенные возможности многократного общения с плавной интеграцией инструментов (действий), но полностью функционирует в экосистеме AWS. Он автоматизирует вызов функции или инструмента (называемые группами действий в Bedrock), поэтому вам не нужно вручную анализировать и выполнять действия, а также безопасно управлять состоянием беседы в AWS с помощью сеансов, уменьшая необходимость поддержания журнала чата в приложении.

Агент Bedrock отличается от других типов агентов несколькими ключевыми способами:

• Управляемое выполнение AWS: В отличие от помощника OpenAI, использующего облако OpenAI или агент ИИ Azure, использующий службу Foundry Azure, агент Bedrock работает в Amazon Bedrock. Для его использования необходимо иметь учетную запись AWS с доступом к Bedrock (и соответствующим разрешениям IAM). Жизненный цикл агента (создание, сеансы, удаление) и определенные выполнения инструментов управляются службами AWS, а средства вызова функций выполняются локально в вашей среде.

• Выбор основной модели: При создании агента Bedrock необходимо указать, какую основную модель (например, модель Amazon Titan или модель от партнера) следует использовать. Можно использовать только модели, к которым вы получили доступ. Система отличается от агентов завершения чатов (которые создаются через непосредственный конечный пункт модели) — с Bedrock модель выбирается во время создания агента в качестве основной функции по умолчанию.

• Требование роли IAM: Агентам Bedrock необходимо предоставить ARN роли IAM при их создании. Эта роль должна иметь разрешения для вызова выбранной модели (и любых интегрированных средств) от вашего имени. Это гарантирует, что агент имеет необходимые привилегии для выполнения своих действий (например, выполнения кода или доступа к другим службам AWS) в вашей учетной записи AWS.

• Встроенные средства (группы действий): Bedrock поддерживает встроенные "группы действий" (средства), которые можно подключить к агенту. Например, можно включить группу действий интерпретатора кода, чтобы разрешить агенту выполнять код Python или группу действий ввода пользователей, чтобы разрешить агенту запрашивать уточнение. Эти возможности аналогичны подключаемым модулям или вызовам интерпретатора кода OpenAI, но в AWS они настраиваются явно на агенте. Агент Bedrock может быть также расширен с помощью пользовательских подключаемых модулей семантического ядра (функций) для специализированных инструментов, как и другие агенты.

• Потоки на основе сеансов: Беседы с агентом Bedrock происходят в потоках, связанных с сеансами Bedrock в AWS. Каждый поток (сеанс) определяется уникальным идентификатором, предоставленным службой Bedrock, и журнал бесед хранится службой, а не внутри процесса. Это означает, что многократные диалоги сохраняются в AWS, и контекст извлекается через идентификатор сеанса. Класс семантического ядра BedrockAgentThread абстрагирует эту информацию— при его использовании он создает или продолжает сеанс Bedrock за кулисами для агента.

В итоге BedrockAgent вы можете использовать мощную платформу агента и инструментов Amazon Bedrock с помощью семантического ядра, обеспечивая ориентированный на цели диалог с размещенными AWS моделями и инструментами. Это автоматизирует сложности API агента Bedrock (создание агента, управление сеансами, вызов инструментов), чтобы взаимодействовать с ним в интерфейсе SK высокого уровня.

Подготовка среды разработки

Чтобы начать разработку с BedrockAgent, настройте среду с соответствующими пакетами семантического ядра и убедитесь, что выполнены предварительные требования AWS.

Подсказка

Ознакомьтесь с документацией AWS по настройке среды для использования API Bedrock.

Добавьте пакет агентов семантического ядра Bedrock в проект .NET:

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

Это обеспечит поддержку SDK для семантического ядра в Bedrock, включая зависимости от AWS SDK для Bedrock. Также может потребоваться настроить учетные данные AWS (например, с помощью переменных среды или конфигурации AWS по умолчанию). Пакет SDK AWS будет использовать настроенные учетные данные; убедитесь, что у вас настроены AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, и указаны регион и регион по умолчанию в вашей среде или профиле AWS. (Дополнительные сведения см. в документации AWS по настройке учетных данных.)

Установите пакет семантического ядра с дополнительными компонентами AWS:

pip install semantic-kernel[aws]

Это гарантирует, что необходимые библиотеки AWS (например, boto3) будут установлены вместе с семантическим ядром. Прежде чем использовать агент Bedrock в Python, убедитесь, что учетные данные и регион AWS настроены правильно (например, задав переменные среды или используя ИНТЕРФЕЙС КОМАНДНОй строки AWS). Необходимо задать AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, и AWS_DEFAULT_REGION (или профиль AWS), чтобы boto3 мог пройти проверку подлинности.

Функция в настоящее время недоступна в Java.

Создание BedrockAgent

Создание агента Bedrock включает в себя два шага: сначала определение агента с Amazon Bedrock (включая выбор модели и предоставление начальных инструкций), а затем создание экземпляра объекта агента семантического ядра для взаимодействия с ним. При создании агента в AWS он запускается в не подготовленном состоянии, поэтому дополнительная операция подготовки выполняется для его подготовки к использованию.

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

В приведенном выше коде мы сначала используем пакет AWS SDK (AmazonBedrockClient) для создания агента в Bedrock, указывая базовую модель, имя, инструкции и ARN роли IAM, которую агент должен принять. Служба Bedrock предоставляет определение агента, включая уникальный идентификатор агента (AgentId). Затем мы вызываем PrepareAgentAsync, чтобы перевести агента в состояние готовности (агент перейдет из состояния СОЗДАНИЕ в НЕ_ГОТОВЫЙ, а затем в ГОТОВЫЙ, как только он будет готов). Наконец, мы создадим BedrockAgent объект с помощью возвращаемого определения и клиентов AWS. Этот BedrockAgent экземпляр используется для отправки сообщений и получения ответов.

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

В приведенном выше BedrockAgent.create_and_prepare_agent примере обрабатывает полный поток создания: он использует конфигурацию AWS (через boto3) для создания агента в Bedrock с заданным именем, базовой моделью и инструкциями, а затем автоматически ожидает, пока агент достигнет состояния готовности (выполнение этапа подготовки внутри). Результатом является экземпляр BedrockAgent, готовый к использованию. Этот метод создает клиенты AWS (для Bedrock и Bedrock Runtime) с использованием учетных данных по умолчанию, поэтому убедитесь, что среда AWS настроена. Если вам нужна настраиваемая конфигурация, вы также можете вручную создать клиенты AWS и передать их в качестве параметров (например client= boto3.client("bedrock") и runtime_client= boto3.client("bedrock-runtime")) в вызов create_and_prepare_agent функции.

Функция в настоящее время недоступна в Java.

Получение существующего BedrockAgent

После создания агента в Bedrock его уникальный идентификатор (идентификатор агента) можно использовать для его последующего получения. Это позволяет повторно создать экземпляр семантического BedrockAgent ядра без повторного создания экземпляра с нуля.

Для .NET идентификатор агента Bedrock является строкой, доступной через agent.Id. Чтобы получить существующего агента по идентификатору, используйте клиент AWS Bedrock и создайте новый BedrockAgent.

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

Здесь мы вызываем GetAgentAsync на клиенте IAmazonBedrock с известным идентификатором, который возвращает определение агента (имя, модель, инструкции и т. д.). Затем мы инициализируем новый BedrockAgent с этим определением и теми же клиентами. Этот экземпляр агента будет связан с уже существующим агентом Bedrock.

В Python можно аналогично получить агент по идентификатору с помощью клиента AWS Bedrock boto3, а затем упаковать его в 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"])

В этом фрагменте кода мы используем boto3 для вызова get_agent в службе Bedrock (запуская его в потоке через asyncio.to_thread, так как boto3 блокирует). Возвращенный agent_info["agent"] объект содержит сведения агента (идентификатор, имя, состояние и т. д.), которые передаются в конструктор BedrockAgent. Поскольку мы явно не предоставили BedrockAgent клиентов AWS, BedrockAgent будет создавать новых клиентов с настройками по умолчанию. (При необходимости можно предоставить client= и runtime_client=, чтобы повторно использовать клиентов, если они у вас есть.)

Функция в настоящее время недоступна в Java.

Взаимодействие с BedrockAgent

После того как у вас есть инстанция BedrockAgent, взаимодействие с BedrockAgent (отправка сообщений пользователей и получение ответов ИИ) просто. Агент использует потоки для управления контекстом беседы. Для агента Bedrock поток соответствует сеансу AWS Bedrock. Класс семантического ядра BedrockAgentThread обрабатывает создание и отслеживание сеансов: при запуске нового диалога запускается новый сеанс Bedrock, а по мере отправки сообщений Bedrock сохраняет чередующийся журнал сообщений пользователя или помощника. (Для этого требуется, чтобы журнал чатов переключял сообщения пользователей и помощников; Логика канала семантического ядра вставляет заполнители при необходимости для применения этого шаблона.) Вы можете вызвать агент без указания потока (в этом случае SK создаст новый BedrockAgentThread автоматически) или явно создать или сохранить поток, если вы хотите продолжить беседу в нескольких вызовах. Каждый вызов возвращает один или несколько ответов, и вы можете управлять временем существования потока (например, удаление его при завершении сеанса AWS).

Особенности потока агента Bedrock абстрагируются классом BedrockAgentThread (который реализует общий AgentThread интерфейс). В настоящее время BedrockAgent поддерживает только потоки типа 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 });
}

В этом примере мы явно создадим BedrockAgentThread (передавая runtimeClient объект, который используется для связи со службой среды выполнения Bedrock). Затем мы вызываем agent.InvokeAsync(...) с ChatMessageContent, представляющим сообщение пользователя. InvokeAsync возвращает асинхронный поток ответов — на практике агент Bedrock обычно возвращает один окончательный ответ на вызов (так как промежуточные действия инструмента обрабатываются отдельно), поэтому обычно вы получите один ChatMessageContent из цикла. Мы распечатаем ответ помощника (response.Content). В блоке finally мы удаляем поток выполнения, что приводит к завершению сеанса Bedrock в AWS. Мы также удаляем сам агент в этом случае (так как мы создали его только для этого примера) — этот шаг является необязательным и требуется только в том случае, если вы не планируете повторно использовать агент (см. раздел "Удаление BedrockAgent ниже").

Вы можете продолжить существующую беседу, повторно выполнив те же agentThread действия для последующих вызовов. Например, можно циклически считывать входные данные пользователя и вызывать InvokeAsync каждый раз с тем же потоком для выполнения диалога с несколькими поворотами. Вы также можете создать BedrockAgentThread с известным идентификатором сеанса, чтобы возобновить беседу, которая была сохранена ранее:

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

Использование агента Bedrock в Python аналогично, так как BedrockAgentThread управляет сеансом. Вы можете запустить новый поток или передать существующий, чтобы продолжить беседу:

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

В этом коде мы перебираем пару пользовательских вводов. Во время каждой итерации мы вызываем agent.get_response(...) с сообщением пользователя и текущим потоком. Первый вызов запускает сеанс Bedrock и возвращает AgentResponseItem (или ChatMessageContent), содержащий ответ помощника. Мы печатаем ответ, а затем берем response.thread — это тот же BedrockAgentThread, обновленный с учетом нового контекста сообщения, чтобы использовать его для следующего хода. После разговора (в этом примере два обмена репликами) мы удаляем тему, чтобы завершить сеанс в AWS.

Если параметр thread опущен в вызове, agent.get_response или agent.invoke автоматически создаст новый поток для этого вызова и включит его в ответ.

При необходимости вы также можете отправить пакет сообщений одновременно, передав список сообщений в get_response или воспользовавшись асинхронным потоковым вызовом. Например, чтобы передать ответ помощника (токен за токеном) для одного запроса:

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

Метод invoke_stream(...) выдает ChatMessageContent объекты по мере создания ответа. Выполнив итерацию, вы можете вывести ответ помощника постепенно (здесь мы печатаем символы без новой строки, чтобы сформировать полный ответ).

Функция в настоящее время недоступна в Java.

Удаление BedrockAgent

Агенты Bedrock являются постоянными ресурсами в вашей учетной записи AWS и будут оставаться там (возможны затраты или превышение лимитов на обслуживание) до тех пор, пока они не будут удалены. Если вы больше не нуждаетесь в созданном агенте, удалите его с помощью API службы Bedrock.

Используйте клиент Bedrock для удаления по идентификатору агента. Рассмотрим пример.

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

После этого вызова статус агента изменится, и он больше не будет пригоден для использования. (Попытка вызова удаленного агента приведет к ошибке.)

Вызовите метод удаления агента. Например:

await agent.delete_agent()

Это запустит службу Bedrock для удаления агента (и внутренне пометит объект BedrockAgent как удалённый). Вы можете проверить, проверив agent.id или флаг, если он указан (например, _is_deleted).

Заметка: Удаление агента Bedrock не приводит к автоматическому завершению его текущих сеансов. Если у вас есть длительные сеансы (потоки), их следует завершить, удалив потоки, что вызывает функции Bedrock "EndSession" и "DeleteSession". На практике удаление потока (как показано в приведенных выше примерах) завершает сеанс.

Функция в настоящее время недоступна в Java.

Обработка промежуточных сообщений с помощью BedrockAgent

Когда агент Bedrock вызывает средства (группы действий) для получения ответа, эти промежуточные шаги (вызовы функций и результаты) по умолчанию обрабатываются внутренне. Окончательный ответ агента будет ссылаться на результат этих средств, но не будет автоматически включать подробные пошаговые сведения. Однако семантический ядро позволяет использовать эти промежуточные сообщения для ведения журнала или пользовательской обработки, предоставляя обратный вызов.

Во время agent.invoke(...) или agent.invoke_stream(...)можно указать функцию обратного on_intermediate_message вызова. Этот обратный вызов будет вызван для каждого промежуточного сообщения, созданного в процессе формирования окончательного ответа. Промежуточные сообщения могут включать FunctionCallContent (когда агент решает вызвать функцию или инструмент) и FunctionResultContent (когда средство возвращает результат).

Например, предположим, что наш агент Bedrock имеет доступ к простому плагину (или встроенному инструменту) для информации о меню, аналогичной примерам, используемым с Помощником 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()

В этом коде, каждый раз, когда агенту нужно вызвать функцию из MenuPlugin (например, get_specials или get_item_price), колбэк handle_intermediate_steps выводит строку для вызова функции и другую для результата функции. Окончательный ответ помощника для каждого запроса пользователя затем печатается как обычный. Наблюдая за промежуточным содержимым, можно проследить, как агент прибыл к своему ответу (какой инструмент использовался, что он вернул и т. д.).

Например, выходные данные могут выглядеть следующим образом:

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

В приведенном выше взаимодействии промежуточные выводы показывают, что агент успешно вызвал функции MenuPlugin.get_specials и MenuPlugin.get_item_price в соответствующее время и использовал их результаты, чтобы ответить пользователю. Эти промежуточные сведения можно регистрировать или использовать в логике приложения по мере необходимости (например, для отображения действий агента).

Поддержка обратного вызова промежуточных сообщений в BedrockAgent (C#) соответствует аналогичному шаблону, но точный API находится в процессе разработки. (В будущих выпусках будет возможно зарегистрировать делегата для обработки FunctionCallContent и FunctionResultContent во время InvokeAsync.)

Функция в настоящее время недоступна в Java.

Использование декларативного YAML для определения агента Bedrock

Платформа агента семантического ядра поддерживает декларативную схему для определения агентов с помощью YAML (или JSON). Это позволяет указать конфигурацию агента — его тип, модели, инструменты и т. д. в файле, а затем загрузить это определение агента во время выполнения без написания императивного кода для его создания.

Заметка: Определения агента на основе YAML являются новой функцией и могут быть экспериментальными. Убедитесь, что вы используете версию семантического ядра, которая поддерживает загрузку агента YAML, и ознакомьтесь с последними документами по любым изменениям формата.

Использование декларативной спецификации может упростить настройку, особенно если вы хотите легко переключить настройки агента или использовать подход к файлу конфигурации. Для агента Bedrock определение YAML может выглядеть следующим образом:

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

В этом (гипотетическом) YAML мы определяем агент типа bedrock_agent, присваиваем ему имя и инструкции, указываем базовую модель по идентификатору и предоставляем ARN роли, которую он должен использовать. Мы также объявляем пару инструментов: один включает встроенный интерпретатор кода, другой включает встроенное средство ввода пользователя, и настраиваемый плагин для меню (который будет определён отдельно в коде и зарегистрирован в качестве функции ядра). Такой файл инкапсулирует настройку агента в форме, доступной для чтения человеком.

Чтобы создать экземпляр агента из YAML, используйте статический загрузчик данных с соответствующей фабрикой объектов. Рассмотрим пример.

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

Данный метод анализирует YAML и создаёт BedrockAgent экземпляр (или другой тип в зависимости от поля type), используя предоставленные ядро и фабрику.

Скоро будет доступна обработка декларативных спецификаций BedrockAgent.

Функция в настоящее время недоступна в Java.

Использование декларативной схемы может быть особенно эффективным для конфигурации и тестирования сценария, так как можно переключить модели или инструкции, изменив файл конфигурации, а не изменив код. Обратите внимание на документацию и примеры семантического ядра, чтобы получить дополнительные сведения об определениях агента YAML по мере развития функции.

Дополнительные ресурсы

• Документация по AWS Bedrock: Дополнительные сведения о возможностях агентов Amazon Bedrock см. в Amazon Bedrock Agents в документации AWS (например, как настроить доступ к модели и роли IAM). Понимание принципов работы службы поможет правильно настроить разрешения и эффективно использовать встроенные средства.
• Примеры семантического ядра: репозиторий семантического ядра содержит примеры концепции для агентов Bedrock. Например, пример простого чата агента Bedrock в примерах Python демонстрирует простой чат вопрос-ответ с BedrockAgent, а пример агента Bedrock с интерпретатором кода показывает, как включить и использовать это средство. Эти примеры могут быть отличной отправной точкой для просмотра BedrockAgent в действии.

Благодаря интегрированной интеграции агента Amazon Bedrock Agent семантический ядро обеспечивает действительно многоплатформенные решения ИИ, независимо от того, используете ли вы OpenAI, Azure OpenAI или AWS Bedrock, вы можете создавать богатые приложения для общения с интеграцией инструментов с помощью согласованной платформы. Открывает возможности для использования последних базовых моделей AWS и безопасной, расширяемой парадигмы агента в проектах семантического ядра.

Дальнейшие шаги

Познакомьтесь с агентом завершения чата