Getting Started with MCP For LLM Agents

Key Takeaways

What's up folks? Welcome back to the channel. In this video, we're going to talk about MCP. Now, what is MCP? Well, check out the official model context protocol documentation. You're going to learn that MCP is an open protocol to standardize how applications provide context to LLMs, right? Think of it like a USBC port for AI applications. Now, what does that mean? Well, consider this, right? when you have a user interacting with an LLM and the LLM is working in and has control over a set of tools like searching the web uh checking Wikipedia checking archive sending emails calendar management etc right when I have this little situation uh to build the most basic vanilla agent possible you can set up a little loop that looks like this right the LLM has two choices it can either given some prompt prompt from the user, right? Which will contain some sort of task that the user is sending to the LLM. The LLM can make a choice. It can either perform some action to go further into resolving the task or the LM can return a final output to the user. Right? If the LLM chooses to perform an action that the LLM is going to make what is called a the thing that's in this line over here is something called a tool call. Okay, what does that mean? A tool call? It means calling a tool, preparing inputs for some specific function that performs an action like calling an API, executing a program and so on, right? This the output of that action is going to be in this context something called an observation. All right? And what this observation is going to do is is going to provide more information to the LLM in order to finish the task or not. Imagine if the task was to check your calendar to uh get the events from your calendar. The um LLM might call the calendar tool and that might lead to an output that is the recent events and their descriptions, right? That's going to be the observation that's produced out of the output of the tool and that gets fed back to the context of the LLM. And now the LLM can make a choice. The LLM can say okay given that what I'm going to do is I'm going to write a little summary for the user and now I'm ready to give the final output. I don't need to use any any other tools. And this is something that works folks. This is something great. This is something that's powering most of the AI agents that you use today. Okay. Now the trick here is that in order to set this up in whatever framework you want, whatever language you want, you have to write the code for the LLM API access, you have to write the code that connects these LLMs to different tools and resources, and you have to write the code for the logic of the agent, how this workflow is going to go. Now, the example that I demonstrated here is a basic agent loop, something called like I was showing before, a react loop. And if you don't know what React is, that's a reference to this paper called React, Synergizing Reasoning in Enacting Language Models. And in this paper, they show that you could have a lot more a lot better performance with large language models if you have them interle thoughts, actions, and observations out of the actions they take and and go systematically solving more complex tasks. Now, re React is awesome and this loop works, but you do have to write all of this code. LM API access, connection to tools and resources, the logic of the agent and so on. All right. So, what's the problem? Well, the problem as I've come to realize after reading a very cool um I think it's a course or article by hugging face on MCP is that you get to the situation where you have multiple possible LLMs accessible. If you want to use different LLMs within this system, uh for each of them that you're going to have to write the connections to the tools, resources, and prompts. So you end up having to write a lot of redundant code, right? Because you that leads to like multiply by n integrations that you have to maintain in your code as demonstrated in this beautiful drawing that I have over here. Okay. So uh actually a really good source on this topic if you want to go deep into uh not only this but just uh an MCP intro in general is this course by hugging face MCP which pretty much goes into all of the stuff that I'm talking about and this is from this is where I went to get this idea of the multiple connections right here. Once you have a bunch of models and multiple tools number of integrations becomes too large to manage each with its own unique interface. All right. So it leads to this problem of too many integrations to maintain. Right? And MCP folks as I'm demonstrating beautifully over here is trying to solve that problem. Okay? So MCP is trying to turn a problem that previously was multiply by n into a problem that is now m + n number of integrations to maintain. So if you want to switch LLMs in your system, if you're using MCP, you as long as they connect to MCP, MCP is going to connect them to resource tools and prompts. So you don't have to write that many integrations anymore, right? So M integrations for how many models you need to connect and N uh integrations depending on, you know, how many resources you have, tools you have, prompts, and so on and so forth. Okay, so this idea is pretty cool. It works. Beautiful. So this is the scenario where something like the model context protocol shows up, right? And what does it mean to say that MCP tries to facilitate connecting LLMs to context? Well, for that, let's take a look at the documentation. Right? So here they talk about why MCP and they make a similar argument to what I just made. They go into the architecture. We're going to talk about that in a second. And uh then they show you how to build these different agents. Now, if I go over actually to my own little diagram over here, I think it's the best way to quickly go over this topic. I'm going to actually pull up my presentation. Let me just pull that up. There we go. And here we go. Here we are. So, what's up with MCP? So, here's the thing, folks. Now I'm going to actually jump over to the side that I want to present. There you go. So what MCP is doing is essentially this. All right. MCP is saying, okay, check this out. You have three major core components for the MCP infrastructure. Okay, what are these three components? Well, we start with the host or userfacing application. This is your application. This is where the thing is going to live. Okay. So you have a host that can be for example a great example of application that today can um integrate easily with MCP servers is something like claw desktop or different IDEs like cursor and others. All right. So you start with your host userfacing application. Inside of that host we're going to have clients. Now what is a client? is something that's gonna handle onetoone connections with MCP servers. All right. And what is an MCP server? An MCP server is something that's going to expose functionality. What functionality? Tools, resources, prompts, right? Just like we were talking about before, it's going to expose anything that might be useful to use by an LLM. Okay? And like I was demonstrating in this beautiful drawing here. yesterday when I was teaching this course to actually 780 people. Uh the LLM lives inside of the host which means that the host is responsible for implementing the LLM providers. Okay, now this is great but how can we actually get a sense of like get a a natural idea of what this looks like? So instead of me continuing to go on on the very details and specifics of what the host is, what the client and the server are, let's just write some code and see what that looks like. Okay, so I'm going to pull up my editor here. There we go. I'm going to open up a file and I'm going to save this file and this is going to be my simple my simple server. I'm going to call it my simple MCP server.py. Okay. And for this simple MCP server.py, I'm going to try to do it by head, but if I don't remember, I do have some cheats here because I already wrote this code before, but so if I don't remember, I'm going to go and cheat a little bit and check that out. So, we're going to import from MCP uh the fast MCP uh module. All right, that's going to allow us to create uh I think it's a fast API uh MCP server uh fast NPI based MCP server. I'm pretty sure, but let's let's check that out. I'm not actually 100% sure. So, uh MCP.server MCP docs uh fastmcp MCP protocol. There we go. So, Python SDK and then Python SDK. I actually want to know. Yeah, this is a simple server that exposes. I'm going to go ahead and think that fast MCP is just a fast API based MCP server. All right, I'm fine. I'm fine with that. Uh I mean obviously install set up your environment, right? So here in this folder uh I have an environment that I don't want to use actually. So I'm going to deactivate this environment. Going to deactivate deactivate deactivate in the uh model context protocol documentation. If we go over here the way they the way they advise you to set it up for server development is to um to use UV. So that's what we're going to be using. All right. So if we go over here in the page there we go. Mac OS Linux UV init CD weather vmv source we add the mcp cli and httpx and then we create the file. So let's go ahead and let's do all of those steps. All right. So I'm going to go uv init uh simple mcp server. Beautiful. I'm going to go into this folder. I'm going to um I'm going to say uv venth. I think that's what I got to do, right? Um and then I'm going to activate that environment bin activate. Beautiful. And now that I've activated that environment, I'm going to create the file, right? Yeah. I'm going to add the dependencies. So I'm have to add mcp cli and I have to add httpx. And now I have to move this simple mcp server.py Pi file to here. And now we are ready to go. Simple MCP server. We're ready to go. And it's going to be pretty simple. I'm going to say MCP equal fast MCP. I'm going to name my instance simple MCP server. All right. And now we can use very simple decorators to create the functionality that we want to expose. All right. And to get to give you a sense of what that would look like, I'm going to create um two essential ideas. Okay. So, we're going to start with a tool. So, mcp.tool. And now for this tool, I'm going to create a function that creates a file. Okay. Given a file uh given a file path and its content. And what the output of this function is actually going to be is a dictionary that returns um uh this uh string when I a dictionary with the file path and the content saved inside that file path. Okay. And that's going to be important for later. So now cursor is already helping me build this thing. So this is pretty cool. I'm going to come over here and see if everything's good. Okay. So with open file path right then write the contents and then return uh this message I don't like. What I want to build actually is file path and then the actual content of the file. There you go. I'm going to return this in the dictionary. Right. Nice. And now that we have that I don't want the read file tool for this. Okay. I want this tool to create a file and let's just start with that. Okay. So I have this tool that I can now expose to as a functionality to my to my as a as an MCP server. So let's do that. I'm going to say if name MCP run. Now there's a default parameter here that I'm going to explicitly state because it's important. It's called transport. And I'm going to say st the stdio. What this means is that we are there are two transport layers essentially for MCP local and remote. Okay. Uh the local is called stddio standard input and output. And this means that this server is going to be exposed in a way that it can be accessed via a simple command on your local folder. And if you don't understand what that means, stick with me. We'll see what that means in a second. All right. So, we're exposing the server and everything's beautiful. And now let's see what happens when I just run this script. Okay. Simple MCP server. I'm running with Python. And well, all right. Not a lot is happening. Okay. So, what is going on right now? The server is opened, right? So, here's the thing. uh I wouldn't I wouldn't use it like this because this is stdio but the idea here is we have this file that we can run and when we run this file this file is exposing this MCP tool okay so keep that ID in mind beautiful so now I'm going to stop running this file okay and now I'm going to actually run something that comes pre uh that comes installed with the MCPLI in order to take a look at this server to inspect it, to debug it, to troubleshoot it. So, I'm going to run mcp uh dev and then I'm going to give the path to the server. Simple MCP server. And now something has started. And now I can open up this little link here on my logo host. Uh let me go over here. Nice. And now we are inside of the MCP inspector which is a very nice tool to inspect everything about your MCP server. So here it's indicating how you could theoretically run that server. So saying UV argument server.py. So let's see what happens when I click on connect. When I click on connect, now my server is connected and I can list all the stuff that that server is exposing. So resources, potential templates or prompts, right? I can list the tools. Now if we go back into that server, we see that the only thing that we are exposing is a tool. So I'm going to click come over here in tools and I'm going to click on list tools. And when I do that, what happens is we get this information that this is the tool that's being exposed by the server called create file. So if I click on create file, we see what are the characteristics of this create file tool and it creates a file with a given content. So imagine this. I can give a file path. I can give some content and I could click on run tool and I could test if this tool is running correctly or not, which is pretty cool. Let's try that out. So I'm going to try locally and I'm going to say uh file.txt txt and the contents is this file was made with an MCP server. And now I'm going to click on run tool. And now the two results says success. And the output was this very nice dictionary with the file path and the contents of the um file that I put right over here. So this is a very the inspector is going to be this great tool for us to understand if the stuff that we're exposing with our MCP server is actually working and everything is going well and beautiful and marvelous. So I can go back to my folder to my editor. I can check that as you can see over here in file.txt a file was created. The file was made with MSP server. So it actually works which is awesome. All right. This is pretty cool. Now, if I'm going to stop uh the MCP inspector for now and even though the inspector is great, we this is half this is half the story, right folks? We've created our MCP server, but like we were talking about a second a second ago. When we actually have MCP working, when everything is like amazing, we have two aspects of this story, right? We have one aspect which is the server and the second aspect is the client. So we made a server right. How would it work to build and interact with the server via a client? Now lucky for us the MCP documentation is really awesome. What they do for us is in the documentation, if we go down over here, they have an example of a much more complex server than the one that I just demonstrated here, which is great. You should go check it out. It's a nay async, super nice server. Now, what we're going to do is we're going to go down here where they say client developers. And in this example here on the documentation, they show you how to build a simple LLM power chatbot client that connects to MCP servers, which is exactly what we want to understand how all of that little infrastructure works with MCP. So I am very lazy right now. So, instead of me writing everything again, what I'm going to do is I'm going to click on the complete code for this tutorial, blah blah blah, and I'm going to go over to client.py and I'm going to copy all this code and we're going to work through this code and see what's going on. Okay, so we're going to copy this raw file and now I'm going to go over to my editor and I'm going to open up a new file. I'm going to paste this in. I'm going to call this client test simple mc. Ah, this is a terrible name. client test.py. I think client test.py is more than enough. Now I'm going to run. Yep, everything works. Uh, one note folks, I think I've ran my server like Python. This is probably probably wasn't Oh, no. That's fine. Yeah, because we created with UV. Yeah, it's fine. So now that we've now that we've done this and now we're happy and everything is good, here's what we're going to do. We are going to uh take a look at this client code and understand what is it implementing that kind of helps us understand how the whole idea of MCP works. And this MCP client is a very simple class that has a session something called a exit stack and some and anthropic which is the easiest easier part to understand here which is this is going to be responsible for loading up the enthropic client so that we can use the cloud model as our LLM of choice. Okay, this is actually not our choice. This is the choice from the documentation. Now there are if we zoom out a little bit there are two functions in this client that I want to take note. One to connect to the server and one to process the query. Okay. Now there's a third one that's also important which is the chat loop. Okay. And I don't even care about cleanup right now or main. What I care about right now is something that connects to the server, something that processes a query. Now, check this out. I'm going to put this code on the left and on my right, I'm going to put the browser. I'm going to open up that beautiful diagram, and I'm going to zoom out of this diagram a little bit. And I'm going to go to another drawing that I really like in order to understand what is going on. And this very drawing over here is actually extremely useful. Now in this drawing what we're doing Oh no, that was bad. In this drawing, what we're doing is we are uh outlining how the communication flow on a basic MCP client host infra would work would go down. Okay. Now a really good explanation on all of this is actually right here. Let me just show that to you. If you go to understanding MCP capabilities, another the hugging face course. This is a very great source on this topic. MCP capabilities. I want to find something that was called the communication protocol. There you go. The communication protocol. Right. I'll leave a link to this course and to the documentation in the description. Don't worry. So, in this communication protocol, they outline everything about how the format works, JSON, RPC, stuff that we haven't covered yet. I'm probably not even going to touch on this on this video. This is a very introductory video. What I care about, folks, is something much simpler, which is if we go down, if we go down, down, down, down, down. There you go. Discovery. Where is the I thought it was here. Maybe I was maybe I was a bit wrong. Maybe it wasn't communication protocol. Maybe it was like the flow server sends client reviews, samples, reviews, returns. Yeah. And how capabilities work together. Uh I thought it was in the communication protocol, but the communication protocol was more focused on the JSON RPC formatting and then how the images are connected. Okay, so that was my bad. So let's just go through this uh diagram and let's just focus here. This is a basic flow for how the communication is going to go down between user host MCP client and the MCP server. All right. And what is going on? What's going on is very simple. We have the user interaction, right? Sending a query and then the host processes that query. So you can start see the connection with the code that we have on the left, right? We have some code over here that's called connect to the server. We have some code over here that's called process the query. And this happens at the host client level. So the host and the client are connected, right? The client then does what? It connects to the server to discover capabilities from the server. So if we go here on my left, we see that there's some code over here to list out the tools from the session. What is the session folks? If I go a little control F on the session over here, you see that the session is the client session that was created. Okay, great. And when we when we take a look and see what this session is actually doing, the session was created to connect to the server via stddio, right? And it has a command to connect to that server and it has the path to the script for that server. So when we list the tools, we're listing the tools that are being exposed by the server. So we are doing this capability discovery from to know what the MCP is actually exposing and you guessed it the MCP server is going to go back and say look these are the available tools resources and prompts. All right great. So what the client is going to do is say okay so now I know this information. So now the LLM that sits at the host application can if needed the LLM can invoke a capability. it can call a tool that's being exposed by the server. All right? And then if that happens and the LLM invokes that, the client sends that message to the server to execute whatever the LLM says the LLM wants to invoke and call and so on. So the server as I'm drawing more red over here executes that functionality returns the results to the client which relays that back to the host so that the host can integrate that into some chat conversation with the user and then the user sees some response some summary in a chat whatever it is. And in this code here on our left, we see that at the fake host level in the form of this little chat loop that we have here uh that in the case of this script is written in the client. But I do like seeing this code as an example of um uh implementing you know an aspect of the host and the client. So I think that this is a pretty simple easy way to understand how communication is flowing, how the messages are being exchanged. And now we can focus a little bit more here on the code that we have. And if we go up over here, we can now go do a little walk through of what the code is actually doing for us. So we're initializing these things and then we connect to the server, right? to connect to the server. All we need is the path to the script. So, we need the path to this simple server script that I wrote. And then this code is identifying if the script is going to be Python or JSON. So, I don't even need to check for JSON because I'm just going to build servers with Python. And the server specifies, okay, what is the command to run that? In this case, it's Python is fine. It could be UV run script, but Python is fine. And then we have to specialize uh specify the parameters in this stddio server parameters uh object giving the command and then the arguments for that command. All right. And if we have environment variables authentication stuff and so on that would go probably right over here. Then once we've done all of that, we have some boilerplate to set up the transport the uh stddio the right and the entering the async cont. I'm not even going to pretend that I know what's under the hood here, folks. What I care about is that we are initializing our session. All right. Okay. We're initializing our session. This is beautiful. The next thing is to process the query. So this is something that we are more used to when we're playing around with um LLM APIs, right? Preparing a message for some OpenAI model, some CHP model, some cloud model, whatever it is. So this is usually going to be a list with dictionaries containing a row message that says user or assistant or system message and the content of the query. Right? So this is the query that the user is going to be sending for the LLM. And then we're going to wait for the response to get we're going to make that call and say what are what is the ex the functionality being exposed. We get the information of what is the functionality being exposed and we put that into a little list and we send a message we send a message to in this case to claude right self.ropic messages.create create. We send a message to Claude. Maximum number of tokens is a thousand messages and the tools available. The tools available are going to be are organized in this very nice little uh list of dictionaries containing the name of the tool, the description of the tool and the input schema for the tool so that the model knows how to properly send input for that particular tool. And remember when we say tool here in the case of our example we're it's just going to be this tool which is a tool to create a file. All right. Beautiful thing. So now we can process and handle those two calls. This is great. And then uh here is a classic loop to process a message that might contain a tool call or might contain a message for the user. Now folks, I want you to take a look at this little easy loop here because this is a classic um this is a classic uh loop for uh an agent. What do I mean by that? When we were over here, we were talking about this loop, right? We're talking about this loop. User sends a message. The LLM can use a tool or respond. So if I put this side by side with this, we can actually see how everything comes together. So we analyze the content of the response. If it is text, we append that to a message that's going to be sent to the user. So that would be the final output or context for the LLM and so on. uh then the uh if the in the content output of the LLM there's a indication of two use well then we're going to understand what is the tool that should be used what are the arguments for that tool and then we're going to call that tool so we are taking care of the execution of the tool here because we're not using any frameworks that usually uh do that for us like lang chain, langraph or uh Google ADK or openi agents SDK or the open old assistance API so on and so forth and then we append that the information that we call the tool to a little list uh containing information saying calling to blah blah blah. Okay, so this is interesting because now we are in the context of the model that we're using. This information about what happened if we call the tool is being added. So the model knows what happens in the past. So the model can do something. Remember these LLMs have no memory whatsoever. We have to do the work ourselves. And now we have a a second message to kind of concatenate everything together. And we append everything to the final message for the user, right? You append the final text. And here's the thing, you've seen code like this before before MCP. If we go to something like something very obvious, if I go over here to the OpenAI function calling docs, you've seen code that looks something like this, right? So we've seen if I go down down down let me see if I find an example that looks very much like this. Yeah, I think this example here, right? OpenAI you initialize a client you have a list with two schemas messages and then you get a completion and there's a possibility of calling tools because the tools are being given to the model and then you see the output and the output indicates ah no you should I want you to call a function and what is the name what is the argument okay and then you execute a function so you get the tool call you get the arguments and then you execute the function you see get weather and the arguments for the function and look at this now this being implemented in the client because self session represents an instance of the client session and this is using this call tool that's going to call this tool. I just have to give the name and the arguments and the reason why we can do this is because we are exposing tools with the MCP server so that they can be called and executed and so on. Uh, and this will essentially send all of this information to for execution on the server. All right. So, perfect. Now that we've kind of done, we can actually test this out. So, here's what we're going to do. Uh, we're going to run this client. And in order to run, we're going to have to specify what is the path to the server script. That is that's all. That's all we got to do. And notice I don't have to run the server because we're using transport stddio. So I can just come over here. I'm going to run uh I can run with UV run and then I can give the client test and the path to the server is simple MCP server. And that didn't work because I didn't install enthropic. So I did install entropic in the that's true. So UV I think I I can go UV add entropic then UV run client test and then the path to the server. Nice. So now we connected to the server. We know that the tools available are create file and I can say write a three paragraph essay on pancakes and somehow related to the idea of standardization protocols for building production ready LM agents. So we're going to send this input and we're going to analy we're going to take a look at what happens as we are sending this input processing request of type list to request. You see that uh a a two call a two call was made and then we're seeing that I'll help create this essay by writing it and saving it to a file. We see that it's saved to a file called pancakes in standardization.txt. Pretty nice. And we can actually inspect and see if that file actually exists. So I'm going to run control P and then pancake something. And then here we are folks. We have a wonderful essay about pancakes and standardization. Just as the perfect pancake requires a standardized recipe and precise execution, development of agents demands well- definfined protocols and blah blah blah blah blah. This is awesome. So in in a very simple and easy manner where all of the complexity really just came from uh the code that we took from uh the MCP protocol for the client. We were able to build a simple server. We exposed a very simple functionality and we accessed that functionality from the client side and we used it which is pretty awesome. So thanks for watching folks. Don't forget to like and subscribe and see you next time. Cheers.