$ ▍
Instructor: Daniel academyintermediateAI
This course is for people who write Python, have used an AI assistant, and want to give it hands: their files, their database, their internal API. MCP is the protocol every serious client now speaks to reach an external tool, and here you learn it from the bytes up. Three modules, twelve lessons, seven of them graded in the browser. You start by naming the four JSON-RPC message shapes and answering a server/discover, the one call every server must implement. Then comes the idea the whole protocol now rests on: a request carries its own context. You validate params._meta, refuse an unsupported protocol version with -32022, refuse an undeclared client capability with -32021, answer tools/list with real JSON Schema and tools/call with argument validation. You finish with a whole stateless server in a single file: blank lines, unparseable lines answered with -32700, the envelope checked on every line, and state that exists only behind an explicit handle the client hands back on each call. That file, launched as a subprocess by a real client, is a real MCP server. Now the part most courses skip. The trainer grades your code on Judge0 with Python 3.8.1, in a sandbox with no network and no pip. The official MCP Python SDK cannot run there: it requires Python 3.10 or newer and depends on pydantic, httpx2, starlette and anyio. So this course imports no SDK and never pretends to. You will not deploy anything here, and no exercise calls a live API. What you get instead is the thing an SDK hides: every key, every error code, every rule about who may answer what and when. Pick up an SDK later and you will recognise all of it. The closing lesson covers, honestly and without simulating it, what an autograder physically cannot check: the Streamable HTTP transport, wiring your server into a real client's config, and the security rules of the specification. A word on versions, since courses usually skip it. You learn revision 2026-07-28, released on 28 July 2026 and current: it deleted the initialize handshake, made the protocol stateless, moved the protocol version and the client capabilities into the _meta of every request, added resultType to every result, and removed ping along with the session it existed to keep alive. That model is the main line of this course from the second lesson on. The handshake era is not hidden from you either, because most deployed clients, servers and SDKs still speak it: the last module has one lesson that shows initialize, capability negotiation and the version dance exactly as they were, every block of it marked legacy, plus a field-by-field migration table. The exercise after it puts you on the client side for the only time in the course, probing an unknown server and deciding whether it is modern, modern on another version, or legacy. The rule that a fallback must never key off a single error code is baked into the hidden tests. The course is free, and it is the entry point of the AI track. When you want the applied side, "AI Tools from Scratch" covers working with models day to day, and "AI Telegram Bots" turns the same skills into a product users can talk to.
3 modules · 12 lessons
A fragment of the course's final project. Every graduate writes this code with their own hands.
from openai import OpenAI
client = OpenAI()
reply = client.responses.create(
model="gpt-4o-mini",
input=f"Summarize this support ticket in one line: {ticket}",
)
print(reply.output_text)