Hey, they're eating here.
Let's talk about MCP model context protocol.
This is very hot right now.
Everyone on ECS are talking about it.
We're seeing tons of implementations of MCP servers.
We see a lot of people are using MCP within their AI apps like cursor, like cloud.
And the entire goal of what I'm trying to do is to make you become proficient in MCP.
So you know exactly what's happening under the hood, and you'll be able to use MCP servers and to build
MCP servers yourself.
So before we talk about why, I think it's super important to understand why do we need MCP.
All right.
So let's say we have an AI agent.
And we want that agent to be able to maybe send messages on slack, or maybe read and send emails or
make queries to a DB.
So generally we would need to implement those functionality.
So we would need for example, to see how to work with the slack API or the Gmail API.
And we would need to write some custom code that is going to be wrapped around as a tool, which we're
going to let our agent use.
Now most likely, For example, we would like even to write our own custom implementation to those tools.
For example, we don't want anybody to delete our emails, so we don't want to give our agent access
for the delete API in Gmail.
So the point here that we have some custom implementation that we are going to implement ourselves.
So we can do that, for example with a framework like LinkedIn, which also, by the way, comes in
with built in tools for Gmail, which have already implemented the entire Gmail API.
And we can use that out of the box in case we want something generic.
Anyways, the point here is that we would need to implement it ourselves, right?
So now our agent is able to send some emails, maybe to send some messages on slack or even to make
DB queries.
All right.
So this is working for our agent.
But let's say our agent is so successful that other people want to use it, maybe in their agents or
maybe on already existing ones.
So they really want to use the functionality that we wrote, right?
So let's take this example concrete and let's say that the agent is cursor.
So cursor now can send messages on Slack and Gmail and make DB queries.
Now what happens if other people, for example, in windsurf, want to use this agent?
So because we custom wrote it tailor made into cursor, if you want to integrate it into windsurf,
we would need to go and to work on that integration ourselves and to implement custom code that would
do it.
So it really adds up a lot of code that we need to write.
And if you want to add it to lovable or to bolt, or to a GitHub copilot, or to every AI code assistant,
we need to do it over and over again to write the integration to that custom agent.
And who wants to write a thousand integrations?
And MCP is going to solve exactly that.
And it really comes from a core principle in computer science and in software systems that if you want
to solve a problem, you simply need to add another layer of abstraction.
That is exactly what MCP is going to do, and this is how it's going to help us to support all those
types of agents.
And the idea here is that we are going to integrate only once into our MCP server.
And because all the other agents support MCP, The model context protocol.
Then they will be able to easily connect to our MCP server.
And in fact, we'll only need to implement our agent once with compatibility to the MCP server.
And then we can migrate to all those other agents which supports the MCP protocol.
So the agent that we wrote that was compatible with cursor is now also compatible with windsurf.
And we as the developers of the agent that is going to be used, we didn't need to add any logic.
And everyone who supports the MCP protocol can use our agent and we can integrate it seamlessly.
All right.
And this is like sort of like social media.
So if we have a social media application, if we have only a bunch of people using it, then we wouldn't
get really the value of it.
But if we have millions of people using it, creating user generated content, it's a huge flywheel
and provides a lot of value.
And this is exactly what's happening with MCP, because so many people are using it right now, and
there are tons of MCP servers out there.
And really the possibilities are endless.