Discover the advanced features that separate a toy MCP server from a production one. You'll use sampling to borrow the client's language model, stream log and progress notifications from a slow tool so users see it working, and enforce roots so a server only ever touches the files it was granted.


Video: Let's get started!

Video: Sampling

Sampling

Sampling walkthrough

Delegate the summary with sampling

Video: Log and progress notifications

Log and progress notifications

Notifications walkthrough

Add progress and logs to a slow tool

Video: Roots

Roots

Roots walkthrough

Stop your tool from escaping its roots

Read a file only if it's inside the roots

Core MCP features

Go to the wire level and see how MCP clients and servers actually talk. You'll hand-write JSON-RPC requests and notifications, trace the initialization handshake, and compare the STDIO transport for local servers with the StreamableHTTP transport for remote ones, including how Server-Sent Events and statelessness shape what each can do.


Video: JSON message types

JSON message types

Sort the MCP messages

Build a request and a notification

Video: The STDIO transport

The STDIO transport

Initialize an MCP connection in the right order

Watch messages flow over stdin/stdout

Video: The StreamableHTTP transport

The StreamableHTTP transport

Flip the flags, predict the breakage

Video: StreamableHTTP in depth

StreamableHTTP in depth

Trace the SSE message flow

Video: State and the StreamableHTTP transport

State and the StreamableHTTP transport

Stateful or stateless?

Video: Wrapping up

Transports and communication

Already built a basic MCP server and want to go further? This course dives into the advanced features production servers and clients depend on. You'll use sampling to let a server borrow the client's language model, stream log and progress updates from long-running tools, and enforce filesystem boundaries with roots. Then you'll go to the wire level: JSON-RPC message types, the STDIO transport for local servers, and the StreamableHTTP transport for remote servers, including how it handles state. By the end, you'll understand how real MCP connections work under the hood.

You've built an MCP server that exposes a few tools - now it's time to make it behave like the ones running in production. Advanced MCP is where servers delegate work to clients, report on what they're doing, respect filesystem boundaries, and talk to clients across very different transports.
<br><br>
<h2>Master Core MCP Features</h2>
Start with sampling, which lets a server hand a prompt back to the client's language model instead of holding its own API key. Then stream log and progress notifications so learners watching a 30-second tool call can see it working, and use roots to define exactly which files and folders a server is allowed to touch - a boundary the SDK leaves you to enforce yourself.
<br><br>
<h2>Understand How Clients and Servers Talk</h2>
Go to the wire level and see what actually crosses the connection. You'll hand-write JSON-RPC requests and notifications, tell the two apart by their id field, and follow the initialization handshake message by message.
<br><br>
<h2>Compare the STDIO and StreamableHTTP Transports</h2>
Learn why a STDIO server only works on one machine, how the StreamableHTTP transport uses a long-lived Server-Sent Events stream to push messages back to the client, and what the stateless_http and json_response flags trade away. By the end, you'll know which transport fits a local tool versus a remote, load-balanced deployment - and why.

Introduction to Model Context Protocol (MCP)

Go beyond MCP basics: sampling, progress and log notifications, roots, JSON-RPC messages, and the STDIO and StreamableHTTP transports in Python.

Model Context Protocol: Advanced Topics

Go beyond MCP basics with sampling, notifications, roots, and the STDIO and StreamableHTTP transports in Python.

Roots

Model Context Protocol: Advanced Topics

ejercicio interactivo práctico