Learn about creating mono context

protocol or MCP servers using fast MCP.

MCP is the standard rule set that allows

AI agents like GitHub Copilot and Gemini

to securely and intelligently interact

with your databases, functions, and

applications. Carlos Leon created this

course. He'll first define what MCP is

and its significance before getting into

practical hands-on learning across three

distinct coding scenarios. You will

build real world examples including

different calculator types using both

standard input output and HTTP stream

transfers. Carlos then explores advanced

techniques by showing you how to use

APIs to fetch dynamic content for an

agent. To ensure reliability, you'll

learn essential testing practices by

leveraging GitHub C-Pilot to inspect and

test your new MCPs. As a final bonus,

Carlos demonstrates the critical step of

deploying your MCP effortlessly on the

fast MCP cloud providing you with a full

end to end development cycle.

Hey, hello people from Prico Camp. I

hope you're going to enjoy this course.

It's going to be about MCP servers. So,

we're going to go what is MCP first and

then learn by doing it. And we have two

examples for that. We have uh two

examples of calculators in two types of

transport. So, SDIO and the other one is

going to be HTTP. And the last one is

going to be how to use a Fits parser in

order to get data about the new content

of PROC camp on YouTube channel and

their website. So, I hope you like it

and if you have more questions, I'll

leave the repository below. You can go

and see the code and also if you have

any comments, please leave them below. I

hope you like it and keep coding.

All right. All right, welcome to the

course introduction to MCPS. It's not as

sweet as expect. So let's start. MCP is

a model context protocol. So by protocol

means standard rules when you let some

AI agents to interact with databases

functions or in other words, it's like

teaching an agent to interact with

things in your own way. The types of

MCPs you got to find nowadays are two

mainly. The first one is standard input

output. So this is when you deploy

things locally. So it's like you are

running another process in your

computer. So you just let the agent to

connect to that process. So HTTP stream

is when you try to do external apps do

that. So it's for remote connections and

this for production things. So some

examples you can find like GitHub MCP.

So you can manage branches and WhatsApp

you can read some messages and also

send. So also there are more examples

built by the community. So you can just

check out some unofficial websites like

this one that is here and you can see

the list of things that people are doing

nowadays because this is now trendy.

Okay. So the question here is how to

build MCP server. I can tell two ways is

go to the official SDK that you have

multiple language to use or the two main

ones that we're going to use for this

course. The fast MCP and the fast API

MCP. The fast MCP is like you build an

MCP from zero. You know it's quite easy

to do it and you can do SDIO CBP. And

the second one is when you come from the

API and then you convert it to a MCP. So

we're going to use a calculator example

for that. How to test an MCP server. We

have SCP inspector. So when you try you

want to try things, you just need to use

this command that you see here. MPX at

model context protocol/ inspector. And

the command it's going to depend if it

is a SDIO or if it is a HTTP type of

MCP. And yes, we're going to use it

throughout this course. So don't worry

too much about it. But just keep in mind

that we have inspector test feeds. So

not only code and then you see what

happens, right? Yeah. All right. Now

this is the important part. I hope you

understand what happens here. So when we

build a SCP server, we need a client. So

this client is going to be a agent and

this agent if it's local, it going to be

like a g compil ji or the cloud for

desktop. So this when you connect to the

other server that it looks looks like an

app uh sorry like a process okay also

you can do uh through IDE like Visual

Studio Code or Poor they have some

agents inside or if you only use HTTP

you can use some external tools like

chat GPD or Mistra they have leat where

you can just use the the connectors

there to connect to the MCP server that

is now deployed on certain address. So

for this I will give you an example at

the end of the course how to deploy this

using a pass MCP cloud and we can going

to use the shut so going to be more easy

to understand. So first of all let's

start with the calculator examples as I

mentioned first we're going to start

with the library fast MCP and we just

going to build it with the type SDIO

standard input and output. So are you

ready for this? Let's go to Visual

Studio Code.

Right now that we are here, we try to

install the libraries. So we're going to

go p install pass mcp. That is all we

need for now. So take some time. All

right. After we do that, remember if you

want to use a virtual environment in

Python is recommendable. If not, then

just go just b. So here in a folder

we're going to create the file fastp

calculator.py. Don't worry it's going to

be on the GitHub as well. So you can

take a look that later because we're

going to go a little bit fast here. So

let's import the library that we need.

So the only mater

right no. So the first we're going to do

is from say from fast MCP import what

the fast MCP. Let me see if everything's

right.

See fast MCP. Yes.

All right. Now all we have to do is to

create the MCP object. So how we do

that? Say that it's going to be equal to

pass MCP. We going to give it a name. So

what is going to be the name of this

MCP? Let's say calculator. Yeah, makes

sense, right? on how we are building

some mathematical

operations here. All right. So we give a

name to our MCP server here.

Now it's time to use the decorator MCP.

That this means that we're going to use

a function. So we're declaring this

tool. We're going to use the keyword

def. That's for function in Python. Let

me give it a name. So the name of this

tool will be let's start with multi.

Yeah, multiply. Thank you for the

suggestions. Compile it. And then we're

going to say that the argument is going

to be type float. Are you going to

return a float? Is it important? Yes. As

you can you can skip that part, but you

can just keep it depend if you want

certain schema. And don't worry, we're

not going to go much into detail at the

same time with if this function is

synchronous or synchronous. For now,

it's going to be synchronous. So don't

worry too much. And this is the dock

stream. You see like some comments

there, right? This is important to let

the agent that this tool do certain

things like this is the description of

the tool this is really important and

maybe you might not think like ah this

is not important this is only for

developers no but now we are talking to

agent so agent need to read what this

function does that's why we use the dock

string this is very important in by

using this library fastmcp and of course

you can use it uh something like you can

say the tool specifically you can give

it a name that doesn't correspond the

name of the function and you can give it

a description that doesn't correspond to

the doc stream as well. So for that you

can you can see here like we also do

like tool and then we open here and we

can give it a name that we want. So for

this operation this is going to be let's

see we have multiplication. What else?

Huh? Let's maybe do addition. Let's do

it shortly. Okay. Add we add a

description about this. So you see it's

not visible like just add some numbers.

I can just do it like before like add

some arguments you know like put more

context of it. This is important but for

now we just leave it like that just to

give an idea that we can also do that

way or just do it inside the function.

And then for tax this is like a way of

letting the agent to access this tool

like maybe this tool is related to math

maybe this tool is arithmetics you know

just keep some at the end keywords that

recognize this tool. So now below this

we're going to build our function as you

know now we can just put another name

this doesn't really matter because the

decorator itself we put a name and a

description that this is going to be for

the agent and you can see here this dock

stream here is not going to be uh taking

account it's going to be the description

on top so you can do both ways but what

is the best for you uh I can tell you

choose. So let's build the the rest of

the tools. So we are here. Let's see.

MCP tool. Let's build another function.

Let's say subtract. Yes. Now we don't

need to specify too much. We already

have the doc name the function. So I

think this is enough for the agent to

know that is for subtracting. Right. You

see let's compare to the others. Okay.

Subtract multiplication and then grab

division. Okay. Let's divide two

numbers. There are float and the return

also we have the assert if it is equal

to zero then okay okay that seems to be

that we are almost there so now we need

to call this method the main when we

need to call a file this is going to go

to C first this is like the main

function let's say so everything that is

inside is going to run when we call this

file so we're going to run our MCP

server by just calling the MCPrun so

everything goes here and it's going to

run MCP. Let's see. And this is going to

be SDIO by default because we didn't

specify. So you can do do HTTP as well,

but for now it's SDIO because it's by

default. So we just run it Python. We

call the name of the file and then this

is running. But how do we test it? Well,

it's not that simple as it seems like.

There is no way to do it. You see there,

but as we talking from the beginning, we

need to use something like an inspector.

For this we need to go to the to the

folder that we are currently using. So

you see we are here in a scenario one.

So everything is correct. Yes. All

right. So now we need to type the

command on inspector that is mpx at

model context protocol. Well that's

pretty long. Let me see.

SL inspector. And now the argument is

going to be python

and the name of the file fast sp.py.

So you see now is the IO. This is the

argument that we need to send. Um of

course this is how it is

running. Okay. So now we have here the

interface on inspector. This is nice.

You click here connect and there you

have it. So this is how it looks like

the UI. So not much to say here.

Resources or template is for uh things

that you might see in another course but

resources you got to get like some data

um information where to access to to the

agent. The tools is the thing that we're

going to see the most. So the tools that

you see we just define them like some

functions and you see here the

description of the ad is different than

the others. Why? Because it's taking

into account the one not the dog string

but that one. So not like the other

ones, right? And yeah, that's the

difference between those tools. You see,

multiply, add, subtract, divide. Yeah, I

hope this is like I understandable here.

So let's test that and see if they work.

Let's try to add some numbers here just

for plain 10. Okay, let's run the tool

and see the result. All right, that

seems correct to me. What do you think?

Okay. So, that seems the multiply works.

What else? Ah, that's the obus schema by

the way. And yeah. Um, let's see what

else. Um, let's add some numbers. Okay.

And seems that this is correct. All

right.

Okay. So, I think for the rest you might

look like, yeah, this is going to work.

Uh, notification because this is um

STIO, we don't need it that much. But if

you want to HP, this is really

important. It's going to be like

advanced topic for prompts. This is to

tell the assistant or the agent let's

say to interact certain way. Resources I

tell is to let it to know where to

access what kind of information to

access. Um yeah, we're not going to go

more into detail into pro resources. And

here on the left we have transport type,

you have STIO, we have the Sce that is

deprecated, but we're going to use it

for the next example. Maybe sometimes

you see it but we don't need to use it

anymore. HP is the recommended one.

Environment environment variables. Yeah,

sometime need aification as I told you.

Maybe my token or or out and yep now

let's try another things. Let's see the

tools all the functions and yep we have

it over there. So are you ready to see

an example that we're going to use

another library and it's going to be

into HTVP where we start from an API and

then we go over to the MCPS. Okay, let's

close this first and then let's look

into the second example. All right, let

me close this. Okay. Okay. So now as I

told you the second is going to be a

calculator API. So now start from the

API and we convert it into MCP. For this

we're going to use pass API_MCP.

It's another library. It's not the same.

Remember that. And this is going to be

HTTP. And at the end of it, I going to

teach you how to do that with our

previous library. So first of all, let's

go here to

All right. Now let's go and install

things. Install fast API. This a library

just do the APIs. Now the fast API NCP

that converts the API into an MCP and

lastly our UI that's going to help to

deploy a server. All right. So let's see

and let's wait for a few seconds.

It takes minutes but you get the point.

So let's wait.

All right. After everything installed

then we're just going to create our

file. So let's see scenario two. Let's

create the file and you're going to name

it as

API.

Yeah, CPIC, right? That's quite easy.

Okay, there's going to be also I file

just forget that. Okay, we go that M.

Okay, let's put like calculator as well.

This is going to be long but specific,

right?

MCP calculator guy. Okay. So now as I

told you we're going to do first the API

and after that we're going to build

build it into MCP. So and yeah it's

protocol is going to be HTTP.

So I also did something here by default

is S S

but we should take into account HTTP

because it's the standard nowadays but

let's let's see. Okay. Now let's create

import the pass API. Let's try to create

our API app. So, okay, let's come here

just to get a reference. Uh how let's do

it. Um are we going to do your yeah

calculator, right? Okay. But anyway,

let's let's build a pass API app and

it's going to help us uh Yep. Just give

it here.

I don't want to come in there. Okay. The

app or the fast API just do it this way.

I will give it a name. this case is

going to be a title of the API. So how

we going to call that? As before

remember we use a calculator but now

just put API to just distinguish this.

All right. Now that we have our app then

we need to keep the endpoints of it and

you know we have some some standards

like we get post put and but for this

we're gonna be just post because we're

gonna send things and and get it back

right. So, so for the endpoint of let's

see the we're going to have the employee

multiplication it's going to be multiply

when we address this we're going to have

we're going to have like a parishion so

for this we create a function let's see

uh for this function is going to be

multiply numbers this float float yeah

makes sense right we're going to return

this

one field that's going to be the result

okay not bad I will say this kind of

compel this I I kind of like it now.

Okay. And here remember we cannot use

that like float. Not no we are using API

first. All right. This is enough MCP as

well. Um okay. Now let's continue with

our endpoints. It's going to add the

input of addition. So the same process.

Now it's going to go for subtraction.

And here we go. And lastly for division.

So you see here. Okay. So this is only

an API. Remember we don't have much here

to tell is the MCP. No, no, no. We

haven't even called the library yet.

Okay. So now let's try to run it. What

are we going to do first? Okay. Remember

just call the main function. So when we

call this, we're going to deploy as

server. And you see here it's going to

run here at the host. Yeah, it's going

to run our app at the host. Let's see.

Zero.

and the port so that is available by

default is 8080 but yeah let's leave it

at 808 80 is fine okay everything seems

fine and let's run it ah by the way

there's something that inel we try to

run it yeah let me go to the folder but

when we try to run it into

0000

you know this is going to be on our API

address so that means people can access

to our API address and that port and

voila, you have the API. But we don't

want that. As you as you see here, 00

doesn't exist, right? You need to put

the API address, but I'm not going to

show you my IP address. Instead, we can

change it to local host for now. Just

talking that we can just use the

computer for this example. It doesn't

have to be an IP address. So, okay,

let's try to run the API. So, going to

go here to local host, try to access.

And you see there's nothing but ha

here's the magic. Let's go to

slash

and then we put the input tax and then

you see like u swagger here where you

can see all the inputs that we have

available for the API and of course you

can test them. So here we have the all

of them are type post

multiplication. Uhhuh.

Addition subtraction and the division.

Voila. That's pretty much what we have

here. Do you want to check the schemas?

Yeah, that's another topic for another

day. So don't worry. And MCPS also have

schemas, but we're not going to go much

into detail. All right. So this is the

return time. is a JSON that they give

you some details. If you are more into

APIs, you already know this, but let's

test it out. So, you have here on the

right a button to try it out and we'll

put some values here

8. Try to run this and we got the

return. Yeah, that seems right, right?

Okay. Now, let's go for another one. So,

it says here 10 two. So, it should be

12. Let's check. Yeah, the result is 12.

And we can keep going with the other

functions. Sorry, end points now. And uh

it says okay, it seems that everything

works as expecting

division.

Yeah, it sure it should work, right?

Yeah, let's hope so. And yep, let's see.

As you remember, if you go without

input, we don't see anything.

Okay.

So now let's try to convert this into

MCP. What we're going to do first,

remember we have a library specifically

for this. Now we just try to see here.

Yeah, here's where I go with the SMCP

part. We just leave a comment and then

we're going to import the library just

you know for reference in case you're

going to go to GitHub repo and you're

going to check the file. Ah yeah, you're

going to remember this part. Okay. So

first of all we're going to call this

library. So we're going to import it

from let's see fast API.

Yeah. Fast API

MCP. And this is the tricky part.

Remember to import the name of this is

tricky. As you know capital A

MCP like this I yeah just remember that

because I made some mistakes in the

past. So just remember to keep it like

that and we should you should be fine.

Now we try to convert this API app.

Remember that the name was app at the

beginning when we Yep. We get the fast

API app and then voila that's how we

build the MCP. Now we converted but of

course in order to work you need to kind

of say the protocol and everything but

for now we just give it a name. Don't

worry. So for the name of the MCP is

going to be a calculator MCP something

simple. Now in order to run we need to

mount it somehow. So we need to say that

this MCP is ready to start. So we just

do it by MCP mount. And yeah that seems

to be there. But this is still not

finished because we didn't specify the

the format. Remember I told you by

default it's like sce and no http. Why

is that important? Because one is

duplicated no longer used. So yeah but

okay let's go with example first. Let's

try to run this and see if that works.

So we're going to go to the folder.

We're going to run this. We're going to

call Uber. So you see it's going to

deploy in certain

location. It's going to be in on at our

local host the port.

But yeah, you see the comments here, you

need to use something specific like HTTP

or something to specify what kind of

protocol are we using.

We are using here. So if you're http

let's go like that. Okay.

So okay now this seems that the server

is running. We are ready to go to that

address right and we need to find the

now that is MCP. We need to find the

input MCP. You will see that briefly

this. So don't worry too much about it.

Just remember that this is should be

clear enough but okay let's try to

access and we access again dox we still

see the endpoints over there. All right

but now the MCP part it's going to be

the endpoint of MCD. All right then

seems like yeah we cannot do much here

right like how can we access this? Okay

maybe we can just come prompt here. Um

yeah, maybe we can just like uh request

something from this address. Let's see.

Uhhuh. Should return something and I

will tell you no, that doesn't happen.

So uh how can we test something like

this? And of course this is where the

inspector comes. So let's try to run it.

And one of the mistakes that we can make

is that we can call it as a SDIO and

this is not like this. So you see here

this could be a common mistake that we

can call it like python and then we call

the name of this but no we are no longer

using stdio. So for this we just put the

address that's going to be local hostah

slashmcp where this is deployed right.

So that's how we can test inspector

and yeah let's give it some time to just

initialize and there we have it the UI

again. So here on the left you see

everything we're trying to connect but

ah that won't be possible because we

need to change something. Can you see

that? Yeah. Yeah. Yeah. Can you see it?

It's on the left top left. No. So yeah,

we can spend like a lot of time, but you

have to do this manually. So you can

check here the transport type. We have

STIO. So we need to change it into what

for now. We're going to use the server

and events as E by default. But remember

that we no longer use that nowadays.

It's created. But here we go. It works

that way for this example. So you see

the tools that we created now are into

MCP because yeah they're API but now I

compared to MCP tool you see nice oh

well um what else can we do here so you

can test them as well and also if you

want you can just go to the API so

that's the advantage of having this so

for multiply let's see okay let's try to

multiply two numbers again just to see

everything works run it and voila

You see

and let's see that addition part.

Okay.

Something that needs some improving if

you see is the description of the tools.

It's not like that customizable as the

other one. But of course there's there

should be some parameters that we did

change there. But at the end this is

what we have two different leveries. And

okay we got more things to change for

now. No. Okay. So, what if we want to

use the HTTP?

Well, uh we just need to change

something. Remember that SS is

duplicated. So, we need to change the M.

So, for this, okay, let me close the

server first. So, make sure that it's

not running anymore.

Mhm. Okay. Close it. And so, for this, I

ask you, we have the MCP mount, right?

That's what they call the gimbus server

side events. We don't want that anymore.

So, we just need to use HTTP. Here we

go. Just change that and we run it

again. So, let's see if the protocol is

running here. Yeah. Okay. Let me just

try to close this everywhere and try to

call the protocol again. Try to run the

server.

Let's run the server now in HTTP mode.

And finally the inspector. But actually

inspector we cannot close it just

refresh it. But well as a rule of thumb

we just try to you know restart the

things like the way we do things in a

computer sometimes when doesn't work.

You just restart it right.

Okay. So see that's should be the the

address.

Correct. Okay. Just let's wait a few

minutes here

and yeah. Voila. We are here. So now

just go to the transport type. We change

it to streamable http

one. We connect and we are there. Okay.

So now we just go list of tools and yep

you have it. Wy

the

working. Yep. Okay. We don't need to

test too much, right? already tested

with the SSC and we don't have any

errors. So yeah, this shouldn't be the

case as well.

Yep, that's is a second example. And if

you're thinking what are the other

things like resources, tools for this

needs to be

non display but oh yeah there are some

limitations still and we need to go to

implementation but we're not going to

use too much this library but I just

wanted to show you that this is possible

coming from the API and converting into

MCP. So what if you want to do this into

HTTP but the fast using the fast MCP

library the one that we use for the

first scenario. Well, that's kind of

simple. So, let's go to our previous

sample, the first scenario. So, we're

just going to close this.

This is using fast API because this is a

API.

But, uh I will change it to SVP. But,

you know, this really needs a API for

work, right? So, okay, let's don't talk

too much about it and let's go to our

previous scenario. So we just going to

go here. We're just going to copy all

that. And then we're going to create a

new file. So for this, okay, let's

create a new file. Ah, I'm going to call

this

calculator now version two because now

it's going to be HTTP. What's going to

be the difference here?

So here in the main function by default

is STIO. So when we want to http we just

need to specify that the transport now

it's going to be yeah you name it http

all right so also we're going to run a

local host at the port why do we need

that because we can tell the unicorn to

deploy this at that that address

okay so without more to do here let's

try to run

Let's go here. Um, okay. Let's we need

to change the folder. So, let's go here.

So, for this we need the command SD to

points. We go to SD and scenario one.

Okay, we are here in the folder. So, now

we just call Python and the name of our

file. Okay, since there are no errors.

Okay. So now we just need to do

something similar. Okay. You see local

host is running

and check our inspector.

So same address we should do. We can go

to the MCP endp point the same as

before. So we just need to do it through

inspector. So let's go to inspector and

check out inspector. We closed before.

So we just need to run it. And do we

have to go to the folder? Not

necessarily because this is HTTP. So you

can run it anywhere and just give it the

local host. But again, if you want to

try the STIO and anything, just go to

the folder.

Okay. So for this, let's check it out.

Since

[Music]

Okay, so the port was wrong. We did a

different port. Now it's 83. You see

resources we don't have. We don't have

templates prompts. No, but at least it's

activated. That's the difference with

this and the previous version. So, okay.

You have here everything looks in order.

Um, yeah, this should work. But now it's

different protocol. But just checking

again.

[Music]

Okay, that works.

Hey, 10 times. I'm sorry. I'm looking at

other numbers here. Okay. Uh um and

yeah, that seems to be the tool working.

Okay. So, that's the another way to do

it with only fast MCP. Um yeah. Now,

let's go to our next part. The third

scenario that is a little bit more

complex is going to be a feed search.

This has some applications in real life.

So, we're going to use something called

RS. That stands for reality sequence

indicator that is useful for

notifications. So it tell you about the

new content and pretty much just by

extracting the file. So we're going to

do this for the YouTube channel and also

for the website. So don't worry, we're

going to explain a bit how it works. So

you know when you go to the website of

free cap you can search for maybe some

courses, blogs or anything related. So

let's say search for Python and you're

going to see okay new courses. But if

you go to the RS, you know, if you do

that method, we're going to see what are

the new updates. So let me show you now.

We go to free cap and it should be yes

RS and you see this XML file that has

some new content of the website, right?

So it doesn't tell the whole thing but

at least this is where we're going to

extract some of the data and we're going

to

do like our MCP server to let a agent to

search on this file. So yeah, you see

here there's a title, description, the

content to tell you a little bit about

one of the entries, but what we're

looking for might be the titles of of

it. So it tells you about like oh maybe

a course or something. Okay, so that's

pretty much the RS that helps you for

notification, you know. So we don't get

too much. So you see that's for we

search about Python and now we search

about Python. You see some keywords

going on there. So yeah, there might be

some information about Python that's

coming to the website. So first of all,

we're going to install a fit parser. So

we're going to update this XML file and

then we're going to search for the title

or certain

tags in this file. So okay, let's go to

our terminal here. You need to install

it's called pf install feed. Uh what is

the name of this? Feed parser. Let let

me double check the spelling of it. I'm

you know not nice speaker as you have

noticed but okay check okay let me do it

again install fearser all right so yeah

yep that's the library that we need for

go onto the XML file and then just get

the content that we want so yeah we need

to go onto that file so for inance same

h those are the text what are the texts

that we we're going to look for all

right might be this one I the beginning

the title right so this is something

that might interest my might interest

interested us and later on we're going

to do this for the YouTube channel as it

as I mentioned it but for YouTube

channels not a process actually for this

we need to go to the to get the ID of

the channel so for that you go here

channel copy the ID channel and we're

just going to keep it somewhere uh let's

keep it here all right that's the idea

of the channel later on we're going to

see how to to get some data from there.

But for for now, let's focus on the

website. So, we're going to create a new

file here. Let's go to the folders in

our tree and then okay, how how do we

name this? You know, this is also a

dilemma every time that we create files.

So, let's put it um

what else to see. Okay, makes sense,

right? All right. So, what we're going

to do first is try to import things. So,

as you know, rule of thumb, we already

have working with fastmcp. So let's

simpize MP now our new library of fit

parser to take information about the XML

file. So let's create our MCP server

just give some name of it. Okay we're

going to say preode camp. Um

yeah kind of news but let's see. Yeah

actually it's a feat search. Yeah makes

sense right? This is what we do trying

to get to the feet and then get some

data from there. It's not the ideal

solution. you know we can get an API

instead but we haven't found any API

yet. All right. So, MCP tool here. So,

we're gonna create our function. Let me

see what are the suggestions here. So,

yeah,

goes close to that. But let's do it

manually. Okay. Search. Give it a name.

So, the queries. Yeah, we might need

maybe to search for a certain keyword.

So, this will be our query. What type

will be our query? Yeah, maybe text,

right? So, let's put as a string. And

then okay maybe we have a lot of

results. So let's say maximum results

going to be an integer. So yeah we not

might get like a lot of results but just

in case. Okay let's put a string by

default. And then we we just add like

some do string just to let the agent

know what this function does right as we

can just add the return type on top. But

yeah it's up to you. As I told is very

much about the schema how you want the

output but we don't go too much deep in

the course for this but all right so

let's go here let's say it's a bit about

description something simple enough but

you can get you can get more deep into

that right so don't worry too much so

okay search code

and yeah we're going to get again title

and there should be another tag that we

are looking for here let me see

description might work. What do you

think? Description can tell you a little

bit about it. Okay, the title and

description. Okay, that sounds perfect.

What do you think? So, we go to the

website, get into the feed and search

for the for the tags of title and

description. All right. So, and here the

suggestions tell us that go to certain

website. Yeah, I like it. Let's go here.

So, the fit uh it's going to be fit.

Uhhuh. You're going to select the parser

here and then we're going to tell it to

go to certain website and the website

looks

Yeah. All right. That's the one here as

no feet. All right. Yep. Now we going to

say we're going to parse on this address

and then we're going to have a list of

results empty by the way. So we're going

to add there our results. So for this we

need to add a selector, right? Let me

see here. for the query we just need to

put it lower you know sometimes we don't

we put something in menu so as this is

something like standard that we do

sometimes so for every entry we say like

okay we need to get um information about

the title so we go to entry dot the

title and for description we're going to

do similar thing so you see

if you So,

okay, let me search

or something.

Um,

yeah, only description. Okay, so they go

again description here. It's going to be

similar method. So, you only get the the

text of description. We not get anything

else.

So, let's see. Let's see if our query uh

is in title, we're going to put it into

the list at the same time. If it is

description part of the you know um the

keyword then we just going to put it in

the results.

So yeah that's pretty much if the query

let's say a keyword python is eaten

title or description we're going to add

it to our list. So this is what we're

going to do here and for now we're going

to just add it to the results by call it

append. So we're going to append this to

the list and what is going to be that.

Okay, here we go. 10. Yep, I think it

could work. We can add content and the

URL could be important as well.

But okay, let me Okay, let's put

something like a title like this.

Yeah, that correct. Let's see what are

the other things. URL is it's important,

right? Because we need to refate

somehow. So, let's get it. We haven't

got this. So you could do entry you know

the parser somehow

I get the text link the content of that

and the description we already extracted

so not much of a deal here check

everything working l okay let's delete

description

just let's get the link okay if the

length of results is larger than the max

of results we just um break some down

get out of the loop here but This is not

going to happen as I told this is a a

feat. So it's like you don't have like a

lot of results here but anyway and then

return all the results on let's take

something by default like there was no

results. What do you think? Let's see

here the suggestions and they say yeah

just just put something like okay they

say yeah message like oh the results

were not found. Okay so sounds good. Are

you ready to test this? Okay, now that

we got our function about feet search

[Music]

looks okay. Please let me know if you

can also improve this function on the

comments and you will be happy. Don't

worry, this is going to be also on

GitHub so you can check out this later.

So for now, let's go to our method of

main and let's start our MCP server. So

for this it's going to be MCP run and by

default it's going to be SDIO standard

input and output. So it's going to run

locally as a program. So okay, let's try

to see if there are any errors or

something going on. Let's run it first.

Yeah, it seems that there were no

messages going on. Okay, so now let's go

and see the inspector. So for the

arguments, we're going to add the

command Python and the name of the file.

So here we go. We're going to start our

CP inspector to see if this is really

working. All right. So looks here

arguments. Okay, let's connect.

All right, now we are here. We got the

tools. That's all the things that we

have activated here. And see the

function here. Okay, we query and where

are the results? Okay, so we found one

how to run Python and we have the URL.

What do you think? We can also add the

description if you want, but we only got

those things. So, if you go to the news

and you see, yes, the title looks there

and the content makes sense somehow.

Okay, we did get description, but can we

see the link? Yes, it seems correct. So

we found it somehow we we got to extract

the URL and we got to extract the title.

So this is the content. So now there is

a tutorial by our friends in fre on fre

campam. So perfect. Let's prompt

engineering. Yeah, makes sense. So it is

there. Okay. So at least got this

prompt.

All right. Perfect. So there's another

entry here. Okay. So that's how the new

search work. Now let's go to copy the ID

of YouTube channel. As I we mentioned at

the beginning, we need to create the ne

next function or the next tool. Now that

we're talking about MCP. Okay. So let's

get back here. So yeah, let's create the

MCP tool. You know this add the

decorator mcp. tool. And now you create

the function. This this is synchronous

for now but you can make it as

synchronous if you want I would

recommend as synchronous because you

know you can run this you know like not

nonblocking so it doesn't wait for other

process to finish. So yeah any case just

let you as a homework so don't worry. So

okay sorry I'm talking too much and I

already did a lot of stuff here. So we

do the query again. Max results the same

logic that we did for the P um function.

So you see max results. I don't think

this is going to be a lot of videos. So

let's do it by default here. So for this

we're going to give a description and

again what we're going to say we're

going to search has the name of Frs

Vel.

Yeah, kind of makes sense now, right? We

are just using title here. I don't know

much about the YouTube

uh file, but we're going to do simply by

at least by my by title URL. All right.

If this is and then we give the address

of it there's a specific address for

YouTube. So if I Google it, I know that

is the YouTube channel. So for this we

go to YouTube channel. Uhhuh. Pretty

much the feed section. Now the video is

XML and then you need to give the ID of

that channel. So for the ID we already

extracted and we're going to just go

here copy and paste it. All right. So

that seems to get us that file

and yep. So here we're going to go a

little bit blindly blindly. So this just

pay attention to this. I hope this

works. If not I just going to fix it.

But don't worry this is the course. So

okay just going to do the results here.

the query the same process that we did

before for an entry and all the entries

that we have let's say we're going to

iterate here and okay you're going to

search for yeah we're going to have a

title and somehow the URL kind of the

same thing that we did before so yes

kind of copy paste let's say so yeah it

should give us an XML that looks similar

to our previous one and we're just going

to categorize everything by title and if

the title is

the the query is in the title. Okay,

just go to the list, append the results

and the link. So we not look for

description here, just title. Okay, so

now we return the results or we send a

message that the results were not found

again. And voila, that's pretty much

just kind of co copy paste of the

previous function.

And with this, we can just start running

it. But let's

check if we have any errors. And no,

it's running. So, okay, MCB Spectre, we

run it again. Ah, we close it. Okay.

Anyway, we we restart it and here we go

again. So, connect

drive in. And now tools. We have two

tools here. Tools. Yeah. Let's go to

YouTube search then. So, I don't know

something about title.

Found something. Yay. Yes, we found it.

So, there should be a a new video

coming.

Yeah, I got a aent with Python.

All right, that's perfect. So, it's

quite recent. So, you see that's why we

use the fit because it tells about the

recent updates. All right, let's see

another query. What do you think? Um,

hey, what what can we do? AI.

Okay, we have Okay, two videos to a GTKI

uh using AI as a accelerator. Good.

That's good. That's good. So it seems

working.

So what do you think? Uh now we are

ready to get like a real life example as

you can use it for other purposes. Maybe

some websites that you have in mind or

maybe you have an API instead of just

using this method of the RS. Right? So

yep. And also we're going to create

another tool. This is for giving you um

secret message. So for example, you have

your own way to you know to tell certain

things like I have a secret message. So

so the agent will try to find this

secret message that we have. So over

there are we going to do this as a

function? Let's say okay let's return

secret message.

Okay. Uh what do you think about sub

secret? I think there's no recipe to

code. So everything that we have to do

is to keep exploring and of course um

keep coding. So you're exploring and

happy coding sounds perfect what you

think and don't forget to leave your any

thoughts here on comment section. So get

creative I will say just if you have

more messages it would be great. All

right so yep that sounds cool. Um

description return message of free cut

camp

[Music]

have been cutting. Okay, that's perfect.

Um yeah, we're not going to test that.

You already know that that should work.

It's just a message. So all right, now

we can go to the next part. We can go to

connecting our MCPS. So for this, it's

going to be directly into VS Code. So

for let's go here. We're going to create

a file that it's mainly work for VS code

configuration. So we're going to go to

the folder VS code MCP JSON. So you see

here MCP JSON it going to give us the

information about how to set up MCP and

this only for V code. Remember we need

to go to the VS code. So for that we're

going to open brackets. We're going to

get the keyword servers and here we're

going to put the information about the

NCP server. So for this we need a uh the

title of the HTP server. You see you're

going to put a calculator. The command

will be how you going to open or start

the server and the arguments. Yeah,

they're going to depend if it's SDIO or

HTTP. So yeah, and the address where is

uh the path sorry and the password is

your your file. So for this let's say

we're going to go for the scenario first

scenario.

So the name of the file is going to be

SDIO for now. So

py the first one that here and the

command python and here we don't need

environ environments will going to be

like a token or notification to you

might have here okay so command will be

python by default but since I'm using a

virtual environment in python I need to

put the full path where is my python

file so I need to go here to the

okay to the virtual environment where

where I have the folder virtual

environment so if you didn't install a

virtual environment you put Python I

should work for my case I need to find

the PythonX

and there you have it so I need to cop

the full path and Mhm. need to change

here the

slider.

That looks better. Okay. So now you can

avoid that command or just put Python if

you don't have a virtual environment.

Okay. So that should do the job for

this. You tell the V code to to add this

MCP server.

And also you can do this manually but I

haven't really tried that way. I I've

seen that they have a functions a visual

code to do it but it's not that clear to

me yet but I hope this one works and

it's quite clear for you. So if you have

another method please let me know. Okay.

So what we're going to do here as I told

you can this automatically here like

kind of go and add a command to run this

is going to be Python blah blah blah but

it just gonna give you an ID and this ID

I don't know where it is. So yeah, it

was looking quite confusing. Let's open

the agent mode here. And now you're

going to have an icon of the servers.

You have the agent. Yeah. Go to the

method of agent. You can choose the the

model that you you want or at least you

have access to. And then you have the

icon of

kind of servers here that tell you how

to runa. So to run the MCP server and

it's kind of running somehow,

but you need to be quite careful. So

let's go here to this area and just make

sure that it's running or not. So here

you see somehow it's running but we

don't see it. So let's go to the output

problems the console or something. No.

Okay. So let's stop it. Restart it. See?

Okay. So now we see it somehow. So let's

see if it's running. Yes, it's running

with transport SDIO. Okay, so it seems

that the configuration was correct. Now

we can make use of our SCP server. So

it's going to go to the agent mode. And

here we're going to try to maybe ask for

a something that we already have in our

MCP server, right? So let's see. Okay,

let's multiply three times two. And it's

going to wait for the result. Uhhuh. So

now you're going to ask us to run our uh

a function in our NCP server tool sorry

a tool. Okay. Okay. And voila you have

it. So the protocol is going to be six.

So that means it works. Also if you had

a different configuration of

multiplication it going to run on that

point. For example you can set a

multiplication to power off in your SCP

server. You're going to get the result

of power even though you have the

function assembification. But okay. So

here is just the summary what you can do

at least you can see the configuration

file here as well what we have just done

and yeah voila that's the first one so

there are two more to go okay so let's

go and create the second scenario so for

this one was uh HTTP do you remember

that yeah so we do something similar but

okay I going to do this again and then

we're going to copy inside the keyword

of server So this one gets a little bit

more clear again,

right? So for this we can just copy

paste what we just done.

But this is going to be a duplicate. So

later on we're going to put inside one

keyword server. All right. So okay,

don't worry. We're just going to do that

in a moment. So let's focus on this.

First of all, we're not going to use the

executable Python. But here we need to

change the name to HTTP first. Okay. For

the executable, we don't use Python.

It's going to be HTTP. Is it? So we need

to connect to a server. So for that

we're going to use mpx command and here

we're going to have something really

important here. You need to put the

keyword mcp remote so that you tell it

that this server we are using something

remotely right. So you need to connect a

server somehow. So you got to connect at

this address. So if it is deployed

somewhere you have to put it slashmcp.

Okay. Okay, so this is running local

host at this port and the MCP is running

at this endpoint. All right, so that

seems correct.

But is it enough? H there is something

wrong. I told you at the beginning we

can we need to put it somewhere inside a

keyboard. Aha. So this is not enough.

You see this code start to give us some

hints there that something is wrong. So

well yes. So we need to put everything

inside one keyboard servers otherwise

it's going to be messy. So here we go

again. So this copy mark here the name

and then the commas and everything.

Okay let me just go here command. Okay

sorry if this was not that um you know

clear

but yeah now it does. Let's go to agent

mode and see the icon of servers here.

Trust our own server. Yes. Okay. So this

is will try to connect to the MCP server

somehow

to connect to that address but not

really running it. you will see what I'm

what I'm saying here like okay so how it

says like okay there is a server running

here right so let's restart it so it

tell us about like connection error da

da da da okay so that's what it tell us

is that there is nothing going on that

address so what we have to do is to go

to our terminal at the server now in

http mode

all right so we can deactivate the stio

so we only focus on the MCP of HTTP to

see how it works. So let's go this far.

We see that it's not running. It's only

HTTP connection.

So let's say multiply two times by

and okay. So this is by default by the

agent. It's not something you know using

the RMCP. What can we do? The

configuration is correct. At least it's

accessing it. But something is going on.

Okay, we're going to try to implement

the tier one and then I going to show

you the the solution for this. So let's

do this simply. Okay, for now we have

the the feet as well and we're going to

add Python because we are using a

virtual environment. We just need to

tell the scenario tree is going to be

the name of the file. The name of the

file is feet

score mcp. Okay. So after doing this

configuration on the third NCP server

then we can fix that part. So let's

double check if on extension we find the

new one. Yes. Yeahp.

Correct. Okay. Let's try that here. MCP

model is where you can choose what kind

of model can access to your SAP server.

So this is what what happened with

previously. So we didn't say

specifically to the

let's say like the UI over visual studio

code to let compiler to access to

certain MCP servers. So here you need to

tell it exactly what kind of agents have

access to what kind of MCPs. So yeah, we

see here configure mode access and you

can tell okay only three mini only cloud

can access to this or yeah so that's was

the thing that we miss but now should

work without a doubt. Okay so that one

now let's just yeah

looks good. Mhm.

And yeah let's try here. So

I just tried that before.

Okay. Now we can say we like to find if

there are any

courses in let's say precook

but related to Python. Check.

Now it should run the MCP.

Uhhuh. Yes. We're going to query for a

Well, it's quite long. Probably is not

going to get any results. We need to

find by insert by keyword.

Uhhuh. As it goes to YouTube channel.

Yeah. Probably is going to not going to

find anything. You see, it didn't find

anything there. Okay. So, we need to

tell the to act to try to search by

keyword instead of like a sentence.

Okay. What if you make the search

easier? Uh

just search by keyword and actually this

we can do it on the dock stream. We can

just put like search by keyword instead

of just you know say it to the assistant

multiple times. Yep. Let's run this part

and also go to the YouTube

and then we need to get the results. You

see here all right we have it. So for

the on the website we get this and from

the YouTube channel we get that. Okay.

But there is something missing right? We

didn't get the link somehow.

Okay. So we we can actually put linksh

and it can ask us to open the Yeah. I'm

not going to open it now, but at least

we already tried it and we know that

those URLs are correct. Okay. And now we

tell we are on a mission.

And then we need to get a secret

message.

Cam. All right.

Can you pretty much

tell me anything about it?

Okay, so you you know now Legend knows

where to find this message and goes to

that and returns the secret message. So

what do you think? I hope you like this

tutorial. It's seems to be a little bit,

you know, fast in that way, but I hope

you enjoy it and give you an idea how to

build MCP servers. So yeah, the next

step will be you can deploy MCP server.

You can keep reading the documentation

of course keep exploring because this is

a trendy topic nowadays and people are

building stuff with it. So yeah and for

the next step this is a bonus part. I

told you that we going to deploy MCP

servers. We have we have cloudare Google

cloud and also this option that is in

beta now the fast MCP cloud. So the ones

from the same library that we use for

the mainly this course. So for here you

need to create like an account go to

your GitHub or email then you need to

create a workspace. So for this we're

going to go here and put a name that we

want camcp

and yeah we need to connect to our git

in order to connect it to a repository

right so okay we need to tell it where

it is. So for this we need to create

like a repository. I already created

this but we need to load some code and

you might ask yourself like hey wait you

didn't give me any code for this. Um

yeah we we haven't create anything ready

ready to be deployed. So the closest

thing that we have here is the fit right

uh kind of fit search. So we're going to

here I create a new folder. Okay I

create a file here then and then we

create a folder with this. So the folder

we're going to be deployment

slash now the name of our file that's

going to be fit. Okay, it's going to be

something like um

okay something simple fit fine and we're

going to copy what we have just done and

we just going to change the

configuration from SDIO into HTTP. So

pretty much now the the transfer is

going to be HTTP instead of SDIO because

we are going to deploy something. So for

this we're going to just say okay HTTP

but we need to specify exactly

um see as we did here you know the

transport

so let me check transport is going to be

HTTP what else about the

the port and the rest I'm not so sure

about it since I don't know how it's

going to happen in that platform but at

least we know that the transfer For now

it's going to be HTTP. And of course, we

need to also get like a requirements

file. So instead of just confusing you

in the GitHub, you know, this is going

to be everything here. I going to call

it requirements deployed. You can name

it as you want. The only things that we

need for deploy this

file, you know, we need the fit parser

that we just installed and the fast MCP

library. So those are the only two

things that we need and they're

important in order to let know the

platform where to find and install

things right in order to deploy this

server. So okay we we upload our file so

you finding them. Um okay and I going to

tell you that what we have to do now

here. Okay just put a name of your

server whatever whatever you want to

call it. Uh for this example we're going

to say fre camp. Um okay feet recode

camp hemp yeah okay okay no no one is

using it so that's good notification do

we need a notification for now okay this

is really important right but since we

are just for testing purpose this is

like a button section I just going to

disable it but don't do that please try

to authenticate all the time scable no

for now resources okay we can select

like one of the hard what the hardware

that they available but not for just now

and requirements. This is very important

by the way. Um you need to you need to

tell exactly what is the main file for

the entry point. So for our case

is the fit.py

and also the requirements. This is

really important as well. Requirements

you need you need to tell the name of

the requirements file. So for our case

it's requirements

deploy.txt.

Otherwise, it's going to look for the

default that is going to be requirements

txt

txt but um it not going to work because

we didn't specify the requirements. So I

try to rerun it again now by changing to

default requirement txt or going to

configuration and then tell it to go and

search this file requirement txt that is

default or requirements deployed as we

have at the beginning. So either case

should work rename as a default or

specify it. So yeah that was the default

and the past and we change it. Okay so

yeah after testing it I hope that I gave

you the idea that you need to it's

really important to put here the

requirements file. So I told for our

case it was requirements deploy

but yeah anyway so it's going to run and

now we can think about where to connect

it like now we're going to use external

tools here at least in this platform you

have some examples you can connect it to

at least maybe the SDK OpenAI

uh how to connect it to the

uh what is the OpenAI codeex right the

cloud code cloud desktop. All right. Um

yeah, also they have an interface you

can just test it first. So you have the

chat MCP. You see MCPS that are tools

that are available. So let's ask him

similar things about what we

done in the course.

Yeah. kind of course with keyboard AI

and yeah should be returning something

right you know blah blah blah and by the

way this is going against synchronous if

you want to do this in parallel please

try to do a synchronous but as I told

you I'll leave you this as a homework

all right so I found something and aha I

got it to ai and later okay that's great

right So,

we are just going to waste some money by

saying thanks to the agent. I'm just

kidding. Don't do that. Sometimes we

need to be nice, right? So, clients

here. Okay.

What else do you think? Where where

should we connect this? I'm thinking

about going to Mistral and address. So,

let's go to chat mist. The connectors

and then you can add the connector here.

Then custom connector. Give it a name

that you want. Okay. So, let's going to

copy the address of our MPCB server.

Okay. Now, the description of it is

really important.

Let's say just for your reference.

Notification method we don't have for

now, but this is really important. Ah,

okay. Name is connector names required.

What is happening here? Ah, we didn't

put it. Sorry. Uh, needs new glasses

here. Okay. Let's put it here then.

Tricky camp. And then description you

can just tell about something

um random. Okay. Search and

or information related to free co right.

So cap and perfect

this should be all together. So that's

fine. So after this we notification and

sure connect.

Okay we have it here now in on the mist

track. All right. Okay. So, let's go to

the chat and then we try to ask

anything. Let's check the connectors.

Yeah, it's on. So, just asking a few

things. Can you search by keyword

if there are like any courses related to

w anything? I already know that I it

should work. Um, wow. An idea. I mean,

maybe

to UI

pretty cool camp. Yeah, I was going to

just search something randomly, right?

So, let's wait for the chat to answer

us. And yeah, it ask us to run the

tools.

Yep.

And it's doing it. So, this is great,

right? So now you know exactly where to

deploy how to use external tools and

maybe you can even create like business

around it. You know there are GPD

rappers nowadays so why not so related

to MCPS.

Okay. Okay. So now you have some results

here. Okay. Let's focus on it now.

So

[Music]

okay interested. Uh I remember that we

only found like something related to the

title and the link, right? But now it

give us some description. So ah nice

that at least the agent give us an idea

about what they are about. Okay. And now

we need to ask them about the secret

message. So

let's see

if it can. Okay. Let's check if you can

find it. And you know the the

possibilities are infinite like you can

even create your own algorithm of

encryption decryption or specific ways

to do multiplication. If we just go back

to our example the calculator this is

the possibilities that you could do with

the MCP. It's pretty much giving

instructions to the agents to do things.

All right. So that was it. Uh I need to

tell you to keep exploring the happy

coding. I hope you like it and don't

forget to leave your comment. I hope you

can uh keep being more stuff, right? So,

voila, that was it and thank you for

camp and have a great day.