Building An AI Agent That Can Use Tools Without LangChain (Part 1)
For quite some time, the idea of leveraging artificial intelligence to build agents has intrigued me. The allure lies in the vast capabilities these agents can harness, especially with the advent of large language models (LLMs). These agents stand as a testament to the rapid advancements in LLMs, embodying their ability to understand, process, and generate human-like text.
In this article, my goal is to demystify the process of creating such an agent. My goal is to craft an AI agent equipped with tools that enable it to execute intricate calculations, scour the internet, and much more. The potential applications are vast, and by the end of this piece, you’ll grasp a clear understanding of my approach.
The creation of such agents isn’t merely about programming; it’s about integrating tools and utilities that augment the agent’s capabilities. To this end, agents stand as the perfect application to exploit the recent strides in LLM technology. By integrating these models, agents can answer a wide variety of questions, perform complex tasks, and even automate intricate processes.
For the purpose of this tutorial, I’ll be leaning on ‘anonLLM’, a nifty package I’ve designed to streamline the integration of large language models. This package not only simplifies the process but ensures that the agent can readily communicate with the model. For those interested in replicating my steps, anonLLM is easily accessible via pip. What’s more, anonLLM comes bundled with an Openai wrapper, which I’ll be utilizing extensively throughout this guide.
Tools
As I delved deeper into the problem, it became evident that two primary classes would serve as the backbone of our agent: the Tool class and the Agent class.
Let’s start with the Tool class. At its heart, this class is designed to house various tools, each with its unique functionality. The cornerstone of this class is the call_function parameter, which essentially encapsulates the Python code that drives a tool’s function. Every tool we create gets appended to a list, a design choice you’ll soon see the significance of.
The Agent
The Agent class is the beating heart of the AI agent’s architecture, serving as the central mechanism that drives the agent’s interactions and decision-making processes. The inclusion of a large language model (LLM) within the Agent is of paramount importance. This LLM acts as the adhesive that seamlessly binds two essential components: natural language understanding and shallow reasoning. While the former is crucial for comprehending user queries, the latter aids the agent in judiciously selecting the appropriate tools to address the posed problem. Moreover, the LLM’s adeptness in crafting coherent sentences ensures that the agent can eloquently convey its responses to the user.
Beyond the LLM, the Agent’s memory is another integral facet. This memory is not merely a data repository; it plays a pivotal role in preserving the agent’s “reasoning steps.” Such a feature ensures that the agent’s approach to problem-solving remains consistent and coherent. Each step the agent takes, every decision it makes, is meticulously stored, allowing for a systematic and logical progression in addressing user queries.
Complementing the LLM and memory is the agent’s arsenal of tools. These tools, stored in a list, empower the agent to perform a myriad of tasks. From simple calculations to intricate operations, these tools expand the agent’s capabilities, ensuring it can tackle a diverse range of problems.
The agent’s modus operandi is characterized by a methodical, step-by-step approach. Upon receiving a user request, the agent embarks on a journey of problem-solving. It commences by identifying the initial step, progressing to execute it, and subsequently assessing the results. This cycle of identification, execution, and evaluation is pivotal. It aids the agent in discerning whether it has amassed enough information to address the user’s query. If the acquired data suffices, the agent furnishes its final response. However, if gaps persist, the agent revisits its memory, considering previous reasoning steps to determine the subsequent course of action. This iterative process persists until the agent deems its response satisfactory.
The “execute_step” function is the linchpin in this process. It oversees the logic behind each step’s execution. The function’s responsibilities span from selecting the appropriate tool for a given task to discerning the parameters required for that tool. By doing so, it ensures that the agent’s response aligns with the user’s expectations and the problem’s demands.
For this first part of the tutorial series, I just added one tool, the calculator. In the next tutorials, I will add other tools and refactor the code a bit.
For now here is how to use the agent and the results I got:
Stay tuned for what comes next.
