All right. So in this workflow, we will

start by fetching a product from our

Shopify store and then we will check

first if it needs context. And let me

just try and start the workflow here. So

basically we'll check if it needs

context. For example, if it does it have

data, does it have a description or you

know product attributes and if it does

not have it, we'll use OpenAI to do

product research of this product. So

it's actually able to search the web. So

it can search and uh in this case we'll

use it to search information about our

product and and this information it's

going to use in a later step for the

product description to write a product

description based on that context. So it

can take a while and in my test it can

also become a little bit expensive if if

it does multiple web searches. So

sometimes it does like five or six web

searches and if you use an expensive

model for example the newest GBT5 it can

become quite expensive and in some of my

tests it cost like almost 50 cents per

run and in this workflow we have several

calls to an LLM. So one full run can

potentially become very expensive

especially with the the search here.

Sometimes it will have errors. I've

experienced that sometimes it doesn't

really understand how to, you know, take

the the query into the the API calls,

but uh most of the time it it it does

work, but that's something I will need

to to fix. All right, now that it's done

with the web search, it's going to merge

some data and pass it over to OpenAI. So

again, we use actually OpenAI to check

the existing description if it conforms

with our requirements. And if it does

not, we're going to prompt the LLM to

write an a description. And so it's

going to write the description based on

our requirements that we put into the

prompt, but it's actually also going to

do an internal link to a relevant

product in this example. So I actually

hooked into a tool which allows it to

search for products on our store.

After it's done that, it's going to

prompt the LM again to test if the link

works that it got from the search

products. And if it does, it's going to

pass it to Google Sheets. So you can see

now we have a description that's ready

and we have a uh let me see we have yeah

so we have a link here

uh that you can see here

and then it's going to continue to write

a title tag. You see it actually also

written a title tag already. So for the

title tag it basically checks the title

tag if there's an existing title tag and

what length it is. It's going to set a

counter because we uh want to make sure

that it has a correct length for the

title tag. Then it's going to write the

title tag with the context from a

previous step. Increment and then check

the length. If the title tag is not

within the length that we specify, it's

actually going to increment this count

and then do it again until it gets the

correct length. So you can see here it

was correct and passed it over to Google

Sheets. And I see the meta description

is also ready.

So then it's going to go over here,

check if the product that we fetch in

the first step has a meta description

and if it's within the correct length.

Then it's going to set a counter, write

the meta description based on our prompt

and requirements, increment the counter

and then it checks the length of the

meta description. If the length is

correct, it's again pass it to Google

Sheets. If not, it's going back and

write the meta description again. And

then I've said I I put this counter here

uh where I increment the counter. So we

don't want to just have an infinite

loop. We want to stop it at one point.

So like if it if there's a case where it

cannot get the correct length like at

all, we have to stop it. Otherwise, it's

going to be very expensive. So in this

case, we just don't do anything. We just

skip it. Here we probably want to record

this somewhere in our system that hey

this one we had an issue with this.

Could not write the meta description. So

maybe we just do it mainly. But in my

test, and now I've done this quite a few

times, it seems like OpenAI has gotten

really good at writing text within a

certain length. So, and I've done many

tests and I have I have yet to

experience one time where it did not fit

fit within the length that I specified

in the prompt. All right. And so, for

the product description that we we

wrote, let me just copy it into uh

Shopify here. And then you can see how

it looks like. And we have so this is

based on the requirements that I've u

specified in in the prompt right and

then you can see here that we also have

a link to a different product than this

generator. So we have this generator and

you can see here that it will recommend

another generator. Uh so let me just try

and um see if this works. So we have uh

the link here and this I can pass over

to my website here. So you can see here

it actually found this product that it

recommends. So this is kind of an

efficient way of creating some kind of

an internal linking between products

that is relevant to each other uh where

it simply just hooks into our search

engine and then finds a similar product

based on the the product title in this

example. So yeah, that's how it works.

And for the next step, what I'm going to

add to this uh workflow is another node

which will generate product features. So

for example, in the example of a

generator, we can we can you know get

information about like the you know the

power of the generator, what kind of

fuel is it, electric, does it use gas,

diesel and stuff like that. Get all

these features of the product and we can

use that as filters on Shopify. making

it easier for people to search uh for

products in case we don't have this data

already and especially if you have a

very large store with thousands of

products. This can be a very big task to

achieve if you're going to do that

manually. But actually using AI and

using N8N, you can actually, you know,

uh do this much faster than you would

otherwise have done if you did it

manually. You could also go and add a

human step into it. So for example, an

idea that I'm tinkering with now is now

I've added all the data here to my

Google Sheets. I can do that for all the

products. We could also go and actually

have, you know, a manual check within

our Google sheet. For example, we add a

checkbox here. And then if we check it,

that means that it's approved. And then

we're going to have our workflow

actually populating Shopify with this

data. But that's the next step. So, this

is just an example of how you can create

a workflow using this system here and

automate a lot of the boring tasks that

you might have in your Shopify