Hang tight while we fetch the video data and transcripts. This only takes a moment.
Connecting to YouTube player…
Fetching transcript data…
We’ll display the transcript, summary, and all view options as soon as everything loads.
Next steps
Loading transcript tools…
Model Context Protocol (MCP): The Key To Agentic AI | Jack Herrington | YouTubeToText
YouTube Transcript: Model Context Protocol (MCP): The Key To Agentic AI
Skip watching entire videos - get the full transcript, search for keywords, and copy with one click.
Share:
Video Transcript
Video Summary
Summary
Core Theme
The Model Context Protocol (mCP) is a new standard designed to provide AI models, particularly Large Language Models (LLMs), with the necessary context (tools, resources, etc.) to perform complex tasks by enabling seamless communication between AI clients and specialized servers.
Mind Map
Click to expand
Click to explore the full interactive mind map • Zoom, pan, and navigate
mCP or the model context protocol it's
what everybody's talking about and here
is your executive summary what it is why
it's important how it works how it
Compares with other protocols and some
key takeaways let's get right into [Music]
[Music]
it all right let's start with breaking
down the name mCP stands for model
context protocol and the m4 model in
this case is an AI model and while you
can use it on image models and text to
speech models and really all kinds of
models it's really most useful for llms
or large language models like open AI
gbd4 Google's Gemini and anthropics CLA
and when it comes to AI models context
is everything let's take a query like
this one have a look at my sqlite
database and make sure that the sum of
all the orders is correct and matches
what's in my presentation no model by
itself is going to be able to do this it
lack context it needs to be able to
query the database to get the orders and
it needs to be able to read the
presentation which is in a file
and then when it has both of those then
it can answer your question so that's
where the C in mCP comes from that
stands for context and what mCP servers
do is they provide a way for AI models
to access the context they need to
accomplish tasks in the case of this
query you probably have one mCP server
that can access the database and another
mCP server that can access your
presentation file maybe from the cloud
and the model can use both of those mCP
servers to accomplish that single task
askk now there are four types of context
Primitives that an mCP server can
provide to an AI model first is tools
these are functions that the model can
use to perform actions like creating a
database or updating a database or
anything really there's also resources
resources are essentially attachments
that you're providing to the model in
our case that would be the presentation
file now resources and tools are by far
the most common that I've seen But there
are two others there sampling which is a
way for the model to query other models
and then there are parameterized prompts
that clients can use as templates when
making requests to the model and these
two are less commonly used but they're
still part of mCP and we might see them
being used more in the future now I've
been talking a lot about mCP servers and
clients so let's dig into that mCP
servers are programs or servers that
handle requests from mCP clients the mCP
server implements the tools or provides
the resources and the mCP client is what
makes the request to the server for
those tools and those resources so
here's a site that has a list of all the
MCB clients as well as a massive list of
mCP servers I put a link to that in the
description right down below and you can
have a look for yourself in the case of
our example the mCP client is the chat
interface that we're typing into Claude
desktop and the mCP server would be a
program that we're running on our own
computer or hosted in the cloud and
would give us access to the SQL database
and the presentation
now the p and mCP means protocol and the
mCP protocol defines the structure of
the messages that are sent between the
client and the server and honestly you
don't really need to know all the
details of the messages themselves but
what is important to know is that there
it is well defined and it supports
something called
reflection and reflection is the ability
for the client to ask the server for
information about The Primitives that
the server provides like the tools and
the resources reflection is a critical
part of mCP and it's what makes mCP
different from other API protocols like
trpc grpc and rest now I mentioned that
mCP servers are programs that you can
run or they can be deployed as a service
and that's because the protocol is
designed to be used with different types of
of
transports and there are two main ones
take from the start the first is the
standard IO transport and that's where
the mCP client runs the mCP server as a
program on your own computer directly
and then the mCP client communicates
with the mCP server using the built-in
Unix or window
standard input and output mechanisms or
standard IO for short the other
transport mechanism is ssse or server
sent events this is network based so
your mCP client is configured with a
remote URL and then messages are sent
back and forth using SS events over HTTP
or https now which one of these
transport mechanisms you use depends on
your use case in our example we'll
probably use standard IO for both of
these because our local machine has
access to our sqlite database as as well
as our presentation file all right now
let's actually try out an mCP server in
fact let's try out an sqlite server that
fits with our example and for an mCP
client we'll use Claude desktop now this
is actually going to get pretty complex
mCP is still new and so these flows are
still a little rough first you need to
download the source code onto your
server which I've already done then you
need to configure the client and each
client handles this a little differently
for CLA desktop that actually means
editing a Json config file
and adding a new server configuration
and because we're using standard IO
transport we're going to need to run the
server as a program so we specify the
command and the arguments and then
Claude desktop handles booting that
application now we can reboot Claude
with a new configuration and we can see
this little connector icon and when we
click on that we can see that we have a
server running and now we can type in a
request to use a sqlite database and at
each point it's prompting us to confirm
whether it's doing the right thing
because this MC server could actually
make changes to the database and so we
want to make sure that those
confirmations help you understand what's
happening and stop it if it's not doing
what you want now that we understand
more about how the client Works let's
dig a little deeper into the server and
I'll do that for two reasons the first I
do want to show you how mCP servers work
and secondly I want to encourage you to
build your own mCP server to fit your
specific use case so this is the code
for a very simple server example written
in typescript you can see at the top
here we Define the server with it name
and its version and then down the bottom
we run that server using standard IO
transports that means that it's going to
be a program that you're going to run on
your own computer and in between
defining those two things we add our
tools and our resources for each tool we
give it a name and a description and
those should be written in a way that
makes it easy for the AI to understand
what the tool is and when it should use
it then we Define the parameters to the
function but again we add descriptions
so that we can hint to the AI what each
parameter is for and what the format of
the parameter is then we Define the
function body and this is where you
actually have like your custom query
code which would connect to your
database or your API to go and get the
orders the cool thing is we can test all
this out without an AI we actually can
run this server in What's called the
inspector and then you can see up at the
top here we've got all the different
types of Primitives and we can click on
tools and check those out now notice
that we got a list of all the tools
available and that's because the mCP
protocol supports reflection so the
first thing the client does is ask a
server for its tools and resources and
whatever Primitives so it knows what it
has access to then this is super
important because not many protocols
support reflection we can even run the
tool in the inspector which is certainly
cheaper than testing it out in an AI and
we can make sure that we're giving the
AI the right results now back in the
code we can also Define resources where
you provide a list of all the possible
resources for example this might be a
list of files or a directory and then we
have a method that gets it when a
specific resource is requested and of
course we can test out those resources
in the inspector so now that we know
broadly what mCP is and how it works
let's answer the first question that
everyone asks which is why use mCP
instead of a more generalized API
standard like graphql I mean graphql has
reflection just like mCP although it can
be turned off and graph is a really
well- defined protocol so why not just
use that well it helps to understand the
difference by looking at it from the
perspective of the AI model llms support
tools graphql doesn't have tools as a
primitive it's got entities and it's got
Fields but no direct remote procedure
call or RPC mechanism akin to tools so
if you want to connect an llm model to a
graphql API you have to create tools
that query the entities in those fields
and then give the tools to the model mCP
is just a standardized mechanism for
doing that so how about other grpc
mechanisms like trpc grpc well these are
all great but they don't inherently
provide reflection there's no way for an
AI model to directly connect to one of
them and ask hey what tools and
resources are available to me so again
you have to create that mapping layer
from the AI tools to RPC calls in your
code and this see me my first key
takeaway which is that you should use
mCP in conjunction with a backend API
not as a replacement for that API you
can think of mCP as a more efficient
user interface for the AI model not as a
new generalized API standard for
everything another key takeaway is you
shouldn't try to do everything with a
single mCP server just do your unique
thing and let the mCP client use your
mCP server in conjunction with other mCP
servers mCP is designed for that so a
client can and should talk to multiple
mCP servers to accomplish a given task
and my final key takeaway is that you
should keep your mCP server at as high a
level of abstraction as possible if you
want the AI to create for orders then
don't give it full access to your
database and your schemas and all those
lowlevel details give it a tool to query
for the orders and add more tools as you
need again this is about giving AI
models context and giving it to them in
a way that is as time and cost efficient
as possible all right that's my highle
overview of the model context protocol
in subsequent videos we be digging more
into the details of it if any questions
or comments please put that in the
comment section right down below and if
you like this video hit that like button
if you really like the video hit the
Subscribe button and click on that Bell
and be notified the next time new blue
Click on any text or timestamp to jump to that moment in the video
Share:
Most transcripts ready in under 5 seconds
One-Click Copy125+ LanguagesSearch ContentJump to Timestamps
Paste YouTube URL
Enter any YouTube video link to get the full transcript
Transcript Extraction Form
Most transcripts ready in under 5 seconds
Get Our Chrome Extension
Get transcripts instantly without leaving YouTube. Install our Chrome extension for one-click access to any video's transcript directly on the watch page.
