Agents are the vital components of the LangChain Large Language Model as they can manage all the steps and tools. The tools are required to fetch the answers to the questions asked by the user in the chat models. Different tools are required to complete the process from getting the input to the extraction of the final answer. The agents also control when and which tools are required for a particular job.
Quick Outline
This post will demonstrate the following:
- How to Cap an Agent Executor Within a Limited Amount of Time
- Installing Frameworks
- Setting OpenAI Environment
- Importing Libraries
- Building Language Model
- Setting up Tools
- Configuring Agent Executor
- Configuring Prompt Template
- Limiting the Execution Time
- Getting Output With a Limited Execution Time
- Conclusion
How to Cap an Agent Executor Within a Limited Amount of Time?
LangChain enables the user to add a limit to the agent in terms of the time it takes to complete the process of fetching the answers. The user simply needs to add the “max_execution_time” parameter while initializing the agent to add a cap on it. Interruption of the agent might return the error and it can be solved using the “early_stopping_method” parameter in the agent.
To learn the process of adding a cap to the time limit of an agent executor in LangChain, simply follow this guide:
Step 1:Installing Frameworks
Firstly, install the dependencies of the LangChain module using the following code in the Python Notebook:
After that, install another module called OpenAI that can build Large Language Models or LLMs:
Step:2 Setting OpenAI Environment
Now, set up the environment by entering the OpenAI API key which can be extracted after signing in to the account:
import getpass
os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
Step 3: Importing Libraries
Once the environment is successfully set up, import the libraries required to complete the process using the following code. The agents and llm dependencies are required to import the libraries like load_tools, Tool, initialize_agent, AgentType, and OpenAI:
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.llms import OpenAI
Step 4: Building Language Model
Now that the libraries are imported, use them to get on with the process like building language models, tolls, and others. Define the llm variable with the OpenAI() method containing the value of the temperature argument to get more reliable answers:
Step 5: Setting up Tools
Build the tools for configuring the agent using the Tool() method with the name, func, and description as the arguments. The “name” parameter contains the name of the tool, “func” contains the functionality of the tools, and the “description” contains its working:
Tool(
name="Jester",
func=lambda x: "foo",
description="helpful in answering queries",
)
]
Step 6:Configuring Agent Executor
Getting the tools enables us to build the agent using the initialize_agent() method with multiple arguments like tools, llm, agent, and verbose:
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
Step 7: Configuring Prompt Template
Build the template for using the agent explaining what are the steps the agent needs to perform or which are the answers to be extracted at the end. The template specifies that the agent needs to be executed 3 times before extracting the final answer to make sure that it gets the most accurate one:
FinalAnswer: foo
For this template, access the tool 'Jester' by calling this tool and call it 3 times before it will work
Question: foo"""
Run the agent by calling the adversarial_prompt configured in the previous section in its argument:
The agent has made 3 iterations to get the final answer as configured in the adversarial_prompt variable:
Step 8: Limiting the Execution Time
Now, simply add the “max_execution_time” parameter to cap it to a certain amount of time in LangChain:
#configuring agent with all the components with limited time
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
max_execution_time=1,
)
Run the agent again to check if it gets the answer within the limited amount of time:
The agent has produced the error message as it was stopped before it could extract the final answer:
Step 9: Getting Output With a Limited Execution Time
Make sure that the agent returns the final answer within the limited amount of time by adding the “early_stopping_method” parameter:
#configuring agent with all the components with limited time
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
max_execution_time=1,
early_stopping_method="generate",
)
The agent has extracted the answer within the given time as displayed in the following snippet:
That’s all about applying a cap on a maximum number of iterations in LangChain.
Conclusion
To cap an agent executor after a certain amount of time in LangChain, install the required module to get the dependencies for building the agent. Use these dependencies to import the libraries for configuring llm, tools, and agent_executor. Initialize the agent with the “max_execution_time” parameter to add a limit to the execution time. Get the final answer within that time by using the “early_stopping_method” parameter. This guide has elaborated on the process of adding a constraint to the agent for extracting the final answer within the limited time.
