Quick Outline
This post will demonstrate the following:
- Installing Frameworks
- Setting up OpenAI Environment
- Importing Libraries
- Building Language Model
- Setting up Tools
- Configuring Agent Executor
- Testing the Agent
- Limiting the Number of Steps
- Getting Output
How to Cap an Agent With a Limited Number of Steps in LangChain?
Limiting the agent to take a certain number of steps for the complete process saves a lot of effort and time in extracting the answer. However, it can also make the agent less accurate as it only has a limited number of steps to get the correct answer. So, it won’t have the required dataset to play with and get the desired result every time or for each query.
To learn the process of capping an agent by taking a certain number of steps in LangChain, simply go through the steps:
Step 1: Installing Frameworks
First of all, start the process by installing the LangChain framework and getting its dependencies for building the agent and limiting its steps:
After that, install the OpenAI module with the dependencies for building the language model:
Step 2: Setting up OpenAI Environment
The next step is to set up the OpenAI environment using the os and getpass libraries to access the operating system for entering the API key:
import getpass
os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
Step 3: Importing Libraries
Once the setup is completed, use the installed dependencies of the LangChain framework to import the required libraries for building the llm, agent, and its tools:
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.llms import OpenAI
Step 4: Building Language Model
Use the OpenAI() method with the temperature as its argument to build the language model by initializing it in the “llm” variable:
Step 5: Setting up Tools
After that, set up the tools for the agent to perform all the steps in order to get the answer from the language model. The name of the tool is the “Jester” and it uses the lambda function to return the “foo” keyword upon execution:
Tool(
#configuring the tools by explaining the name, its function, and details
name="Jester",
func=lambda x: "foo",
description="useful for answer the question",
)
]
Tools are used by the agents for getting the answers to the questions asked by the user:
Step 6: Configuring Agent Executor
Now that the language model and tools are configured, it is time to build and initialize the agent by defining the agent variable:
agent = initialize_agent(
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
The initialize_agent() method is used to invoke the agent with tools, llm, agent, and verbose as its arguments. The agent variable contains the type of agent used to complete the process which is ZERO_SHOT_REACT_DESCRIPTION:
Step 7: Testing the Agent
Now, build the template for the agent before executing it to get the required steps and specify in the template that the agent should run 3 times before extracting the answer. The answer extracted at the end of the agent should be the “foo” keyword that was initialized when tools were set up:
FinalAnswer: foo
For this new prompt, access the tool 'Jester' by only calling this tool and call it 3 times before it will work
Question: foo"""
Finally, test the agent using the run() method with the adversarial_prompt method containing the required template to execute:
The agent has successfully extracted the answer after three set of iterations and each iteration contain all the required steps as well:
Step 8: Limiting the Number of Steps
After successfully testing the agent, add a max_iterations parameter to add a cap on the agent and its value suggests the number of iterations for the agent:
#initialize the agent to make it start working with all its configured components
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
max_iterations=2,
)
The agent has been restricted to take only 2 iterations, whereas, it needs to run 3 times before it can extract the final answer. Run the agent with the prompt variable in its argument to check how the agent will react:
The agent was interrupted before it could extract the final answer so it returned the “Agent stopped…” message:
Step 9: Getting Output
We can add another parameter that is “early_stopping_method” to get the answer from the agent with a limited number of iterations. It enables the agent to return the answer if it is stopped prematurely using the “max_iteration” parameter:
#initialize the agent to make it start working with all its configured components
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
max_iterations=2,
early_stopping_method="generate",
)
Test the agent to check whether it returns the answer or not by running the following code again:
The agent returned the answer after 2 only iterations as shown in the screenshot below:
That’s all about applying a cap on a maximum number of iterations in LangChain.
Conclusion
To cap an agent at taking a certain number of steps in LangChian, install the modules and get their dependencies for building the agent with its tools. Import the libraries using the dependencies of the LangChain to build the llm, tools, and agent. After that, use the “early_stopping_method” parameter while initializing the agent to get the answer, if it is interrupted ahead of its due time. This guide can lead to adding different restraints on the agent to maximize its efficiency and performance in LangChain.
