Add Superpowers by Connecting Agentic Workflows - Bolt.new Workshop

Hey there, Bolters. Welcome back to another premium customer workshop. We've

got a really packed agenda for you today. We'll learn how to supercharge

today. We'll learn how to supercharge your app by connecting Agentic Workflows. So, we'll be using the N8N

Workflows. So, we'll be using the N8N builder and then by using an HTTP request, we'll be able to send data directly from it into your Bolt database. So, we'll be creating a

database. So, we'll be creating a workspace in linear that will automatically trigger an NAND workflow and then send that over into Bolt. Now,

just a little bit of warning ahead of time. We weren't actually able to fit

time. We weren't actually able to fit all of the content into the one hour of the workshop today. So you'll notice it's broken down into three different parts. The first part is the first hour

parts. The first part is the first hour of everything that I could teach in the time possible. Then what we did is we

time possible. Then what we did is we opened the floor to other bolters and we let them present their projects. So

we've got three presentations which will take about 15 minutes. And then the last 15 minutes is the last part of the workshop where we just tidy things up.

We get the rest of the workflow working.

So with that, let's dive into it. What

we're going to be doing is we will be going over how to add superpowers into your bolt project by connecting agentic workflows. We'll be basically creating

workflows. We'll be basically creating your agentic workflows within NADN and then we will be basically running those agents and then sending all of that

information directly into your bolt database. By connecting these agent, it

database. By connecting these agent, it adds all sorts of things. Your

creativity is basically your only limit.

So, we'll be going over how to connect that to Linear, a task tracking app, and going through that entire process on this call. So, super excited to have you

this call. So, super excited to have you join us. Now, just as a little bit of

join us. Now, just as a little bit of housekeeping, you can see we've got Erica on our call. So, she's one of our customer success engineers. She is

>> welcome. Thanks for coming.

>> Yeah. So, Erica will be here in the comment section. So, notice we're a

comment section. So, notice we're a little bit different from how Zoom normally works. If you've got any

normally works. If you've got any questions, leave them in the comment section and we're able to highlight those, put them on screen. We can't

actually reply directly to your individual comments, so it's just one continuous stream. She'll be doing her

continuous stream. She'll be doing her best to get to all of them. So, as

always, feel free to introduce yourselves, say where you're calling in from. I know we get people from all over

from. I know we get people from all over the world, so say hello. You can say what your background is and if there's like a bolt project that you're proud of. Maybe you've recently published it

of. Maybe you've recently published it or gone live with, feel free. You can

drop that in the link so anyone else on this call is able to look at it for a little bit of inspiration.

Now, there is one more exciting thing that I want to mention to you this week is we're actually going to be doing a little showand tell section at the end of the workshop. So if you've been working really hard, you've built

something that you're super proud of and you want to share that with other people here on the workshop, then at the very end what we'll do is we'll give chance to a few of you, probably just a handful, where you'll have a minute or

two, where you'll be able to share your screen and present what you've been working on and basically share that with the rest of the workshop. So stay tuned for that. And then once we get to the

for that. And then once we get to the end of the workshop, we'll be sending out a link where you'll be able to join this live stream and share what you've been working on. So with that, let's

dive right in to adding superpowers to by connecting aentic workflows. Now the

agenda for today is the first thing we're going to do is we're going to look at our task tracking app. So we're going to be using linear. Now, Linear is similar to like Jira or other task

tracking apps that kind of lend themselves really well for developers and you know it's a great way to kind of manage tickets. Anybody in your team can

manage tickets. Anybody in your team can submit these tickets and then you can mark them as completed and then you can save them in your backlog or you can say they're in review and it's a great way

to manage your tasks. So, we're going to quickly look through Linear. We're going

to set that up and we're going to connect it to an NADN workflow. Now,

some of you probably haven't heard of NAND, but we'll be going over that as well. Within NAND, that's where we're

well. Within NAND, that's where we're going to be performing an agentic action. So, we're going to connect an

action. So, we're going to connect an LLM to these linear tickets to be able to summarize them. And then by using an HTTP request, we'll then be able to send

that over into our Bolt database. And

we'll make sure that we're determining the correct JSON structure along the way for the data transfer and then send that into the Bolt database. So with that, let's dive into it. First, first first

of all, what I'm going to do is we're going to get started in linear. So if we have a quick look here, this is what the linear workspace looks like. Now I'm

going to come in and I'm going to entirely create a new workspace. So if

you don't have linear, it's like a free tool. Feel free to like download and use

tool. Feel free to like download and use it. So I'm just going to create a new

it. So I'm just going to create a new workspace entirely from scratch. I'm

going to call this workshop for Bolt. Great. So, we're going to

for Bolt. Great. So, we're going to create this workspace.

If you've got any questions along the way, feel free to leave them in the comments. Erica will share them on the

comments. Erica will share them on the screen and I'll answer them. Okay, so

here we are in Linear. We have just set it up our new workspace and these are some example tasks that it has. So

notice if I click on one of these we can change the status here where okay now it's in progress or we can change it to done canceled etc. Let's come back in and if we want to make a new one let's

say please implement dark mode on the dashboard and we can add a description and we'll create the issue. Great. So

we've got linear set up and working.

Now, what I'm going to do is I'm going to come in into our settings and under security and access, I'm going to create

a personal API key. And we're going to create this API key. So, here we go. And

I'm going to copy this to our clipboard.

Now, please note if you're unfamiliar with Linear or you're using another tool, then don't let this deter you.

This is just one example of what I'm working on or like one way to get data into NAD. So don't feel like you have to

into NAD. So don't feel like you have to strictly follow this exact process. So

we've got our API key copied. Now let's

come back in and we'll have a quick look at NAD. This is their homepage. Flexible

at NAD. This is their homepage. Flexible

AI workflow automations for technical teams. You can create an account, do a free trial. I think you do need to pay

free trial. I think you do need to pay for a subscription, but it's worth testing out and you can determine on your free trial whether it's worth it or not. So, here we are within NADN. I'm

not. So, here we are within NADN. I'm

going to click on personal. Notice that

I've already got two workflows set up.

These were some demo workflows that I was practicing with. And we're going to create another one entirely from scratch. So, let's click on create

scratch. So, let's click on create workflow.

And now, the first step we're going to do is we need to connect this. We want

linear to be our trigger. So, we're

going to type in linear. and you'll see it pops open on the right here. And we

can see that we've got all these actions and we've got a trigger. So, as our first step in the workflow, we're going to say on linear event. Now, because

we've just created a new linear workspace, I'm going to have to go ahead and create a new credential. And this is where I'm going to paste that API key

that we just copied over from our linear dashboard. So, with that in there, I'm

dashboard. So, with that in there, I'm going to click save.

Connection tested successfully. Okay.

So, now we have our trigger and that's set up here. It's got a little sort of exclamation mark next to it because we haven't fully set it up yet. So, that

team name that we also created, workshop for bolt, we can see that this data is populating through into our NAN workflow. And this can be a little

workflow. And this can be a little confusing, but I'm just going to say an issue. there's a variety of different

issue. there's a variety of different things that it can listen to and so we're going to listen to a specific issue. Now let's come back into linear

issue. Now let's come back into linear and what we're going to do is notice that where we can click execute step

with this first node of our inn workflow. So it's basically listening

workflow. So it's basically listening for a test event from linear. So we'll

leave that over here. We'll come back into linear and here was a ticket that we had just created. You know, please

implement dark mode on the dashboard.

Now, we're going to change this to done.

Now, I click this and we'll come back over here and this has now successfully listened and it's received an output from that event that we just sent

through to it. So on the left hand side of these NAD nodes is where the input is because this is the first event. All it

needed was sort of just a trigger. And

then on the right hand side is the output. And this is all the data that it

output. And this is all the data that it just received from that linear web hook that was sent across. So if we look

through we can see all sorts of data in here. If we look for

here. If we look for William because I was the one who made the ticket. Now we can basically search

the ticket. Now we can basically search and find all of the locations where I've been mentioned.

Also, if we write dark mode here's it's got a URL for this ticket and then here it should have the description in here or here we go. Here's the title. So,

please implement dark mode on the dashboard. That's basically some of the

dashboard. That's basically some of the information that we're going to be referencing in a second. Now that we've got that set up, what we're going to do

is this can actually this can trigger if you change the status of any of these issues within linear. It's going to come

through. But let's now add a filter. So

through. But let's now add a filter. So

we're going to filter just for our done tickets. Basically, what we want to do

tickets. Basically, what we want to do is we want to create a a tool that summarizes all of the tickets that get marked done within a certain period of

time. So, let's imagine you're working

time. So, let's imagine you're working in your larger team and every week you want to be able to go to a website and you want to see everything that your

team has marked as done and as completed so you can get a recap of what they've worked on. So, that's what we're trying

worked on. So, that's what we're trying to address here. To do that, what we want to do is we want to create this filter. And we just want to pass all of

filter. And we just want to pass all of the tickets through that have been marked as done. Let's look in here. And

what we're going to do is we're going to scroll down and we're basically going to look for the state. And here we go. We

can see state and we can see this is marked as done. So, we can simply grab that name, drop it in the top here, and then we'll leave this as is equal to,

and we're going to say done.

So, what that should do is it should only pass items from this input side over to the output side once that's been marked as done. So, let's test this out.

What I'll do is we'll press execute step. So, yep, that's all flowed through

step. So, yep, that's all flowed through perfectly. And if we click execute

perfectly. And if we click execute workflow, here we go. We can see this little loading signal at the bottom. So

it's basically waiting for this linear trigger to come through. Let's go over to linear. And now we're going to change

to linear. And now we're going to change this to in progress. If we slide over, we can see by changing its state from

down to in progress, it has triggered the linear trigger. It's gone to the filter. And we can see one item has

filter. And we can see one item has started on the left and then nothing has come over onto the right. And if we click it, we double click and we open

it, we can now see that it's got these two tabs. It's got discarded and kept.

two tabs. It's got discarded and kept.

And now this was discarded because it didn't meet this condition. So let's do this one more time. What we'll do is we'll execute the workflow. We'll come

back in and we'll change this to done.

Now we can see that this item has fully gone through because we can see there's one item on this side. It's got the green bar and it's now within this kept

tab. So that's exactly how we want it

tab. So that's exactly how we want it for now. Now what we need to do is we

for now. Now what we need to do is we want to create a data table. We want to add all of this information within a table here inside NAD. So we can write

data table and then what we're going to do is we want to insert a row. Now

here's our input data. We're going to insert a row and we're basically going to we want to create a data table. Now

there's a few ways that we can do this.

The simplest way that we want to create a D table is we can simply do it right in here by clicking that. It's brought

us to a new tab and we're going to call this workshop data table. We're going to create that. And now notice it's got an

create that. And now notice it's got an ID, a created at, and an updated kind of input. But it doesn't have any columns

input. But it doesn't have any columns to it yet. So here is where we're basically going to create linear ID. Whoops.

ID. Whoops.

Linear ID.

We're going to add that column. We're

also going to add a title.

We're going to add a description.

And obviously, you can configure this t table as however you want. Completed

by.

And last one I'm going to do is I'm going to do linear URL.

Great. So, we've now created this table.

It's got no rows in it. And the way we can get to our tables is here in NAD on the dashboard personal. Instead of

looking at the workflows, let's come into data tables here. And you can see the workshop data table is the one that we just created and it's completely empty.

Let's jump back into our workflow.

Notice that our workshop has my workflow 2. So, I'm just going to rename this

2. So, I'm just going to rename this linear trigger workshop.

Okay. So, there we go. Now, we're up to this insert row. Let's just configure this node. So, the data table is we want

this node. So, the data table is we want it to add a row to the workshop data table, the one we just configured. And

now these five columns that we just created are here. So what we're going to do is we're going to look for the linear

ID. We've got our identifier. This W5.

ID. We've got our identifier. This W5.

So if we look back into linear, here we go. This WR5. Every

single ticket that you create creates this linear ID. So that's exactly what we want. So we're going to bring that in

we want. So we're going to bring that in here. Now the title should be in here

here. Now the title should be in here somewhere. So here we go. Here's the

somewhere. So here we go. Here's the

title. going to pop that in. We can also search for description.

It didn't actually have a description, so that's kind of empty for now. But if

we drag that over, that should add that in there. And then

in there. And then we got to find who it was completed by.

So assigne.

Here we go.

put that in there. And then the linear URL is I believe it's this one here.

We're going to drag that and we're going to pop that in there. So now when we execute this step, it should put all of that through that goes into our data table. Now let's just

double check on that. So we'll come back into our data tables. We'll open that workshop. And there we go. So we can see

workshop. And there we go. So we can see that information has successfully gone into the data table. That's one of the NADM workflows that we need to create.

Now, let's go ahead and create a second one. So, basically what we need to do is

one. So, basically what we need to do is actually let's make sure that we publish this. So, now that that's all created,

this. So, now that that's all created, I'm going to click publish.

We're fine with that. Workflow will be published. And there we go. So now it

published. And there we go. So now it should be running and it should be live.

And whenever I make a change then it should add something into this data table. So we can maybe test this a few

table. So we can maybe test this a few times. Testing issue

times. Testing issue description test. Put my assigne. We'll create the

test. Put my assigne. We'll create the issue. And then now that we've done

issue. And then now that we've done that, let's put it into done.

And if we scroll over here and we look back at our data tables, hopefully we have there we go. We have a second row testing issue with the description. And

this is all working.

Okay. So I see we've got one question.

How do you know if it's working and not silently failing? Yeah, let me just pop

silently failing? Yeah, let me just pop that on. Yeah. So the best way to go

that on. Yeah. So the best way to go about it is testing like this. So what

we've done is we'll just come back in we do a real world example and once we've tested it out on in within linear itself

rather than actually kind of executing the workflow within NADN once the workflow is published then all we want to do is we just want to test that this works. So we come in do exactly what we

works. So we come in do exactly what we just did and then we bring that across.

Okay now we're ready to set up the second workflow. Now, this is kind of an

second workflow. Now, this is kind of an exciting one. So, what we're going to do

exciting one. So, what we're going to do now is we're going to start off. We're

going to trigger this manually.

And basically, what we're going to do is we're going to get our rows. So, we're

going to look at the data table again.

We're going to go down and let's see get rows here. We're going to get rows.

rows here. We're going to get rows.

We're going to choose we're doing it from the workshop data table. Now, our

condition, we're going to add our conditions to it here. So, the condition is that we want our

created at date to equal. And now we're going to put in a value in here. Now,

let me just copy something over from my notes.

Copy this over. And I'm going to put this little JavaScript snippet in. And

this basically determines what is the time now minus 10 minutes and actually we want this to be greater than. So we

want the time right now.

So the first one is we wanted our when we created our linear tickets we wanted to bring that inside data into NAD. Now

the second thing that we want to do is we're now basically using NADN to aggregate all of the data from the last set amount of time. So in a real world

example, we may want to get all of the tickets that have come in from Linear from the past week. And then what we're going to do is we're going to send that into an AI agent which is then going to

use an LLM and it's going to summarize all of those tickets from the last week.

And then it's going to spit out a summary and we're going to send that summary directly into the Bolt database and we're going to visualize that within our website. For the purpose of this

our website. For the purpose of this demo, I'm just going to trigger everything that's happening in the last 10 minutes so that you can actually see that this is working. We're going to say

we want the time of the created date to be greater or equal than the time from 10 minutes ago. So basically this filter

is only going to bring linear tickets in from the last 10 minutes and then send them out as an output here. And this is a great way if we trigger this to happen

every 10 minutes and it only brings in the last 10 minutes of data then that's a good way for it to sort of segment all of the data that it's sending to the LLM

within these 10 minute slots. As I said, in a real world example, you may want to do this over like a 7-day period or a daily period.

So, with that, we're also going to make sure that we return all of the items. Now, let's hit execute step. So, it

looks like two items have gone through.

So, we've got our implement dark mode and we've also got the testing issue.

What if we change this minutes down to five and we execute the step? There we

go. We've only got one issue coming through. And if we make this a huge

through. And if we make this a huge amount of minutes and we execute this step, well, because we've only actually sent through two into the database,

right? Now, it's only showing two, but

right? Now, it's only showing two, but you get the point. Now, we're ready for the next step. We've been able to get those rows. Now, this is the exciting

those rows. Now, this is the exciting part. We're going to send all of this

part. We're going to send all of this data to an AI agent. and let's click AI agent. I basically press add AI agent

agent. I basically press add AI agent and it builds this AI agent here. Now,

there's a few things we need to connect to this. And I know NAD can be a little

to this. And I know NAD can be a little bit technical. Just bear with us here.

bit technical. Just bear with us here.

What I'm going to do is I'm going to connect chat model. So, I'm going to say AI chat model. I'm going to choose Yep.

GPT mini. Happy with that.

Now, let's come back. So, we've got that connected in there. Now, the AI agent itself needs a prompt. So, we're going to define the prompt below. And here,

we're actually going to define a prompt for it. So, what I'm going to do is I'm

for it. So, what I'm going to do is I'm just going to copy a prompt that I had created before. I'll

give you guys a little insight into this prompt. So, here we go. You're a highly

prompt. So, here we go. You're a highly strategic product manager. Your job is to read a list of completed tasks which are linear issues and summarize them into a structured report for the team.

Here is the raw data. So by adding this little snippet in here that will send all of the raw data through to the LLM.

So there's rules for your output. So you

got to count the tickets, create a highle summary, create completed ticket lists, etc. Adding a date range. I'm going to

copy this prompt and put this into our AI agent here. So,

there we go. The final thing that we want to do within our AI agent is we want to basically make sure that it sends out this information in a very

specific format. So, we're going to say

specific format. So, we're going to say we're going to require specific output format, but we'll get to that in a second. So, now let's press execute step

second. So, now let's press execute step and we'll see what happens. So basically

now with those two items that are coming through from our database, it's going to our AI agent and it's sending that raw data off with the system prompt to the

chat model where then it's then able to it should basically it'll execute this node and it'll have an output. In the

meantime, let's go into Bolt and let's start getting our interface ready to get all set up. Let me just grab a bolt prompt that I want to use. So, here we

go. Copy a bolt prompt over. I'm going

go. Copy a bolt prompt over. I'm going

to add this in here. So, let's build a site which acts as a notice board for other members in my team. I would like notice cards stacked vertically on top

of each other. Below is example data of the JSON input it will receive via API endpoint. Do not build the API endpoint

endpoint. Do not build the API endpoint just yet, but please set up a database which expects this data. Now, I see we've got

a question from Scott about guardrails.

No, I don't have any guardrails set up on this. And the reason why is because

on this. And the reason why is because this is just using our own internal linear data. I don't need to worry about

linear data. I don't need to worry about any risk of say prompt injection from anybody else because this is an internal tool using our linear tickets as the

data input. So it should be fine. But

data input. So it should be fine. But

you do make a good point that guard rails are important and that's something worth considering. And if you were

worth considering. And if you were building this in something like the open AI agent builder, they have guard rails that you can add in there naturally. You

mean from hallucinating? Oh, good

question. I don't have any hallucination guardrails in here just yet, but that's probably another step that you can add.

I don't have a huge amount of time. I

just want to get this workshop, this flow built in this workshop. But that's

a good point. you know there are risks of hallucinating and probably like a good way to consider this is that we want to you know define our JSON output

and when we're sending this data over to the API endpoint that's where we want to export it as JSON data so that it doesn't risk hallucinating. So we should

get to that in a sec. So let's go ahead.

What I'm going to do is we've got our bolt prompt here. Now what I'm going to do is we what have we said? So build a site

which acts as a notice board for other members of my team. I would like notice cards stacked vertically on top of each other. Below is an example data of the

other. Below is an example data of the JSON input it will receive via API endpoints. So what I'm going to do is we

endpoints. So what I'm going to do is we should get our out output data. So let's

have a look at this. Here we go. Yeah,

we haven't quite built the endpoint data just yet. So I might just manually write

just yet. So I might just manually write that in. Example data that will be

that in. Example data that will be receiving should be linear ID

title description completed by and What was the last one? Let's go over

here. Linear ID

here. Linear ID linear URL.

Do not build the API endpoint just yet.

Please set up a database which expects this data. Great. So, we've got that

this data. Great. So, we've got that there. Now, there's another exciting

there. Now, there's another exciting thing that I want to show you guys.

We've recently launched MCP support literally today, just an hour or so before this workshop. So, basically, I'm not going to do a deep dive on that

today, but what I'll do is I'm going to turn off some of these other MCPS that I've enabled before. And Shad CN, which

is like a a design library, has an MCP.

So, I'm going to turn that on. And then

I'm going to prompt it to please build with shad CN components where possible. We'll plan this out and

where possible. We'll plan this out and we'll start building off this Bolt project.

We'll let Bolt do its thing over there.

Now, let's jump back in. We've got our agent. So, here's our agent and it

agent. So, here's our agent and it worked. It had two items coming in and

worked. It had two items coming in and it's got two items coming out. So, what

we want to do is we want to actually structure this output. So at the moment what we're going to do is we want to say

we're going to require a specific output format. And to do that it's requiring us

format. And to do that it's requiring us to connect an output passer. We can just come down here click output passer and we're going to say structured output

passer like so. Now by clicking on this basically what it does is it now shows us what is the input that it's getting

from that AI agent and then now we create a JSON example of the JSON output and this is what we're going to be

sending via HTTP request or response to Bolt itself. So, this is kind of where

Bolt itself. So, this is kind of where we need to be very specific about the output of this. Now, this can get a little bit complicated. I've got a

little snippet here. Now, if this kind of gets a little bit complicated for you knowing exactly to put as the JSON data, what we can do is we can actually do something as simple as this. So, I'm

going to take a screenshot of this structured output passer. I'm going to open Gemini. I'm just going to pop this in

Gemini. I'm just going to pop this in here. Choose your LLM of choice. And you

here. Choose your LLM of choice. And you

can basically ask it with a screenshot like this. On the left hand side of the

like this. On the left hand side of the screenshot, you can see my input. Please

help me create an example JSON output that I can use as an HTTP request to convey this information.

So, we'll send that off and it'll help us create that JSON response. Now, we'll

let it do its thing. Um, what's the most robust way to trigger an NAD workflow from Superbase insert without exposing web hooks in the front end? Should I

rely purely on the Superbase database web hooks? Wow, that's a good question.

web hooks? Wow, that's a good question.

Yeah, so good point that we don't want to expose these things in the front end like this. You don't want to sort of

like this. You don't want to sort of hard code it. Potentially an edge function, a server function is what I'm thinking. We're actually going to be

thinking. We're actually going to be creating an edge function directly here to receive this data. That may help answer your question. I can see Scott's

also said edge function there as well.

We'll actually be asking Bolt to create a edge function to do something very similar. So here we go. It's basically

similar. So here we go. It's basically

created this payload option two.

Now we do look it's putting both of these issues. So if I come back in and we look

issues. So if I come back in and we look let's refine it. So if we let's just copy

one of these issues. If we

let's put this in here and see how this works. So we've got the linear ID, the

works. So we've got the linear ID, the title description completed by. So

hopefully that works. Let's come back in here. Notice that our output at the

here. Notice that our output at the moment it has these new line breaks and it's got this kind of odd formatting. So

now that we've required the specific output format and we've got this output passer, let's execute the step error in subnode structured. So let's open this

subnode structured. So let's open this expected non-white character here.

So if we get rid of that, let's try that again.

Hopefully it should give structured JSON output now.

It's working on that.

So it's still digesting our information.

We look back into bolt. It's finished

our plan. So should notice display in reverse chronological order. Yes. Newest

first to have a color palette neutral and green.

Three is completed by field meant to indicate who completed the task or an assigne or who assigne. Great. So, we'll

turn off plan mode and let's send this off to build. Great. So, while Bolt is building, let's have a look back in here. That

just finished. And now look at the output from our agent. It's got this structured JSON data. Now, what we'll do is we'll basically come in here and

we're going to create HTTP request. So what we want to do is we

request. So what we want to do is we want to send this directly to Bolt and we're going to say post. And this is

kind of where we need to create this URL.

So to do this, what we need to do is we actually want to prompt Bolt itself. So

we'll just wait until Bolt finishes building in here and then we should be able to create this.

I guess it's like an API endpoint. So,

we're sending this data into Bolt to be digested.

Here we go. So, it's setting up the Bolt database.

Okay. So, it's already got notices here.

We can see this is the data structure that it's created.

So, it looks pretty good so far. And

it's put some example issues in there.

Okay. Now this agent workflow that we have at the moment is a very simple one and it's something that perhaps can be done

within linear itself or linear has like the function to do like a summary like this but what I really wanted to demonstrate is by creating these nodes

directly and you can create this kind of multi- aent workflow is there's a limitation to how well some of these large language models work. And if you give them too much to work on, then it

reduces their performance. So something

like this where you could spin off an AI agent to just do research. Say you're

trying to find events in a particular city, you may ask it to just focus on finding events in a particular date range or you can change what your model

is depending on how complex the ask is.

Then you can feed that through to another agent and you can say please summarize all of this information that's come through and you can string together

a multitude of agents which are actually proving to be really capable and it's a really effective way if one LLM can't do everything you're asking for itself.

This is kind of a multifaceted way that you can address the task at hand.

So let's see how Bolt's going. This is

almost done.

We've got about 20 minutes left. So,

we'll get this all done and then I'm excited. If you guys want to share your

excited. If you guys want to share your projects, obviously, no pressure, but feel free.

All right, so this is almost done. We'll just let it refresh.

Now what we can do is we can say please let's just start getting our next prompt ready. Please create a server function

ready. Please create a server function which

acts as an API route to ingest data.

The data will be in the following format.

Please provide go back in here. When we're setting up this HTTP request, please provide the

URL or the API end point

for me to send the data to.

Great. So, we'll copy that. You can

that's the notification for the MCPs.

Guess in the meantime I can quickly show you how they work. So we've got some default MCPS here. So you can see I've already connected Linear, GitHub,

Notion, and I've added a Shaden as a custom MCP. You can add these yourself.

custom MCP. You can add these yourself.

Now, something really exciting about the GitHub MCP, which I was just testing recently, is you can basically ask the Bolt agent directly to go into your

GitHub account as long as you provided all the permissions and you can say look at a specific repository and find a particular feature or find a component or a screen or whatever it may be and

bring that into this bolt project. So

now if you've got two bulk projects and you've saved them both as repos in GitHub, you can now basically use the GitHub MCP and bring features directly from one because it'll use the context

of that other project codebase and then bring that in which is super exciting.

I think the agent does get a little bit caught up like this. So what I would do just to naturally sort of diagnose the issue is I'd just press stop. So, I

guess I might just have to I'll just start a new project in the meantime.

So, we'll go grab our prompt.

Here we go. Copy this and paste it.

Build a site which acts as a notice board for other members in my team. I

would like notice cards stacked vertically on top of each other. Below

is an example of the JSON output input it will receive as API endpoint.

And what we can do is we can try and do this all in one shot. Please

build a server function to ingest this data with a

database. Okay. Now what I'm going to do

database. Okay. Now what I'm going to do is I'll just turn off MCPS instead of trying to use the shad CN MCP. I'm just

going to leave that off as well. and

we'll make sure that we're going to copy our output data. So, here's example of the output. So, I'm going to copy that

the output. So, I'm going to copy that and then we'll come back into bolts.

We'll paste that in. We're going to plan it out and build that.

Okay. Yeah, as I was saying, if you do run into issues like this, feel free to Sometimes you just got to stop and restart it. It may be something to do

restart it. It may be something to do with the MCP. I was trying to use the shad CN MCP here. So maybe that's something we need to diagnose as it is our launch day. But here we go.

Hopefully it should be done in a few minutes.

Do we have any questions so far? I hope

this is all making sense. I know we had to jump through it quite quickly. And

what we can do is we can look through some of these other slides. So, Agentic

Workflows let your app react to the real world without manual intervention, which is a great way you can trigger these things. At the moment, if we look back

things. At the moment, if we look back into our workflows, our first workflow happens automatically every single time you change a linear status. Whereas

here, this one at the moment, we've just set it up to trigger the workflow when you press execute. But there are

triggers that basically it'll do it'll be like a timebased trigger. So if I delete this and I want to add a trigger

in here, there's trigger manually.

There's also trigger on schedule. So we

can get this to schedule every five minutes for now.

So now by connecting this schedule trigger, this is a great example of how you can get something to operate once a day, once every 5 minutes, once a week,

whatever it may be, so that it triggers this automatically. So now we should

this automatically. So now we should start seeing this trigger on a regular basis.

Back into bolt. So it's written our plan. Should the notice board be

plan. Should the notice board be publicly accessible? I'm going to say no

publicly accessible? I'm going to say no just for the sake of time and to build it out for simplicity. Linear

tickets. Okay, let's build that out.

So, what we've done in this bolt prompt this time is we've actually copied over kind of the JSON that it's expecting.

So, now it's going to build out because we've asked it to build out a server function. It's going to create a server

function. It's going to create a server function that will then basically be expecting this JSON data and then it

should use that to ingest it into the Bolt database itself.

So, let's build this out. That'll

probably take a few more minutes.

Okay. Yes, I see I'm using a cheat code.

I don't need to worry about burning tokens. This is true. I've obviously

tokens. This is true. I've obviously

built this out twice. The way I look at it is if you compare this to traditional software development, it's like for what you can do, like you can build, you

know, a working platform for, I don't know, $20 or something, which is just a complete step change in development costs compared to what it was a few years ago.

Okay, so we'll let that build out.

I know we're probably going to be running short for time, but we'll see how well we go.

Now, while that's building, let's see if we have anything else to adjust here.

So, we basically just need to fill this out. Bolt will provide once it builds

out. Bolt will provide once it builds out that API endpoint, it'll provide us with a URL and then we're going to add our authentication in here. So, I'm just

going to sort of set this up in the meantime. We're going to choose a

meantime. We're going to choose a generic credential type in here for this HTTP request. And we're going to say

HTTP request. And we're going to say header authentication.

And we're going to create a new credential.

And this is dependent on what Bolt says.

So, we'll be we'll configure a secret that basically provides the authentication. So we've got the secret

authentication. So we've got the secret on the bolt side and then we'll set up we'll add it in here as the header of this HTTP request and so it'll compare and make sure that they match and then

that's kind of like a secure way so that we don't have any random person making an HTTP request and sending it through.

So here we go. This is almost done.

Yeah, this one just got stuck. So

I press stop build. Let's see what that does.

build. Let's see what that does.

Okay, almost done.

Now what we're going to do in here is with the HTTP request is we're going to send this body as well. And this is where it's going to send basically body contents.

Now to do this one sec just get something set up on my end we can basically if we wanted we can bring

all of these in directly.

So, because this is structured data output, what we're going to do is we're going to click this.

We're going to put that in there. Oh,

actually, I think what we need to do is we're going to call this linear ID.

And then we're going to bring this in here as the value.

We're going to add another body field.

We're going to bring the title in here.

title.

Add another one. Let's write

description.

Bring the description in here.

Then let's add completed by and we will add the linear URL as well.

Okay. So I heard one of these beep. Here

we go. All right. So this one is the where we tried to set up the server function as well initially from just one prompt. And so you can see it's already

prompt. And so you can see it's already giving us a URL that we want to be sending this to. So notice that I guess we can read through this. So it's

created the board send data to the board and we want to post it to this. And now

notice this is our superbase URL. So if

we come into our code and we look and we see in our env file that we've got mwh that's our superbase URL. We've got the

same thing here mwq etc. But now it's added our functions v1 ingest notice we're going to copy this.

So now that we've copied this let's then come back into enable. We're going to come to the top of this and we're going to paste this here. So, I've added that

in there.

And it also will need some form of security.

Let's see what happens if we try and trigger this directly.

So let's when we try and execute this step, basically what we need to do is we want

to add some security here on the bolt side. So basically what I want to say is

side. So basically what I want to say is let's also consider adding a header

to this HTTP request so that this is done in a secure manner. I should save

the password here in the bolt secrets.

Okay. So we'll send that off. We'll have

a look.

Okay, come back in now because our rows have now expired. Let's

come back into linear. Let's create.

Please add dark mode to the dashboard description.

Add this. Great. We'll do another one.

Improve the AI agent. The AI agent should have a wider context history.

We're going to create issue now. Now

issues. Let's mark both of these as done. Great. We're going to mark this as

done. Great. We're going to mark this as done.

Now with this, let's hit we're going to execute that workflow. So it goes off.

It's with those two items has gone through the AI agent. It'll summarize

those. And there may be an issue with this request because we haven't added any security just yet. But we'll find out in a sec.

So now on the bolt side of things is we're adding a custom header. So now the server function on Bolt's end is basically going to check that this HTTP

request that's coming through from NAND, it's got to have a specific kind of security or some secrets to it. So we're

going to come into to this bolt secrets and notice that it says to ingest the endpoint. It's now secured and it

endpoint. It's now secured and it requires an X API key header on every post that you send across. And we're

going to call this ingest API key. So

we're going to open secrets and I'm going to just write password just for the simplicity of this. We'll create

this secret.

So that's created successfully.

We're going to copy that. Now we'll come back into NADN.

Now this wasn't working. What we're

going to do is our header authentication is we want to send the header and we

want to basically add ingest API key.

We're going to write SW and we're going to save that.

So now we're kind of configuring this header and let's see how how well this works.

Now, it also potentially needs a bearer ID.

So, what I'm going to do is let's I just kind of want to show you through this workflow of troubleshooting as well. So,

what we're going to do is I'm going to bring this screenshot in and it said I've added the header to the HTTP

request. Does it need a bearer or

request. Does it need a bearer or anything else inside of the HTTP request header?

So often it's kind of like a two-step security process. So step one is the

security process. So step one is the information will be sent from NAND over into Bolt. And for Bolt to actually do

into Bolt. And for Bolt to actually do anything, it needs to match those passwords. And then step two for the

passwords. And then step two for the server function that Bolt has created, it'll often need like a bearer ID or

some other form of authentication within there as well. It's checking the X API key directly against the ingest API key.

So we want to make sure that these are matching your NAN setup instead of using generic credential type with ora switch to send

headers.

go. Let me create a new.

So, yeah, sometimes getting these headers working correctly can be a little bit of an issue.

So, X API key. Let's copy this.

And I think what I'm going to do is we're just going to add it in secrets as well. So, let's go into secrets. I'm

well. So, let's go into secrets. I'm

going to say X API key password. Let's

save that as well.

I guess we have to use underscore.

So we'll come into secrets x API key

pass word create secret.

Okay, so that's added. Let's come back into our workflow.

X API keyword save word and we're going to add another one. So

we'll do the ingest as well key. So what we're doing is we're

key. So what we're doing is we're actually sending multiple headers. So

we're doing it up here and then we're kind of doing it manually as well which isn't an issue.

we execute this step. Let's have a look.

Okay, we're having problem in node HTTP request. Please check your credentials.

request. Please check your credentials.

So what we can do is let's copy this.

We'll copy this error and we'll come back into bolt and we'll say getting an

error sending the HTTP request. Here it is.

request. Here it is.

Paste that. We'll plan it out and we'll see what it says.

Okay. I notice we've just sort of hit the 1 hour mark. So hopefully we can get this all dialed and we'll be able to send it across.

into our bolt project. Ultimately, what

it will do is we'll be able to add information directly from NAND into one of these rows here.

Okay. So now what it's going to do is it's going to check the edge function and it's going to see how it validates the API key.

Added the error message in there. So

there we go.

Okay.

I can see we've got a few messages here in the chat. Yes, I'm in Pacific time at the moment. So, it's late morning for me

the moment. So, it's late morning for me now. Let's just see if we can finish

now. Let's just see if we can finish this off really quickly. If not, what I'll do is I'll with this recording, we usually post it to YouTube. So, I'll

finish it off in there and you'll be able to see it. Let's have a look what it says. You have both these configured

it says. You have both these configured in the edge function secrets. The code

only reads this summary. The fix is straightforward. remove header or

straightforward. remove header or credential from the NAN node and instead manually add the X API key header with the exact value.

Okay, so let's copy this header or head.

Okay, I think I may have to finish this off offline. Let's have a look. I'm

off offline. Let's have a look. I'm

reading through the comments now. So, we

should let's have a look at our boat bolt project. It should have been able

bolt project. It should have been able to set up a server function in here. So,

here's our server function. And then to look at the server function, here we go.

Ingest notice.

So, it looks like it's looking for the X API key.

I know we had header off before.

Let's do X API key.

Password save. So, we've saved that in there.

save. So, we've saved that in there.

Let's try this again.

Process your request item.

Yeah, look, I guys, I feel like I haven't clearly explained this to you guys in particular. I think sometimes I get it working first time and sometimes

I don't. So, apologies that I haven't

I don't. So, apologies that I haven't been super clear with you on this. What

I will do though is I'll make sure that I'll clearly articulate all of the processes that we need to do on a YouTube recording and we'll post that on our YouTube within the next week or so, within the next week. So, probably

sometime before Friday. Apologies, we

couldn't quite get this done exactly in time. I think we probably spent a little

time. I think we probably spent a little bit too much time on the NADN side of things. And I also think by configuring

things. And I also think by configuring all of this in one step by trying to set up the bolt project and then also get this server function, there may be some issues that need diagnosing. So, with

that said, we're going to share a link for everybody to join. if you'd like to present feel free. So I'll copy this

link and I'll paste it here within the chat. So in the comments now

the chat. So in the comments now basically you'll see the way this will work and this is our first time doing this is I'll open up the floor to Erica

if you want to join us again. What we'll

do is for anybody if you do feel like you want to present, you want to share your projects, use the link below. By

clicking on that, you should enter into our stage and the floor will be yours.

We'll add you. You should be able to share your screen with the other viewers on the workshop. Let's see if we have any takers. Okay, we've got one person

any takers. Okay, we've got one person who's joined. What I'll do is I'll add

who's joined. What I'll do is I'll add you onto the stage and let's just spend probably two to three minutes explaining what you've done in Bolt and feel free

to do a live stream or share your screen as well. So here we go.

as well. So here we go.

>> Hey everyone, how's it going? Thanks for

having me. Yeah, if you don't mind, let me share my screen real quick.

>> So I've been developing this app.

Everybody see my screen? There we go.

Yep. It's called the So quickly run through it. It's basically, you know, an

through it. It's basically, you know, an all one AI subscription. I've done

everything through bolt so far. The back

end is superbase also. So I have a multiplication fully working. I have

different account creation admins just go >> and it's kind of similar to chat GBT but it's basically meant to have all AI models in one. So you can go through

different AI models Google cloud perlex deep we have all these different models you can speak with it. And the best part about it is we have a personalization aspect. So you can actually go in here

aspect. So you can actually go in here place move your mind and what would happen is you would actually go to your chat GBT you would copy the memory that you have and you can paste it in here and then when you do that you click this

it basically parses all that information and puts it into a structured prompt for all the models that you have basically fill all this out automatically. That

way, anytime you chat to any one of the AI models, instead of having multiple different dashboards, multiple different prompts, you have a customation here for you that works with all models all in

one. You can also upgrade the plans. We

one. You can also upgrade the plans. We

plan on adding a few more features soon with image generation, video generation, and basically have a full all-in-one AI model.

>> This is incredible. And so, you've built this all in bolt. How long did it take you if you don't mind me asking?

>> I've been doing the past couple months, but honestly, it's been in sprints. So,

I'd say total around a 100 hours maybe a bit more just depends on mainly bug fixing especially manage back end most of these are API calls with open road

>> but let me show you about real quick >> how close are you to launch >> hopefully within two three weeks I want to integrate the images and video models and then we're going to have about three

weeks of testing and hopefully launch midappril if we can >> incredible >> see basically autofills all this That's very cool.

>> As a dark mode, >> one-stop shop.

>> There you go.

>> Now, some of you may seen we've got a bit of a showcase page on our on our vault homepage. And so, with the Now,

vault homepage. And so, with the Now, what I wanted to say is for things like this, I think that's an incredible project and we're working on getting our showcase up and running. So, we want our best for you guys to be successful. And

so, projects like this, feel free to email me. We'll do our best that we can

email me. We'll do our best that we can kind of share these with some of our socials because if you build a project successfully and we can share that with you guys then we can share that with all

of our audience then hopefully that gets you get some more eyeballs on your project. What I'll do is I'll leave my

project. What I'll do is I'll leave my email here in the chat in a sec and then if you can maybe just send me that URL and we can be in touch and if you'd like to we can do some sort of like collaboration there and we can sort of

showcase this with our wider audience.

Yeah, absolutely. That would be great.

Like I mentioned, we plan on hopefully testing in a couple weeks. We're

actually looking for a bunch of different people to specifically test it. That would be very helpful.

it. That would be very helpful.

>> Great. Thank you for having me.

>> Yeah, pleasure. So, Scott, you're up next. What we'll do is we'll add you to

next. What we'll do is we'll add you to the stage.

All right, Scott, the floor is yours.

>> Okay, so how do I put my I just have to share it, right? There

>> should be a share screen option. Yeah.

See if we can do this.

I have a big screen, so it's going to be a problem, but Okay, take your time. No

worries.

>> Oh, you know what? I got it. I got I'll do this tab. Here we go. Sorry. Here we

go. Okay. Can you see that?

>> No.

>> Not quite made me What I'll do. Here it

is.

>> Go.

>> There we go. Great.

>> Okay. So, the first one is you were just using N8N. This is N8N, but it's I think

using N8N. This is N8N, but it's I think it's better because >> So, here's flows, right? And here's a flow. And all you have to do is speak

flow. And all you have to do is speak you basically it's a chat and if you want to send a Google calendar, you just tell Google to send it >> and it'll literally just set it up for

you. You don't have to figure out all

you. You don't have to figure out all those crazy things, right? So, it's

basically Nad with just chatting.

>> Incredible. And these all work like you could open weather. So, it'll go from here to here. If I said set up create an event on my primary calendar at whatever

time with whoever I'd send this, then it would send it to Slack. And you can create very, very detailed workflows.

And it was pretty tough setting up because the key to this was it's all AI, right? So here's where the credentials

right? So here's where the credentials are set up, your credentials. You can

add AI to your API keys. This is the MCP hub. So at this point, I just kind of

hub. So at this point, I just kind of finished this up where now I can just start registering MCPS. So I'm going to register about 50 MCPS and then launch

it and see how it goes.

>> Wow. Wow.

So this is >> Yeah, go ahead. Sorry.

>> I was just going to ask it's almost like a competitor to something like Nad where people can create these AI automations themselves or these agentic workflows directly by chatting with it.

>> Exactly. But what you were doing it's like so I thought of this because it's bulk >> for N8N right >> here you are bolt could have written all

that JSON code that NAN it's like going into Starbucks and they make you say latte and all this other stuff right I just want a large coffee this is like bulk for nadn because that's how I came

up with that idea you just go to your flow anybody can at least click a button you start a new flow you say Okay, I want my Google calendar. There it is.

>> Connect it. And I want open weather.

>> Mhm.

>> You know, Slack, like you said, just start connecting them >> and all you have to do is then talk to it. So, I'll send, you know, you could

it. So, I'll send, you know, you could log in and tell me if it works for you, right?

>> Yeah. We'd love to test it out, Scott.

>> And I'm showing you this because this is what I built all in bolt, which is Oh, and look at how it runs. It's really

cool. I'll just do that quick. So this

was here. So we had some neat animation when it run. When it runs, it literally tells you what it's doing. So here it is. It's going it's going into send the

is. It's going it's going into send the Google calendar.

>> Uh I wonder if I put in the right stuff.

It might not have. Yep. So it went it sent the meeting out. It's saying what it's doing.

>> It's sending out the Slack message. Oh,

this is using this is very complicated because it's using the edge functions that we were touching base on and it literally this was one of the first edge

functions I created and then over here it's you now can have a chat with any one of these notes just like because I'm using open AI right oh it said could you

please provide the specific start and end time of the meeting because I didn't provide it here so now it wants that to finish it >> wow That's awesome.

>> It works. I mean, I was so happy when it worked, too. I saw the calendar things

worked, too. I saw the calendar things popping up. I'm like, "Holy cow." Okay.

popping up. I'm like, "Holy cow." Okay.

So, I'll send that to you. I mean, do you think people would use this?

>> Definitely. Yeah. Yeah. I mean, we just spent 30 40 minutes seeing the process of using an 8N. And if you get one of those little connections wrong, then it can cause an issue for your whole thing.

>> So, here's what I'm going to send you.

I'm gonna take lineer is going to be the next one. Mhm.

next one. Mhm.

>> And I wanted to take linear and confluence. So you could

confluence. So you could >> I was waiting for the bolt mcp. So I'm

going to take bolt.

>> It's going to every time you finish a you know like something works in bolt will send it over to lineer. It'll write

it up. It'll send it over and then lineer can send to Slack that it got the message right. And then it's going to

message right. And then it's going to take that and actually register the document, >> right? The AI can then write up the

>> right? The AI can then write up the document as you're kind of building your application, which I thought >> incredible, Scott, thank you. Thank you

so much for sharing. This is I can't wait to see. Do you have plans to launch it soon >> or as you said, you want to add some?

>> Yeah, I'm going to send it to you guys because I was waiting and this is the stock market. This is up if you guys

stock market. This is up if you guys want to go to app.ac.com.

We're taking 50 50 login. So, this is actually an AI app for the stock market.

So, you could look up any company like Nvidia and here it is, right? Everything

on the company.

>> Wow. But what's really cool here too is you can talk to you can have a discussion with AI here and you could go to your dashboard

and you could say pin a watch list on my dashboard.

So it'll help you pin things to these dashboards. It's interactive. So

dashboards. It's interactive. So

whatever you see here on the screen, it can basically manage with you here in this place. So it's saying back to me.

this place. So it's saying back to me.

Okay. Go to signals desktop. Find the

custom watch list >> dashboard left. So it knows this area.

Let me just change one of these here.

You see these here?

>> Yep.

>> So let me take one of these stocks here.

So this this is like one of my watch lists, right? So, if I wanted to add IBM

lists, right? So, if I wanted to add IBM to this, I could say, I'm just going to show you that. Please add IBM to my

watch list. Hopefully, it'll work. I was

watch list. Hopefully, it'll work. I was

working on this, so it's not working right now, but yeah. Why don't feel free to drop the URLs in the comments so we can anybody else can look at it if

they'd like to.

>> Yeah. So, this is up at app.ac.com.

It's free, so you can get real time stock quotes. You can analyze any stock

stock quotes. You can analyze any stock on the stock market. You can look up private companies. You can look IPOs

private companies. You can look IPOs that are coming out. There's signals for >> Yep.

>> There's IPOs. These are the new IPOs coming out. Like here, there's IPOs

coming out. Like here, there's IPOs coming out here.

>> Pretty cool.

>> Thank you for presenting, Scott. I think

we've got time for one more. I see Paul Smith has joined as well. We'll hand it over to you in a sec. But yeah, thank you for presenting, Scott. We really

appreciate that. It looks great.

And Paul, welcome.

>> Hello.

Hi.

>> Okay, now I switched to the speaker. You

can hear me okay now?

>> Yes.

>> Okay, good.

What I've done is something that's actually simple. It's if you know

actually simple. It's if you know Beethoven he's written theme and variations and this is a simple idea.

You start with a theme and you follow it with a variation and another variation and another one. But in one instance in his life he didn't do that. He created a

theme and in each bar of it he switches to a new variation on the very next bar.

So, it's a highly fragmented oneshot pass through of all the variations in his second symphony in the third movement. And I thought it would be fun

movement. And I thought it would be fun to chop up all of those pieces in audio and build an interface where people could just kind of play their own

version of that same piece of music.

I'm going to share the screen. I posted

the link in the chat.

I'm a little concerned that sharing over this might not transmit the audio to everybody, but that's okay. You'll see

how it looks, how it works.

>> Yes, >> we should.

>> Yes.

>> Well, I'm getting >> Here we go. need to I think it might be >> Oh, I'll turn it down. I don't have headphones here with me.

>> No problem.

>> You're seeing this kind of There we go.

Okay. You can see this brown thing with this clock face. Good.

The way it works is very simple. You

press a number and it plays that particular variation, but they're all synchronized together. So,

synchronized together. So, Wow.

>> So that's that seems fun or silly, I guess.

>> Uhhuh.

>> But I put a YouTube video here for you to hear what Beethoven actually wrote.

So you hear how it's almost on every beat it just sounds very different.

There's loud, there violins, there's the orchestra. And I created these 12

orchestra. And I created these 12 versions of that that if you just let one play all the way through, it doesn't change.

>> So the idea is that you it's your job as kind of the musician to come up with some path through that maybe someone didn't think of before.

And you can record them if you want and share them with others and replay them.

So here's one that I made a couple of weeks ago.

So now I'm not clicking on those buttons. It's just playing back.

buttons. It's just playing back.

>> Mhm.

>> And if someone liked that, they could remix it and so forth.

>> That's awesome. Thank you so much for sharing Paul.

>> That's super exciting. I honestly didn't know Brian was known for dropping up his music that much, but that's good little music lesson. Thank you.

music lesson. Thank you.

Do you plan to share it?

Okay, great. So, I think it's just back to Erica and I. So, again, if you want, if you've got any projects that you feel like are worthy of the Bolt Showcase,

feel free to share them with me directly here. we can do our best to try and

here. we can do our best to try and promote those and help you grow if you're close to launch. So, I'm happy to be in communication about that with you.

And as always, let's say a big thank you to Erica for joining us in the chat. I

know we've had a slightly different format this time not being on Zoom, but hopefully it's been a little bit better.

Let me know what you think in the comments. As always, your feedback on

comments. As always, your feedback on Luma goes a really long way to helping us determine how much resources we should put into these workshops. So if

you like them, your feedback is always greatly appreciated. We've also just

greatly appreciated. We've also just recently built a page specifically for these past workshops. So if you go to workshops.bolt.host,

workshops.bolt.host,

you'll be able to find all of the previous workshops. We're also looking

previous workshops. We're also looking to build out that site a little bit more so that we can add GitHub repositories of projects once they're finished. And

then also, I think we'll be voting on workshop topics. So stay tuned there.

workshop topics. So stay tuned there.

And again, thank you so much everybody and look forward to seeing you next week. We've got office hours again next

week. We've got office hours again next week on Tuesday and then another workshop on Thursday. Hey everyone,

we're back and we're going to continue the workshop from where we left off. We

didn't quite have time to finish everything. So, we're going to jump in

everything. So, we're going to jump in and just get everything sorted now. So,

let's have a look at where we're currently at. We've got a little bit of

currently at. We've got a little bit of an issue where the header authentication of the HTTP request isn't successfully sending from NAD. So, what I'm going to do is let's just test it one more time.

At the moment, we're saying we're doing like a header authentication here. And

then we're specifying the headers just for certainty in here as well, but it's still not um creating any fix. So, what

we're going to do when we press execute step, we've got this issue, I'm going to take a screenshot of all of this. We can

include the input on the left as well.

come into bolt and let's just drag this directly into our bolt agent. This is a great way to troubleshoot if you don't exactly know how something is working.

So now we'll scroll down as well and we'll take a screenshot of like specifically the headers.

Whoops. Go.

We'll bring that over and drop that into bolt.

And then one more thing is this header or count. So

or count. So pass word. Hopefully the agent can understand

word. Hopefully the agent can understand that. So I'll take screenshot of that as

that. So I'll take screenshot of that as well.

Now let's bring this into bolt.

Let's have a look at our error. So

problem in node HTTP request and let's actually we'll copy this error details as well.

Great. So we'll jump into bolt and we'll say we're still having an error with the node in nan, I have copied

I've added screenshots for context.

Note that my password is where it is asterisked out.

I know that's not really a word, but they should understand it. And then

here is the error message from within N8N.

We'll paste this error message. It's in

plan mode. We'll see what Bolt says about this.

Okay, so the good news, the authentication is now working. You got

passer 401. The new error is a 500 server error about the database, not an orth problem. So the error says null

orth problem. So the error says null value in column ID. So this means the edge function is successfully receiving the request, but when it tries to insert

into the notices table, the ID column has no value. So what it should do is it should basically fix the edge function

and the database so that it's using the right data. So let's go ahead and it

right data. So let's go ahead and it says add auto increment default the ID column. Sure. Update the edge function

column. Sure. Update the edge function not to require ID column from the payload. Sure. And then clear up the NAN

payload. Sure. And then clear up the NAN headers minor. You currently have three

headers minor. You currently have three things sending the API key in the header. So plus two manual.

header. So plus two manual.

So we can remove the ingest API key from the header. And since that is not a

the header. And since that is not a recognized header name by the function, keep only X API key in the header. Okay,

great. So let's go ahead. We'll

implement this plan in bolts. Come back

in here. Do what they suggested. We

don't need this one.

Let this agent build it out. Great. So

the agent has finished building. It's

updated the database and the edge function. So it now should suit the

function. So it now should suit the payload of what it's expecting. Now what

happens if we press execute? There we

go. So node executed successfully. What

we'll do is we'll come back into linear and let's just change some of these to in progress and then we'll move them back to done. So we've got dark mode.

Let's change this one to please fix the user interface of the database.

Great.

Instead of a modal, please make it full screen so I can see more of the data.

And then so we've got dark mode on the dashboard written twice. Maybe we'll

change this one to say please improve the layout of the secrets.

When I add too many secrets, they overlap at the bottom. So here's some example issues. What we'll do is we'll

example issues. What we'll do is we'll change that to done. We'll change that to done. And we'll change that to done.

to done. And we'll change that to done.

So that should fire off our first NAD automation. And then instead of waiting

automation. And then instead of waiting for this time to happen, we're just going to hit execute. So now it's sending all of these items out. And what

I want to do with the AI agent is actually go into settings and we're going to hit execute once. So now, no matter how many different items we have

coming into it, it should be able to use all of that data and make sure that it only sends out one JSON output

database table. If we refresh this,

database table. If we refresh this, hopefully those new items. Yep. So those

new items that we just changed have come through.

Let's look back in agent still working.

It should hopefully send all of this out. Let's have a look at bolt. Okay,

out. Let's have a look at bolt. Okay,

here we go. So, it looks like it's kind of working. We've got the title. Here's

of working. We've got the title. Here's

the highle summary. So, the team completed a focus set of front-end UI and layout improvements to enhance usability. Adding dark theme improving

usability. Adding dark theme improving views where data and secrets were hard to read. So, that's the high-end summary

to read. So, that's the high-end summary that the agent in NAND was able to create. And then it's got the three

create. And then it's got the three tickets in here. So it looks like it's working. It's got the count as well.

working. It's got the count as well.

It's got the time zone. Now there are just sort of some final UI tweaks that we may want to make. So like for example, we may want these linear links

to be visible. We may want the dates to kind of be clearly shown. But you get the point. What we've been able to do is

the point. What we've been able to do is we able to move this data across over into Bolt. As soon as you publish this

into Bolt. As soon as you publish this project and somebody views it as like a live URL, whenever they refresh their page, their viewer, that's when they're pulling in fresh new data from the

database. And so, as I said, you don't

database. And so, as I said, you don't need to come in and republish to Bolt.

It's got all those added advantages of just streaming directly into the database and then sharing that here on your website. So, there we go. So, I

your website. So, there we go. So, I

know that last bit was a little bit hairy trying to work out how that header connection worked and how it works securely with that payload, but we got there in the end. And I hope you found

this video really useful.