So before we dive into the components of MCP, let's talk a bit about the general architecture and the
goal of MCP.
And let's recap on that.
So the model context protocol supposed to standardize how applications provide context to LMS.
So context to LMS can be very thin.
So context can be additional information to the prompt.
A context can be maybe which tool to invoke.
And a context can even be the prompt itself.
And I know the last sentence sounds a bit funny, but I'll show you an example of it in later videos.
Once we have a standard that becomes popular, then we start seeing insane things that are being built.
So take for example, this MCP server that Eric Dickerson wrote to cursor.
And this MCP server is going to give the AI application which is cursor in this scenario to order food.
Now you can see in the prompt he wrote I want fika.
Where can I get kain Cane wool.
I have no idea what it is.
Actually, I don't know what thicker is as well, but let's see what it will get.
And this MCP server is connected to his Uber Eats account, so he gave cursor the capability in tools
to find the menu options, which he gets.
Then it goes and it's going to filter by cannibal.
And then it goes to get those results.
And then it's going to prompt the user to order it.
So it's going to say yes I want to order.
It's going to invoke the Order Food tool, and it's going to order this in this dish.
And let me show you what he got.
So this is a kind of pastry.
It turns out it looks delicious.
But the point here is that you can do insane things with it.
And here is the open source repo, which I will, by the way.
Link.
And because MCP is like the USB-C and let's say this MCP server is like an external device, we can
go and take it and connect it to another AI application like cloud desktop or windsurf and it would
work as well.
Now notice I'm not talking about summit 3.7, for example.
I'm talking about Cloud Desktop because Cloud Desktop is the AI application which uses under the hood
the models of anthropic.
It can be our own AI applications that we build, as long as we follow the protocol and implement it.
And we're supposed to see this in the course as well.
And this gives a very convenient way to plug and play to our AI applications.
Again, not models directly, but the AI applications.
So we can connect them and enrich them with external data sources and tools.
And we'll cover it later in this course.
Alrighty.
So let's summarize the advantages we can see in the documentation as well.
We have a huge list of integrations and tools and data sources we can plug and play to our LMS.
This is number one.
Number two is that really the core of AI application development is the fact that we are not coupled
to any LLM vendor or to any AI application builder.
So we simply need to write our tools that we're using.
And this is the core functionality.
And we can migrate and use them in different vendors, which is very convenient.
And by the way, link chain, the open source framework does this as well.
But I will make a video really comparing the two and seeing how they blend in together and what value
does each one give.
There are some problems in AI engineering that they both solve, but each one does it in a different
way.
Yet those ways that they solve those problems do not overlap.
So for example, the plug and play capability.
But we'll dive deep into this when we'll compare link chain and MCP.
Alrighty.
So in the next video we'll cover MCP, the model context protocol core components.
So let's list them.
Right now we have on the left side the MCP host.
So this is for example Cloud desktop an IDE like cursor or windsurf or any other specialized AI application
like an agent that supports the MCP protocol.
And those are the application we're going to augment with the MCP protocol.
So we're either going to give them external tools that they didn't have, or maybe connect them to a
data source that they didn't have access to, or even to specific prompts.
Cool.
So this is the left side.
And on the right side is what we're going to augment those applications with.
So it can either be some access to external tools like making a certain API call, like getting the
weather.
It can be searching in a database.
It could be knowledge and information like PDFs, like a lot of text.
And the list goes on and on and on.
All right.
And now it's time to talk about MCP servers.
And the servers are the component that will expose those resources, those tools, those prompts.
And they will be the proxy, the gateway however you want to call it that will expose that functionality.
And in order to expose that functionality.
So this is the actual protocol.
It needs to have certain methods in certain functions.
For example least prompts, get prompt list tools, call tool list resource templates, and progress
notification and we'll cover it in the server section once we implement MCP servers.
The point here is once we implement an MCP server, then we can basically connect it to any MCP host
that is supporting the protocol.
I mean, if I call it an Sapi host, this means it does support the protocol.
So this means we can write functionality once and then plug it to, for example, many, many MCP hosts.
So this is the big deal over here.
And this is what is so game changing.
Cool.
So in order to connect those MCP servers into the MCP hosts.
So for example, let's take the concrete example we saw earlier in the course.
We want to connect the weather map server into Cloud Desktop, and then we'll need to do it with an
NCP client.
So the NCP client and again we'll cover it in depth in the course sits inside the NCP hosts.
And it's going to be able to interact and to talk with the NCP servers.
And they're going to do this via the MCP protocol.
So this is the language that they're going to interact with.
And this is the protocol.
So it's important also to note, by the way, that there is a 1 to 1 connection between an NCP client
and an NCP server.
So you can't have an NCP client that talks to multiple NCP servers.
So NCP hosts, if you want to connect them with multiple NCP servers, then we'll need to have multiple
NCP clients inside them, and we'll talk about it in depth in the client section when we will be implementing
an NCP client.