How MCPs Make Agents Smarter (for non-techies)

All right, so keep in mind there is zero prompting going on within the actual agent. It just says, "You are a helpful assistant." Now I'm gonna ask it to get Airbnb listings in Miami. It's hitting Airbnb's NPC server in order to understand, okay, what resources do I have? What actions can I take? What are the tool names? And now it's hitting its execute tool in order to fill in the tool name and fill in the different parameters that it needs to pull back those listings that we're looking for. So it should be finishing up any second now and we will be able to see these listings that we got. There we go. So we have, here are some Airbnb listings in Miami. 126 Sailboat, it gets us price information, location, all this kind of stuff. If we click in here, we should see an actual picture of Airbnb listing. This is actually kind of just a boat, but either way, we got 5 total. Here's a beautiful suite in Miami, which once again, Airbnb Miami. Now to look at what it actually did. As we know, it hit the server first to list out the tools. So as you can see, it has Airbnb Search, which we use when we want to search for listings, and here are the different filters that we can use, the different parameters. Parameters. And then we have the other tool, which is listing details, in order to get information about a specific listing. And in that case, these are the different parameters that we would send over. So because the agent was able to understand this is what I have access to and this is when I use each one, I'm going to fill in my tool, which is over here. The tool I used is Airbnb_search, and I know that one of the parameters I need to fill out is the location, which I will put Miami. And then we get all of our actual results back. Cool. We're going to do one more quick example, which is asking it to scrape Chipotle. So sent that off, it's gonna hit Firecrawl's MCP server this time in order to understand what actions do I have over here, what can I do. And now it's hitting the actual tool to take action for us, and we should get back, you know, the, the scrape results from chipotle.com. So it's finishing up now, and we should see the results right here. So let's make this a little bigger. I've scraped the main content from Chipotle homepage. Here's a summary. We have new Chipotle honey chicken, Chipotle rewards, menu highlights, guacamole, all this kind of stuff. And if we were to click into the Firecrawl Actions tool, we can see that Firecrawl has more than just those two actions that Airbnb had. It has scrape, it has map, it has crawl, it has all of these, it has 9 total, even deep research. And then the execute tool is able to say, okay, in this case, I need to scrape, I need to use this URL, I am going to format it in Markdown, and then we get our answer back here. So what's going on in this tool is it's basically 9 tools wrapped into one, and all of these other ones are multiple tools wrapped into one as well. So if we wanted to build out this entire agent, it would have to look something like this if we weren't accessing MCP servers. And once again, in that demo, there was zero prompting going on within the agents, and there was no prompting going on within the descriptions of the parameters to be sent over either. So this is really just, all I did was plug in the servers and give it a chat model. If we really got more refined with our prompting, these things are going to get really powerful. So we're going to hop into an Excalidraw. I'm going to break down what is actually going on, what MCP is, as simple as I can. And if you guys are wanting a step-by-step build of, you know, how we actually, you know, spin up a self-hosted environment, install the community node, right, that we're looking at right here, make sure everything's configured correctly, and then, you know, actually connect to the different MCP servers that we want, then definitely drop a like and let me know in the comments if you wanna see that, 'cause I would love to make a video covering this topic. So let's get into the breakdown. Okay, so model context protocol. I swear the past week it's been the only thing I've seen in YouTube comments, YouTube videos, Twitter, LinkedIn. It's just all over. And I don't know about you guys, but when I first started reading about this kind of stuff, I was kind of intimidated by it. I didn't completely understand what was going on. It was very techie and, you know, kind of abstract. I also felt like I was getting different information based on every source. So we're going to break it down as simple as possible, how it makes AI agents more intelligent. Okay, so we're going to start with the basics here. Let's just pretend we're going back to ChatGPT, which is, you know, a large language model. What we have is an input on the left where we're able to ask it a question, you know, help me write this email, tell me a joke, whatever it is. We feed in an input, the LLM thinks about it and provides some sort of answer to us as an output. And that's really all that happens. The next evolution was when we started to give LLMs tools. And that's when we got AI agents, because now we could ask it to do something like write an email, but rather than just writing the email and giving it back to us, it could call a tool to actually write that email, and then it would tell us, there you go, the job's done. And so this really started to expand the capabilities of these LLMs because they could actually take action on our behalf rather than just sort of assisting us and getting us 70% of the way there. And so before we start talking about MCP servers and how that enhances our agent's abilities, we need to talk about how these tools work and sort of the limitations of them. Okay, so sticking with that email example, let's pretend that this is an email agent that's helping us take action in email. What it's gonna do is each tool has a very specific function. So this first tool over here, you can see this one is going to label emails. The second tool in the middle is going to get emails, and then this third one on the right is going to send emails. So if you watch my Ultimate Assistant video— if you haven't, I'll tag it right up here— what happened was we had a main agent and then it was calling on a separate agent that was an email agent. And as you can see here was all of its different tools, and each one had one very specific function that it could do. And it was basically just up to the email agent right here to decide which one to use based on the incoming query. And so the reason that these tools aren't super flexible is because within each of these configurations, we basically have to hardcode in what is the operation I'm doing here and what's the resource. And then we can feed in some dynamic things like different message IDs or label IDs. Over here, you know, the operation is GET, the resource is message, so that won't change. And then over here, the operation is that we're sending a message. And so this was really cool because agents were able to use their brains, whatever large language model we had plugged into them, to understand which tool do I need to use. And it still works pretty well, but when it comes to being able to scale this up and you want to interact with multiple different things, not just Gmail and Google Calendar, you also want to interact with a CRM and different databases, that's where it starts to get a little confusing. So now we start to interact with something called an MCP server, and it's basically just gonna be a layer between your agent and between the tools that you want to hit, which would be right here. And so when the agent sends a request to the specific MCP server, in this case, let's pretend it's Notion, it's going to get more information back than, hey, what tools do I have and what's the functionality here? It's also gonna get information about like, what are the resources there? What are the schemas there? What are the prompts there? And it uses all of that to understand how to actually take the action that we asked back here in the whole input that triggered the workflow. When it comes to different services talking to each other, so in this case, n8n and Notion, there's been, you know, a standard in the way that we send data across and we get data back, which has been the REST APIs. And these standards are really important because we have to understand how can we actually format our data and send it over and know that it's going to be received in the way that we intend it to be. And so that's exactly what was going on back up here, where every time that we wanted to interact with a specific tool, we were hitting a specific endpoint. So the endpoint for labeling emails was different for the endpoint for sending emails. And besides just those endpoints or functions being different, There was also different things that we had to configure within each tool call. So over here, you can see what we had to do was in order to send an email, we have to give it who it's going to, what the subject is, the email type, and the message, which is different from the information we need to send to this tool, which is what's the message ID you want to label and what is the label name or ID to give to that message. By going through the MCP server, it's basically going to be a universal translator that takes the information from the LLM and it enriches that with all of the information that we need in order to hit the right tool with the right schema, fill in the right parameters, access the right resources, all that kind of stuff. The reason I put Notion here for an example of an MCP server is because within your Notion you'll have multiple different databases, and within those databases you're going to have tons of different columns, and then all of those, you know, are going to have different pages. So being able to have the MCP server translate back to your agent Here are all of the databases you have. Here is the schema, or the different fields or columns that are in each of your databases. And also, here are the actions you can take. Now, using that information, what do you want to do? Real quick, hopping back to the example of the Ultimate Assistant, what we have up here is the main agent, and then it had 4 child workflows, child agents, that it could hit that had specializations in certain areas. So the Gmail agent, which we talked about right down here, the Google Calendar agent, the contact agent, which was Airtable, and then the content creator agent. So all that this agent had to do was understand, okay, based on what's coming in, based on the request from the human, which of these different tools do I actually access? And we can honestly kind of think of these as MCP servers, because once the query gets passed off to the Gmail agent, the Gmail agent down here is the one that understands, here are the tools I have, here are the different, like, you know, parameters I need to fill out, I'm gonna take care of it, and then we're gonna respond back to the main agent. This system made things a little more dynamic and flexible because then we didn't have to have the Ultimate Assistant hooked up to like 40 different tools, you know, all the combinations of all of these, and it made its job a little more easier by just delegating the work to different MCP servers. And obviously these aren't MCP servers, but it's kind of the same concept. The difference here is that let's say all of a sudden Gmail adds more functionality, we would have to come in here and add more tools in this case. But what's going on with the MCP servers is whatever MCP server that you're accessing, it's on them to continuously keep that server updated so that people can always access it and do what they need to do. By this point, it should be starting to click, but maybe it's not 100% clear. So we're going to look at an actual example of like what this really looks like in action. But before we do, just want to cover one thing, which is, you know, the agent sending over a request to a server, the server translates it in order to get all this information and get the tool calls. All that kind of stuff. And what's going on here is called MCP protocol. So we have the client, which is just the interface that we're using. In this case, it's NNN. It could be your Claude or your, you know, coding window, whatever it is. And then we're sending over something to the MCP server, and that's called MCP protocol. Also, one thing to keep in mind here that I'm not going to dive into, but if you were to create your own MCP server and it had access to all of your own resources, your schemas, your tools, all that kind of stuff, You just gotta be careful there. There's some security concerns because if anyone was getting into that server, they could basically ask for anything back. So that's something that was brought up in my paid community. We were having a great discussion about MCP and stuff like that. So just keep it in mind. So let's look more at an example in n8n once again. So coming down here, let's pretend that we have this beautiful Airtable agent that we built out in n8n. As you can see, it has these, um, 7 different tools, which is get record, update record, get bases, create record, search record, delete record, and get bases schema. The reason we needed all of these different tools is because, as you know, they each have different operations inside of them, and then they each have different parameters to be filled out. So the agent takes care of all of that. But this could be a lot more lean of a system if we were able to access Airtable's MCP server, as you see what we're doing right here, because this is able to list all the tools that we have available in Airtable. So here you can see I asked the Airtable agent, what actions do I have? It then listed these 13 different actions that we have, which are actually more than the 7 we had built out here. And we can see we have list records, search records, and then 11 more. And this is actually just the agent telling us, the human, what we have access to. But what the actual agent would look at in order to use the tool is a list of the tools where it would be, here's the name, here's the description of when you use this tool, and then here's the schema of what you need to send over to this tool. Because when we're listing records, we have to send over different information like the base ID, the table ID, max records, how we want to filter, which is different than if we want to list tables because we need a base ID and a detail label. So all of this information coming back from the MCP server tells the agent how it needs to fill out all of these parameters that we were talking about earlier, where it's like send email, you have different things than you need to fill out for labeling emails. So once the agent gets this information back from the MCP server, it's going to say, okay, well, I know that I need to use the search records tool because the user asked me to search for records with the name Bob in it. So I have this schema that I need to use, and I'm going to use my Airtable execute tool in order to do so. And basically what it's going to do is going to choose which tool it needs based on the information that was fed previously. So in this case, the Airtable execute tool would search records and it would do it by filling in this this schema of information that we need to pass over to Airtable. So now I hope you can see how basically what's going on in this tool is all 13 tools wrapped up in a one. And then what's going on here is just feeding all the information we need in order to make the correct decision. So this is the workflow we were looking at for the demo. We're not going to dive into this one because it's just a lot to look at. I just wanted to put a ton of MCP servers in one agent and see that even if we had no system prompt, if it could understand which one to use and then still understand how to call its tools. So I just thought that was a cool experiment. Obviously what's next is I'm going to try to build some sort of huge, you know, personal type assistant with a ton of MCP servers. But for now, let's just kind of break it down as simple as possible by looking at an individual MCP agent. And so I don't know why it's called an MCP agent. In this case, it's just kind of like a Firecrawl agent with access to Firecrawl's MCP server. So yeah. Okay, so taking a look at Firecrawl agent, we are going to ask, what tools do you have? It's hitting the Firecrawl actions right now in order to pull back all of the resources. And as you can see, it's going to come back and say, hey, we have these, you know, 9 actions you can take. I don't know if it's 9, but it's gonna be something like that. It was 9. So as you can see, we have access to scrape, map, crawl, batch scrape, all this other stuff. And what's really cool is that if we click into here, we can see that we have a description for when to use each tool and what you actually need to send over. So if we wanna scrape, it's a different schema to fill out than if we want to do something like extract. So let's try actually asking it to do something. So let's say, um, extract the rewards program name from, um, chipotle.com. So we'll see what it does here. Obviously it's going to do the same thing, listing its actions, and then it should be using the firecrawl_extract method. So we'll see what comes back out of that tool. Okay, it went green. Hopefully we actually got a response. It's hitting it again, so We'll see what happened. We'll dive into the logs after this. Okay, so on the third run, it finally says the rewards program is called Chipotle Rewards. So let's take a look at run 1. It used Firecrawl extract, and it basically filled in the prompt, extract the name of the rewards program. It put it in as a string. We got a request failed with status code 400, so not sure what happened there. Run 2, it did a Firecrawl scrape. We also got a status code 400. And then run 3, what it did was a Firecrawl scrape once again, and it was able to scrape the entire thing, and then it used its brain to figure out what the rewards program was called. Taking a quick look at the Firecall documentation, we can see that a 400 error code means that the parameters weren't filled out correctly. So what happened here was basically it just didn't fill these out exactly correctly, the schema of like the prompt and everything to send over. And so really these kind of issues just come down to a matter of, you know, making the tool parameters more robust and also more prompting within the actual Firecall agent itself. But it's pretty cool that it was able to understand, okay, this didn't work, let me just try some other things. Okay, so real quick, just wanted to say if you want to hop in N8N and test out these MCP nodes, you're gonna have to self-host your environment because you need to use the community nodes and you can only access those if you are self-hosted. But I will leave a link in the description for the documentation for this MCP node as well as this link which has basically all the servers that you can connect to. Um, so obviously in this one we were doing like Airbnb and we had Brave Search, we had Firecrawl. There's a ton that you can use. And just so you know, one issue that I was running into in setup is some of these aren't like publicly available or completely published yet. So like Perplexity I was trying to connect to and it wasn't letting me, and I was thinking I did something wrong, but some of these just aren't like published yet. And once again, if you guys want a tutorial of, you know, spinning up a self-hosted environment, installing the community node, connecting to a bunch of different ones here, then let me know in the comments and give this video a like. I'd love to make a video about that. All right, but that is going to be it for this one. I hope that you enjoyed this one. I hope you learned something new. If you did, please give it a like. It definitely helps me out a ton. As always, appreciate you guys sticking around to the end of the video, and I will see you guys in the next one. Thanks everyone.