LangChain Tutorial (JS) #6: Self-Reasoning Agents with Tools
LangChain JS TutorialAging📅 2024-01-29
Multi-Agent Architecture
┌─────────────────────────────────────────────────────────────────────┐
│ MULTI-AGENT SYSTEM │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────┐ │
│ │ ORCHESTRATOR │ │
│ │ (Manager Agent) │ │
│ └─────────┬─────────┘ │
│ │ │
│ ┌────────────────┼────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Research Agent │ │ Writer Agent │ │ Reviewer Agent │ │
│ │ │ │ │ │ │ │
│ │ • Web Search │ │ • Compose │ │ • Validate │ │
│ │ • Data Gather │ │ • Format │ │ • Improve │ │
│ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ SHARED TOOLS │ │
│ │ [Web API] [File System] [Database] [Code Executor] │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘Agent Workflow
- Agent configuration
- Tool integration
- Memory management
Transcript
[00:00] Up until now, we had a look at creating chains. And chains follow a predetermined sequence specified by us. But agents are different in the sense that we can simply give it an instruction and it will dynamically figure out the actions to take and the sequence of those actions to find a final solution. And we can also assign tools to an agent and the agent will know exactly when to use which tool to complete a task. Let's see this in action. In our project, let's create a new file
[00:31] and let's call it agent.js. Let's set up the basics for our project. Let's import our environment variables. Let's also import chatOpenAI in order to create our model. And let's also go ahead and import our chatPrompt template. So far, this is nothing new and we've covered this in the previous videos. Let's instantiate our model by calling new chatOpenAI and let's pass in the model name as GPT 3.5 Turbo 1106.
[01:02] And let's also set our temperature to something like 0.7. Let's also create our prompt by calling chatPromptTemplate and let's use the fromMessages method. This takes in an array of values and let's first pass in our system message with the value of you are a helpful assistant called Max. Let's also set our human message as a placeholder called input. There is one additional variable that we do need to include in our prompt template. And this is not something that we will populate manually,
[01:33] but instead the agent will use a behind the scenes to keep track of all the tools and steps that it's executed. We can add this special variable by using the messages place holder object. Let's import that object from the prompts package and this is called the messages place holder object. Let's add that to our prompt by calling new messages place holder with a value of agent scratchpad. You will see this in action once we start executing the agent.
[02:03] It is at this point where we would usually create our chain, but instead of creating a chain, we will now create an agent. We can do that by setting agent equal to something that we need to import from Lang chain. Let's import something from Lang chain agents and this something is called the create open AI functions agent. So down here, let's say agent two await create open AI functions agent. And this takes in an object as input
[02:33] and this expects three properties, the LLM, the prompt and tools. It said LLM equal to our model. It's also pass in our prompt and for tools, let's simply create a new variable called tools, which is equal to an empty array. Like so, we will have a look at tools in a second, but for this AI functions agent, we do need to specify at least one tool. You can also have a look at all the different agent types on this page.
[03:03] And if we scroll down to this went to use section, you can see all the different agent types and their uses. In this demo, we'll have a look at this open AI functions agent, which we can use to call functions. This agent also allows us to add chat history, which we will do in this video and we can pass in multiple tools. Let's add a few comments just to keep this code clean, like create agent and create and assign tools. And in order to invoke an agent, we need to make use of an agent executor,
[03:36] which we can also import at the top of our code from the agents package. And all we need is the agent executor. So at the bottom of our code, let's also create this agent executor. Let's call it agent executor, which is equal to new agent executor. And this takes in an object as input. And here we need to pass in our agent as well as the list of tools like so. Now lastly, we can invoke our agent by calling agent executor dot invoke.
[04:07] And we need to pass in an object with our variable name, which we called input and let's simply pass in a low, like so. Let's await this response and let's assign the response to a variable called response. And lastly, we can console log response. Now I can tell you now that this will not work yet because the agent expects at least one tool in this tools list. And I can prove that to you by trying to run this in the terminal. And indeed we get this message saying
[04:37] that this array is too short. It's fixed this by assigning our first tool. And in this video, we will assign two tools to this agent. First, we will provide a tool that will allow the agent to search the internet. And lastly, towards the end of the video, we will pass in this retriever, which we used earlier in the retrieval chain video as a tool as well. And that will allow the agent to answer questions from a custom data source. Now let's assign the search tool first.
[05:08] At the top of our code, let's import something from Lang chain community slash tools slash Taverly search. And what we want to import is Taverly search results, like so. Let's scroll down to tools. And just before the array, let's instantiate this Taverly search class by typing cons search tool is equal to new Taverly search results, and that is all we need to do. And let's assign this
[05:38] variable to our array. Now in order to use Taverly, you do need an API key. So simply go to this URL, I'll leave a link in the description below, and then copy your API key, and then in your environment variable file, create a variable called Taverly API key, and then paste in your API key in between these quotes. Now that we finally assigned the tool for our agent to use, we can go ahead and test this. So in the terminal, let's run node agent, and we do get a response back.
[06:11] It's also changed the message to something like, what is the current weather in Cape Town, South Africa? And let's run this again. And this should now use the search tool to fetch this information and provide an up-to-date answer. Let's take this one step further, and let's convert this agent into a chatbot. So the first thing I want to do is, I do not want to hard code this input, but instead we need to be able to pass in the input from the terminal. We can fetch input from the terminal by installing the following package,
[06:41] npm install readline. And now all we have to do is import readline from readline, and then let's go back to the bottom of our code again, and I'll add a comment like, get user input. We can now instantiate readline by setting a variable like RL equal to create interface. This takes in an object as input with two properties. The first is input, which is equal to process.standard_in,
[07:11] and output, which is equal to process.standard_out. Now we can fetch the input from the terminal by calling RL.question, and for the first value, we can simply pass in a prefix for the terminal, and secondly, a callback function, which will provide the input, and now we can do something with that input message. For instance, we could cut all of this logic to call the agent and simply add it to this callback function.
[07:41] And because we need to call await, let's just convert this function into an async function like so. And now instead of archiving this value, let's simply use input instead. Let's test this in the terminal, and now we can see that prefix for user, and it's simply type something like hello, and we get our response back. Let's also fix up this formatting for the console log. Let's start the AI message with agent, and let's only output response.output, so this value here. I'll just press
[08:12] Control-C to stop this session, and let's run this again. Let's type in hello, and now the agent's response looks way better. So the issue is we can't continue typing. If I press Enter, nothing will happen. So let's just fix this up, and let's call this logic in a loop so that this feels like a true conversation. Let's create a new function. Let's call it ask question. We don't need any parameters, and then in the code, let's grab all of this code, and let's move it up into this function.
[08:42] And after we output the agent's response, it's simply call ask question again. And this will effectively place us in an infinite loop. And just below this function, let's call it for the first time. Let's test this in the terminal. So let's simply say hello, and after we get the agent response, we are able to continue the conversation. Let's say what is the weather in Johannesburg, and we do get our response back. Let's give the user some way of exiting out of this conversation. So just above call agent,
[09:14] let's add this if statement to say if input.toLowerCase equals exit, then we will close the read line by calling readline.close, and finally, we will simply return. So let's try this in the terminal. I'll just press Control C to exit out of the previous session, and let's run this again. Let's say hello, and let's type exit and press enter. And now we've successfully exited out of the conversation. Great. Now one thing to note about this conversation, if I quickly start it up again,
[09:45] is let's provide information like my name is Leon, and then let's ask the agent what is my name? And as you can see, the agent didn't know how to answer that question. So let's add chat history to this agent, and this is really easy to implement, and it's very similar to what we did in the previous video, where we created our conversational retrieval chain. All we have to do is enhance the prompt template slightly, so under the system message, let's create a new messages placeholder
[10:17] for our chat history, like so. Then just above ask question, let's create a variable called chat history, and let's set it to an empty array. We can now take this chat history variable, and when we call the agent, we can pass in the property chat history, and set that equal to our chat history array. Now we just need some way of appending the user and AI messages to this chat history array. And we did have a look at this in the previous video,
[10:48] so I'm just going to go through this quickly. So just below the console log, let's say chat history dot push, and we'll first push the human message, and then we'll push the AI's response. But in order to push messages to the history, we need to use a specific schema. So let's import something from Lang chain, let's say import something from at Lang chain slash core slash messages, let's import the human message,
[11:19] as well as the AI message schema. And as I'm editing this, I am realizing that you might have run into one small bug. We've instantiate this read line, I'm directly calling the create interface function, which was automatically imported from the read line package by VS code. But what you also could have done is to call read line dot create interface as well. Either way will work. So now that we have our human and AI message schemas,
[11:50] let's go back to this code, and let's append a new human message with a value of input. And for the response, we'll actually write this value. So we will append new AI message with the value of response output. That is actually all we have to do to add conversation history to this agent. Let's test this in the terminal, and let's try something easy, like my name is Leon. Let's now ask what is my name?
[12:21] Let's look at the slightly more interesting use case, like what is the capital of South Africa? And we are getting this answer back, which is correct, but now we can ask a follow-up question, which will also force the agent to use a tool. It simply say, what is the weather like there today? And we can see that the agent understood that we were asking about the weather in Pretoria, and it used the Taverly search tool to find this information. And we can actually see that
[12:51] by using a tool called Langsmith. And Langsmith is a fantastic tool that you can use to troubleshoot and debug your Langchain applications. I highly recommend signing up for their wait list, but don't worry if you don't have access. It's not important for this video, but it is useful to see what these agents are doing behind the scenes. This changes for most relevant to show all, and if I change this to Runnable Agent, we can see the input that we passed in last, as well as the chat history
[13:22] with all of those messages. And for the output, we can see that a tool was selected, and specifically the Taverly search results tool in order to find this information. And we can then see that the Taverly search tool was called, and this is the output that we received from the tool. Now lastly, let's have a look at how we can include a retriever as a tool. And this is a very common use case. At the moment, our agent is able to do two things. It's able to answer questions from the training data
[13:54] on the original OpenAI model, and it's able to use a search tool for instances where it does not have the answer. But what if we wanted to attach a custom knowledge source, like a PDF document or a website? We already had a look at this in the retrieval chain video, so I do recommend having a look at that code. And in fact, I'm simply going to copy the code from that video, so everything from the loader, all the way down to where we create the retriever.
[14:24] And let's add that to our agent file. You can also find the source code in the GitHub repository, which you can find in the description of this video. At the top of this code, I'll just paste in all of that retrieval logic, and let's also import a couple of things to make this work. Let's copy everything from the Cheerio base loader all the way down to the memory vector store, and let's add that to our imports as well. So as a recap, we are using a document loader, specifically a web base loader,
[14:55] to scrape information from the specific web page. And that is installed in a documents variable. We then use a text splitter to break that document up into smaller documents, and we then create a vector store from those list of documents. And lastly, we then instantiate a retriever, which we can use to retrieve the most relevant documents from the vector store. If you are rusty on this, then I do recommend having a look at my retrieval chain video. So now how can we pass this retriever
[15:25] into our agent as a tool? This is really easy to implement. Let's go back to our imports, and let's import another tool, I'll call it import something from lanchine slash tools slash retriever. Let's import the create retriever tool. Then let's scroll down to our tools, and just above the tools variable, let's create a new variable called retriever tool, which is equal to create retriever tool.
[15:56] And this takes in our retriever as input. And secondly, we need to pause in an object with two parameters. First is the name of the tool, I'll simply call it lcelsearch for lanchine expression language search. And the second property is the description of the tool. And this is used to tell the agent when this tool should be used. So let's add something like use this tool when searching for information about lanchine expression language.
[16:26] Now, all we have to do is to add this retriever tool to our list of tools. And that is it. Let's test this again in the terminal. And let's test this by typing what is lcel. And this time, instead of using the search tool, I would expect it to use our lcelsearch tool. We do get a response back. And if I go back to Langsmouth, we can already see in this view that it was the lcelsearch tool that was called. And we can actually see the two documents that were returned from the Victor store.
[16:59] So this is working. If you enjoyed this video, then please consider subscribing to my channel, hit the like button, and please share this video.