Flowise v3 Complete Tutorial: Build AI Agents WITHOUT Coding
FlowiseAI v3 TutorialRecent📅 2025-06-03
Build Process
┌─────────────────────────────────────────────────────────────────────┐
│ BUILD CHATBOT WORKFLOW │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ PLANNING │
│ ──────── │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Define │───►│ Choose │───►│ Setup │ │
│ │ Scope │ │ Stack │ │ Project │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │
│ ▼ │
│ DEVELOPMENT │
│ ─────────── │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Build │───►│ Add AI │───►│ Test & │ │
│ │ Features │ │ Logic │ │ Debug │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │
│ ▼ │
│ DEPLOYMENT │
│ ────────── │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Deploy │───►│ Chatbot │ ◄── LIVE! │
│ │ to Cloud │ │ Running │ │
│ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘Key Components
- Project architecture
- Core features implementation
- Best practices
Transcript
[00:00] Flowwise version 3 released a short while ago and I must admit I'm really impressed. It comes with a lot of quality of life improvements that not only affect the UI but also the way we build a gentic systems. If you're new to Flowwise, it's a no code platform for building AIdriven solutions. You can use it to build anything from simple chat bots to multi- aent AI teams, advanced agentic rack systems, deep research agents, and much much more. Now, you
[00:32] might be wondering how this is different to other platforms that I've covered on my channel like nn and make.com. I will be creating a dedicated comparison video in the near future. But in a nutshell, N8N and make.com and to an extent Zapier are workflow automation tools with some AI capabilities bolted on as an afterthought. Whereas FlowWise places the AI capabilities at the front and center of everything it does. This makes it very easy to build AI systems where
[01:05] agents can talk to each other and collaborate to achieve a task. It also makes it really simple to include things like human in the loop capabilities and for dealing with complicated knowledge bases by providing a dedicated document store solution. This makes it very easy to add and remove things from your knowledge bases. It's also important to note that Flowwise is truly open source. So on the GitHub repo we can see it uses the Apache version 2 license which means you are able to selfhost and flow wise
[01:37] for free in your company and projects. Whereas make.com is a paid service which to be fair offers a generous free tier but it can get quite expensive when you start scaling up your project. Whereas N8N actually implements a fair use license. So if we scroll down, it implements a fair code or fair use license, which is something you need to consider if you are planning to use this in larger projects. Don't get me wrong though, I actually use Flowwise and Nadn
[02:09] in a lot of my projects. Naden contains a lot of very cool automation features and integrations into external apps whereas Flowwise is extremely powerful on the AI agent side of things and it does offer some integration solutions as well. Right now let's get back to Flowwise. There's a lot to cover here. So I've decided to create a dedicated playlist to go over everything the new version of Flowwise has to offer. You can find the link to that playlist in
[02:40] the description of this video. In this video, you'll learn how to get started so you'll learn how to set up FlowWise on your own machine or sign up for free using Flowwise Cloud. In order to sign up for Flowwise Cloud, you can go to flowwiseai.com or use the link in the description of this video. By using the link, you will be supporting my channel. If we have a look at the pricing, you can sign up for FlowWise using their free tier which gives you access to two flows and flows are pretty much
[03:10] workflows which allow you to add one or multiple agents. You also get 100 predictions a month. You get some storage and access to advanced features like evaluations and metrics. Of course, you can upgrade to one of the paid packages to get access to unlimited flows. In order to follow along with the series, you can definitely get away with only using the free tier. Because FlowWise is open- source, we can of course deploy it ourselves and host it for free or way cheaper. In this video,
[03:41] I'll show you how to set up FlowWise on your own machine so you can create unlimited flows for free. Scrolling down on their page, all we have to do is run these two commands to set up FlowWise on our own machines. Before we do this though, we need to have Node.js installed on our machines. So go to node.js.org and then download and install Node.js. After that, open up the command prompt or terminal on your machine and run the following command. Let's enter
[04:12] npm-g then install and flow wise. This will simply install all the FlowWise dependencies on your machine and this will take a minute or two to complete. Great. Now that FlowWise has been installed, we can start it by running the following command. npx flowwise start. So what you can do then is open your browser and go to localhost colon 3000 or localhost port 3000. The first time you access flowwise, you will be
[04:42] asked to provide your name, email, and a password. Do take note that this information will not be sent over the network, but it will be used to protect your instance running locally on your own machine. So, simply go ahead and fill out this form and click on sign up. And that's it. Welcome to the Flowwise dashboard. Let's have a look at navigating FlowWise. On the left hand side, we can switch between chat flows and agent flows. Now, historically, chat flows were used to build things like chat bots, like customer support agents,
[05:14] as an example, and agent flows were used to build multi- aent solutions, like AI agent teams. But as part of flowwise version 3, they released a brand new version of agent flows called agent flows version two. And in my opinion, this can do everything chat flows can do and everything version one of agent flows can do and much much more. So all you really need is agent flows. Whether you're building something very simple or
[05:44] some super complex agentic system. So for the majority of the series, we'll simply be using agent flows. In the executions menu, we can view all the previous executions of our flows. And this can be helpful for troubleshooting workflows or accessing workflows that require human in the loop. Under assistance, we can create AI agents without having to add anything to the canvas whatsoever. All you really have to do is fill out a very simple form.
[06:15] So, we could just enter something like demo. And from here you can easily build out your AI agent along with tools and knowledge bases without having to spend any time on a canvas whatsoever. In marketplace we can see existing examples of agents that other people build and we can simply copy and change those agents as we see fit. Flowwise also allows us to build custom tools which we can assign to our agents and we can also create credentials and this is basically
[06:46] where all our API keys are stored to things like open AI or third party integrations. We can also set things like global variables. We can also set our API keys and this is used whenever you're calling flow wise from outside of the flow wise platform. So say you're building something using lovable or some external system. You can then call your flowwise agents by using the flowwise APIs or the flowwise SDK and document stores is an extremely powerful feature
[07:17] which allows you to create knowledge bases and maintain the content of those knowledge bases with ease. We will be diving into all of these features in the series. So for now let's go to agent flows. Within Asian flows, ensure that you do have version two selected. And if you don't see version two in your instance, it does mean you need to upgrade flow-wise to version three or greater. And by the way, in order to upgrade flow-wise, all you have to do is run
[07:47] npm-g and update then flow-wise. And afterwards, if you refresh this page, you should see v2 show up over here. Right. To create a new agent flow, click on add new. Then let's give this flow a name by clicking on save. And let's call this tutorial. All right. So, welcome to agent flows. Each flow starts with a start node, which is the logical beginning of our flow. On the top right, we can see the API endpoint menu. And
[08:18] this gives us several options for integrating our flow into external systems. If we want to add our agent to a website as an example, like a customer support bot, we can embed it using this script. We can also call our endpoints from Python or JavaScript or using this scroll URL. We can also publicly share the bot by clicking on share chatbot. We can make it public and then anyone can access it using this URL. We'll get back to these options in a future video. We
[08:49] can access the project settings by clicking on settings. And here we can view past conversations. If we build a lead collection chatbot, we can view all the leads over here. And we can also load and export our agent flow. Of course, we can delete it as well. Under configuration, we can add a lot of additional functionality to our agent. For example, we can set starter prompts and things like follow up prompts. We can also add speech to text which will allow the user to chat to the agent
[09:20] using their voice. We can also enable chat feedback which will allow the users to like or dislike a response from the agent. We can then view the feedback that our users gave in order to optimize our chat flows. We can also analyze the chat flows using tools like Langsmith, Langfuse and a lot of different options. This can be great for viewing the token usage, performance, and costs for our agents. We can also enable lead collection, which we can use to get our
[09:52] agent to collect information from our users. And of course, we can also enable file uploads, which will allow the users to upload things like images and documents in the chat window. Looking at the canvas, we can add new notes to the canvas by clicking on this blue button. And here we can see all the available nodes that we can add to our project. We can also generate our project using AI by clicking on this generate agent flow button. And here we can simply describe the project that we're trying to create.
[10:24] For instance, a team of agents that can handle all customer queries. And then all we have to do is select a large language model and flow wise will generate the workflow for you. On the right hand side, we can click on checklist and we can use this to validate the flow and this will tell us if any notes are missing or incomplete in our workflow. Lastly, we can chat to this agent by clicking on the chat bubble and here we can send messages like hey for now we haven't attached any nodes to the canvas. So this flow simply
[10:56] completes and we don't get any response. Let's fix this by adding an AI model to our project. Under add nodes, we can add AI capabilities to the project by using either the agent node or the LLM node. First, let's add the LLM node and then we'll have a look at the agent node to see the difference. The LLM node is the easiest way to add some sort of AI functionality to your project. This node does not allow you to call tools as an example, but it's ideal for once off AI
[11:29] processing like classifications, generating content, etc. Let's double click on this node. First, we can give it a name like joke generator and then we can select a large language model. Flow-wise provides integration with several services, but in this tutorial, we will be using OpenAI. Now, of course, if you want to use free models, you have those options as well. If you're running FlowWise locally, you could simply use O Lama to run a large language model on your own
[12:00] machine, or you can use Grock Chat to use an open-source model hosted on Grock. However, I will be using OpenAI for the duration of this tutorial as these OpenAI models are really powerful and actually very affordable. Now, let's expand chat open AAI parameters. Here we need to set the credentials for connecting to OpenAI. Let's click on this dropdown and let's click on create new. Let's call this credential OpenAI API. And now let's get our OpenAI API
[12:33] key. You can get your API key by going to platform.openai.com/api keys. Now do take note OpenAI is a paid service, so I do recommend loading a few dollars onto your account. Trust me that credit will go a very long way. Then under API keys, click on create new secret key and let's give it a name like Flowwise V3 demo. Let's click on create secret key. Let's copy this key and add it to Flowwise.
[13:04] Let's click on add. And now let's select our model. This includes everything from generation models, reasoning models, and multimodal models. Let's select GPT4 mini. But if you are using a reasoning model, then I recommend setting the temperature to one. And if you scroll down, you will see this reasoning effort section and you can change this from low, medium to high. This will affect the time that it will take for the model to process and the amount of tokens that get used. I'll simply go for GPT40 mini
[13:36] with a temperature of 0.7. In Flowwise, you can also enable streaming. And this means that the model will stream its response back to you instead of waiting for the whole response to be generated and then sent back to the user in one chunk. Right? That's all we have to set for now. So let's close this. And now we can also set messages. And this allows us to set things like system messages or we can mimic AI responses and user messages. This can be ideal for one or
[14:07] few shot branchs. Let's set a system message. This is effectively where we can control the role and behavior of this LLM. So let's say your role is to generate a joke based on the users topic. I also want to mention that you can click on this button and you can then get flowwise to generate the system prompt for you. I'll simply leave it like this. What's also cool is we can expand this and we can then use markdown
[14:39] to format this content as well. So if we wanted to add a heading, we could create a new line, type in a single hashtag and then enter roll and we now get this neatly formatted content. Let's save this. Then we can also enable or disable memory. Flowwise will automatically keep track of the conversation history. But if we don't want to include the history in a specific node, we can simply disable it at this point. Enabling
[15:09] memory will allow this node to look at the previous messages to try and figure out what it needs to do. If you disable memory, the conversation history will not be included in the context for this node. There are many reasons as to why you want to do that because including the conversation history will use up a lot more tokens than not having the history in the context. I'll keep it enabled for this node. If you do include memory, you do have different memory types. We can decide to include the
[15:40] entire conversation history in the context or we can set a specific window size. So maybe we only want to include the last 10 messages. We could also include a summary of the conversation history or we can include a conversation summary buffer which will summarize the conversations after some token limit is reached. I'll simply leave it on all messages. We can use input message to append a custom message at the very end of the conversation but we'll simply leave this as blank. Then we can also
[16:12] set the type of response generated by this LLM. So by default it will be returned as a user message or we could return it as an assistant message with LLM nodes. We can also set things like JSON structured output. So for example, let's say we don't want to receive a text output, but instead the output generated by the LLM should follow very specific rules. We'll have a look at JSON structured output in a future video. And finally, we can also update
[16:43] state. This is an incredibly powerful feature offered by Flowwise. If you are familiar with frameworks like Langraph, this works exactly the same. We will have a detailed look at state within the series. But one of the strengths of FlowWise is we can set state at the very start of the flow and then each node within this workflow has access to that global state and it's also able to make changes to that state as well. and each note in the workflow will be aware of
[17:14] those changes. Shared state is incredibly incredibly powerful. But like I said, we will get back to that in this series. Right. So all we have to do now is connect our start node to our LLM node. Save this flow. Let's run our checklist. And everything is validating. Let's open chat. I'm going to expand this. And I'm going to clear this chat window. Let's say tell a joke about horses. Right? So we get our response
[17:45] back and we also get this very cool feature which we can expand and this will show the execution of each node within this flow. So we have our start node and if we expand this it shows the input into that node as well as the output. Now the start node doesn't output anything at the moment unless we provide it state. Then after start the joke generator node was called. And if we expand this we can see the system prompt that we provided along with the message from the chat window and the
[18:17] output from this node. We also see other valuable information like the time it took for this node to execute as well as the token usage. Let's go ahead and add another node. So under add nodes, let's add the llm node. Let's connect these two. And let's actually rename this node to joke analyzer. And under model, let's select chat open AAI. Under parameters, let's select our open AAI API key. And I'll simply use GPT40 mini again. So
[18:50] let's close this. And under messages, let's add a system ro. And then for the role, let's say your role is to extract the setup and punchline of a joke. Let's save this. We'll enable memory. And I think that's actually it. Let's save this flow and let's clear the chat and let's simply say cats. Great. We get the response from the final node in the flow which
[19:21] was our jug analyzer. When we expand this, we can see the start note was executed, then the joke generator, then the joke analyzer. Let's expand the joke analyzer. And here you will notice that we actually get the entire conversation history in this node. First, we get the role for this joke analyzer node. Then we get the full conversation history. This is the message that the user sent in the chat window. Then this is the response that was generated by the joke
[19:52] generator node. And then finally, this is the output from our joke analyzer node. So for this node, I think you will agree that the user message is actually not relevant. The joke analyzer only needs to response from the joke generator node in order to do its job. So what if we didn't want to include this conversation history? In fact, let's try this. Let's immediately send another message like horses. And now let's have a look at joke analyzer. And we get the conversation history related
[20:23] to cats. Then we get the new message for horses. We get the new joke generated for horses. And then finally this analysis. Now I think you will agree that everything above horses is actually irrelevant for this node and we really do not need the entire conversation history. So what we can do instead is disable enable memory. And now this agent will not have a view of the conversation history. So we kind of have to inject the context in manually. Let's
[20:54] click on add message. Then let's add a user message. And now let's reference the message from the previous node. We can do that by entering double curly braces. And this will bring up a lot of different variables within this flow. question is the message from the chat window which is not what we want. We can also pull in the entire chat history which is not what we want either but at the very end we can see the output from this joke generator. This is indeed what we want to include in this context and
[21:26] I'm just going to change the role to assistant instead as this response was generated by an assistant after all. So let's save this. Let's clear the chat and let's add dogs as the topic. When we expand this, we can go to joke analyzer. And now you'll notice that the user's message from the chat window has been emitted from this view. And this node is only taking into account the message that was generated by the previous node. This can save on token usage and reduce
[21:56] costs. So before we build our first agent, let's actually go back to the dashboard and let's go to executions. Here we can see all our previous executions. We can filter executions by state and by a date range. We can click on any execution to see the input and output from each of the notes in that execution. This can be very helpful for troubleshooting your agent flows. So next, let's have a look at building our very first AI agent that's got access to
[22:27] a custom knowledge base and tool use. I'll see you in the next one. Bye-bye.