What I want to do today is uh just show

you uh the MCP inspector and uh the um

let's see here. Yeah. Um

so

when you're developing MCV servers uh

the very first thing that you find out

is you need um some reference servers to

see how they're actually built and uh

you know because you've got the spec you

know you can go to the mc model

contextprotocol.io IO and read the spec

and see all of the good stuff that it

supports. And that'll get you really

excited, but then you're like, okay, how

do I implement this and you start out

with a project, maybe you do something,

you know, like Ebony did there with a

fast MCP and you got a nice little quick

start uh thing. But however you go about

it, you're gonna start you're going to

start realizing like as you get deeper

into it like if I want to do sampling,

if I want to do elicitation, if I want

to do, you know, like

features like subscribable resources or

things like that, how do I do it? how,

you know, how does, you know, if I'm

just doing it with the TypeScript SDK or

Java SDK or whatever, uh, MCP SDK that

we're using, um, there are packages

built on top of those that make it even

easier.

However, um you need to know

how to implement the things and then as

you're implementing the things on your

own with your own server, uh you need to

be able to test them and see if uh you

know, sanity check uh is it is it

sending the right stuff? Does stuff come

in? You know, when I send stuff in, you

know, am I handling it right? And and

all of that. So, that's what the MCP

inspector is for. uh and we'll throw out

a link to the repo where uh the MCP

inspector lives. Uh there was there is a

repository uh where you can get it.

There's an MPM package. So if you have

node installed, you can just do npx

at model context protocolspector

and run it. Um you know, and launch it.

Uh that way you don't have to you know

clone the repo and locally and uh you

know build it and run it. If you if you

want to you can uh it'll give you a

great insight into how the client side

of MCP works. Uh it's a nice open source

client. Um and

there's another repo here that I u a

servers repo. I I'm running a um we have

a a reference server called everything

and that's kind of the you know

everything in the kitchen sink. We try

try to implement all of the features of

the protocol in this one server. It's

kind of crazy and I don't know what

percentage of everything we actually

have implemented there. We're constantly

trying to um to get to 100, but we'll

see.

>> It reminds me of an everything bagel.

>> Yes. Yes. That the everything all at

once.

>> Uh that's that's uh what the everything

server is. And so uh in the background

here, I have launched the inspector from

my local instance of it. I have also

launched uh the server uh the everything

server. We can dive into the code of

that a little bit later. But um I'll

just go ahead and uh connect to it.

And

first thing that you see is uh a little

um toolbar here. We've got various

things that you can look at. Um, this is

kind of silly. Uh, it being an actual

tab all to itself. We're going to have

to change that. But, uh, the primary

things when people when people say, uh,

MCP is just a wrapper for APIs, right?

Why do we even need that? Well, it's

not. It's there's more stuff to it. and

the inspector kind of lays that out for

you. And it's nice if you fire up the

the everything server and you fire up

the inspector uh and have a look at it,

you can see that it MCP goes a little

bit deeper. One of the things is

resources and um minimize that thing

here. Get you out of the way.

Uh so here the everything server has

created some number of of uh resources

here that I could have and a resource

can be anything. It can be uh a blob. It

can be text. It can be uh a dynamic

construct. I have a server. The first

MCP server I wrote uh had state machines

operating inside of the server and you

sent commands and uh actions to them and

they changed state and so forth. And so

that each state machine was a resource

and so clients could subscribe to that

resource and see okay wow the state of

the state machine changed. So what a

resource is is anything you want it to

be. If you can give it uh if if if you

can give it in a URI of some sort that

is unique uh and present it in the

server uh you've got a resource and you

you can subscribe to it. That's this

little this little dynamic this button

here that says subscribe. Um that is a

uh that lets me say okay if this

resource changes send me a notification

and you'll see a little notification

coming up here in the everything server

will sit here if I've got if I have

subscriptions it'll send me a little

notification saying hey this resource

you subscribe to is updated it's

simulating that the resource has changed

just to show you uh how that works and I

can say let's unsubscribe and then those

updated messages will stop.

Um that's just one part of um of

resources and you can have a a resource

template where you can say okay well

this was resource resource number one uh

I've got a resource template where I can

say where I can put in the resource ID

and um

read that particular resource. I don't

have to get the list and then choose it.

If there's a template, then I can put in

some parameters into a template in order

to fetch that resource. So that's kind

of how resources are. Prompts uh work

kind of similarly. Uh you can say, okay,

I've got a a prompt. And a prompt is um

going to be a a client may need your

server may want to provide various

prompts

that are related to the functionality

that it provides.

And uh so let's say that you're you have

a server that is for um maintaining

spreadsheets,

right? or uh office documents, you know.

So, you might have a prompt that uh

tells you to uh that is a way of telling

the server, hey, um tabulate all of you

know column A and you know, give me a a

result. Um so

so that the if the user does that a lot

you know especially if it's more complex

uh it's better to go ahead and not make

the user have to figure out how to type

in the words and you know engineer their

prompt to be wonderful. You can provide

a a stable of prompts that are great for

working with the stuff that your server

provides. Um, and so here you can have a

prompt that says

um

this is just um

I think

not sure what it's wanting what this

prompt is warning here. Okay, so here is

uh

>> this is really a prompt template, right?

Like the idea is that you can

essentially like you don't have to like

feed in these array of messages every

single time. You can very quickly get

them and they're parameterized with some

of the arguments to construct uh them

based on like the temperature that you

entered or the style that you mentioned.

>> Yes. Yes. Exactly. If I if you uh if the

if you're if you're usually like if if

people are tabulating columns often and

the only thing that you need to know is

which column uh then you could say a

prompt that says please tally all the

numbers in column and then a parameter

and then so you present that prompt you

present a UI to the user that collects

that parameter says which column would

you like to tabulate and then uh it

fills in the prompt and then sends that

to the OOLM and and uh so then the OOLM

goes oh okay well I'm going to call the

tool the tabulate tool uh and I'm going

to pass it the column that is in this

prompt and so forth so that way it's

it's just much easier on the user um and

you could have a prompt that has a

resource

um associated with it. So

>> this is I guess similar to an attachment

that like I attach a PDF to a prompt or

something like that.

>> Exactly. Exactly. Previously in the

resources section we saw that there are

a number of resources that this that

this server provides and here is a

particular resource resource number one.

Um, and you know that could be uh, you

know, it might not be a resource ID, it

might be a file name or something like

that. So that you could say, hey, um,

you know, uh, can you summarize the

profit and loss and tell me whether I'm,

you know, my company's going to live,

you know, through this next quarter, you

know, or or whatever. And uh so it would

then get the profit and loss resource a

you know uh a report that your server uh

exposes as a resource and and stick that

into the prompt that's going to the LLM.

So yeah. Yeah. Prompts are you you could

a simple prompt is ju is just can just

be uh

hey

uh you know just words. That's that's

it. You know just send this to the LLM.

That's not super useful. But definitely

uh prompts with arguments and prompts

that include resources uh give us a a

really great way of being able to

simplify the business of having a user

be able to

say, "Hey, I want to give you certain

information, some of which may be fixed

resources that that we have access to."

and then you know just do the thing with

it

>> right without having to you know uh be a

prompt engineer and you know uh possibly

you know have it work better or worse

depending upon uh you know how much

effort they put into the prompt you know

if the server engineer can engineer this

prompt to be optimal

you know for what for how it works so

that's resources and prompts already

we're seeing that you know

MCP is more than just in an API wrapper,

right? We're just now getting to tools.

So,

the server uh exposes a bunch of tools

and um I'm just going to clear some of

these notifications here.

and some simple tools that just let you

say, "Hey, uh, echo back this this

message here." Or, uh, the classic one

that uh Ebony uh showed uh let's

add two numbers, right?

A longunning operation.

Here's the thing. Um, when you have a

longunning operation, you might want to

get notifications

about the progress,

right? Which could then use be used to

show a progress bar. Out of a total of

five, we're four along or we're three

along or we're two along or whatever

like that. So, in that way, uh, you can

drive you can give the client some hints

about, you know, how much time is left.

Um, and uh,

you know, hopefully

not I did a I did a Windows 11 uh,

upgrade in a VM yesterday and saw that

they still have that wonderful thing

where it says I'm taking it'll be about

it'll be about 15 minutes. It'll be

about an hour and a'll be about three

hours.

It just keeps getting longer and longer.

Uh, hopefully you'll have that. I'm

curious, what are like some pieces of

the inspector uh that uh people are not

familiar with that you wish people were

more familiar with or things that like

it can do that are like uh that are that

maybe pleasant surprises for for for

folks who are building MCPS?

Well um

a couple of features that are not Okay,

so tools are, um, obviously,

uh there

a feature that isn't implemented very

often. It's really cool and people need

to be aware of and we need to client

developers need to get on the bandwagon

and support this and server developers

need to be able to use it as

elicitation.

Uh and with elicitation,

you can run a tool, but then that tool

gets along at a certain point and says,

"Hey, I need a little input from the

user here before I can go uh forward."

Whoa, got a little error there. Oh,

that's probably because I've got a time

out that's uh it's not

there

>> if there's more time on there

uh

right uh things time out there uh in the

uh

in the inspector. So uh let's go back to

tools. Let's go to elicitation. This

one, this is a tool that starts

elicitation. So, if I run the tool, uh,

first thing it does is go, hey, I need

to grab some information from the user

here. Uh, what's your favorite color?

Uh, what's your favorite number?

Um,

and what kind of pets do you like? I

have five cats right now, so I'm gonna

say cats, and I'm going to submit that.

Okay. So at this point the tool has

enough information to complete its job

and it has uh come back and said okay

well the user's favorites uh favorites

are this and uh and so forth and here's

here's the actual uh raw c content that

came back. So

that's

>> that's very cool. Like so I just want to

point out to folks that like basically

this tool was paused at that point,

right? While the form was shown and was

waiting for you to provide input before

it proceeded execution.

>> Exactly. Exactly. So and now the LLM

could have chosen that tool. It could be

you could have provided a prompt

and the the LLM is chugging along and

it's going okay uh at you know I've

called tool A tool B tool C oh but right

now I need to call tool D and tool D is

going oh okay uh cool but I need to talk

to the user first

>> so it's it's looping you in right uh

this is not I mean just because we

invoke the tool from this thing it's you

I want to make it clear that this could

be part of an LLM's part of a agentic

workflow at which point the tool can

decide, hey, I need to I need to I need

the user to provide a little bit of

input here. And that can be things like,

hey, hey, hey, I'm I'm getting ready to

I've collected all this information and

maybe you want to review it first. This

is what we've come up with. Is this

good? We're going to go ahead and write

this document and then we're going to

move ahead with with the rest of the

plan which is kind of you know we don't

want to move on until we're sure that we

have a good plan in place. Right.

>> Eliciting user input.

>> Exactly. Exactly. So that's uh super

important uh thing uh for

>> sorry to cut you off Cliff but uh just

in the interest of time actually I

wanted to ask uh two things. One is uh

what's next for Inspector and second if

someone wanted to like get involved and

contribute because this is an open

source project and you are like just

like open like a maintainer of this

project and you're contributing a ton of

time just making sure that the community

is uh like has this tool available? Uh

how do people get involved?

Um so

there's a couple of things, uh, and

you know, you've got the the link, uh,

you can throw up there to, uh, users,

uh, with the, uh, the servers repo and

the inspector repo. There are a whole

bunch of other repos involved with the,

uh, with the whole, uh, protocol

project. uh and you you can you can get

into them from there. But, uh, coming in

from my perspective, uh, if you wanted

to help with the inspector or the

reference servers, like for instance,

you got the the everything server here,

and you find out, oh, well, this is

really cool, but there's this feature of

the spec that isn't implemented. And,

you know, I'd really like to put that in

my server, but I don't see it. I don't

see a way that I can see it tested so

that I can feel confident moving forward

with it. So um you know you might go to

the servers repo and just check out the

everything you know check out the repo

you know uh fork the repo and then uh

create a branch and add the feature and

then create a pull request uh to our

repo uh and we'll uh you know you can

tag me at cliffhaul uh and I'll have a

look at

Um or otherwise someone someone tending

the the farm will uh have a look at it.

It's definitely going to not going to

disappear into the quagmire hopefully.

Uh a lot of people a lot of people are

putting in uh PRs to say hey put my

server on the readme there's a massive

list of of repos which uh by the way if

you're looking for hey what are people

doing with MCP servers anyway? what ones

are out there. And I'd like to look at

their code. Go just go to the servers

repo read me and just look at the

massive amount of official and community

uh contributed server servers that are

out there and you can just go trolling

through the repos and see all of the

code and it's a it's a great uh place,

but um sometimes it's hard to swim

through all the PRs of getting onto that

readme to find the oh hey I'm adding

this feature, right? So, you might, if

you're doing that, you might want to tag

me directly just to say, "Hey, here's a

here's a feature I need to get this

going." Um, and same same with the

inspector. But uh one thing I would like

to point out though uh if you don't feel

confident or ready to put the effort in

to like you know fork the repo and

create a PR and put it in and maybe or

maybe not get it approved or go through

the process. If if you're not there yet

uh you can still help a ton by just

going to the issues column of either of

those repos or any of them in the

project. You can go to the uh model

context protocol uh organization on

GitHub and find all of our stuff um and

find find issues in the thing that

you're interested in like people

complaining about this that or the other

things saying hey I'd like to have this

feature whatever weigh in on it just hop

in the comments and and and say hey uh

yeah I think that'd be a great feature

uh and this is why I think it would be

good you know to help upvote that uh

that that feature request or uh hey oh

I'm having that problem that you're

saying too and I tried this workaround

it seems to work for me or you know it

used to work in this version but it

didn't you know if you can add some

elucidation to a person's issue or maybe

even go oh you just need to put in this

this little argument here and it will

work for you you might be able to close

an issue and and you know that is a form

form of help that doesn't require any

kind of approval or anything. You can

just get

>> so really just get involved uh in any

way you can. Um and I just want to also

point out like uh I think I see this as

the debugger for MCP. Like you can't

really develop things in the MCP space

without Inspector and you've been like

the leading edge of just making sure

that we have this incredible tool

available to us. And so I also wanted to

thank you for all your contributions. Um

and I think uh so thank you so much F

for for presenting this and I'm sure

folks can take a look there. H will

share some links afterwards as well.