So today is a yellow day, and if you've been following my color scheme system, you will know that
a yellow day means integration's day.
And if you dread all things integration, you needn't, because today is going to be a great integration
day.
There's one tricky integration and several easy peasy, fun integrations.
Welcome to week three, day two.
Welcome to our next integration today.
And I've called it here in the Timeline Advanced Integrations.
Because this is the Pro week and we're getting advanced.
And of course there's a fork in the road.
As I said last time, that that most of you, I imagine, like me, will be now going back to the cloud,
to cloud, because we're focused primarily on building commercial functionality this week.
But some of you may wish to stay running local, uh, in which case, uh, I very much encourage that.
But you will need to fend for yourself in a couple of places, like, like using, uh, ngrok for webhooks
and things like that.
But you've got this.
But otherwise, come with me back to Nate and Cloud.
But just before we do that, a couple of of refreshes and recaps.
You know, I like to do them because sometimes the best way to reinforce is to be a little bit repetitive.
Let's quickly review.
And there are of course the three styles of authentication of credentials.
There's the simple ones.
Just an API key.
You're just connecting to OpenAI.
You got a key.
You paste it in, you're careful as you paste it in, you get the green and we're set.
That's the easy ones.
Then with OAuth two we've already experienced what what I'm calling here one click, which is when we're
working in cloud say and it's already got an OAuth client configured.
Nan is already kind of connected to Google say.
So we can go through the OAuth two flow.
And it's actually pretty straightforward to integrate with Google Sheets and Gmail.
It was easy, but there are some other Google APIs and a bunch of other Google APIs when you have to
jump through more hoops, and this is the harder OAuth two strategy when you have to actually set up
an oath to client yourself.
And that's what we're going to do today is our first integration.
It's the only hard integration.
And as I say there's there's there's some shenanigans that you should get ready for.
And if you're using Na and locally, then you kind of have to do this for many of your OAuth two integrations.
So you would get somewhat used to it.
And there's one step in it where you have to be careful with a URL that you have to copy and paste,
and you have to get it right otherwise otherwise trouble.
So get it right.
Uh, so we'll do that together.
And I'll tell you the part that that you have to pay close attention to.
Um, but otherwise once you've done it a couple of times, it becomes second nature.
So it's a great thing to do.
And we'll be doing it today.
Okay.
And the other refresher is this, this old chestnut.
Remember this?
Uh, I think this is going to be the last time we review this.
You're like, okay, we get this.
All right.
Calling an API is basically when you're talking about the web, it's talking about making a web request
using HTTP, and when you call that URL, the URL itself is known as an endpoint.
That web address is the endpoint that you're calling to.
And so the language you might use is hey, I'm making an API call.
I'm calling an API by making an HTTP request to an endpoint that is calling an API.
And the reverse of it, perhaps you might say like a, like a reverse API is if you're on the receiving
end, you're the one providing the API that someone is calling you, and they're calling you particularly
to notify you of like a real time event.
Something has happened and you need to be notified.
And when you think of it that way, that that endpoint, that URL you call a webhook, it's something
that gets called to tell you about something.
So for someone else, they think of it as they're calling an API for you.
It's like an event coming in.
And the language you would use to describe it is, hey, I've set up a webhook.
Please make an HTTP request to this endpoint to notify me that something has happened or, hey, can
you tell me your webhook so that I can notify you when something happens?
That is webhooks.
Basically the same.
The same concept, but from the thought of from the other side.
And you'll remember the technicality about these HTTP requests is that there's different flavors known
as the method, the HTTP method and get and post are the most common.
Get is usually used to get some information that comes back in the form of a JSON document, and post
is normally used to send some information, and the information you're sending normally goes in a section
that's called the body of the HTTP post, which in traditional internet, when you submit a form, it's
like doing a post to a URL, and the contents of that form is what goes in JSON in the body.
Not that you need to know that, but that's that's that's what HTTP post is.
And of course we used that ourselves when we had 11 labs calling in to N810 in week two.
All right.
That is the deeper terminology and APIs.
And of course you can relate this to some of natans nodes.
Natans nodes that are triggers.
Very often those triggers are actually webhooks.
So when there's things like the slack trigger you remember that that we could get a different URL for
test environment or prod.
Those are webhooks that get called.
And similarly when we were when we were using 11 labs, we actually set one up in that was that was
a webhook.
We used the generic webhook one, just a generic node that allows you to, to specify to, to, to,
to collect a URL and that webhook gets called and that triggers a particular workflow.
So so triggers and can often be webhooks.
And the, the actual action nodes in Nan, when they are integrating with things they are often making
HTTP requests to endpoints.
That's what they're often actually doing.
Uh, which is probably obvious to you.
Like uh, and whether they are actions or whether they are tools that we're equipping an agent with.
So if you think of the pushover one, that pushover node we used once as a tool and once as just an
action on the workflow, just as a node.
When you use that, it's it's making an HTTP request to an endpoint for pushover.
And that's, that's all it's doing.
It is making a request.
And in fact, and I think I mentioned this before, there is also a generic node called the HTTP request,
which is completely configurable and allows you to make any HTTP requests to the internet.
So you can either use one of the Pre-baked ones, like the pushover one, or you can use the generic
HTTP request one and make your own.
Just like for the triggers, you can either use a Pre-baked one like the slack one, or you can make
your own, as we did for 11 labs.
That all rings true.
That's all connecting for you.
And if not, you'll see a little bit more of that in a second.
And with all of this, it's time.
That's enough talk.
Let's get back to action.
Let's get back to cloud.
Have you missed it I have.
Let's go there now.
And so here we are back at Nano by pressing the sign in button coming in here.
Remember this screen?
The dashboard.
Now opening up my instance.
Here it comes.
Okay.
So what we're now going to do is press create workflow.
Get rid of that I'm still on my trial press create workflow.
Here we are.
We know this screen so well add a first step.
Let's have the chat message.
Why not click and escape.
Press the plus button AI AI agent.
It's like second nature to you.
You've got such such muscle memory for this.
Uh, and uh, let's add a chat model.
Let's use open router, open router, chat model.
Here it is.
It has a credential already.
The open router account.
Let's go with deep seek.
Let's let's find a deep seek AI deep seek AI deep seek 3.2 here we go.
Click and escape.
And we will give it some standard memory.
Simple memory.
All sounds good.
And now we will open a chat and say hi there.
And make sure that we haven't forgotten how to use and cloud that everything works.
There it goes.
Hello, how can I help you today?
So far so good.
And since we're in Pro week, let me just show you a couple of extra features so that you get comfortable
with some of the bells and whistles.
And then over here is projects list where you can see I've got like my project.
You get projects by pressing the plus button here and selecting project.
Now unfortunately on this free trial period, I'm only allowed one project and I already press the plus
button.
You probably don't have my project.
I already pressed plus and created my project without realizing that I was already allowed to create
one.
But I will in a minute sign up for the full plan and then I should be able to create more.
But you can of course create them.
And then you can create a workflow as part of this project.
Think of a project just being as a way to organize different workflows.
Um, because as we'll discover later this week, you can have multiple workflows that collaborate together
to achieve some bigger business outcome.
But I've got them all under personal right now, uh, which is, uh, which is where they're all sitting
for the moment.
Although I should go one step deeper and say that it's actually even more than that.
There are there are projects and there are also folders within each project or even within this, this
personal space here.
But let's take so let's take the one we've just created.
Let's give it a name.
Let's just call it, uh, deep seq because it's a little conversation with deep seq.
Go back to personal again.
And there you can see deep SEQ is right here.
I'm going to go to these triple dots over on the right here and go uh move and from move I'm going to
choose to move it to a project which is going to be my project, the only one, uh, that I've got,
uh, and uh, also share the one credential, the credentials are associated with the project, uh,
not moving any additional sharing.
Select a folder, no folder, project root and then move.
And off it goes.
It's gone from here.
If I now go over to my project, you will see that it's here and the other credentials are associated
with with this.
Um, okay.
So over here, uh, I am now going to be able to create a folder so I can open this, create a folder
in my project, and I'm going to call this folder, um my first folder.
Spell it right create.
There we go.
And now I've created a folder inside my project that's called my project.
Okay.
So the next thing I'm going to do is I'm going to drag and drop deep seek in there.
And now it's gone into my first folder.
There is one workflow.
And I can now click in here.
And now we are inside my first folder.
You can see there we can see my project slash my first folder.
And here is the deep sea workflow.
So uh and you can obviously create another folder in this.
So it's like a normal file system hierarchy situation where you can have multiple folders within folders
and they can all form parts of projects.
So you can imagine you have a number of projects and each project contains some folder hierarchy with
workflows at various points in that, in that hierarchy.
And we've created a project called Myproject with a folder called Myfirst folder that contains deep
seek, which is R1 workflow right here.
Hopefully that all makes sense.
And then there's one more little thing to show you a little bell and whistle.
A feature I'm clicking on chat to bring this down over here are stickies and stickies which is also
shift.
S will give you a sticky note.
We can press this to create a note like this.
And this allows us to uh, to to sort of put some, some framing around things.
Double click to edit me.
Uh, I'm going to I'm a note I'm going to put in markdown here inputs.
This is data flowing in okay.
Let's have a look at that.
So this is one sticky I'm going to get myself another sticky.
And here I'm going to have, like, um, make this a bit bigger.
And call it processing.
This is the business.
And there we go.
And now I'm going to move these in here.
And stickies just give you a way to be a little bit more organized about everything.
Nothing more than nice.
Minimize that again.
There we go.
Look at that.
Doesn't that look nice?
So stickies, it's just purely cosmetic stuff, but it gives you an ability to organize your nodes,
put them into groups, display them, show them.
So you can use a combination of stickies.
And then also grouping things into folders and having those folders within a project as your way to
be super organized about how you build everything.
And since later on this week we're going to be building increasingly sophisticated projects, it makes
sense that we know that the tooling available to us to keep ourselves organized.