Introduction to MCP and Its Role in the Future of AI Agents

Understanding MCP’s Architecture

Diving Into MCP Servers and a Workflow Example

Building Your First MCP Server – Let’s Get Coding!

Connecting Your MCP Server to Claude for Desktop

Closing Thoughts and Next Steps

Introduction

( the primaryDescriptionMarkdown is long - several lines, include images, as long as you want )

In this course we <headline of what we do>. <why this technology is good> but <here's how learning it is problem>. 

In <the length of these lessons> we cover <three salient points about what we cover. Your BEST points>. Its <however long it is> and comes with <these bonus features, and reasons to buy. code, etc.>

It's taught by <author name> who <credibility, reason you should listen to them>. <social proof, if you have it yet>

<then you can list other supporting stuff you want to add, anything you want here>

-------
Example:
-------

We created a free course to create your first GraphQL server (from scratch) using Node and TypeScript. TypeScript and GraphQL are a powerful combo, but there's a lot of confusing edges if you're getting it setup the first time.

In this course we cover the basics of getting TypeScript setup with Node, how GraphQL works, and how to set up a GraphQL server using Apollo server. It's two hours long, it comes with complete code examples, and we walk through the code step-by-step.

It's taught by my friend, Shopify-engineer Hassan Djirdeh and he's integrated what he's learned using GraphQL in production as an engineer at Shopify. We've already had over 1,300 students enroll and it's been getting great reviews so far.

// ... and so on

How Model Context Protocol (MCP) will Change the Way we Build Al Apps and Why you Need to Learn It

In this course we’ll walk you through everything you need to know about MCP—from its core components and main concepts to practical implementations. We will focus specifically on building an MCP server, as it is likely the most useful and frequently used part of the MCP architecture that you will want to implement.

MCP in Practice: The Future of AI Agents

Now that we’ve got the basics of MCP under our belts, it’s time to dig into the architecture. Don’t worry, nothing scary here—we’re going step-by-step to unpack how this whole thing works. By the end of this lesson, you’ll have a solid grip on the pieces that make MCP tick and why they’re set up the way they are.

MCP’s architecture boils down to three key components. Well, technically two are must-haves, and the third is optional depending on what you’re doing. Here’s the lineup:

So, how do these pieces play together? Imagine you’re in your app (the host) and you ask, “What’s the weather like today?” The host chats with the LLM (large language model) inside it, passing along your question. The MCP client then steps in, checks what servers are available, and picks one—say, Server B, the weather guy. The client sends the request to Server B via the MCP protocol, Server B does its thing (maybe hits an API under the hood), and sends the answer back. Boom, you’ve got your weather report!

APIs Aren’t Dead—They’re Just Wrapped Up

You might be thinking, “Wait, Max, didn’t you say MCP replaces APIs?” Not quite! APIs are still there, doing their job beneath the surface. The MCP server is like a wrapper—a neat little package that hides all the messy API logic inside. You write the code to connect to APIs or whatever else inside the server, but from the outside, it’s a clean, standardized connection. This makes it super flexible—you can tweak the server however you want, and it’ll still plug into any MCP client easily. Plus, you can share it with anyone, no fuss.

Think of it like this: the API calls are still happening, but they’re nested inside the MCP server. It’s doing the dirty work so the client doesn’t have to. Beautiful, right?

---
title: Understanding MCP’s Architecture
privateVideoUrl: https://stream.mux.com/i1ARPUeqTGUFpwJ3NUnqKulq6t4vHZcu6p9LCDDB0134.m3u8
isPublicLesson: true
---

Now that we’ve got the basics of MCP under our belts, it’s time to dig into the architecture. Don’t worry, nothing scary here—we’re going step-by-step to unpack how this whole thing works. By the end of this lesson, you’ll have a solid grip on the pieces that make MCP tick and why they’re set up the way they are.

## The Big Picture: Three Main Parts

MCP’s architecture boils down to three key components. Well, technically two are must-haves, and the third is optional depending on what you’re doing. Here’s the lineup:

1.  **The MCP Host with MCP Client** (aka the “application side”): Think of this as where your AI app lives—like Claude, some IDE plugin, or another tool you’re using. For now, let’s just call it the “client side” to keep it simple. We’ll break down the host vs. client distinction in a sec.
2.  **The MCP Server**: This is the workhorse that connects to data or tools and does the heavy lifting. It talks to the client side through the MCP protocol—both sides need to support MCP for this to work.
3.  **Data Sources** (local or remote): This is where the info lives—databases, files, APIs, whatever. It’s optional because not every task needs data; sometimes the server just crunches numbers or runs a task.

So, how do these pieces play together? Imagine you’re in your app (the host) and you ask, “What’s the weather like today?” The host chats with the LLM (large language model) inside it, passing along your question. The MCP client then steps in, checks what servers are available, and picks one—say, Server B, the weather guy. The client sends the request to Server B via the MCP protocol, Server B does its thing (maybe hits an API under the hood), and sends the answer back. Boom, you’ve got your weather report!

## APIs Aren’t Dead—They’re Just Wrapped Up

You might be thinking, “Wait, Max, didn’t you say MCP replaces APIs?” Not quite! APIs are still there, doing their job beneath the surface. The MCP server is like a wrapper—a neat little package that hides all the messy API logic inside. You write the code to connect to APIs or whatever else inside the server, but from the outside, it’s a clean, standardized connection. This makes it super flexible—you can tweak the server however you want, and it’ll still plug into any MCP client easily. Plus, you can share it with anyone, no fuss.

Maksym Mitusov

And right now it's time to get into some architecture.

we'll learn about everything, then about server,

And the third part can be excluded, if needed.

First of all, it's host with the MCP client.

Just in short, I would play in the difference

But let's call it for now the client, right?

They're all once again connected, why MCP protocol?

And they both need to be like support the MCP itself,

we have some local storage, remote storage,

We are giving some instruction on the client side

I need to know what the weather is, right?

A host is responsible for the actually talking to the LLM

no worries, we'll go over more detail just on the next slide,

and what actually it can pick for the task.

and we are then connecting to the, for example, server B,

server B is responsible for weather or whatever.

And then we are sending whatever we have the query

to the server in some specific structured way.

Server on its side makes the API goals underneath the hood

and then it actually goes and fetch some data or a,

but it can just perform some calculations and corporations.

That's why I mentioned that the storage is not usually

- So it can go fetch data and could calculate something

on the server side, then the results are being sent

Okay, so we still use the API in the next hood

and this is correct because we are not exactly like

by magic throwing away all the API connections, right?

that we are writing to connect to the different services

So it's like a group with beautiful wrapper, right?

but it would still be easily connected to whatever we want

and whenever, and we can easily share it with whoever we want.

It just wants to get a wrapper which gives us super easy way

and flexible way to apply this server to whenever

if we want, but the, it would still is wrong,

and it just underneath the hood doing a job.

Then I believe we can talk a little bit more

First thing that I want to address is about actually

figuring out what's the difference between MCP host

This is actually really interesting solution

and really right solution of the anthropic

Actually, it's processing the data we are interacting with it.

And another logic is responsible for actually sending

and basically keeping the connection with the server, right?

So as I mentioned before, you can see about the MCP host

as the your AI application that you're using for choice.

And MCP host on the other hand, it actually includes

it can spawn multiple MCP clients inside.

Why exactly spawn because the client is responsible

which would be basically managing the connection to it.