MCP · Model Context Protocol

The Model Context Protocol
Complete Explanation

Why MCP quietly became the standard way AI connects to everything — your files, your databases, your tools — and what it actually is: how it works under the hood, where it sits inside an AI agent, and how to find, plug in, and build MCP servers safely.

Source: youtube.com/watch?v=_fzpnqt39jQ · Channel: Aishwarya Srinivasan

Agenda

What We'll Cover

Core Concepts

Why MCP exists — the drawer of chargers
What MCP is — the USB-C for AI
The three pieces — host, client, server
Where MCP sits inside an AI agent
MCP vs function calling, APIs & plugins

Practical Playbook

Finding MCP servers
Local & remote servers — how you actually use one
The security reality no tutorial mentions
Building your first MCP server

Section 1 · The Problem

The Drawer of Chargers

Every connection between a model and a tool is a custom integration — you write it, test it, maintain it. Ten applications and a hundred tools means potentially a thousand integrations, each one bespoke and brittle.

Before — point-to-point chaos

One cable per device, none of them interchangeable.

Each app is wired by hand to its database, CRM, Slack, and files — connectors that only work for the exact pair they were built for.

After — one standard plug

Any AI app connects through the MCP protocol to any server.

One standard cable reaches a database server, a CRM server, a Slack server, a files server — build the connector once, use it everywhere.

The AI ecosystem hit the same wall as the phone drawer: many models, many tools, many data sources, all wired together by hand. That is the problem MCP exists to solve.

Section 2 · The Standard

The USB-C for AI

Open standard

Originally released by Anthropic in November 2024.

One common language for AI models and the tools and data around them. Build a connector once — Claude, ChatGPT, Cursor, or your own custom agent can use it, with no rewrites and no special casing per platform.

Vendor-neutral

Donated to the Linux Foundation in December 2025.

MCP became a community-governed standard — not a one-company thing anymore. The industry essentially agreed on the shape of the plug.

The numbers

From roughly 100,000 downloads a month to 97 million a month in about eighteen months — and the default way an AI application connects to the outside world.

Section 3 · Architecture

Three Pieces: Host, Client, Server

Exactly three pieces — and the USB-C analogy maps onto them almost perfectly.

Host

The AI application — Claude Desktop, Cursor, VS Code, ChatGPT.

Think of the host as your phone.

MCP client

The USB-C port inside the host.

Speaks the protocol and manages the connection. Invisible plumbing from your point of view — from the protocol's point of view, it is the endpoint doing the talking.

MCP server

The accessory you plug in.

A small program wrapping tools and data sources — your database, calendar, GitHub — exposed in the standard MCP format. Don't let the word "server" intimidate you: it can be a hundred lines of Python on your laptop.

The server speaks MCP to the client over stdio (local) or HTTP (remote).

Section 3 · Inside a Server

Tools, Resources & Prompts

A server gives the model three kinds of things — the clearest way to see the difference is onboarding a new employee.

Tools

What the model can do.

Like giving the new hire software access so they can take actions. A filesystem server exposes read and write operations as tools.

Resources

What the model can read.

Like handing the new hire the company wiki. The same filesystem server lets the model open files as resources.

Prompts

Reusable templates for doing tasks well.

Like your standard operating procedures for common workflows.

When a client connects, it asks "What do you have?" The server advertises its tools, resources, and prompts — with descriptions and typed inputs. Everything is discovered at runtime, nothing hardcoded — that single discovery step is what makes MCP feel like magic.

Section 4 · Agents

Model Decides, Harness Executes, MCP Connects

MCP alone is not an agent. When people say "AI agent," what is really running is a harness — a loop around the model: the model reasons, while the harness manages memory, tracks state, decides when to loop again, and executes actions.

Model — the brain Harness — the workstation & workflow MCP — the company badge: one standardized access layer

Model decides it needs rows from a database Harness routes the intent through the MCP client Client calls the tool on the right server Server does the work, returns the rows Result flows back into the model's context Model keeps reasoning — loop until the task is complete

Section 5 · Comparison

It Replaces Nothing You Already Use

MCP sits underneath the layers you already have and standardizes the connection between them.

Layer	Role
Function calling	Capability of the model — sees the task, decides a tool is needed, produces a structured request with the right arguments
MCP	The transport — carries the request to the tool and brings the result back
Your API	Does the actual work on one service — MCP is a standard layer on top of it

You need both

Function calling is deciding to call somebody and dialing the number; MCP is the telephone network that lets any phone reach any other. Building with MCP is not replacing function calling — it is giving it somewhere standardized to land.

"It replaces your APIs" — no

An API is a point-to-point connection to one service; it doesn't go anywhere. MCP just gives every model the same way to find your API and talk to it. If someone tells you MCP replaces APIs, they have misunderstood the stack.

Section 5 · A Little History

Why Plugins Lost

2023 ChatGPT plugins

Proprietary — one cable per brand.

Build it for one platform; want the same capability anywhere else? Build it again. Every AI platform ran its own plugin store.

MCP flips the model

One open protocol — every platform implements the same port.

Build your server once and it works on Claude, ChatGPT, Cursor, VS Code, and whatever agent framework you run.

That is why the plugin era quietly ended — even the platforms that built plugin stores moved to MCP. To be fair, plugins are not all invalid today; some tools still use them. But MCP has become the more standard way of doing it.

Section 6 · Discovery

Search Before You Build

There are over 10,000 public MCP servers at last count — discovery is genuinely the easy part.

Official MCP registry

The canonical directory, where verified publishers increasingly list their servers.

GitHub reference repo

The Model Context Protocol servers repository — the reference servers filesystem, fetch, and memory — one of the most-starred repositories in the whole space.

Community directories

Pulse MCP and similar — browse by category: a Notion server, a Postgres server, a GitHub server.

Rule of thumb

Before you ever build your own MCP server, search first — the integration you need probably already exists.

Section 7 · Using a Server

Local or Remote — One Config Entry Either Way

Flavor	What it is
Local server	Runs on your machine; talks to the client over stdio — standard input and output between processes. What you want for local files and experimentation.
Remote server	Hosted somewhere else; you connect over HTTP and typically authenticate with OAuth. How most companies expose their products.

Add a small config entry — launch command (local) or URL (remote) Restart the app Client handles the handshake — tools discovered automatically Talk to your AI normally; it calls the tools when needed

Recommended starting point

Go local with something low-stakes — a filesystem server — and watch how the model calls its tools. Build your intuition there before scaling up to many servers.

Section 8 · Security

The USB Stick From a Parking Lot

An MCP server is code that gets a direct line into your AI's context — and often into your real accounts and data.

The trust gap

Only 13% of publicly available MCP servers meet high trust thresholds

Independent assessments scored documentation, maintenance, and reliability — and most public servers fall short.

Real incidents, not hypotheticals

Dozens of CVEs in early 2026
Tool-poisoning attacks — malicious instructions hidden inside tool descriptions
A hosted platform's path-traversal flaw that exposed thousands of applications

This actually happened.

Installing a random MCP server is like plugging a USB stick you found in a parking lot into your laptop. Yes, it can be that scary.

Section 8 · Defenses

Least Privilege, Humans in the Loop

Prefer official servers from verified publishers — or read the code before you run it (it's usually small enough)

Least privilege, always — if a server only needs to read data, give it read-only credentials

Keep a human in the loop for everything sensitive or irreversible — writes, deletes, sending messages

At team scale: route servers through a central gateway or internal registry — you control exactly which servers agents can reach

Default everything to scoped read-only credentials, put sensitive operations behind human approval — that setup handles thousands of tool calls a day. Security and scale are not opposites; the guardrails are what let you scale.

Section 9 · Build

The Fifteen-Minute Path With FastMCP

Your first working MCP server is genuinely a fifteen-minute project — and Python is the shortest path.

Pick one API or data source you use daily Write a typed Python function with a docstring Add the FastMCP decorator — the SDK turns it into a fully described tool, no protocol plumbing by hand Trigger it in the MCP Inspector first Register the server in your app config Your AI calls your code over stdio

The SDKs

FastMCP ships inside the official Python SDK. TypeScript developers get an equally solid official TypeScript SDK.

The MCP Inspector

A local web interface where you can trigger your tools manually — before any model ever touches them.

Section 9 · The Project

Don't Overbuild Your First Server

Pick one API or data source you use every day — Notion, a weather API, or a read-only view of your own database — and wrap it in one well-tested tool over stdio.

Validate it in the MCP Inspector Connect it to your client Watch your AI call it in daily use Graduate it to HTTP with OAuth only once more than one person needs it

MCP is not the intelligence part — it is the plumbing part. And right now, the teams winning with AI are exactly the ones doing that plumbing: giving their models a standardized way to actually touch real-world data.

Most people overbuild their first server — don't do that.

Key Takeaways

The Complete Picture

MCP is the "USB-C for AI" — an open standard from Anthropic (Nov 2024), now community-governed under the Linux Foundation (Dec 2025)

Adoption exploded from ~100,000 to 97 million downloads a month in about eighteen months

Three pieces: host (the app), client (the in-host port), server (wraps tools, resources, prompts)

Servers advertise their capabilities — everything is discovered at runtime, nothing hardcoded

MCP alone is not an agent — model decides, harness executes, MCP connects

It complements function calling and APIs; it won the race against proprietary per-platform plugins

Over 10,000 public servers — official registry, GitHub reference repo, community directories; search first

Local over stdio, remote over HTTP + OAuth — a config entry and a restart is all it takes

Only ~13% of public servers meet high trust thresholds — verified or read the code, least privilege, humans in the loop

A first server is a 15-minute FastMCP project — typed function + decorator, tested in the MCP Inspector

The End

Go Build the Plumbing

MCP is not the intelligence part — it is the plumbing part. The teams winning with AI are the ones giving their models a standardized way to actually touch real-world data.

Source: "MCP Complete Explanation" — Aishwarya Srinivasan (youtube.com/watch?v=_fzpnqt39jQ) · Channel: youtube.com/@aishwaryasrinivasan

The Model Context ProtocolComplete Explanation