Hello everyone and welcome.
In today's session we will learn about runtime execution of agents.
The first step here involves pre-processing of the data.
For that we need user input.
Agents will then fetch any augmented prompt associated with the data or user input.
It then looks for any conversation history associated with the user input.
These two steps are optional.
An application may or may not have an augmented prompt and a conversation history associated with a
user input.
Then it manages to contextualize and categorize the user input, and can be used to validate the input.
Here, the category might involve whether the input is not harmful.
It validates whether the input matches the required categories that a use case has, and then it moves
on to the next phase, that is, the orchestration.
The agent interprets the input with a foundation model, and generates a rationale that lays out the
logic for the next step it should take.
It generates and parses the response from the foundation model and predicts which action it should take
if the agent determines that it has to invoke an action.
The agent sends the parameters determined from the user input to a lambda function.
If it determines that it has to invoke an associated knowledge base to retrieve additional context,
then it invokes the passes the query to the knowledge base and gets the response back.
The agent then generates an output known as the observation, from invoking an action, or summarizing
the results from the knowledge base.
This loop continues until the agent returns the response to the user, or until it needs to prompt the
user for extra information.
This is how the entire runtime execution happens for the agents.
In the post-processing step, the agent formats the final response to the user and it's done.
Now let's understand and run a hands on exercise in our next video to see all of this in action.
Thank you.
I'll see you in the next video.