Agent is the component that implements the interface to interact with Chain by deciding how to
respond to users or whether agent requires to use any tool.
It could use different prompts for different functionalities agent could have. The main goal
for agent is to plan for the next step and then either respond to user with AgentFinish or take a
action with AgentAction.
There are a few typical interactions an agent should support:
prompt
Depending on agents you are building, you might want to write different agent’s
planning prompts. Policy controls the steps agent should take for different situations.
Those prompts could be string templates so that later agent could substitute
different values into the prompt for different use cases
should_answer
Not all the questions should be answered by agent. If agent decided that this
is not a query that should be handled by this agent, it could gracefully exit as early as
possible.
plan
This is the core of the agent which takes in all the stored memory, including past
conversation history and tool outputs, which are saved to previous AgentAction, and prompt the
model to output either AgentFinish orAgentAction for the next step.
AgentFinish means agent decides to respond back to user with a
message. While not just plan could output AgentFinish, AgentFinish is the only way to
exits the chain and wait for next user inputs.
AgentAction means agent decides to use a tool and wants to perform an action before responding
to user. Once chain observes agent would like to perform an action, it will calls the
corresponding tool and store tool outputs, into the chain’s memory for the next iteration of
planning.
clarify_args_for_agent_action
When agent wants to take an action with tools, it is usually required to have some input arguments,
which may or may not exists in the past conversation history or action outputs. While the
smartest agent would output AgentFinish with response that asks user for missing information.
It might not always be the case. To decouple the problem and make is simpler for agent, we
could add another step that explicitly ask user for clarifying questions if any argument is
missing for a given tool to be used. This function will either outputs an AgentFinish, which
asks the clarifying question or AgentAction that is same as action just checked, which means
no more clarifying question is needed.
We skipped implementing this for OpenAI agent with function calling and rely on its native
response for clarifying question.
This is the a basic agent with a simple default prompt template to have nice conversation with
user. It could also use tools if provided.
While it does not use native OpenAI function calling, this agent showcases the interaction between
memory and prompts.
User could provide a custom prompt injected to the prompt template,
which contains the prompt placeholder variable.
At Jun 13, OpenAI released function calling
, which is a new way for model to use tools natively with function calling.
We introduced OpenAIFunctionsAgent to support native function calling when tools are provided.
To give a system message or instruction to agent via prompt, user could provide the prompt when
creating the Agent, such as agent = ConversationalAgent.from_llm_and_tools(llm=llm, prompt=prompt)