[0:00] all right today we've got a very
[0:01] exciting one this is the nadn master
[0:03] class where ideally I'm taking you from
[0:05] a beginner in nadn all the way to an AI
[0:08] agent Builder by the end of this or even
[0:10] just someone who wants to implement AI
[0:12] automations into their daily life or
[0:14] into their work so I was about to say
[0:16] grab a pen and a piece of paper but more
[0:18] realistically since you're here grab
[0:20] some sort of AI notetaker and let's dive
[0:22] into this one this is a master class so
[0:24] we're going to start at the bottom start
[0:25] with the basics and we'll continuously
[0:27] work our way up but just want to start
[0:28] off here with what is any
[0:30] so at this point I'm sure you guys have
[0:31] been hearing the term low code no code
[0:34] tools and nadn is a low code no code
[0:37] automation tool so that just basically
[0:39] means that nadn allows users to automate
[0:41] processes build workflows with minimal
[0:44] coding knowledge and the key idea behind
[0:46] this is that low code means it's very
[0:49] easy to develop things with a very
[0:50] userfriendly interface where people can
[0:53] just go in there and drag and drop
[0:54] different components different nodes is
[0:56] what they're called in nadn to create
[0:58] these flows without having to come in
[1:00] here and type a bunch of JavaScript or
[1:02] python this is so significant because
[1:05] it's going to allow anyone to be able to
[1:07] get an in and get up and running with
[1:09] building automations even if you don't
[1:11] have you know a background in computer
[1:12] science or programming the barrier entry
[1:15] to this is so low it's very very
[1:17] accessible for anyone to get in here and
[1:18] start playing around with stuff but even
[1:20] though it's very simple it also retains
[1:22] a lot of flexibility for more advanced
[1:24] users who do have coding background and
[1:26] they're able to come in here and take
[1:28] some of the basic principles and also
[1:29] come come on top of that with you know
[1:31] custom code or different type of logic
[1:33] and Integrations and it's a very very
[1:35] powerful tool you can build tools
[1:38] directly in NAD as you see here and
[1:40] that's a little bit different from other
[1:42] things like make or zappier because you
[1:44] can build let's say an agent that's able
[1:45] to call four or five tools and these
[1:48] tools you built within NN itself which
[1:50] is just super super cool stuff what
[1:52] about the importance of automating workf
[1:54] flows so we've got five points here I'll
[1:56] touch on real quick increasing
[1:58] efficiency and productivity automation
[2:00] is going to eliminate repetitive tasks
[2:02] it's going to reduce human error and
[2:03] it's going to allow you and your team to
[2:05] focus on higher value work it's also
[2:07] going to save time and money of course
[2:10] automating workflows is going to reduce
[2:11] operational risk free up Time by
[2:13] completing tasks faster than manual
[2:16] scalability and adaptability you can
[2:18] scale a lot more effortlessly you can
[2:20] focus on your growth as a business and
[2:23] these Solutions these automation
[2:24] Solutions can be customized or adjusted
[2:26] to meet your changing needs you've also
[2:28] got improved data handling automation is
[2:30] going to integrate data from various
[2:32] sources it's going to provide real-time
[2:33] insights for better decision making and
[2:36] then the last benefit I wanted to hit on
[2:37] here was enhanced customer experience
[2:39] you're going to be able to respond
[2:40] faster to your clients or automatically
[2:42] to your clients personalize interactions
[2:44] through automated workflows and all of
[2:46] this is just going to lead to better
[2:47] customer satisfaction and Customer
[2:49] Loyalty moving on here we've got why
[2:51] should you learn nadn so when I was
[2:54] building the slide I had so many
[2:55] thoughts and I tried to put them all
[2:57] under three main bullets and so this
[2:59] first first one here is nadn empowers
[3:02] non-developers with Automation and I
[3:04] know we've touched on this a little bit
[3:05] with the whole low code no code stuff
[3:07] but it's just so powerful that anyone
[3:10] can pretty much come into NN and start
[3:12] building things in 15 20 minutes that's
[3:14] actually going to automate real work
[3:16] that they would do on a daily basis so
[3:18] even if you're not a programmer you can
[3:19] come in here create workflows it's going
[3:21] to save you time make your life easier
[3:23] for example you could very easily get up
[3:25] a workflow that is going to
[3:26] automatically move data from one app to
[3:28] another like ually copying contacts from
[3:31] one spreadsheet to another without
[3:32] having to do it every time it's like
[3:35] having a digital assistant that can
[3:36] handle these repetitive tasks for you
[3:38] and you don't really need the technical
[3:39] skills to set it up so super cool stuff
[3:42] the second one we've got access to over
[3:44] 300 built-in Integrations which is
[3:45] insane andn comes with a ton of
[3:48] Integrations ton of connections to
[3:49] popular tools that you probably use
[3:51] every day like Gmail um Google Sheets
[3:54] slack Twitter we got Microsoft stuff too
[3:57] if you want to connect to teams or
[3:58] Outlook it's super super cool what you
[4:00] can do these Integrations let you
[4:02] connect quickly to these tools and you
[4:04] can connect tools to other tools without
[4:07] needing to like code in between that for
[4:10] example you could set up a workflow
[4:11] where every time you receive an email
[4:12] it's going to automatically add that
[4:14] information to some sort of spreadsheet
[4:16] and then it's going to send you a
[4:17] notification on slack or teams and all
[4:20] of that will take place without you
[4:21] needing to be in there and doing it
[4:23] manually then this last one you can
[4:25] connect to almost any tool so kind of
[4:26] similar to the second point but if
[4:28] there's something that you want want to
[4:29] connect to that there's not a built-in
[4:31] integration to you can still pretty much
[4:33] connect to it whether that's through an
[4:34] API or a web hook um these ones are a
[4:37] little more technical but for the most
[4:39] part um you know a quick YouTube video
[4:41] or using chat gbt even you'll be able to
[4:43] get them up and running and connect to
[4:44] almost anything you want a little bit of
[4:46] custom code and um really when you
[4:49] realize you can connect to almost
[4:50] anything then you have almost endless
[4:52] possibilities of what you want to
[4:54] automate all right we're going to be
[4:56] moving into part one of this master
[4:58] class here which is just very simple
[4:59] getting started with NN we're going to
[5:01] talk about how you set it up the
[5:02] different ways you can set it up and
[5:04] then we'll just get into the interface
[5:05] and start actually learning what it
[5:07] looks like and what everything does the
[5:09] first thing I think that we should talk
[5:10] about when it comes to setting up your
[5:11] NN is if you want to set it up
[5:14] self-hosted or if you want to Cloud host
[5:17] and I'm going to run through a few
[5:18] features of each of these two different
[5:19] options and then we'll talk about which
[5:21] one you should choose so first with
[5:23] self-hosted some of the things that it's
[5:24] going to offer you are control and
[5:26] flexibility you're going to have full
[5:27] control over your environment you can
[5:29] customize your server integrate with any
[5:30] internal system you have the ability to
[5:33] adjust your configurations as needed
[5:36] we've got data ownership so all the data
[5:38] and workflows are going to stay on your
[5:39] private server so this is ideal if you
[5:41] need to comply with privacy regulations
[5:44] or you want to keep sensitive data
[5:46] in-house cost self-hosting can be more
[5:49] cost effective in the long run it
[5:50] depends on the server and maintenance
[5:52] costs but there's no ongoing
[5:54] subscription fee to naden like if you
[5:56] were to do Cloud hosted but with the
[5:59] cost as aspect you may need to account
[6:01] for infrastructure with like database
[6:03] management or server hosting and you
[6:05] also may need to have some sort of team
[6:07] that will help you maintain it but who
[6:09] knows fourth with self-hosting is
[6:11] installation and maintenance you are
[6:13] going to be responsible for setting up
[6:14] and managing and updating your instance
[6:17] this also includes backups and scaling
[6:19] so this is going to require more
[6:21] technical knowledge then finally we've
[6:23] got customization so you can modify the
[6:25] source code you can add custom features
[6:27] that might not be available in the cloud
[6:28] environment so this is cool if you want
[6:30] complete freedom to modify the system as
[6:32] you want and now moving on to the cloud
[6:34] environment here are some features of
[6:36] cloud it's going to be easier to use
[6:38] because it's managed by nadn itself so
[6:40] there's no need to worry about setup
[6:42] updates scaling maintenance stuff like
[6:44] that so good for beginners you've also
[6:46] got availability and reliability so the
[6:49] NN cloud is hosted on a scalable and
[6:51] reliable infrastructure it's going to be
[6:53] maintained by Ann's team so they're
[6:55] always going to keep stuff up to date
[6:57] with the latest features and Bug fixes
[6:59] the security is a little different it's
[7:00] going to be managed security so SSL
[7:03] certificates or you know secure API
[7:05] handling and that's going to be done by
[7:07] the N team and then also this is going
[7:09] to be more suitable for users who don't
[7:11] want to handle server security now when
[7:13] it comes to cost of nadn it's really not
[7:15] that bad either way the cloud version
[7:17] comes with a subscription model that's
[7:18] going to be based on usage tiers how
[7:20] many products you want how many seats
[7:22] you want on your you know an inn
[7:24] environment and so you'll be basically
[7:26] paying based on that so in the long run
[7:28] it could be more expensive if you have a
[7:30] ton of users and a ton of projects going
[7:31] on but if that's the case then hopefully
[7:34] you're either saving a ton of money or
[7:35] you're making a ton of money so balance
[7:37] is out then finally we have data
[7:39] handling different than self-hosted data
[7:40] is going to be stored and processed in
[7:42] the cloud so like I said if you're a
[7:44] business dealing with highly sensitive
[7:45] data this may be a limitation due to the
[7:48] server dependencies okay so at this
[7:50] point you may already have an idea of
[7:51] which one you're going to choose but if
[7:52] you don't real quick you should go with
[7:54] self-hosted if you need full control
[7:56] over your data and your infrastructure
[7:58] if you want to integrate any in deeply
[8:00] with other on premise systems and if
[8:02] you're technically comfortable handling
[8:04] server maintenance and management or you
[8:06] have a dedicated team that will do that
[8:08] for you and then you're going to want to
[8:10] go with Cloud if you prefer Simplicity
[8:11] and you don't want to handle
[8:12] infrastructure or server maintenance you
[8:14] want a quick setup and reliable hosting
[8:16] it's going to be managed by the NN team
[8:18] and you're okay with paying for a
[8:19] subscription for a managed service and
[8:21] you don't mind being handled by a third
[8:24] party provider okay so before we
[8:26] actually hop into NN and we look around
[8:28] at the interface probably important to
[8:30] understand the difference between
[8:31] workflows nodes and executions so I'm
[8:34] going to break this down as simple as I
[8:36] can pretend you're in a restaurant we've
[8:38] got workflows which are going to be the
[8:39] recipes nodes are going to be the
[8:41] ingredients the steps within each recipe
[8:44] and then executions are going to be
[8:45] every time someone sits down and orders
[8:47] that specific recipe or workflow so the
[8:51] workflow think of it as like a set of
[8:52] instructions that you're going to be
[8:53] giving to nadn in order to automate a
[8:56] task so for this example we'll say that
[8:58] the workflow is a a chocolate cake then
[9:01] we'll move down to nodes nodes are like
[9:03] the building blocks of the workflow each
[9:05] node is going to represent a single step
[9:07] a single action within a workflow so one
[9:09] node might send an email one might
[9:11] update a spreadsheet one might pull data
[9:13] and then you can kind of Link those
[9:15] together in order to make the chocolate
[9:17] cake so you know eggs flour baking soda
[9:21] we're going to put those together then
[9:23] we have the execution which is simply
[9:25] just running your workflow in nadn this
[9:27] can happen by different triggers whether
[9:29] you want to do that manually or whether
[9:31] you want the automation to take place
[9:32] every time you update a row in a
[9:34] spreadsheet but in the example like I
[9:36] said just picture someone coming to the
[9:38] restaurant and ordering a piece of
[9:40] chocolate cake and then you kind of
[9:41] start that process of making the cake
[9:43] and delivering the cake all right now
[9:45] that we've covered the three main
[9:46] building blocks that go into pretty much
[9:48] every automation let's actually get into
[9:50] nadn look around a little bit at the
[9:52] user interface see what I'm talking
[9:53] about when I say drag and drop we'll
[9:55] talk about accessing Community Resources
[9:57] Community templates stuff like that and
[10:00] it'll really start to make more sense
[10:02] all right so we're in nadn as you can
[10:04] see as what we're looking at right now
[10:06] is we're just on my homepage so it's
[10:07] going to show me a ton of the different
[10:08] workflows that I've been working on um
[10:10] we've got our projects right here so I
[10:12] only have the one right now it's called
[10:13] Nate testing so in here it's pretty much
[10:15] just everything I have but if you had a
[10:17] specific project for a specific client
[10:19] or a specific project for an actual
[10:21] specific project at work you could add
[10:23] them here so you can keep everything
[10:24] organized honestly my stuff is not too
[10:26] organized but here's what it looks like
[10:28] we've got stuff on the Le hand side we
[10:30] can see we have an admin panel we have
[10:33] templates we have variables we can see
[10:35] executions of each workflow we've got
[10:37] some help and then you have your profile
[10:38] down here as long as well as you know
[10:41] I'm Cloud hosted so I can see that
[10:42] there's some updates here with some bug
[10:43] fixes that I'll I'm going to be able to
[10:45] just go in and install real quick let's
[10:47] just add a new workflow right here and
[10:50] see what the interface sort of looks
[10:51] like so this is the canvas that I was
[10:53] talking about where I said it was a very
[10:55] userfriendly drag and drop interface the
[10:57] first thing you're going to see is that
[10:58] you have and add First Step button so
[11:01] we'll get into different types of nodes
[11:03] after this and we'll talk about triggers
[11:05] and all that but first step is always
[11:07] going to be a trigger so you'll click on
[11:08] that and it will list up you know some
[11:10] triggers trigger manually just means
[11:12] that you'll be hitting test workflow
[11:14] button down here in order to run the
[11:15] workflow execute the workflow every
[11:17] single time you can schedule it you can
[11:19] do um on chat message you can call it by
[11:22] another workflow so that's where all the
[11:24] stuff is super powerful we'll just add a
[11:26] manual one so you guys can see what it
[11:28] looks like this is where you hit test
[11:29] workflow in order to run it and you know
[11:31] obviously nothing's coming through but
[11:33] it didn't fail so that's good then from
[11:35] here you would want to add different
[11:36] nodes to connect to so you could do that
[11:38] from either clicking on this plus button
[11:40] where it says click to add node or drag
[11:42] to connect or up in the top right you
[11:44] can click up here and it will pull up
[11:46] this panel for you to search through
[11:47] nodes you know by category or you can
[11:49] just search for them if you want um
[11:51] another cool thing with the triggers is
[11:52] there's not just those triggers there's
[11:54] different triggers for each app so let's
[11:56] say that you wanted to run a workflow
[11:57] every time you got an email you can
[11:58] click on on Gmail down at the bottom
[12:00] you'd see different triggers and this
[12:01] one says on message received so this
[12:04] would execute the workflow every time
[12:06] you get an email and you can tell a
[12:07] trigger if it has this little lightning
[12:09] bolt so that's a trigger node but
[12:11] anyways let's just say that we wanted to
[12:13] put some fake data in here so I would
[12:15] just come in here and I could either
[12:17] type for the the node that I want or I
[12:19] know I'm looking for an edit Fields node
[12:20] so I can come to data transformation and
[12:22] I would see edit Fields right here this
[12:25] is where I could configure stuff so let
[12:27] me just quickly pretend um we're going
[12:28] to make make a field called name and
[12:30] we'll just put in my name and what's
[12:32] really cool about NN is that you can
[12:34] test each step individually as you're
[12:36] going through and automating something
[12:38] so rather than having to run the whole
[12:39] workflow you could just test step right
[12:41] here we'll see that what's coming out of
[12:42] this node is Nate um in the field called
[12:46] name so we have that information running
[12:48] through but it's nice to know because
[12:49] you'll always see on the left of this
[12:51] configuration panel you'll see data
[12:53] that's coming in and then you'll see
[12:54] data that's coming out so it makes it
[12:55] really easy to troubleshoot and test
[12:57] each step individually which is really
[12:58] cool
[12:59] but you have to make sure that your your
[13:02] um nodes are connected because let's say
[13:04] you know I didn't drag this one right
[13:05] here and connect it to the edit Fields
[13:07] if I was to run
[13:09] this nothing would come through the edit
[13:11] Fields there's no output as you can see
[13:13] it says wire me up this node can only
[13:14] receive input data if you connect it to
[13:16] another node and yeah so that's how
[13:18] that's going to work I say this is
[13:20] probably all we'll do for now in here
[13:23] we'll get into some Community templates
[13:24] and just show you how that all works but
[13:26] as far as just basic setting up a
[13:28] workflow and seeing what um the
[13:30] interface looks like how easy it is to
[13:32] just drag and drop stuff that's what
[13:34] we've got so back in the homepage we've
[13:35] got workflows you all can also look at
[13:37] your credentials so this is just
[13:38] different things that you've connected
[13:39] to like I said there's so many
[13:41] Integrations so it can easily access my
[13:43] Google Drive my telegram my Google
[13:45] Sheets all that kind of stuff so that's
[13:47] where you can sort of see and manage
[13:48] your credentials and then down here the
[13:50] only thing I'll touch on real quick will
[13:51] be the templates you can click into
[13:53] templates and it will pull up nad's
[13:55] website where there's sort of like this
[13:56] community where people can upload cool
[13:58] things they're building
[13:59] or you can search for specific use cases
[14:02] specific um you know tools that you want
[14:04] to use so it's a really great place to
[14:06] get in here and learn but as you can see
[14:08] we have you know learn by doing so you
[14:09] can download these templates which is
[14:11] really cool sometimes it's you know it's
[14:12] nice to watch a tutorial on YouTube but
[14:15] being able to really learn you have to
[14:16] just get in there and you have to let
[14:18] things fail in order to figure out why
[14:19] they're failing so right here we have
[14:22] you know AI agent chat we can download
[14:23] from NN we can click here we can look at
[14:26] it um and we can see what's going on we
[14:29] could click this button here to download
[14:30] it and um start playing around with it
[14:32] in our own nadn we have this one where
[14:35] you can click in here and a lot of times
[14:37] people will annotate like what's going
[14:38] on so you can see how to set it up you
[14:40] can see which you know what's taking
[14:42] place in each scenario so that's super
[14:43] super useful and then I'll just show you
[14:45] real quick let say you wanted to use
[14:47] this one we could just import the
[14:49] template to my cloud
[14:53] environment and as that loads up it's
[14:55] pretty much just going to put it right
[14:56] into my workspace so I've got this
[14:59] information here I can now test this
[15:00] data I can look at what's going through
[15:02] each step we can see right here we've
[15:03] got um you know this information's
[15:06] coming through and then it comes out as
[15:07] you know flour eggs milk which is
[15:09] interesting because I just did a you
[15:10] know a little example about cake so um
[15:13] seems like it's meant to be but either
[15:14] way you can start to see actual data
[15:16] moving through which is how you're
[15:17] really going to be able to wrap your
[15:18] head around what's going on another
[15:20] great thing about nnn is there's so much
[15:22] documentation it's super easy to get
[15:24] help so if you come down here you can
[15:25] see help we've got a lot of stuff here
[15:27] they even have a course that you can go
[15:28] through through but documentation if you
[15:31] click on here you can see pretty much
[15:33] anything you need to find like there
[15:34] there's quick starts there is um
[15:37] Concepts about flow logic Concepts about
[15:39] data so like I said super easy to learn
[15:41] about all this kind of stuff you can
[15:43] look at you know what each node is doing
[15:44] specifically so let's say you were
[15:46] confused about the loop node you could
[15:49] come in here read about
[15:51] looping you could see you know how the
[15:53] node works you could maybe see some
[15:55] examples of how people are using it and
[15:57] yeah like at the bottom it's probably
[15:58] going to throw you in some you know
[16:00] templates of actual workflows with loops
[16:02] but super easy to get help Within naden
[16:05] part two of the master class we're going
[16:07] to be talking about some Core Concepts
[16:08] so we just saw what the interface looked
[16:10] like we saw a few nodes but now we
[16:11] actually need to dive into different
[16:13] types of nodes and what they do and then
[16:15] we're going to end this section of the
[16:16] master class with an actual example
[16:19] where we'll get into nadn I'll do a live
[16:21] build of a really quick Automation and
[16:23] then we'll talk about the different type
[16:24] of nodes and how data is moving through
[16:26] so it should be pretty cool to see so
[16:28] before we in nadn and we build out our
[16:30] first automation we really need to
[16:32] understand these sort of four main types
[16:34] of nodes so we've got Trigger action
[16:37] data transformation and logic so let's
[16:40] just break these down real quick
[16:42] starting off here with trigger nodes
[16:44] because a trigger node is pretty much
[16:45] going to be what starts every workflow
[16:46] we just saw these in nadn they were the
[16:48] ones with the little lightning bolt next
[16:50] to them anyways different types of
[16:53] trigger nodes we can look at something
[16:54] like a web hook trigger um an email
[16:56] trigger like I showed you anything
[16:58] that's going to start the the workflow
[16:59] whether that's going to be manual or on
[17:01] a chat or on an event or I have called
[17:04] by another workflow bolded here because
[17:07] it's sort of the power of NN you can
[17:09] build a workflow that will be called by
[17:11] another workflow and then you can build
[17:13] an agent that can call that workflow as
[17:15] well as maybe this agent can call like
[17:17] 10 other workflows so super powerful
[17:19] stuff here next we've got action nodes
[17:22] these are the actual doers they're going
[17:23] to perform a very specific task within
[17:25] your workflow so it's like an assembly
[17:27] line this guy is going to to um you know
[17:30] put the present in the Box this guy's
[17:31] going to wrap the present this guy's
[17:33] going to put the bow on the present all
[17:35] that sort of stuff but they can do
[17:36] different things like you know send
[17:37] email create a record make an API
[17:39] request they can get a text message they
[17:41] can set your calendar um almost anything
[17:44] that you could do on your computer on
[17:46] your phone manually you could have some
[17:48] sort of action node to do this thing
[17:50] third we have data transformation nodes
[17:53] these are going to help you change or
[17:54] process your data in some way so that it
[17:55] flows through the whole process and you
[17:57] get the end result as you want want it
[17:59] so these type of nodes can do things
[18:01] like set that can add Fields change
[18:03] values within Fields it can do some sort
[18:05] of processing your data you've got
[18:07] something like an aggregate where you
[18:09] can combine a ton of data into a single
[18:10] output or something like a merge where
[18:12] you can combine data from two different
[18:14] sources and put them into one the last
[18:17] type I'm going to touch on real quick
[18:18] are logic nodes these are sort of the
[18:20] decision makers they're going to help n
[18:22] and figure out what path to take how to
[18:24] handle a different situation so we've
[18:26] got something like an if node it's going
[18:28] to check if a specific condition is true
[18:30] or false is you know this value higher
[18:32] than 10 it's going to go this way
[18:33] otherwise it's going to go this way
[18:35] we've got a switch node which is going
[18:37] to allow you to put multiple conditions
[18:38] in there and it's going to be checked
[18:40] and direct the workflow to a specific
[18:42] action based on that conditional check
[18:45] and then something like a weit node
[18:46] which is going to pause the workflow
[18:48] let's say you wanted to pause the
[18:49] workflow until you come back and respond
[18:52] like yes that's good to go then it will
[18:53] continue to move on through the rest of
[18:54] the process or you could have it like
[18:56] wait for 20 seconds um what whatever you
[18:59] want it to do all right now it's time to
[19:00] finally hop back into NAD in hopefully
[19:02] these slides weren't too boring but
[19:04] we're going to be building an example
[19:05] workflow here it's going to be really
[19:06] simple it's just going to automatically
[19:08] process customer orders and then it's
[19:10] going to summarize it and send us a
[19:12] report automatically every time we get a
[19:14] new order so super cool stuff let's hop
[19:15] into how we're going to build this thing
[19:17] all right we are in a Google sheet this
[19:19] is going to be the customer order data
[19:20] that we'll be using for this example so
[19:22] I had chat gbt make up some data for us
[19:24] we've got stuff like order ID customer
[19:26] name product quantity price order date
[19:29] and the status of that order so every
[19:32] time a new row is put into this Google
[19:33] sheet it's going to run through nadn
[19:35] automatically it's going to get
[19:37] summarized by some sort of large
[19:38] language model like chat gbt or Claude
[19:41] and then that summarization is going to
[19:43] be emailed off back to us or back to our
[19:45] team automatically so this will be a
[19:48] nice simple example but it's going to
[19:50] feature different types of nodes and
[19:51] we'll be able to see the data move
[19:53] through real time so it'll give us a
[19:55] really good base we are now in n8n this
[19:57] is the canvas we'll be working on and
[19:59] this is the workflow that we'll be
[20:01] building here um NN masterclass customer
[20:03] orders so we know the first step that we
[20:06] always need to do is add some sort of
[20:07] trigger we'll click in here and we can
[20:08] see different triggers like manual um on
[20:11] app event called by another workflow we
[20:13] talked about this but in this case we
[20:15] want to make this one automatic so we're
[20:17] going to be doing a Google Sheets
[20:18] trigger Google Sheets has three triggers
[20:21] it's got on row added on row updated or
[20:24] on row added or updated so we'll do this
[20:26] one because that way if you have to go
[20:28] in there and change some sort of
[20:29] information about an order like let's
[20:31] say one goes from you know the status is
[20:33] pending to shipped or something we'll
[20:36] also get an email about that so we have
[20:38] to set up the Google Sheets account um
[20:41] this is where you're going to have to
[20:42] set up a credential and I'll walk you
[20:43] guys through how to do this so you're
[20:45] going to click create new credential and
[20:47] you'll see this screen pop up where we
[20:48] need to grab a client ID and a client
[20:50] secret um this looks a little confusing
[20:52] and I was definitely confused when I
[20:53] first saw the screen so what we need to
[20:55] do is right here um I talked about how
[20:58] nadn has is really good at having
[20:59] documentation that explains stuff so
[21:01] we'll click on open docs right here we
[21:03] will see that the prerequisite we need
[21:05] is a Google Cloud account so we'll go in
[21:07] here and make a Google Cloud account um
[21:09] and then we can see that it's going to
[21:10] walk you through step by step so if my
[21:12] explanation isn't good enough you can
[21:14] come in here and grab the docs but
[21:16] hopefully I'll show you real quick how
[21:17] to do this so we'll come into Google
[21:19] Cloud um this is what it's going to look
[21:21] like you'll have to sign in make an
[21:22] account then you want to go to your
[21:25] console once you're in your console
[21:27] you'll see the screen
[21:29] you might not know what to look at but
[21:30] all we want to do is we're going to
[21:31] create a project so mine right here is
[21:32] just called my first project make sure
[21:34] you're in your project and then you want
[21:35] to come in this left hand side to apis
[21:38] and services we're going to click on
[21:40] enabled apis and services and at this
[21:42] point you just need to search for a
[21:44] Google Sheets so we're going to type in
[21:47] Google um okay we need to do sheets be
[21:49] more specific so Google Sheets we can
[21:51] see Google Sheets API we'll click in
[21:53] here and then all you need to do is just
[21:55] enable this API so we've got ours
[21:57] enabled already
[21:59] um there will be a button right here
[22:00] it's just as simple as that so get that
[22:02] enabled and then you're going to come in
[22:03] here go back to your apis and services
[22:05] and then we want to go to
[22:08] credentials once we're in credentials um
[22:10] this is where you can set up your client
[22:12] IDs to get an ID and a secret so I'll
[22:15] just walk you guys through how we're
[22:15] going to do this one you're going to
[22:17] click create credentials up here you'll
[22:19] go to ooth client
[22:20] ID once that loads up you want to choose
[22:23] the application type this is going to be
[22:24] a web app you can name it whatever you
[22:26] want we'll call this one demo for for
[22:28] the sake of this video and then all you
[22:30] need to do here is add a redirect URI so
[22:33] this is where you see in nadn you've got
[22:36] this UD redirect URL um we're just going
[22:39] to click here to copy go back into
[22:41] Google cloud and we're going to add this
[22:43] right in here just just paste it in and
[22:45] then you'll hit create you'll get the
[22:48] screen pop up with um your client ID and
[22:50] your client secret so it's as simple as
[22:52] copying the ID pasting that into the ID
[22:55] field in NN going back to Cloud grabbing
[22:58] your secret and pasting it into the
[23:01] secret then you want to sign in with
[23:03] Google so this screen's going to pop up
[23:05] it's just going to be a simple prompt to
[23:06] sign in with Google like you would
[23:08] normally have um so I'll drag this in
[23:10] right here and now it says that Google
[23:11] hasn't verified this app so this is
[23:13] where you need to set up your ooth
[23:14] consent screen um so back in here you've
[23:18] got your ID and your secret now you need
[23:20] to go back in your credentials right
[23:21] here ooth consent screen all you need to
[23:23] do here is either make sure that your
[23:25] app is published so um you need to make
[23:28] make sure the app is published so that
[23:29] it has you know access to actually go
[23:31] through and grab information out of your
[23:33] Google Sheets your drive your email
[23:34] whatever it is or you can add yourself
[23:36] as a test user so I've got my emails
[23:38] down here as test users this also will
[23:40] allow these emails to sign in and go
[23:43] through but if you're getting blocked
[23:45] for some reason it's probably because
[23:47] you didn't set this up right so just
[23:48] make sure it's published or that you're
[23:49] in there as a test
[23:51] user so back into nadn um we've got this
[23:54] signin field we'll hit continue just
[23:56] make sure you give this email access to
[23:58] everything give NAD access and then
[24:00] you'll hit continue and then pretty much
[24:02] you'll be good to go you'll see we got
[24:04] this account created right here it's
[24:05] green we're good so we will come out and
[24:09] now we're
[24:10] connected so now that we're connected we
[24:13] can configure the rest of this node it's
[24:15] going to be running every minute and
[24:16] that's when it's going to be checking
[24:17] for if a row was added or updated now we
[24:21] can select the document that we want so
[24:23] it's really nice you can choose from a
[24:24] list you can enter the URL or the ID of
[24:27] your document but list is so much easier
[24:29] it's just going to access your Google
[24:31] Drive and see what sheets you've got so
[24:33] we're going to do customer orders um
[24:35] there's only one sheet in this document
[24:37] so we'll grab that sheet and it's going
[24:39] to trigger on row added or updated so if
[24:42] we can fetch a test event here we'll see
[24:43] some of our sample data coming through
[24:46] so as you can see we've got um five
[24:47] items we've got the columns up here and
[24:49] then we have all of these orders that we
[24:52] just had right here in Google Sheets so
[24:53] we've got John Jane Mike Emily Robert
[24:56] Brown and in here you can see we've got
[24:58] John Jane Mike Emily and Robert Brown so
[25:00] this node's working we've got our
[25:02] information coming through into NN now
[25:04] we want to add an open AI node so we'll
[25:06] just click on this plus right here or
[25:08] click on the plus up in this top right
[25:09] corner and you can search for a new node
[25:11] we're going to grab open AI you could
[25:13] use a different large language model if
[25:14] you wanted to but I'm going to be using
[25:15] open AI you can see we've got 15
[25:17] different actions within this node what
[25:20] we want to do here is message a model
[25:21] basically just means that we're going to
[25:22] be talking to chat GPT just call this no
[25:26] summarize and now we need to hook up
[25:29] this node with our credentials so at
[25:31] this point if you don't have an open AI
[25:32] account you need to do so and then once
[25:34] you do that you can come in here click
[25:36] create new credential this time all we
[25:38] need is a single API key so once you
[25:41] have your open AI account you'll come
[25:43] into it on left hand side you'll see all
[25:44] the stuff but we just want to go to API
[25:46] Keys up in the top right you can click
[25:48] create new key give it a name and then
[25:51] it will give you a value to copy so
[25:53] pretty simple same thing you just want
[25:55] to come in here and copy that
[25:56] information in or sorry past that
[25:58] information in hit save and it will go
[26:00] green once you're all good um so that is
[26:03] all you got to do but pretty much every
[26:05] time that you need to configure a node
[26:07] you're going to have to grab some sort
[26:08] of key so just keep that in mind so as
[26:11] you can see the resource is text the
[26:13] operation is messaging a model and now
[26:14] we need to choose what model we want to
[26:16] message so I'm going to come in here and
[26:18] grab GPT 40 right there and now we need
[26:22] to configure the rest of this node so
[26:24] this is the message that we're sending
[26:26] to GPT 40 you have a couple options here
[26:30] you can have it be a user message an
[26:32] assistant message or system message you
[26:33] can see the differen is right here
[26:35] usually when you're going to be
[26:36] prompting the node how to act we're
[26:37] going to choose system so in here I'm
[26:40] going to type a quick prompt and I'll be
[26:42] right back to explain it all right here
[26:44] is the system prompt that I came up with
[26:46] just typed this out really quick so I
[26:48] said you are in charge of client orders
[26:50] your job is to take incoming information
[26:51] regarding new orders and give a nice
[26:53] summary that will be emailed to the team
[26:55] the email should be signed off from
[26:56] customer success team and then we want
[26:59] to give it the information from the
[27:00] previous Google Sheets trigger that's
[27:02] coming in here on the left we need to
[27:04] actually give it the information to
[27:05] summarize so it's going to be getting
[27:07] order ID customer name product quantity
[27:09] price order date and status and so all
[27:11] we need to do is come in here and drag
[27:13] and drop each of the
[27:15] fields into the prompt and it will be a
[27:17] variable so it will change for each one
[27:20] so I'll just show you guys order ID we
[27:22] drag this in and I don't know why it
[27:24] does that um we want to make sure that
[27:28] right here with order ID so first of all
[27:32] first thing to note this is a green
[27:34] variable with the two curly brackets
[27:36] around it that just means that it's a
[27:38] JavaScript variable so this doesn't
[27:39] involve any coding it's as simple as
[27:41] dragging and dropping but this just
[27:43] means that it's going to change based on
[27:44] whatever value is in this field so as
[27:47] you can see in the result tab right here
[27:50] we've got the the json. order ID is
[27:52] coming through as 101 because that's the
[27:54] first order and you can see similar
[27:56] things when we drag in customer name
[27:58] we'll get in the the results we got John
[28:00] Doe um we'll drag in everything else and
[28:03] then I'll show you guys so we're just
[28:04] going to drag in product quantity price
[28:06] order date and Status so that's assigned
[28:09] wherever it needs to be and then as you
[28:11] can see in the result we've got here's
[28:12] the information on client orders we've
[28:14] got the correct order ID name price
[28:17] quantity all this kind of stuff we have
[28:18] the actual information coming through as
[28:20] you can see and then the last thing that
[28:22] we wanted to say was please output the
[28:23] following parameters So based on this
[28:26] information that it's getting right here
[28:27] that it's going to sum summarize it's
[28:29] going to Output an email subject for us
[28:31] and an email body for us so we can go
[28:33] ahead here and hit test step and I'll
[28:36] show you one thing about how we want to
[28:38] Output this content as Json so I didn't
[28:40] check this yet and so that means that
[28:42] this is going to execute and it's going
[28:44] to all come out in one sort of like
[28:46] large string so as you can see we've got
[28:50] um for the first order email subject new
[28:52] order confirmation order ID 101 here
[28:55] actually let me make this a little
[28:56] bigger so it says hello team we have a
[28:58] new order that has been successfully
[29:00] processed and shipped below are the
[29:01] details so it's going to summarize out
[29:03] for us and then it signs off thank you
[29:04] for your attention best regards customer
[29:06] success team but this is coming through
[29:08] as one big chunk of text called content
[29:11] so what we want to do is output the
[29:12] content as Json we'll test the step
[29:14] again and now it's going to come through
[29:16] as two separate Fields one will be the
[29:17] email subject and then one will be the
[29:19] email body and this is just important so
[29:22] that we can drag and drop the next
[29:24] Fields later when we want to configure
[29:25] the actual Gmail node so as you can see
[29:27] right here we've got the subject and
[29:29] then we've got the body and we've got
[29:30] the subject and the body we'll read one
[29:33] more real quick so order 103 we've got
[29:35] the subject and then the body says we
[29:37] have a new order summary order ID 103
[29:39] Mike Johnson you got headphones at $200
[29:42] just one pair please let us know if you
[29:44] need further details so as you can see
[29:45] these are all coming through as an email
[29:47] subject and an email body and this will
[29:49] be important when we set up this next
[29:51] node here which is going to be a Gmail
[29:54] node this time we're going to add the
[29:56] node by clicking the plus up here it's
[29:57] the same thing as this plus but just
[29:59] wanted to show you guys different ways
[30:00] we're going to grab a Gmail node and
[30:02] there's 25 actions within Gmail as you
[30:04] can see there's a lot of stuff you can
[30:05] do which is just awesome but here we're
[30:07] going to be sending a message so we'll
[30:08] click on send a
[30:09] message um real quick let's just make
[30:11] sure we wire this one up otherwise it's
[30:13] not going to work and then we'll come
[30:14] back into the node and we can configure
[30:16] it so first thing you got to do is
[30:17] obviously set up your new credential
[30:19] you'll come in here just got to grab
[30:21] that same client ID and secret from the
[30:23] previous one so we'll come back into um
[30:26] our enabled apis and services
[30:28] you want to go to
[30:29] credentials and then you can click into
[30:32] that um client ID that we just made and
[30:35] then all you got to do once again is
[30:37] copy and paste that information in so
[30:39] let me just do this real quick we'll
[30:40] grab the
[30:41] secret paste that in there and then once
[30:44] again just sign in with
[30:47] Gmail it's again going to make you
[30:49] verify the app we'll go through give
[30:51] access to everything and then we go
[30:54] green because we're good to go so we've
[30:55] got that set up now all we need to do is
[30:58] configure the rest of this node so as
[30:59] you can see the resource is a message
[31:01] the operation is that we're sending a
[31:02] message now you can see why it's so
[31:04] important that we set up the email
[31:06] subject and the email body as two
[31:08] separate Fields because we output it as
[31:10] Json so all we got to do is drag in this
[31:12] subject right here where it says subject
[31:15] so the subject of this Gmail being sent
[31:17] off will be order confirmation 101 for
[31:19] John Doe and then same thing with body
[31:21] you're going to grab that and put that
[31:22] in the message field where this is the
[31:24] actual message that's going to be sent
[31:26] in the email we we want to make the
[31:28] email type is text that's just how I
[31:29] usually like to do it and then for the
[31:31] sake of this example we will just put in
[31:34] my email so we can see this email coming
[31:36] through and you could make this variable
[31:38] you could make this change based on the
[31:39] order if you wanted to but right now
[31:40] let's keep it simple we're just going to
[31:42] send it to nerk 88@gmail.com every time
[31:45] and finally you've got some options here
[31:48] you could attach things you could CC
[31:50] people you could change the sender name
[31:52] variably whatever you want to do here I
[31:54] usually just will come in here and click
[31:56] append and add an attribution and make
[31:57] sure I turn that off otherwise at the
[31:59] bottom of the email it'll just say this
[32:01] email was generated by nadn or sent by
[32:03] nadn so this looks good to go we can
[32:06] test this step and it will it should be
[32:08] firing off five emails because we have
[32:11] five emails um in the sample data so you
[32:14] can see these came through it's just
[32:16] giving us a message ID and a thread ID
[32:18] which right now we don't need but you
[32:20] can see that all of these got sent so
[32:22] let's hop over to the email I will
[32:24] refresh and we should see five new
[32:26] emails in my inbox so yeah we've got
[32:28] order um 101 102 103 104 and 105 so this
[32:33] is information from all the orders as
[32:35] you can see this one says new order from
[32:37] Robert Brown he got a tablet three of
[32:39] them actually 600 per unit so the total
[32:42] price was 1,800 it was on August 28th
[32:44] and the status is still pending so thank
[32:47] you best regards customer success team
[32:49] so all that came through exactly how we
[32:50] wanted it so that's good to
[32:52] see now we're back in n8n and we're
[32:56] pretty much done with this workflow
[32:58] we've got three nodes in here and we can
[33:00] save it and now what we want to do is
[33:04] check this box to inactive or sorry to
[33:07] active so all this means is that now
[33:09] that the workflow is activated it will
[33:12] regularly check Google Sheets for events
[33:13] and then it will trigger executions each
[33:16] time that um a row is added or
[33:18] updated and they won't show immediately
[33:21] in the editor so that means like we
[33:24] won't be seeing like these turn green
[33:25] every time it actually is going through
[33:27] but they will'll be going through so
[33:28] let's hop into the Google Sheets real
[33:30] quick add a new row and then let's let's
[33:32] wait for the email okay so I've got this
[33:34] information I'm about to paste into here
[33:36] we've got order 106 for Phil dumpy he
[33:40] ordered 500 crayons $5 for each one
[33:43] we've got the date and we got the status
[33:45] so now we're just going to hop into our
[33:47] email and I'll just refresh and we
[33:49] should see the new email coming
[33:53] through okay so I just refreshed and we
[33:55] can see this new New Order we've
[33:57] received the New Order from Phil dumpy
[33:58] here are the details 106 Phil dumpy 500
[34:01] crayons $5 per unit we've got the date
[34:04] and then we have the status so um as you
[34:07] can see the date is actually coming
[34:08] through is January 20
[34:09] 2025 um and we did not put January 2025
[34:13] so what you can do here is because
[34:14] there's you know a discrepancy we will
[34:16] go back and N ITN we will go to our
[34:19] executions over here or right here so
[34:21] executions we can see this is the most
[34:23] recent execution we'll click into here
[34:25] and we can see what's actually taking
[34:26] place
[34:28] so as you can see the trigger went off
[34:30] it grabbed one new item we'll open up
[34:32] this message and model node so we can
[34:33] see the information coming through and
[34:35] you can see the date come through here
[34:36] as
[34:37] 45585 so that's not what we want um
[34:40] that's why it's coming through as um
[34:43] January 20 2025 so what we need to do is
[34:46] come in here and fix this specific node
[34:48] because we see exactly where the issue
[34:49] is happening I think the issue here was
[34:51] just weird formatting with numbers
[34:53] coming through as far as dates so let's
[34:55] just try this one again I just out of
[34:57] this row so it should be working right
[34:59] now to fire off this email to us but we
[35:01] kept this one as just plain text so
[35:03] hopefully it reads through an n and end
[35:04] as plain text but let's take a look at
[35:06] the email and then we'll take a look at
[35:07] the actual execution okay just refreshed
[35:10] got this new order it's coming through
[35:11] order 106 and we got the date correctly
[35:13] as October 20th 2024 which is what we
[35:16] put right here so let's go back into Ed
[35:18] and let's refresh this page so we can
[35:21] get the most recent execution and making
[35:23] sure all the data is coming through
[35:24] exactly how we want it and it's a great
[35:26] thing to keep in mind that you're able
[35:27] to go into the executions you can see
[35:29] exactly how stuff's coming through so
[35:31] from the Google Sheets trigger we're
[35:33] getting this information and the date's
[35:35] now coming through correctly how we want
[35:36] it previously it was coming through as
[35:38] just like 4554 whatever sometimes in
[35:40] sheets it can be weird with date
[35:42] formatting and then it's being able to
[35:44] come through correctly order date and
[35:46] it's giving us a nice summarization
[35:47] right here we've received New Order with
[35:49] the following details order ID 106 for
[35:52] Phil dumpy crayons 500 all this kind of
[35:55] stuff and then it's just going to take
[35:56] that subject and and um body and put it
[35:59] into a Gmail node which is being sent
[36:02] over to Nate herk 88@gmail.com
[36:04] which is what we see right here so that
[36:08] was it for this first example I know it
[36:10] was very simple we just utilized three
[36:12] nodes to build this workflow that
[36:13] automatically takes data every time a
[36:16] row is added in your Google Sheets it's
[36:18] going to summarize it with a large
[36:19] language model of chat gbt 40 and then
[36:22] it's going to move into the Gmail node
[36:24] which actually sends it off and this was
[36:25] one execution of this work worklow okay
[36:29] now we're moving into part three of this
[36:30] master class which is going to be
[36:31] talking about Rag and Vector databases
[36:34] I'm sure you've heard these terms but
[36:35] maybe you don't completely understand
[36:36] them so I'm here to break it down for
[36:38] you and then we're going to end this
[36:39] part with going back into nadn building
[36:42] out a simple rag AI agent and this will
[36:45] include you know actually uploading
[36:47] information into a vector database and
[36:49] then being able to use an agent and rag
[36:51] in order to go talk to that PDF or file
[36:55] and get answers back okay so what is is
[36:57] rag rag stands for retrieval augmented
[37:00] generation and it's a very powerful
[37:02] technique that's going to combine two
[37:03] different approaches the first part is
[37:05] retrieval and then the second part is
[37:07] Generation so this technique really
[37:09] helps AI models provide accurate and
[37:11] relevant answers especially when you
[37:12] need upto-date or specialized
[37:14] information so the first part here is
[37:16] retrieval when you ask the AI a question
[37:19] instead of it making up answers based on
[37:21] its training data it's going to retrieve
[37:23] relevant information from um external
[37:25] sources so in this case the pine cone
[37:28] Vector database that we're going to be
[37:29] setting up um so this is obviously going
[37:31] to be the database but it could be other
[37:33] documents or it could be websites and
[37:36] then the generation aspect of it is
[37:38] after it retrieves back this information
[37:40] that's relevant and accurate and up to
[37:43] date then the AI model will use this
[37:45] information to generate an answer so
[37:47] this is where the AI actually crafts a
[37:49] human readable response with the
[37:51] information if you don't already
[37:53] understand from that previous slide why
[37:54] rag matters let's break it down real
[37:56] quick let's say for this example you're
[37:59] using an AI assistant that needs to
[38:01] answer questions about your company's
[38:02] internal policies you don't want this
[38:04] thing to just guess um answers based on
[38:07] its training data it might be out of
[38:08] date because you're going to update
[38:10] policies stuff like that so in this case
[38:12] the AI assistant will use rag to
[38:14] retrieve the most relevant information
[38:15] from the system it's going to generate
[38:17] an answer based on that specific
[38:18] information which makes the AI far more
[38:21] reliable and up toate for your needs
[38:23] okay rag is a pretty simple concept to
[38:25] wrap your head around now we're going to
[38:26] move into databases which I think are a
[38:28] little more complicated but once you
[38:30] really break them down not that bad so
[38:33] in order to make rag work the system
[38:35] needs a way to store and retrieve data
[38:37] efficiently this is where the vector
[38:39] databases are going to come into play so
[38:42] in simple terms Vector databases store
[38:44] data in the form of vectors which are
[38:46] just numbers that represent the meanings
[38:49] of words or text or whatever it is and
[38:51] it's going to store these vectors into a
[38:53] multidimens dimensional database so
[38:56] these vectors are going to help us find
[38:57] find similar or related information much
[38:59] quicker than sort of like a relational
[39:02] um structured database this one's going
[39:04] to be using a lot more unstructured data
[39:05] so even if the words are not the exact
[39:07] same for example you're asking about
[39:09] cars the vector database might also help
[39:11] you find related information about
[39:13] vehicles or automobiles as you can see
[39:15] in this picture down here we've got um
[39:17] wolf dog cat and then the query is a
[39:20] kitten so it's going to be searching for
[39:22] a kitten information about kittens and
[39:24] it will kind of be um in this
[39:25] three-dimensional
[39:28] database store it'll be seeing like
[39:29] similarities based on characteristics of
[39:31] these things and as you can see like
[39:33] we've got fruits over here and then you
[39:34] might have vehicles down here and you
[39:36] might have like you know information
[39:38] related to certain types of products up
[39:40] here so that's kind of how this works
[39:42] just as like from a visual perspective
[39:45] so if you're wondering how Vector
[39:46] databases work in relation to rag the AI
[39:49] is going to convert documents or text
[39:51] into Vector stores and it's going to put
[39:52] them in the vector database where they
[39:54] need to be then when a question is asked
[39:56] the system is going going to look for
[39:57] similar vectors and sort of search out
[39:59] the right area to pull information back
[40:02] um you know relevant documents or data
[40:04] and then once it finds these most
[40:05] relevant vectors it's going to retrieve
[40:07] that information and then finally it's
[40:09] going to generate an answer for the
[40:10] human once you understand what a vector
[40:13] database is what Vector stores are you
[40:15] need to understand how can you actually
[40:17] get information into a vector store so
[40:20] this next slide is going to talk about
[40:21] sort of embeddings and stuff like that
[40:24] all right so embedding data into a
[40:25] vector database this this slide is going
[40:27] to be kind of tailored towards doing
[40:29] this in n8n there's other ways to but NN
[40:31] is the way I do it so real quick let's
[40:34] just break down this picture so what's
[40:36] going on here is we're testing the
[40:37] workflow it's going to be searching a
[40:39] Google Drive for a specific file it's
[40:41] going to pull that file and then we need
[40:43] to embed it into the pine cone Vector
[40:45] Store Pine Cone is just a vector store
[40:47] database that we use um it just seems to
[40:50] be you know very cheap very easy to use
[40:51] so this is the one we're using but
[40:52] there's other Vector databases out there
[40:54] you might have heard of something like
[40:55] super base but this one's really simple
[40:58] then what it's going to do is it needs
[40:59] to load the information so the type of
[41:01] information coming through whether it's
[41:03] Json or binary it's going to load that
[41:06] it needs to be able to split it up you
[41:07] know it's going to chunk it up and then
[41:09] it's going to use the open AI model to
[41:11] embed it into the actual Vector store so
[41:14] I know that this stuff may not make
[41:15] sense yet we'll get into an actual
[41:17] example in NN where we're building this
[41:19] out and we're getting real PDFs from our
[41:21] Google Drive up into pine cone and we'll
[41:23] see all that take place but we just
[41:25] wanted to give you a quick visual real
[41:27] quick quick so you can understand what's
[41:28] going through the first thing I'll touch
[41:29] on real quick um is the default data
[41:32] loader aspect of this so in NN when we
[41:34] connect the vector store we have to load
[41:35] the data this node is basically just
[41:37] going to allow us to load data from a
[41:39] previous step flowing through um you
[41:41] know right here and then we need to load
[41:43] it into here so that we can actually
[41:45] chunk it up and get it embedded into the
[41:48] vector store so this note is pretty much
[41:50] just going to be looking at what kind of
[41:52] data we're loading in um if it's like
[41:54] Json or if it's binary that sort of
[41:56] stuff and then we can just you know
[41:58] configure how much we want to pass
[41:59] through stuff like that and then we move
[42:01] into actually text splitting so right
[42:03] here I have a recursive character text
[42:05] splitter as you can see right here the
[42:06] three options in NN will be character
[42:08] recursive character or by tokens so the
[42:11] first option is character text splitter
[42:13] this is just going to split the text
[42:14] into chunks based on a set number of
[42:16] characters so you might want to use this
[42:18] when you want to break down text into
[42:19] equally sized pieces regardless of where
[42:22] sentences or paragraphs end um and then
[42:24] the next one we have is recursive
[42:26] character text splitter which I seem to
[42:27] use the most because this one is going
[42:29] to split text by characters but it does
[42:31] so intelligently because it's going to
[42:33] break down logical points like after a
[42:36] sentence or in between paragraphs stuff
[42:37] like that but same concept of just
[42:39] chunking stuff down so this is
[42:41] recommended when you want to keep the
[42:43] text meaningful instead of cutting off a
[42:44] sentence in the middle it's going to
[42:46] split at natural breaks like after you
[42:48] know a period or a comma something like
[42:50] that and then finally the token splitter
[42:53] this is going to split text based on
[42:55] tokens which are usually words or
[42:57] subwords that the model understands and
[42:59] you kind of want to use this when you're
[43:00] working directly with a language model
[43:02] like Chachi BT because it's going to
[43:04] process text in terms of tokens and you
[43:06] know it's going to chunk It Down based
[43:08] on how the AI model reads the text so
[43:10] you know if you're processing data for a
[43:11] model it's going to split the text
[43:13] accordingly hopefully I didn't confuse
[43:15] you guys too much maybe I went into too
[43:16] much detail but just wanted to break
[43:18] down those different types of splitting
[43:20] but best practic is a lot of times you
[43:21] can just use recursive character so the
[43:23] information stays meaningful but um just
[43:27] a quick summary here so the rag is going
[43:29] to be um retrieving information from
[43:31] documents right here that we're putting
[43:33] into a vector store in order to give us
[43:35] intelligent answers then the vector
[43:37] database is going to store text in a way
[43:39] that allows us to quickly and
[43:41] efficiently search based on meaning not
[43:44] just exact words that are you know
[43:45] hardcoded in we're looking at stuff
[43:47] that's related to specific meanings of
[43:49] words and then we're going to use a text
[43:51] splitter to um help break down the large
[43:54] documents into manageable pieces in
[43:56] order to put them into to the vector
[43:57] database and then open I AI here in this
[44:00] case is just going to embed it into the
[44:02] vector store so that is basically how
[44:04] it's going to work and we'll hop into NN
[44:07] and actually show you guys this as you
[44:08] can see what we're going to do here is
[44:10] build an RG rag AI agent and in this
[44:13] workflow we'll be using a Nike earnings
[44:16] PDF and we're going to put that into
[44:18] pine cone which is the vector database
[44:20] that we'll be using and then we can chat
[44:21] with the agent in order for it to
[44:23] retrieve information about Nike earning
[44:25] so that we don't have to read through
[44:26] the PDF we you can just ask questions
[44:27] about it all right like I said we're
[44:29] going to be looking at this PDF of Nike
[44:32] earnings reports so we're going to see
[44:34] this is the PDF that we're looking for
[44:35] it's 10 pages we don't want to really
[44:37] have to read this thing we want to be
[44:38] able to just chat with an agent and it
[44:41] can pull the information for us so first
[44:43] up here get some sort of document that
[44:45] you want to put into pine cone Vector
[44:47] store then as you can see I have this in
[44:49] my Google Drive right here so that we're
[44:51] able to actually you know call this
[44:53] information and push it into pine cone
[44:55] through nn and then you want to go into
[44:58] pine cone it's just type in Pine cone.
[45:00] it's free to get started you want to set
[45:02] one up you'll come into here and all you
[45:04] want to do is you're going to create an
[45:05] index so you can name it whatever you
[45:07] want um I'm pretty much just going to
[45:10] keep everything as is the only thing
[45:12] that you want to make sure that you set
[45:13] up here is right here you want to set it
[45:15] up by model and you want to choose text
[45:16] embedding three small so you'll set that
[45:18] configuration and then you'll just hit
[45:20] create index your index is going to pop
[45:22] up right here if you click into it you
[45:24] can see that there's no information you
[45:25] can see that there's no name spaces in
[45:27] here um just a really quick explanation
[45:29] of name spaces you can have different
[45:30] name spaces within each index like let's
[45:33] say I was in here and I had one for um
[45:36] internal documents and then I had one
[45:37] for um client a and then I had one for
[45:40] client B that's just going to help your
[45:41] agent be able to search for the
[45:43] information quicker because it can sort
[45:44] of break it down by okay I need to go to
[45:46] this index and I need to go to this
[45:47] namespace and then here's all relevant
[45:49] information regarding this project or
[45:52] client once you've got all that
[45:54] information set up we are good to hop
[45:56] into to NN and start pushing information
[45:58] into that pine cone Vector store so the
[46:01] first thing that we're going to do here
[46:02] is I'm just going to make this a manual
[46:04] trigger in the future you could have
[46:05] this where every time you upload a
[46:07] document to a certain drive it would do
[46:10] a Google Drive trigger and then it would
[46:11] automatically push that information into
[46:13] pine cone which is super cool because
[46:15] then your database is going to you know
[46:16] stay up to date every single day every
[46:19] single time you add more information but
[46:20] right now we're just going to be doing a
[46:21] manual trigger next thing we need to do
[46:23] is add a Google Drive node because we
[46:25] need to get that information from Google
[46:26] Drive drive into NN so we're going to
[46:28] click on this plus button going to type
[46:30] in Google and we will see Google drive
[46:33] right here once again lots of actions
[46:36] the Integrations are awesome but what
[46:37] we're going to do here is download a
[46:39] file so if you haven't got this node
[46:41] configured yet it should be super easy
[46:43] because you've already set up your
[46:44] consent screen and your client ID and
[46:46] secret and all that but in here you just
[46:47] need to go and make sure that you have
[46:49] enabled the right API so as you can see
[46:51] here I've got Google Sheets Google Drive
[46:52] Gmail Google Docs custom search all the
[46:54] different apis that I can use within in
[46:57] NN so set that up make sure you're
[46:59] connected to the right account and then
[47:01] we're going to be downloading is the
[47:04] operation and we're grabbing a file the
[47:05] resource and once again we can choose
[47:07] from a list which is awesome we're going
[47:09] to come in here and look for the Nike
[47:12] press release PDF so I'll grab that and
[47:14] then what we're going to do is just hit
[47:16] test step because then we can see the
[47:17] information coming
[47:19] back so on the output you can see that
[47:21] we're getting this information one thing
[47:23] that's really important to know is that
[47:24] it's not coming through as Json there's
[47:26] no information here it's coming through
[47:28] as binary so we don't have to get too
[47:30] technical on what exactly that means but
[47:32] we have to just make sure we know how
[47:33] this information is coming through so
[47:35] that later when we want to embed it into
[47:37] the vector store we can make sure it's
[47:39] getting loaded correctly and I'll I'll
[47:40] show you guys that later but for now
[47:42] just remember that this PDF is coming
[47:44] through as binary so we can view this
[47:46] PDF make sure it's the right one as you
[47:47] can see it's Nike earnings so we're good
[47:49] to go here and we can move on to the
[47:51] next step we've got our file next we
[47:53] need to add the actual pine cone Vector
[47:56] store so so we can push the information
[47:57] into pine cone so we're going to add
[47:59] this we've got four actions within pine
[48:01] cone right now we're just going to be
[48:02] adding documents to a vector store but
[48:04] as you can see you could also retrieve
[48:06] you could update all that sort of stuff
[48:08] and we will be retrieving later in order
[48:10] to actually chat with our agent about
[48:12] this PDF once again it's a little
[48:14] Annoying to have to set up the
[48:15] credentials for everything but once you
[48:16] have them you're good to go so in here
[48:19] we need to set up the pine cone I'm
[48:20] going to create new credential and as
[48:21] you can see we need to grab an API key
[48:23] once you hop back into pine cone you can
[48:26] see obvious you've got your indexes on
[48:27] the left hand side you can go down to
[48:29] API keys and then all you're going to do
[48:30] is just copy this value with this button
[48:32] right here copy that and then you're
[48:34] just going to really quickly paste that
[48:35] into the API key hit save and it should
[48:37] go green because our connection is
[48:40] successful now we're actually able to
[48:42] insert documents to the index so the
[48:44] index that we want to insert to is
[48:46] called sample and for the sake of this
[48:48] video let's add it to a namespace so
[48:50] click on ADD option Pine code namespace
[48:52] and we will just call this one
[48:55] Nike and now we're good to go with this
[48:57] node but what we need to do is we need
[48:59] to set up like I talked about earlier
[49:00] the the default document loader how
[49:03] we're going to check Chunk Up the text
[49:06] and then the actual embedding so first
[49:08] we will do the embedding I'm going to
[49:10] use open AI you you should have your
[49:12] credential already set up and then we
[49:14] need to choose the model so if you
[49:16] remember when we set up our pine cone
[49:18] index we set up the model of text
[49:21] embedding three small so we don't want
[49:22] to do Ada O2 we want to come in here and
[49:25] grab three small so that it's being
[49:26] being embedded
[49:28] properly then we need to choose this
[49:30] plus button and we're going to do the
[49:32] default data loader like we mentioned
[49:34] now here is what I talked about with we
[49:36] need to remember how the information is
[49:37] coming through this Google Drive so
[49:39] remember we came in here we see the
[49:41] output is binary not Json so binary is
[49:44] how we want the information to come
[49:45] through so in the data loader we need to
[49:48] make sure we're selecting the type of
[49:49] data is going to be binary otherwise
[49:51] you're probably not going to get any
[49:52] information put into pine cone so we're
[49:55] good to go here the last step is just to
[49:57] set up the text splitter so like I
[50:00] talked about the differences between
[50:01] these three as you can see there's also
[50:02] a short little description here so if
[50:04] you forget you can always come in here
[50:05] and read what they do but we're going to
[50:07] choose recursive character text splitter
[50:10] the chunk size like we talked about is
[50:12] just how many characters are going to be
[50:13] within each chunk and the overlap um we
[50:17] don't want to have any overlap and chunk
[50:18] size 1 th I'm sure that's fine for now
[50:21] the PDF is pretty big but we can see how
[50:23] this works so let's just hit save and
[50:25] then we will test out this workflow so
[50:28] it's a manual trigger so we're going to
[50:29] hit test workflow it's going to grab the
[50:31] file download the PDF as you can see it
[50:33] went through the data loader it went in
[50:35] here and then it had to embed it until
[50:37] it came into the actual Vector store so
[50:40] let's hop back over to Pine Cone let's
[50:42] go to our database let's go to the index
[50:44] called sample we can see that we have
[50:46] information in here now and if we click
[50:48] on names spaces we will see that we just
[50:49] created a name space called Nike and
[50:52] there are 29 vectors in here and as you
[50:54] can see 29 items left the pine cone
[50:57] Vector store node all right our
[50:59] information has been successfully put
[51:00] from Google Drive into pine cone now we
[51:03] need to build an agent workflow that
[51:05] we'll be able to chat with in order to
[51:06] get answers from this PDF all right
[51:08] we're in a new workflow here and once
[51:10] again we got to add a trigger so the
[51:12] first step is going to be a chat message
[51:15] because we want to talk to the agent in
[51:17] order for the workflow to start
[51:18] execution so we'll click on chat message
[51:21] we can leave this as is because we'll be
[51:23] using this button down here to actually
[51:25] you know talk to the agent and that
[51:26] that's how it's going to work but we
[51:28] have our chat message trigger now we're
[51:29] going to add a new node we can come in
[51:31] here to Advanced Ai and we see there's a
[51:34] ton of different AI things we can do um
[51:36] there's even some templates up here to
[51:37] see you know what's possible and you can
[51:39] download those and start playing with
[51:40] them but we're just going to come in
[51:41] here and grab an AI
[51:43] agent now within this AI agent you have
[51:45] different types of Agents you can use
[51:48] you've got tool conversational or openi
[51:50] functions agent you can read a little
[51:52] bit about what each of these do but
[51:54] because we're giving these agent
[51:55] different tools I think that we'll just
[51:57] keep this one as a tools agent come in
[51:59] here and call this guy our Nike agent
[52:03] and then you can also do things like add
[52:05] a system message you can return
[52:07] immediate steps you can have him have a
[52:09] max amount of iterations we will add a
[52:11] system message right now it's just going
[52:13] to say you're helpful assistant we can
[52:14] set this up in a sec once we get all the
[52:16] tools configured but this is where we
[52:18] sort of tell the agent you know this is
[52:20] your job here's background information
[52:23] here are the tools that you have here's
[52:25] how you use them here's like an example
[52:27] flow so we'll talk about all that after
[52:30] we get the rest of this workflow
[52:31] configured we've got our Nike agent and
[52:33] then you can see there's different
[52:34] things we need to set up so the first
[52:35] one is going to be the chat model I'm
[52:38] going to grab an open AI chat model and
[52:41] connect our credential once again and
[52:43] then we choose the type of model we want
[52:45] since this is going to be pretty
[52:46] conversational I think I'm going to use
[52:48] 40 it just seems to be the most
[52:49] consistent it's kind of the one that I'm
[52:51] pretty loyal to but sometimes for
[52:53] smaller things like if you're just
[52:54] labeling emails or if you're um doing
[52:57] some sort of classifier where you just
[52:58] need to parse the information and see um
[53:00] like a category maybe then you could
[53:02] come in here and grab you know 35 or 40
[53:04] mini but don't get too caught up on what
[53:07] each model's good at but right now 40 is
[53:09] kind of the most expensive but it is the
[53:11] most
[53:12] powerful so we set that up with 40 now
[53:15] let's really quickly add a memory so
[53:17] this is super super easy we just want to
[53:19] grab a window buffer memory um this is
[53:21] super easy because that's all we have to
[53:23] do we don't have to set anything up you
[53:25] could change the context window length
[53:26] but five chats is how many the model is
[53:29] going to remember so I'm fine with that
[53:31] but this is a really easy way to give
[53:33] the agent some context of what's going
[53:35] on otherwise when you're chatting with
[53:36] it let's say you asked um what was
[53:39] Nike's earnings in you know quarter 3
[53:43] and then if it came back with the
[53:44] information and then you said okay what
[53:45] about quarter 4 it would be like what
[53:47] are you talking about quarter 4 for what
[53:49] so that's going to give context of oh he
[53:51] just asked about earnings now he wants
[53:54] to know about quarter the next quarter
[53:55] so just just going to give context to
[53:57] your agent super easy way to add that
[54:00] memory then finally this is where all
[54:01] the magic happens this is where you can
[54:03] add different tools So within here we
[54:06] have you know different things that we
[54:07] can give our agent access to of course
[54:09] we've looked at all the different nodes
[54:10] and the actions they can take but we can
[54:13] see here that this is where it's really
[54:15] powerful because we can call an NN tool
[54:18] or an NN workflow as a tool so that
[54:20] workfl that we just made about um you
[54:23] know getting information into pine cone
[54:25] we could call as a tool here but that's
[54:27] not exactly what we're going to do we
[54:29] are just going to call um sorry a vector
[54:31] store
[54:33] tool and this is the one that's going to
[54:35] be getting our um Nike information so we
[54:37] will just call this um database and then
[54:40] you need to give it a description of
[54:42] when to use this tool so we'll say call
[54:45] this tool to um read to get get
[54:50] information about Nike's
[54:53] earnings to answer the user
[54:58] question okay so that is the description
[55:00] for this tool now we need to set this up
[55:02] with the actual Vector store because we
[55:03] need to connect this to Pine Cone and
[55:05] then a model of course so let's add the
[55:07] model real quick pretty much same exact
[55:09] thing we're just connecting the
[55:10] credential we're adding a model I'll
[55:12] just do foral mini here um and then we
[55:16] can see we need to grab the vector store
[55:18] so we have in memory we have different
[55:19] options here super base that I talked
[55:21] about but this is how we actually want
[55:22] to work with data within our pine cone
[55:24] Vector store so we're going to click on
[55:25] that
[55:27] um I'm going to set this up real quick
[55:29] and now we see there's different
[55:30] operations this is the time we want to
[55:32] actually retrieve documents we don't
[55:33] want to put anything in there right now
[55:34] we're just trying to get information so
[55:36] we'll click retrieve we need to choose
[55:38] the index that we want which is just
[55:39] sample and then here's another option
[55:41] where we can add the name space for this
[55:43] agent to go search through so we called
[55:45] ours Nike so make sure you put the right
[55:48] name space in here and make sure it's
[55:49] spelled correctly too so now we have
[55:51] that set
[55:52] up so we're almost done with this agent
[55:54] last thing we need to do here is ADD the
[55:56] embedding which once again we did um
[56:01] three small so we need to set up three
[56:02] small once again okay so this is pretty
[56:05] much it for this agent we should be able
[56:07] to talk to it and have a conversation
[56:09] with it now so let's hit save and let's
[56:11] just give it a shot so real quick let's
[56:13] go to the PDF and ask about something so
[56:16] we can see the gross margin for the
[56:17] fourth quarter increased 110 basis
[56:20] points to
[56:21] 44.7% so let's ask about um the gross
[56:24] margin for the fourth quarter so we'll
[56:26] come back into nnn we'll chat with his
[56:28] agent um we'll just say how was
[56:31] Nike's um gross margin for
[56:36] the fourth quarter see what he
[56:41] says Nike's gross margin for the fourth
[56:44] quarter was
[56:45] 44.7% so that was right that's the
[56:47] information we're getting but we maybe
[56:49] don't like the way that this agent's
[56:50] talking to us so that's where we need to
[56:52] actually come back into the agent and
[56:54] prompt it so let me just type out a real
[56:56] real simple prompt and then we will take
[56:58] another look all right I went into chat
[57:00] gbt and I said hey can you help me
[57:02] prompt this agent it needs to understand
[57:03] its role some context instructions I
[57:06] want to give it some example flows of
[57:09] how it should operate and we got a
[57:10] pretty good prompt out of it so let's
[57:13] just read through it real quick we said
[57:14] you are a friendly and helpful Nike
[57:16] representative tasked with answering any
[57:18] questions users may have about Nike's
[57:19] earnings you have access to a vector
[57:21] database with all the relevant data on
[57:23] Nike's financial performance including
[57:24] Revenue profits other earning related
[57:26] info when a user asks a question you
[57:29] should search this database to find the
[57:30] most accurate and up-to-date information
[57:32] and respond in a friendly approachable
[57:34] tone be sure to add humor and use emojis
[57:36] to make the conversation fun and
[57:38] engaging then we gave it instructions
[57:40] for an interaction flow so basically we
[57:42] said a user asks a question you're going
[57:43] to search the database you're going to
[57:44] respond and then we gave it some
[57:46] information or some examples of a
[57:49] friendly tone greeting the user throwing
[57:52] emojis using jokes um all that kind of
[57:54] stuff and then we wanted to give it a
[57:56] sample flow sort of like more exact um
[57:59] the more examples that you can give an
[58:00] agent about you know what it might run
[58:03] into different situations the better and
[58:05] then finally we said the actual tools
[58:07] that it has so Vector database is really
[58:09] the only tool we hooked up and we said
[58:11] to use this to retrieve specific
[58:12] earnings information and financial
[58:14] performance remember your goal is to
[58:15] provide accurate data while keeping the
[58:17] user engaged with humor emojis and a
[58:19] conversational tone all right so let's
[58:22] give this a save and ask another
[58:24] question let's let's just come in here
[58:26] and say um who is Matthew friend because
[58:30] he's the Executive Vice President and
[58:32] CFO of Nike so we'll say who is Matthew
[58:35] friend and like what did he say I guess
[58:37] let's see what we get from
[58:39] that who is Matthew friend and what are
[58:44] his
[58:48] thoughts okay so here's what we got from
[58:51] the agent Matthew friend is the
[58:52] executive VP and CFO of Nike he's the
[58:54] financial Mastro and ensuring the Swit
[58:57] stays profitable and Innovative and then
[58:59] we have um two emojis there let's see he
[59:01] said he G the agent gives us the quote
[59:03] that he said and then at the end it says
[59:05] if you have any more specific aspects
[59:07] you're curious about I can dig up his
[59:09] latest commentary for you so good emojis
[59:11] very friendly um let's just say sure can
[59:16] we get some more
[59:18] info and this is information this is
[59:20] important because it's going to remember
[59:22] what we were just talking about which
[59:23] was Matthew friend and we can see if
[59:25] there's anything else in this PDF that
[59:26] he said um so here's a slice of wisdom
[59:29] from Matthew friend the CFO he recently
[59:32] highlighted that while Nike is driving a
[59:33] better balance across his portfolio the
[59:35] fourth quarter brought some challenges
[59:37] but no worries he's on it Matthew
[59:38] emphasized that Nike is taking strategic
[59:40] actions to reposition itself for
[59:41] sustainable profitable long-term growth
[59:45] okay so we're seeing a conversation with
[59:47] this agent right here in the log you can
[59:49] see exactly what's happening so you can
[59:51] see our agent um it updated the memory
[59:53] it went to the chat model it read
[59:55] through it prompt and then it basically
[59:58] is like making sure it knows what to do
[59:59] it's going to go to the vector store
[60:00] tool and we have the query which is
[60:02] Matthew's friend Matthew friend's recent
[60:04] statements or comments and then it got
[60:06] an output from the um pine cone database
[60:10] so if you don't understand what's going
[60:11] on here basically it's just being able
[60:12] to see the flow of what's going on so
[60:14] that you can um you know troubleshoot if
[60:17] need be but this is super cool and it
[60:20] just shows you how you can connect
[60:22] different tools so we could even come in
[60:23] here and add a um what is it Wikipedia
[60:27] so this is going to let it search in
[60:28] Wikipedia so if there's information
[60:30] maybe that's not about um that's not on
[60:33] this PDF it could also access this tool
[60:35] and we'd have to obviously prompt it a
[60:36] little bit to do that but let's just see
[60:38] if this is going to work we can say what
[60:39] is the capital of Florida and it should
[60:43] be searching through wikkipedia to
[60:44] answer that question so the capital
[60:46] Florida is Tallahassee it's not just
[60:47] about beaches and theme parks haah nice
[60:50] and friendly but um you know this
[60:53] information the capital of Florida I
[60:55] doubt that it was on this earnings
[60:56] report from Nike so that just shows you
[60:59] that it actually went and searched
[61:00] through this tool and you know you can
[61:02] also add like a calculator in case you
[61:03] want to make sure it's doing you know
[61:05] math
[61:07] accurately um so we got a calculator
[61:09] tool here now too so we would prompt in
[61:11] that but it's super cool because like I
[61:13] said you can connect different workflows
[61:15] that you build within NS tools so let's
[61:17] say we have this agent here and we give
[61:20] it a tool that um can send emails
[61:22] because we're going to build a workflow
[61:24] of automatically sending an email and
[61:25] and then we would just give the agent
[61:27] this this tool so that if we wanted to
[61:29] chat with the agent and say hey by the
[61:30] way could you send this information to
[61:32] um you know Matthew friend in an email
[61:35] and it would actually be able to go to
[61:36] do that as long as it had Matthew
[61:38] friend's email which we would give it in
[61:40] some sort of vector store as well so um
[61:43] I hope that that you know is a breaks
[61:45] down the concept of rag Vector databases
[61:48] um pine cone Vector store how you can
[61:50] link all these together when it comes to
[61:52] giving an agent access to all these
[61:53] different things in order to do what you
[61:56] wanted to so at the end of that last
[61:57] build we saw we started expanding on
[62:00] that agent and giving it access to you
[62:02] know Wikipedia and a calculator tool and
[62:04] so I wanted to talk a little bit more
[62:05] about how you can actually expand on
[62:06] these agents to make them even more
[62:08] powerful and scalable um you know like
[62:11] giving an agent access to more tools
[62:13] giving an agent access to agents to call
[62:15] on it's it it's super powerful the stuff
[62:17] you can do so in this part just wanted
[62:19] to quickly talk about building workflows
[62:21] as tools how that all works how that all
[62:23] comes together and the importance of it
[62:25] and then we'll just go through a couple
[62:26] examples in NN of some agents that I've
[62:28] built and you can just see the way that
[62:30] they use different tools all right the
[62:32] power of being able to build custom
[62:34] Tools in NN it's it's honestly insane so
[62:37] first we have the fact that agents can
[62:39] use these tools obviously you can build
[62:41] a tool and have an agent call on it like
[62:43] in this example down here you can see um
[62:46] I have get email tool send email tool
[62:48] update database summarize database set
[62:50] calendar event and get calendar all of
[62:53] these are tools that I built within nadn
[62:55] so these are workflows I'll show you
[62:57] guys them once we hop back into nadn but
[62:59] these are all different tasks that I
[63:01] built out in nadn and then the agent is
[63:03] able to decide based on what I tell it
[63:06] texting it on telegram based on what I
[63:08] tell it to do it will decide which tool
[63:10] to use in order to go complete that task
[63:12] and then it will either tell me that it
[63:13] did the task or it will give me you know
[63:15] the summary of a database or my calendar
[63:18] that sort of stuff so agents can use
[63:20] these tools um you know like a smart
[63:22] agent or a smart AI assistant that can
[63:24] call these workflows so this is a great
[63:26] example right here of a personal agent
[63:28] we also have the fact that tools can be
[63:29] reused and recombined so now that I have
[63:32] these tools built out I have a send
[63:34] email tool if I ever need to build a
[63:36] different type of agent to send emails I
[63:37] can just give it this tool I've already
[63:39] built it so it's already there in my
[63:40] workflow and I can call on it in
[63:42] multiple different agents it won't
[63:43] really matter so that is super cool they
[63:46] can be reused anytime and they can be
[63:48] combined with other tools and now for
[63:51] scaling so this is what I talk about the
[63:53] fact that as you build out tools you
[63:54] just have more and more tasks that you
[63:56] can complete um more things that you can
[63:58] give your agent to do and then it gets
[64:00] even more powerful because um let's say
[64:03] you want to not just have a send email
[64:05] tool but you want to have an agent that
[64:07] can do everything within email so you
[64:09] would have an agent and you would give
[64:10] it a ton of different tasks and email so
[64:12] youd have an agent with get emails send
[64:14] emails label emails draft emails delete
[64:16] emails all this kind of stuff and then
[64:19] you could give your overarching like
[64:21] larger agent access to the agent that
[64:23] does email stuff so this agent would be
[64:26] able to decipher okay do I need to go
[64:28] into Outlook or calendar or teams or
[64:31] slack and then you would down here have
[64:33] one agent that does everything in slack
[64:35] One agent that does everything in teams
[64:37] One agent that does everything in your
[64:38] calendar and then you can just build on
[64:40] top of each other and also that's going
[64:41] to make your workflows more efficient
[64:43] rather than trying to you know send a
[64:45] prompt through with like giving this
[64:47] agent you know 50 to 60 tools like that
[64:50] would be way too much even I think like
[64:52] 20 is probably too much but that way you
[64:53] could give the agent other agents and
[64:56] it's just like you know the hierarchy of
[64:57] it's going to go through this guy then
[64:58] it's going to go to these agents and
[65:00] then it's going to come back so it's
[65:01] just you can get really creative here
[65:03] with how you can get stuff done and all
[65:06] you have to do is break it down by tasks
[65:08] so take a task and combine these with a
[65:11] larger workflow of getting all these
[65:13] tasks done and then you know larger just
[65:15] just scale up pretty much so now let's
[65:18] just hop into nadn and we can take a
[65:20] look at you know this assistant and a
[65:21] couple other ones all right so this is
[65:23] the personal assistant that we were just
[65:25] kind of taking look at back in the
[65:26] slides but as you can see it's got just
[65:29] pretty much seven tools it's got
[65:30] database information so for something
[65:32] like getting or sorry sending emails it
[65:34] needs you know contact data information
[65:37] who do I actually send it to what's
[65:38] their email address and then we have
[65:40] these different tools get emails send
[65:41] email get calendar set calendar and then
[65:44] update or summarize the database so real
[65:47] quick I'll just show you guys how I
[65:48] talked about these ra all tools within
[65:50] my nadn so if I go back here we can see
[65:54] um here's the update database tool
[65:55] here's the calendar email so we can like
[65:57] click into one of these so let's do
[65:59] summarize database as you can see it's
[66:01] just a very simple workflow we've got
[66:03] different nodes we've got um the actual
[66:05] database it's going to call on this
[66:07] database it's going to summarize it
[66:10] aggregate everything into one clean
[66:12] field and then it's going to send the
[66:15] response of the information back to the
[66:17] agent so it's going to go through this
[66:19] process then it's going to have a
[66:20] summarization right here once we get
[66:22] that information summarized it's going
[66:24] to go back to the agent and then it
[66:25] knows its job is done so then it's going
[66:27] to Output a telegram message back to me
[66:30] so real quick let's take a look at this
[66:32] database this is the project database
[66:33] that I'm summarizing in this case so
[66:35] we've got different tools or sorry
[66:37] different projects we've got notes about
[66:39] the project and then we have the
[66:40] different statuses so I know it's a very
[66:42] simple
[66:43] example but that's just you know I was
[66:45] testing out this personal assistant and
[66:47] trying to make a video about it so
[66:48] here's the assistant let me just pull up
[66:50] my telegram with my that I talked to for
[66:53] my AI assistant um as you can see
[66:55] there's different information that I've
[66:56] been testing out with other workflows
[66:58] and other executions but let's just come
[67:00] in here and say can you summarize our
[67:05] database and so this is going through
[67:07] telegram the agent is under getting this
[67:09] prompt right here can you summarize our
[67:10] database it's figuring out which tool it
[67:12] needs to call in order to do that and
[67:14] then it's going to summarize the
[67:15] database as you can see we just got this
[67:16] message back here's a summary of the
[67:18] current status and contents the a AI
[67:20] project is complete the marketing
[67:22] campaign is pending it involves drafting
[67:24] content this that is ready and awaiting
[67:27] review by the marketing
[67:28] head um mobile app project this project
[67:32] involves developing a user
[67:33] authentication module which is currently
[67:34] ongoing beta testing has been scheduled
[67:37] indicating progresses in the works so as
[67:39] you can see it's you know summarizing
[67:41] all this information for us could be
[67:42] super useful if you were on the road and
[67:44] you need to send a quick email so you
[67:46] just have to text this agent real quick
[67:48] or you know on your way to a meeting and
[67:49] you need to summarize get some quick
[67:51] information summarized it could even
[67:52] summarize all the emails you've gotten
[67:54] from a certain day so that is a cool
[67:56] example of um building an agent and
[67:59] giving it examp giving it access to
[68:01] different tools that you've built in NN
[68:03] by the way if you if you want to know
[68:04] more about what this agent can do please
[68:05] go watch the video I'll tag it right
[68:07] here um I made a whole video about you
[68:09] know building this personal assistant
[68:11] and sort of like the capabilities of it
[68:13] and how you can expand on it so
[68:15] definitely go watch that video if you
[68:16] want a more in-depth look at what this
[68:18] agent does here's another quick example
[68:20] of a different way you can structure an
[68:22] agent this one is being triggered by
[68:24] Gmail so every time I got a new email
[68:26] it's going to come through here it's
[68:28] going to classify the email give it a
[68:30] label of high priority customer support
[68:31] promotion finance and billing and it
[68:33] will actually give it a label on Gmail
[68:35] and then for each of those types of
[68:37] email it's going to come through here
[68:38] and select for high priority one it's
[68:40] going to create a draft and then it's
[68:42] going to have the draft sitting in our
[68:43] email and then what I would do is um
[68:46] actually I made a video about this one
[68:47] too so if you haven't seen it I'll tag
[68:49] this one too and you want to you know go
[68:51] look and see how this works and how to
[68:52] build it but then what I did in the
[68:54] video is we hooked it up to a send text
[68:58] message node right here in telegram so I
[69:00] configured this and then it was able to
[69:03] let me know hey we made a high priority
[69:05] draft for you based on this email from
[69:07] Kevin and now it's like there for you
[69:09] and then I did the same thing with all
[69:11] these other ones so like for customer
[69:12] support we let it actually create an
[69:14] email and reply to it so it actually
[69:16] sends off an email and then the telegram
[69:18] message says um we sent off an email for
[69:21] you based on you know it was a customer
[69:22] support email same thing with these two
[69:24] down here in you know if I pull up
[69:25] telegram we can actually see these past
[69:27] interactions I've had so like for a
[69:29] finance and billing one down here we
[69:31] wanted it to summarize the information
[69:33] and then send it to the finance
[69:35] department so right here we see you
[69:37] received a finance and billing inquiry
[69:38] from Angela from the accounts Department
[69:40] we've notified your finance department
[69:41] of this email um right here it's like a
[69:44] promotional one so here are details
[69:45] regarding a promotional email from Nate
[69:47] it gives us a summary of the promotion
[69:49] and then it gives us a recommendation so
[69:50] that's something that we crafted out
[69:52] right here and all of these were linked
[69:53] up to different telegram nodes to let us
[69:54] know notify us of what's coming through
[69:57] and what the agent had done so like I
[69:59] said go watch that video if you want a
[70:01] more in-depth run through of what this
[70:03] um agent does but the purpose of me just
[70:07] showing you guys this real quick was
[70:08] just to open your eyes about how you can
[70:09] expand how you can build off of you know
[70:12] different ways you can structure agents
[70:14] and how you can you know make them do
[70:15] exactly what you want to do and remove
[70:16] yourself out of that process to automate
[70:18] things so just super cool stuff moving
[70:21] on to part five which is going to be
[70:23] talking about apis and HTTP request
[70:25] quests um this kind of stuff can sort of
[70:27] get a little Technical and seem
[70:28] confusing but I'm here to make sure we
[70:30] just sort of break it down as simple as
[70:32] possible so before we really get into
[70:34] the content of this part I wanted to
[70:36] just stress that you know we've already
[70:38] been working with API calls and API
[70:40] tools whether you've known it or not all
[70:43] of the preconfigured nodes in nadn are
[70:45] pretty much just HTTP requests in some
[70:47] way or another so when you're using
[70:49] these nodes naden is doing all that hard
[70:51] work of making the API call for you you
[70:53] know either fetching or getting some
[70:55] data like in that previous example when
[70:57] we were using that Google Drive node to
[70:59] get information to put it into our pine
[71:01] cone Vector store that was pretty much
[71:02] an API call to Google Drive looking in
[71:06] our Google Drive grabbing the file and
[71:08] then we got the information back in Ann
[71:10] so we're pretty much already doing that
[71:13] you only will really need to use apis
[71:15] and HTTP requests in nadn if you want to
[71:17] connect to something that there's not an
[71:18] integration for which um is kind of rare
[71:21] but it's good to go over just in case
[71:23] you do need to do this so yeah the an NN
[71:26] they know exactly what to do exactly
[71:27] where to go where to send their requests
[71:29] and how to get the information you need
[71:30] or put information somewhere that you
[71:32] need to so now we can move into talking
[71:34] about apis so what is an API it stands
[71:38] for application programming interface so
[71:41] basically just think of it as the bridge
[71:42] that is going to allow two different
[71:44] softwares to talk to each other like
[71:45] nadn and Google Drive whatever it may be
[71:49] so here's a concise summary about API
[71:51] endpoints calls and HTTP requests so so
[71:56] um the endpoint is just basically going
[71:58] to be a specific URL or address within
[72:00] the API where a certain service or piece
[72:02] of data can be accessed so it's like the
[72:04] exact path that you need to take once
[72:06] you access that API you have that
[72:08] endpoint so it's going to specify where
[72:10] you need to go then the API call is just
[72:13] that request that you're making to the
[72:14] API asking it to you know perform some
[72:17] sort of task or provide some sort of
[72:18] data so it's like you're placing an
[72:20] order and then the HTTP request is the
[72:23] actual method that you use to send that
[72:25] API call over on the internet so it's
[72:27] sort of just the messenger that's going
[72:29] to carry your request to the API
[72:31] endpoint and then it's going to bring
[72:32] the response back in a nutshell you're
[72:34] going to be making an API call using an
[72:37] HTTP request which is going to be sent
[72:40] to a specific API endpoint and then
[72:42] we'll get the information back from the
[72:44] API and then the HTTP request is going
[72:46] to return the information to
[72:49] us okay so what is an HTTP request think
[72:52] of this as just the way that your
[72:54] computer or nadn is going to be talking
[72:56] to the other service so you can do
[72:58] things like get data which will be sort
[73:00] of a g HTTP request or you can send data
[73:03] which will be a post HTTP request which
[73:06] you'll see once we hop into NN and
[73:08] actually look at some examples but just
[73:09] as simple as either asking for
[73:11] information or sending information
[73:13] somewhere I remember when I first heard
[73:15] about all these different terms I
[73:17] thought to myself like that sounds so
[73:18] similar how do you really distinguish so
[73:20] let's just quickly talk about how they
[73:22] actually work together so like we said
[73:24] an HTTP request is is how you actually
[73:25] make an API call it's the messenger
[73:28] that's going to carry your API call to
[73:30] the server so we've got a quick
[73:31] restaurant analogy let's think about it
[73:33] like this so we have the API this is
[73:36] like the restaurant itself so this is
[73:37] the service that you're talking to the
[73:39] restaurant is going to provide different
[73:40] services to its customers you know just
[73:42] like an API the restaurant offers a menu
[73:45] of things that you can request different
[73:46] actions or different data then we have
[73:49] the API endpoint the API endpoint is
[73:51] like this specific kitchen station that
[73:53] you're talking to so it's going to
[73:55] handle a particular dish there are
[73:57] different stations for each tasks you
[73:59] know cooking pasta making pizza so the
[74:01] end point is like going to the correct
[74:03] station in order to get the specific
[74:05] dish that you
[74:06] ordered then we have API call um an API
[74:10] call is like placing the order it's the
[74:11] actual request so in this case you know
[74:13] we wanted spaghetti that's how we know
[74:15] to get it to the right spot but um you
[74:17] know you look you you'd order the
[74:18] specific meal and then um that's just
[74:20] making the request um for data or for a
[74:24] specific service from the API and then
[74:27] finally we have the HTTP request which
[74:29] like we said is pretty much just the
[74:30] mechanism that's being used to deliver
[74:32] the request so in this analogy it's
[74:34] going to be a waiter who's going to take
[74:36] your order bring it to the kitchen staff
[74:38] and then when they bring the dish the
[74:39] waiter is going to bring back that food
[74:41] to bring back that information that you
[74:43] were looking for so hopefully that was
[74:45] simple enough API call is the concept
[74:48] HTTP request is the tool so you're
[74:50] asking for something with an API call
[74:52] and then the request is going to be how
[74:53] you're delivering it over the internet
[74:56] all right now let's just get into NN
[74:57] real quick and just look at a few
[74:59] examples of an HTTP request node and
[75:01] sort of what it looks like to configure
[75:03] something like that we are now back in
[75:05] nadn as you can see I've got three
[75:06] different HTTP request nodes in here so
[75:08] you would just come in here and grab
[75:09] HTTP request as you can see right here
[75:12] um but these first two we've got two
[75:15] gets so we'll be asking for information
[75:17] in one way or another and then this last
[75:19] one will show a post where we're
[75:20] actually sending information somewhere
[75:22] so let's just go into this first example
[75:24] here
[75:25] so this one's going to be a really
[75:27] simple one we're making a get request
[75:29] like I said so we're asking for
[75:30] information here would be like sort of
[75:32] that API endpoint like we talked about
[75:33] so we're going to be going to
[75:35] openweathermap.org um we're going to be
[75:37] asking for weather you can see here's
[75:39] some parameters Q equals New York so
[75:41] we're looking for weather from New York
[75:45] and then we have a little credential
[75:46] here we had to set up an API key to
[75:48] actually be able to access um the API of
[75:50] open weather map and get into you know
[75:53] that's my API key so it knows that we
[75:54] have permission
[75:55] and we'll hit test step here so we can
[75:57] just see that this request is working we
[75:59] can see information coming through on
[76:00] the right hand side we've got clouds
[76:02] we've got temperatures we've got wind um
[76:04] and then as you can see it came back for
[76:05] the name the city of New York so we know
[76:08] that this request was working I won't go
[76:10] too much right now into you know setting
[76:12] up parameters and headers and body for
[76:14] your request but usually when you want
[76:16] to connect to a certain API they're
[76:18] going to have documentation on it so in
[76:20] this example for open weather map they
[76:21] have exactly like the end points that
[76:23] you need to find or they they'll give
[76:25] you what you need to type in and how to
[76:26] specify parameters it's not like you
[76:28] have to know how to just find the stuff
[76:29] cuz that seems pretty technical um so
[76:32] yeah most of the things that you want to
[76:33] connect to if there's not an integration
[76:35] in NN already we'll have documentation
[76:37] on their website of how to connect to
[76:38] different things how to request for
[76:40] different things how to send different
[76:41] things so you'll just have to read
[76:42] through documentation but another cool
[76:44] thing obviously like we were getting
[76:46] weather from open weather map but as you
[76:47] can see like open AI already or sorry
[76:49] nadn has Integrations for this where
[76:51] it's a lot easier because this is
[76:53] basically setting up that API call they
[76:55] just did all the coding the technical
[76:57] stuff on the back end of that so we have
[76:58] this basically the exact same thing okay
[77:01] so this next one is another get request
[77:04] this one is as you can see we're going
[77:06] to be searching Google so we have the
[77:08] endpoint right here of google.com/
[77:10] search but we did want to set up some
[77:12] parameters here so we have q like we saw
[77:14] that last one Q equals New York this
[77:16] time Q is equaling site colon
[77:18] linkedin.com
[77:20] slin okay so this is the URL that we're
[77:23] basically trying to access so if we p
[77:24] ped this into Google right here we would
[77:28] see like it brings us up Google so
[77:30] that's what we're searching on and then
[77:33] within Google we want to be searching
[77:34] for site umon linkedin.com so we go back
[77:38] to Google paste that in there and you
[77:40] can see what's coming back is actual
[77:42] LinkedIn just LinkedIn profiles so
[77:45] that's sort of how this parameter is
[77:47] working and we can go ahead and test the
[77:49] step real
[77:49] quick we can see exactly what's coming
[77:52] back which is going to be a nasty chunk
[77:53] of HTML a lot of information in here
[77:55] your next step here would be to parse
[77:57] through this information with a
[77:58] different node that would grab you just
[78:00] LinkedIn profiles so like if I come in
[78:02] here and search um linkedin.com you can
[78:05] see like I'm sorry we've got a lot of
[78:07] hits 173 hits and we can sort of go down
[78:09] until we find actual profile so that's
[78:11] what you'd have to be parsing out but
[78:13] right here we have Robert W Livingston
[78:16] so if we go back to the actual Google
[78:17] search we can see that first profile
[78:19] coming through is Robert
[78:21] Livin um and then if we were to continue
[78:23] to go down and look through all the
[78:24] different results we'd see all these
[78:26] different profiles coming through into
[78:27] our naden so that is the way that this
[78:29] request is asking for information from
[78:32] site colon linkedin.com in and then
[78:35] we're actually getting back the
[78:36] parameters from or sorry the information
[78:38] from Google through that request and for
[78:41] this final one we're making a post
[78:42] request as you can see right here so I
[78:44] click into this we'll see what's going
[78:46] on in this node this is a post request
[78:48] and I was able to go to Google apis in
[78:50] order to see how to access my calendar
[78:52] there's going to be different API
[78:53] endpoints in their documentation of like
[78:56] you know copy this URL if you want to
[78:57] create event copy this URL if you want
[78:59] to update an event copy this URL if you
[79:01] want to get information back on your
[79:03] events so that's all I did I I hooked up
[79:05] that that API endpoint in here obviously
[79:08] had to set up my credentials and then in
[79:10] this example we have to send a body
[79:11] because we're posting data sending
[79:13] information and so this is really simple
[79:15] it's just Json um sort of setting up the
[79:18] criteria for the event you could you
[79:20] know go into chat GPT and say hey I'm
[79:22] like accessing a Google API for my
[79:24] calendar can you help me set up a body
[79:25] and it should work with you there but in
[79:27] this case the summary of the event that
[79:28] it's going to be making is meeting with
[79:30] team we have a start date um noon we
[79:33] have an end date of 1:00 and then we can
[79:35] add like attendees and different emails
[79:37] and real quick I'll show you this is the
[79:38] calendar that I'm accessing right here
[79:40] so there's nothing going on today and
[79:41] we're going to make the event for noon
[79:43] so if I hit test step it'll come through
[79:46] and it'll say that it worked and we can
[79:47] see on here we just got our meeting with
[79:48] Team from noon to 1:00 p.m. and the
[79:52] information coming back here is just
[79:53] going to be like you know meeting link
[79:55] it's just going to basically tell you
[79:56] that that post request went through
[79:58] successfully all this kind of stuff but
[80:00] another case where that would just be
[80:03] over complicating things you've got
[80:05] Google Calendar right in here um where
[80:07] is it right here we can get availability
[80:10] we can create an event so all we did
[80:11] right here was create an event this is
[80:13] going to make it a much easier way to
[80:15] actually send that request because you
[80:17] just have to fill in different
[80:18] parameters and you don't have to worry
[80:19] about the API endpoint putting that in
[80:21] you don't have to worry about um you
[80:23] know the Json sending over the data in
[80:25] that post request you could just do that
[80:28] right here as well now that that concept
[80:30] of just how you access endpoints and how
[80:32] you actually send or receive data makes
[80:33] more sense what you would want to do
[80:35] from here is like the more realistic use
[80:37] case when you're building stuff like
[80:38] this and you need to you know integrate
[80:41] with something is going to be a web hook
[80:43] trigger so you can see like you've got
[80:45] your url here you have an HTT method and
[80:48] this is the kind of stuff that you'd be
[80:50] more familiar with setting up once you
[80:51] understand the basics of um sort of
[80:53] these noes but these are going to be
[80:55] really powerful tools because these will
[80:57] let you trigger a workflow based on um
[80:59] information coming through from another
[81:01] site so if you wanted if you had some
[81:02] sort of form on your website and you
[81:04] wanted to hook up to that and then every
[81:06] time someone filled out the form you
[81:07] could have this go through where it's
[81:08] going to you know notify you that
[81:10] someone filled out the form it's going
[81:11] to send them an email sort of welcoming
[81:13] them it's going to throw them into a
[81:15] database and then it's going to send
[81:16] slack message to your team something
[81:18] like that so these web hooks can be very
[81:19] powerful when it comes to automating
[81:22] other processes as well and getting
[81:23] pretty customized but before you get in
[81:26] here and you want to start configuring
[81:27] stuff I think it's just important that
[81:29] you understand the the framework and the
[81:31] basics of you know apis and points HTTP
[81:34] requests and how all that stuff is going
[81:36] to work in nadn and then you can really
[81:38] explore with stuff like web hook
[81:39] triggers which are very cool and offer a
[81:41] lot of flexibility all right we have now
[81:43] made it to part six which is going to be
[81:45] the final part of this master class you
[81:47] know we've covered a lot of ground we
[81:49] started the basics of NN building your
[81:51] first workflow we created an AI powered
[81:53] agent using RG Rag and Vector databases
[81:57] we made API calls and HTTP requests we
[82:00] talked about extending your workflows
[82:01] with custom tools and web hooks so
[82:03] you're no longer a beginner you have the
[82:05] tools and knowledge to create powerful
[82:06] automations that are going to transform
[82:08] your productivity the way you approach
[82:09] your automation projects and I just
[82:11] wanted to close off with talking about
[82:13] error workflows um just sort of best
[82:16] practices when it comes to creating
[82:17] workflows in na then and sort of how you
[82:19] can do that most optimally and then um
[82:21] just some final next steps and just
[82:23] closing thoughts
[82:25] all right back in NN here we have a
[82:27] error demo workflow which is just an
[82:29] error workflow that I just created real
[82:30] quick as you can see it's going to start
[82:32] off with an error trigger so this
[82:34] workflow is going to execute whenever
[82:36] there's an error and another workflow
[82:38] that we're hooking up this one too so
[82:40] that'll make more sense once we actually
[82:41] configure it but as you can see It'll
[82:44] Get triggered and then it will come in
[82:45] my telegram um which will be sending me
[82:48] a message so it's going to notify me
[82:49] that there's an error it's going to tell
[82:51] me the workflow that's erroring it's
[82:52] going to tell me the error message
[82:54] message that happened and then it will
[82:56] give me a link to the actual execution
[82:58] of the error so that would all just pop
[83:00] up on my telegram I can click on the
[83:02] link and come in and see what's going on
[83:04] but in this case this is going to be you
[83:07] know a personal assistant I showed this
[83:08] a little bit earlier so this is the
[83:10] workflow we want to hook up to that
[83:11] error workflow we come in here up top
[83:14] right grab that three dots click on
[83:16] settings and then right here you can see
[83:18] error workflow so a second workflow to
[83:20] run if the current one fails the second
[83:22] workflow should have an error trigger
[83:25] node so we saw the error trigger node we
[83:27] saw that this workflow is called error
[83:28] demo so we've hooked that up as this
[83:30] error workflow and um now we just need
[83:33] to make sure that this workflow is going
[83:34] to error so let's just delete the brain
[83:37] of the assistant so this one should
[83:38] error for sure as you can see it already
[83:40] is and um it's going to be calling this
[83:42] and then it's going to be filling in the
[83:44] information when it airs so let me just
[83:47] pull up my telegram real quick as you
[83:50] can see this telegram this is my AI
[83:51] personal assistant so this is how we
[83:53] talk to it and this is how how it talks
[83:54] to us back right here if you can see
[83:56] this flow but let's just ask it to do
[83:58] something like can you get my
[84:01] emails this should airor and as you can
[84:03] see we got the error notification the
[84:05] workflow is personal assistant which is
[84:07] right up here the message is that a chat
[84:09] model subn node must be connected so
[84:11] that's the eror that's going on right
[84:12] here and then we have a link to that
[84:14] execution I can click on that link and
[84:16] it should bring me into what exactly
[84:18] just happened and we can see why it's
[84:20] erroring so as you can see this is the
[84:22] most recent execution that just happened
[84:24] um it's going to take a second to load
[84:25] up but basically the error is just
[84:26] happening because a chat model sub node
[84:29] must be connected that's why it aired
[84:31] and as you can see that's exactly what
[84:32] it told us in
[84:34] here okay so that's kind of how this
[84:36] works um you know you could even go you
[84:39] could expand off of this so let's say
[84:40] you want to get notified um but then
[84:42] let's say that we want to you know send
[84:45] an email to the team that says hey this
[84:47] this isn't working right now um we're
[84:49] working on this to get fixed so let's
[84:51] just come in here and let's send a
[84:53] message
[84:55] um obviously we need to set up all this
[84:56] information so let me do this real quick
[84:58] really quickly configured this node
[85:00] obviously we're sending a message put
[85:02] who you want to send it to this could be
[85:03] you know a ton of different emails you
[85:05] got the subjects which is going to be
[85:06] error and then it's going to tell us the
[85:07] error message and then the message of
[85:09] the email is going to say hey team we
[85:12] received an error in blank workflow
[85:14] we're working to resolve the issue
[85:15] thanks so if I just you know test this
[85:17] step we would see that that came through
[85:20] um let me pull up the email real quick
[85:22] so here you can see we got the error
[85:23] example error message hey team we
[85:26] received an error in example workflow
[85:27] we're working to resolve the issue um so
[85:29] let's just quickly go back and end it in
[85:31] turn off the append attribution and
[85:34] we'll save this and then we can um pull
[85:37] up telegram we will ask it to get the
[85:40] emails again and we will get an error
[85:42] notification in our telegram right here
[85:44] but then we should also get a new email
[85:46] with that information coming through um
[85:48] so we'll just give this one a sec here
[85:50] okay now we got an error a chat model
[85:52] sub node must be connected hey team we
[85:53] receiving error and personal assistant
[85:55] where we're going to resolve the issue
[85:56] so obviously that's just a very quick
[85:58] example email um you could configure the
[86:00] subject and the message however you want
[86:01] but that's just goes to show how a quick
[86:04] error workflow you can set that up you
[86:07] can hook it up to multiple different um
[86:09] agents multiple different workflows that
[86:10] you have that when they when they error
[86:12] this logic will take place and you'll
[86:14] get notified right away so that's just
[86:16] another cool feature of net all right if
[86:18] you guys have made it this far really
[86:19] appreciate you sticking it through all
[86:20] the way hopefully this has been a really
[86:22] helpful session but before we close out
[86:24] let's quickly go over some best
[86:26] practices for workflow optimization to
[86:28] ensure that your workflows are staying
[86:30] efficient maintainable scalable and you
[86:33] know all this kind of stuff as you build
[86:35] out more complex automations so the
[86:37] first thing I wanted to touch on real
[86:38] quick is just keeping your workflows
[86:39] organized as they grow you got to keep
[86:42] them well organized it's going to save
[86:43] you a ton of time down the road when you
[86:44] realize uh oh like we have to redo this
[86:46] or there's a problem and now we are all
[86:49] confused about what's going on here so
[86:50] make sure you use you know descriptive
[86:52] node names you can throw in comments
[86:54] really easy with a little sticky note um
[86:56] you can you know make notes in your
[86:57] workflow so that if anyone else wants to
[86:59] come in and look at what's going on or
[87:00] wants to help you out in the future they
[87:02] can quickly understand what the workflow
[87:03] is doing what each part of the workflow
[87:05] is doing then we want to be able to use
[87:07] sub workflows for reusability you don't
[87:09] need to reinvent the wheel every single
[87:11] time you want to do a similar task in
[87:13] these different workflows consider
[87:15] creating subw workflows like we talked
[87:17] about with you know maybe one for
[87:18] sending email one for creating calendar
[87:21] events and then you can hook that up to
[87:22] a bunch of different agents or even have
[87:24] agent that's you know a specialist in
[87:27] one certain type of platform so that's
[87:29] going to make it sa saves you a ton of
[87:31] time later down the road when you want
[87:32] to make more complex automations you
[87:34] don't have to build out the same you
[87:36] know five nodes that are going to be the
[87:38] same staple for every single thing that
[87:39] you need to do in that space um so
[87:42] that's just going to save you a lot of
[87:43] time and avoid redundancy and the third
[87:46] thing we want to do is Implement air
[87:47] handling so already talked about that a
[87:49] little bit but you can even take it a
[87:51] step further so you know errors are
[87:53] going to happen
[87:54] no no workflows immune to issues like an
[87:56] API failing or something like that so if
[87:58] you build in some of these issues or
[88:01] error handling issues it's going to
[88:02] ensure that your workflows remain robust
[88:04] you can be notified when something goes
[88:05] wrong you'll have like a safety net
[88:07] behind each of your automations and then
[88:10] finally just you want to optimize for
[88:11] scalability so as your workflows get
[88:13] bigger efficiency is going to be super
[88:15] important so you want to use features
[88:16] like batch processing or pagination you
[88:19] want to have a lot of conditional logic
[88:21] in there in order to handle larger data
[88:22] sets more complex branching workflows so
[88:25] scaling doesn't just mean bigger
[88:27] workflows it also means making them
[88:29] smarter workflows and next steps now
[88:32] that you've made it through this master
[88:33] class you built a solid foundation I
[88:36] encourage you to keep pushing your
[88:37] boundaries there's so much more that you
[88:38] can explore in nadn and your next step
[88:41] should be about expanding your skills
[88:42] and experimenting with sort of more
[88:44] advanced templates so in order to do
[88:46] this to continue growing and learning I
[88:48] definitely want to invite you all to
[88:49] join my fre School Community where we
[88:51] all you know share ideas workflows cool
[88:53] things that we've built using nadn it's
[88:56] all about collaboration and inspiration
[88:57] so whether you're looking for feedback
[88:59] or you just want to brainstorm new ideas
[89:00] or get some questions answered um it's
[89:03] nice to have a very supportive Community
[89:04] to share your progress with and it's
[89:06] going to make the experience a lot
[89:07] better so please hop in the link for
[89:09] that is going to be in the description
[89:10] and I'll also be sharing a lot of
[89:11] resources in there that I I use in each
[89:13] of the videos and stuff like that so I'd
[89:15] love to talk to you guys and I'll see
[89:17] you in there the first thing here is
[89:19] going to be just to get in and start
[89:20] building you know the power of learning
[89:22] by doing is insane a
[89:24] but really anything that involve tools
[89:26] like n is it's best to just learn by
[89:28] getting your hands dirty you know as you
[89:30] build workflows experiment with things
[89:32] push the boundaries of what you can
[89:33] automate you're going to run into
[89:34] challenges and you're going to have some
[89:36] failures but that's definitely a good
[89:38] thing like it's just part of the process
[89:39] and when you fail and you can go in and
[89:41] figure out what happened and actually
[89:42] solve that problem you're going to just
[89:45] understand the process way more than
[89:46] someone who you know is not actually
[89:48] getting in there and doing things just
[89:50] watching YouTube videos stuff like that
[89:52] you even every time I build out any sort
[89:54] sort of agent any sort of workflow it
[89:55] always fails and it's just going to
[89:57] happen but that's how you really
[89:58] understand you know the logic of stuff
[90:00] moving through so these moments where
[90:02] you're going to gain the deepest
[90:03] understanding of how n in works and how
[90:05] you're able to actually improve on your
[90:06] skills so you know don't be afraid to
[90:08] make mistakes it's just going to happen
[90:10] then I would say you want to get in and
[90:12] start exploring some Advanced templates
[90:13] so at the beginning of this master class
[90:15] we looked at sort of the community in
[90:17] nadn and the template Gallery which is
[90:19] just a gold mine of ideas and pre-built
[90:21] workflows so you can dive into those and
[90:23] you can see how people are building
[90:24] things you know there's no one right way
[90:26] to build an automation so you can see
[90:27] different ideas and it will really help
[90:29] you sort of expand your skills there too
[90:31] the third thing I would say would be to
[90:33] experiment with new Integrations you
[90:34] know don't be afraid to try out new ones
[90:36] even though naden supports over 300
[90:38] Integrations for you know popular CRM
[90:40] systems social media platforms databases
[90:43] um it's really important to just get in
[90:45] there play around with HTTP requests
[90:47] different web Hooks and see all the
[90:49] possibilities of how you can automate
[90:50] stuff and it's really just going to you
[90:51] know expand your your capabilities and
[90:55] then you can always start to build and
[90:56] share your own templates once you really
[90:58] get experience with um building out
[91:00] different things and you you start to
[91:02] get more creative with your workflows so
[91:04] that'll be really cool you can share
[91:05] them with the community it's a great way
[91:06] to inspire others and also get feedback
[91:09] on the sort of builds that you're doing
[91:10] and how to optimize them so yeah that is
[91:12] going to be it for the master class
[91:15] those of you that made it this far I
[91:16] really appreciate you taking the time to
[91:17] you know sit down for however long this
[91:19] video was and um just listen through all
[91:22] this kind of information and I really uh
[91:24] try to structure it in a way where you'd
[91:25] really be able to come from a beginner
[91:27] and really understand what goes on in NN
[91:28] and how to just get in there and start
[91:30] building some simple agents and then
[91:31] just make them more more complex as you
[91:33] learn but like I said that's the end so
[91:36] congratulations for making it this far
[91:38] thank you guys so much for your time and
[91:40] I will see you in that school community