Master Sequential Agents: Build Complex AI Apps with Flowise

15.97k views5530 WordsCopy TextShare

Leon van Zyl

In this Flowise Sequential Agents tutorial you will learn how to create advanced AI agent, and multi...

Video Transcript:

Flowise 2. 0 introduces one of the most powerful features to date, sequential agentic flows. With sequential agents, you can control your multi-agent applications like never before.

You can call agents conditionally, run them in parallel, add human in the loop, and much, much more. Unlike multi-agent flows, where the supervisor controls the flow of the application, sequential agents give you full control. In this video, we will look at the most important concepts related to sequential agents.

If you're new to Flowwise, then you're definitely in for a treat. Flowwise is a low-code platform for building advanced AI applications using a simple drag-and-drop interface. It's open source and completely free to use.

I have plenty of videos on my channel showing you how to install, update, and self-host Flowwise. But in order to make this a complete tutorial for beginners, we will set up Flowwise on our local machines. If you already have Flowwise installed, then please ensure to update your instance to version 2.

0 or greater. In order to install Flowwise on your machine, you need to install Node. js from this website, and after installing Node, open the command prompt or terminal on your machine, and enter "npx flowwise start".

The first time you execute this, you will be asked whether you want to install Flowwise and its dependencies. Simply enter "y" and press enter. And once installation is complete, you can access Flowwise in your browser by going to localhost 3000, and you should be presented with a dashboard like this.

Now, in order to build multi-agent flows, we need to go to "agent flows", and let's add a new flow. I'll start by giving my flow a name, and I'll call this "sequential agent basics". Within Flowwise, we can build all sorts of multi-agent solutions.

If we go to "add nodes", we can of course use multi-agent teams, where a supervisor will control the logic flow between the different worker nodes. But with the release of Flowwise 2. 0, we now have sequential agents, which gives us way more control over the flow of our application.

And at first, this might seem extremely intimidating, as we have several nodes to choose from. But in this video, we will go through each of these nodes, and by the end of the video, you will be able to create extremely cool and complex multi-agent applications. Let's start by looking at the start node.

The start node does exactly what you would think. This represents the start of our sequential flow. The start node takes in a chat model as input, as well as memory, state, and input moderation.

Let's start by adding our LLM. Let's go to "add nodes", and under "chat models", we can add any of the available chat models to our application. If you want to follow along without incurring any costs, then I highly recommend using the "grok chat model".

It's free to use and blazingly fast, and I already created a separate video showing you how to integrate grok chat with Flow-wise. But for this demo, I'll actually use the "chat OpenAI" node. So I'll start by adding this node to the canvas.

Let's start by setting our OpenAI credentials by clicking on the drop-down, and let's click on "create new". Let's give our credential a name, like "OpenAI API". Now we just have to fit our OpenAI API key, which we can get from "platform.

openai. com slash API keys". Let's create a new key by clicking on "create new secret key".

Let's give it a name, and let's click on "create secret key". Then copy this key, and paste it into this field in Flow-wise. Let's click on "add", and then let's select our model name.

For this demo, I'm going to select the "gpt40" model, and I'm going to change the temperature to 0. 2. And let's attach our chat model to the start node.

Great! Now let's add our first agent to this Flow. Let's go to "add nodes", and then under "sequential agents", add the agent node.

Let's connect our start node to our agent node. Now let's have a closer look at the agent node. For agent nodes, we can assign tools.

We can also add a preceding node, which could either be a start node, another agent, an LLM node, or a tool node. We can also assign a chat model, but this is optional. If we don't assign a chat model, the agent node will simply inherit the model assigned to the starting node, which in our example is this chat openai node.

We also need to provide our agent with a name, and take note this name needs to be unique. Let's call this agent "assistant". We can also enter a "system" prompt, which we can use to prime the model, provide context, set a role, etc.

Let's clear these values, and let's set our prompt as "You are a friendly assistant called John". Let's have a look at the rest of this node. "Require approval" can be used to enable human in the loop functionality, which we will look at later on in this video.

You can use "format prompt values" to set the values of variables, which we will look at as well, and if we click on additional parameters, we can use the "approval prompt approve button text and reject button" when the human in the loop functionality is enabled. We also have the capability of updating state, which we will look at later as well. But for now, we are done with the agent.

Now before we can run this, we do need to set some sort of end state. Let's go to add nodes, and with "in sequential agents", we can either add an end node or a loop node. Both of these nodes represent an end state in our flow.

For now, let's simply add an end node, and let's attach our agent to this end node like so. We can now save our flow, and in the chat, let's test this out. Let's say "hello".

And of course, we can see that the assistant node was executed as well as the response from that node. Fantastic! We now have an agent that we can talk to.

Now let's discuss agent memory. During the execution of the flow, the conversation history is added to a global state, and after execution, all those messages are deleted. So when we execute the flow again, our agent will not be able to recall information from past messages, and I can prove that to you.

Let's enter something like "my name is Leon". Our agent will greet us with my name, but if I then ask it "what is my name? ", the agent can't recall that information.

So to add memory to our flow, we can simply go to add nodes, then within "memory", we can add the agent memory node. I'm actually going to move these nodes around just to make a bit of space. And now let's attach our agent memory node to the agent memory input on the start node.

With this node, the conversation history will actually be stored in a SQLite database. Let's go ahead and test this out by saving the flow, and in the chat, let's try providing my name again by entering "my name is Leon", and now let's ask it "what is my name? ", and this time our assistant was able to recall my name.

Great! Now let's discuss the state node. By default, the conversation history is added to state and shared amongst all the agents in the flow, but we can also use the state structure to store our very own values, and these values will be shared amongst all the agents in the state as well.

Let's have a look at an example. Let's go to add nodes under sequential agents. Let's add the state node.

Let's attach this node to our starting node, and now we can click on additional parameters to add our very own state properties. Now take note we do not have to add a property for the conversation history as that is handled for us by default, so all we have to do is add any additional values to the state which we want to make available to our agents. As an example, let's set a value for my name in state.

Let's click on add item. Let's enter a key value as a name, and for the operation let's simply select replace. You can use the append operation to simply add values to an array or a list of values.

For now we simply want to replace the value with my name. Great! This value can be retrieved by the agents from the state structure.

Let me show you how that works. Let's make the name available to this agent by changing the system prompt slightly. Let's add something like you are talking to, and instead of hardcoding my name like this, we want to retrieve the value from the state.

So let's add a variable value using opening and closing curly braces, and within the braces let's give this placeholder a name. I'll just call mine name. Let's click on save.

Now we just have to link up this placeholder with the value from state, and we can do that by clicking on format prompt values. At the moment the name variable is simply an empty string, and we can change that by clicking on the edit button, and if we click on this field we can now select from a range of values. The question is simply the message from the chat window.

We can also access the chat history, or we can fetch the first message from the content, or the last message from our list of messages. What we are interested is this option over here. Let's then edit this value, and let's replace this with our name value in state.

So this is referring to this key value in the state structure, which has a value of Leon. So let's test this out by going through the chat, and it say hello, and as you can see the agent now knows our name. So let's say we wanted to change this value from Leon to John.

Let's save this flow, let's test it again, and let's ask what is my name, and as you can see it is pulling the name from the state. Great! Now let's have a look at the condition node.

We can use the condition node to conditionally call agents. Let's assume that the first time you execute this flow the user's name in the state property will actually be blank. If the value is blank then we want to call an agent which will be responsible for collecting the user's name and then storing that name in the state property.

So the second time we execute the flow and then if the name is populated this assistant over here will be triggered. So let's set that up. First I'm just going to make some space by moving this agent over.

Let's break this connection and let's add a second agent which will be responsible for collecting the user's information. So let's add that agent, let's give it a name like name collection agent, and in the system prompt let's enter something like you are responsible for collecting the user's name. Let's also provide the steps that the agent can follow like if the user has not provided their name then politely ask for their name and if the user provided their name then ask them how can I assist you.

Let's save this agent and let's attach our agent to the end node. So now we have two agents which we want to call conditionally based on whether the name is set in state. Let's go to add nodes and with the sequential agents let's add the condition node.

Let's attach the start node to this condition node and now let's have a look at the details of this condition node. First let's give our condition node a name. This can be anything you want like check if the user has a name.

Then let's click on this condition button. Here we can set up the different conditions for this node. We can either use this condition table or we can handle this programmatically using code.

Let's stick with the condition table. Let's add a new item and for the variable we can access the name property in state. So we can say that if the name is not empty we then want to simply continue to our agent node.

You can call this output whatever you want. I'll simply call it continue but if we save this you will now notice this continue output over here. If none of the conditions in this list is met the end output will be executed.

We can also have additional outputs so for example let's say we had a specific output for a name that is Leon. We could add a Leon output as well and if I save this you will now notice this connection over here for Leon but of course we don't need that for now. But if the name is empty this end output will be triggered which we can hook up to our name collection agent.

Like so let's test this out by saving the flow and just as a reminder if we go to state the name is currently John. So we would expect this flow to trigger the continue output over here. In the chat let's say hello and indeed this triggered our assistant node.

So let's test this end scenario by going to state let's clear the name then let's save the flow and in the chat let's say hello and this time it is triggering the name collection agent. Great it's very important to note that although we provided our name this name was not stored in the global state so in order to grab this name from the user's message and then store it in state we will be using another node called the LLM node. We can use the LLM node to process unstructured data like a user's message to extract information from the message and then output the data in a structured format.

Let me give you an example of why you would want to parse unstructured data. In this example I simply parsed my name so you might think that it's simple enough to simply grab the value that the user provided and install that value in state but what if the user entered something like my name is Leon that would mean that the agent would store this entire string as the name in the state which is not correct. We want to use the intelligence of an LLM to identify a human name from the string and then output only that name and store it in state.

All right enough talk let's actually implement this. Let's go to add nodes and with in sequential agents let's add the LLM node. Before we attach this node to anything let's first have a look at this node in isolation.

This node can be triggered by the starting node another agent an LLM or a tool node so effectively this node will receive the output of one of these nodes and then process that data in any way that we want. Let's actually start by giving this node a name like name collector and within additional parameters we can provide clear instructions on what sort of data this node needs to extract. For example your job is to identify and extract a human name from the user's message only respond with the name.

We'll leave the human prompt empty and what we can then do is add a variable for the user message and again we can create variables using opening and closing curly braces. Let's call this question or whatever you want then with informat prompt values we can simply assign the question from the chat box like so. So this will now receive something like my name is Leon and with this prompt the model will try to extract the name.

Now one of the benefits of the LLM nodes is we can return the data in a fixed structure. In this example we want to return the name so let's add an item let's call this name which is of type string and we can add a description like the name of the user. So as this LLM node would have extracted the name from the user's message it will then assign the name to this key value over here and additionally we can also use this node to update state and that is exactly what we want to do.

Let's click on add item within the state we want to reassign this name property and for the value we want to use this name output over here so from this list of values we will select flow dot output and we will replace this key value with name. This is the value from this JSON output structure. I know there was a lot to process but these LLM nodes are extremely powerful.

Simply see it as a node that can receive output from another node, extract information from that output, store the information that it extracted into this structured output list and optionally we can use the values that it extracted to update state. Now the question is where do we add this node in this flow and for me it makes sense to add it after this condition node and during this flow where we collect the name. I'm actually going to move these nodes over let's break this connection let's bring in the LLM node let's attach this end connector to the LLM node and then let's connect our LLM node to our agent.

So let's quickly have a look at this again initially the name property in the state is blank so the condition node will route us down this path where the agent will ask the user to provide their name. If the user simply enters something like hello this LLM node will not be able to extract the name from that text and therefore also not set the name in state then the name collection agent will be called to ask the user for their name. The user will then enter their name which will again trigger this path this time the name collector will be able to extract their name and update state and the name collection agent will then determine that the name was provided and then ask the user how the agent can help them.

In fact in the scenario where the user enters something that's not a name we simply want the LLM node to return a blank value so let's announce this slightly to add something like if you are unable to determine a name like if the user entered hello or hi then return a blank value for the name. Let's save our flow let's enter hello and in the name collector we can actually see the changes that were made to the state which was simply a blank value because we were unable to determine a name. Also the name collection agent responded with what is your name now let's see what happens if we actually enter a name.

My name is Leon this time the name collector was able to extract the name and store that value in state. Now the name collection agent is asking us how they can help if we send another message we will expect the flow to take us to the assistant agent so let's enter something like why is the sky blue so we can now see that the condition node called the assistant agent and it was the assistant agent that responded so I hope you will agree that the LLM nodes are extremely powerful for parsing unstructured data and for setting state.