WEBVTT

00:00.120 --> 00:01.320
Hey, they're eating here.

00:01.320 --> 00:05.280
Let's talk about MCP model context protocol.

00:05.320 --> 00:07.000
This is very hot right now.

00:07.000 --> 00:09.160
Everyone on ECS are talking about it.

00:09.200 --> 00:12.680
We're seeing tons of implementations of MCP servers.

00:12.680 --> 00:18.320
We see a lot of people are using MCP within their AI apps like cursor, like cloud.

00:18.400 --> 00:24.280
And the entire goal of what I'm trying to do is to make you become proficient in MCP.

00:24.480 --> 00:30.480
So you know exactly what's happening under the hood, and you'll be able to use MCP servers and to build

00:30.480 --> 00:32.440
MCP servers yourself.

00:32.640 --> 00:39.240
So before we talk about why, I think it's super important to understand why do we need MCP.

00:40.280 --> 00:40.720
All right.

00:40.720 --> 00:42.960
So let's say we have an AI agent.

00:43.400 --> 00:49.880
And we want that agent to be able to maybe send messages on slack, or maybe read and send emails or

00:49.920 --> 00:51.200
make queries to a DB.

00:51.560 --> 00:56.320
So generally we would need to implement those functionality.

00:56.320 --> 01:01.520
So we would need for example, to see how to work with the slack API or the Gmail API.

01:01.840 --> 01:07.720
And we would need to write some custom code that is going to be wrapped around as a tool, which we're

01:07.720 --> 01:09.320
going to let our agent use.

01:09.560 --> 01:15.330
Now most likely, For example, we would like even to write our own custom implementation to those tools.

01:15.330 --> 01:20.850
For example, we don't want anybody to delete our emails, so we don't want to give our agent access

01:20.850 --> 01:22.730
for the delete API in Gmail.

01:23.130 --> 01:28.090
So the point here that we have some custom implementation that we are going to implement ourselves.

01:28.090 --> 01:32.930
So we can do that, for example with a framework like LinkedIn, which also, by the way, comes in

01:32.930 --> 01:38.330
with built in tools for Gmail, which have already implemented the entire Gmail API.

01:38.570 --> 01:42.530
And we can use that out of the box in case we want something generic.

01:43.050 --> 01:47.250
Anyways, the point here is that we would need to implement it ourselves, right?

01:47.330 --> 01:53.650
So now our agent is able to send some emails, maybe to send some messages on slack or even to make

01:53.690 --> 01:54.570
DB queries.

01:55.010 --> 01:55.530
All right.

01:55.530 --> 01:57.450
So this is working for our agent.

01:57.450 --> 02:04.010
But let's say our agent is so successful that other people want to use it, maybe in their agents or

02:04.050 --> 02:06.250
maybe on already existing ones.

02:06.250 --> 02:09.810
So they really want to use the functionality that we wrote, right?

02:09.850 --> 02:14.570
So let's take this example concrete and let's say that the agent is cursor.

02:14.810 --> 02:19.770
So cursor now can send messages on Slack and Gmail and make DB queries.

02:20.130 --> 02:25.950
Now what happens if other people, for example, in windsurf, want to use this agent?

02:26.070 --> 02:32.830
So because we custom wrote it tailor made into cursor, if you want to integrate it into windsurf,

02:32.830 --> 02:38.190
we would need to go and to work on that integration ourselves and to implement custom code that would

02:38.190 --> 02:38.790
do it.

02:38.790 --> 02:41.950
So it really adds up a lot of code that we need to write.

02:41.950 --> 02:50.510
And if you want to add it to lovable or to bolt, or to a GitHub copilot, or to every AI code assistant,

02:50.510 --> 02:55.270
we need to do it over and over again to write the integration to that custom agent.

02:55.630 --> 02:57.910
And who wants to write a thousand integrations?

02:57.910 --> 03:01.110
And MCP is going to solve exactly that.

03:01.430 --> 03:08.270
And it really comes from a core principle in computer science and in software systems that if you want

03:08.270 --> 03:13.110
to solve a problem, you simply need to add another layer of abstraction.

03:13.670 --> 03:19.270
That is exactly what MCP is going to do, and this is how it's going to help us to support all those

03:19.270 --> 03:20.270
types of agents.

03:20.430 --> 03:26.350
And the idea here is that we are going to integrate only once into our MCP server.

03:26.950 --> 03:32.560
And because all the other agents support MCP, The model context protocol.

03:32.960 --> 03:36.960
Then they will be able to easily connect to our MCP server.

03:37.120 --> 03:43.000
And in fact, we'll only need to implement our agent once with compatibility to the MCP server.

03:43.200 --> 03:49.160
And then we can migrate to all those other agents which supports the MCP protocol.

03:49.400 --> 03:55.720
So the agent that we wrote that was compatible with cursor is now also compatible with windsurf.

03:56.040 --> 04:02.480
And we as the developers of the agent that is going to be used, we didn't need to add any logic.

04:02.720 --> 04:09.480
And everyone who supports the MCP protocol can use our agent and we can integrate it seamlessly.

04:09.960 --> 04:10.520
All right.

04:10.520 --> 04:12.720
And this is like sort of like social media.

04:12.720 --> 04:19.040
So if we have a social media application, if we have only a bunch of people using it, then we wouldn't

04:19.040 --> 04:20.520
get really the value of it.

04:20.760 --> 04:27.200
But if we have millions of people using it, creating user generated content, it's a huge flywheel

04:27.200 --> 04:29.640
and provides a lot of value.

04:29.640 --> 04:35.080
And this is exactly what's happening with MCP, because so many people are using it right now, and

04:35.080 --> 04:37.480
there are tons of MCP servers out there.

04:37.480 --> 04:39.920
And really the possibilities are endless.
