MCP and A2A in Python: The Agent Protocol Course

Ship production MCP servers, A2A clients, and multi-agent integrations in Python. Verified against current SDKs.

New

Created byRicardo Cataldi

Last updated 4/2026

English

What you'll learn

Build FastMCP servers in Python that expose resources, tools, and prompts any MCP-compatible agent can consume.
Implement A2A servers and clients with the a2a-sdk, including agent cards, capability discovery, and streaming responses.
Design synchronous request-response integrations with retries, timeouts, and structured error handling that survive production traffic.
Deploy asynchronous, event-driven agent patterns with SSE streaming, callbacks, and long-running task orchestration.
Apply gateway, orchestrator, and mesh architectures to coordinate multiple agents across teams and services.
Combine MCP and A2A in an end-to-end capstone: a multi-agent research assistant you build from zero to deployment.

Course content

6 sections • 38 lectures • 5h 29m total length

Important notes before you start4:01
Welcome and Course Roadmap8:16
Lecture 01 — Welcome and course roadmap
Section: 1 · Duration: 5 min · Type: Video
Objective
Frame the course, the protocols, and how the six sections build toward an end-to-end multi-agent system.
Core concepts
What MCP and A2A are and why both exist
How the sections progress from primitives to an integrated build
Tooling: uv, FastMCP, a2a-sdk, MCP Inspector
The Problem — Fragmented Agent Integrations8:34
Lecture 02 — The problem: fragmented agent integrations
Section: 1 · Duration: 8 min · Type: Video
Objective
Motivate MCP and A2A by showing the combinatorial integration problem they solve.
Core concepts
Why every new tool × model pair becomes a custom integration
Where MCP fits (tool surface) and where A2A fits (agent surface)
How a shared protocol collapses N×M work into N+M
MCP Architecture — Hosts, Clients, Servers9:06
Lecture 03 — MCP architecture: hosts, clients, servers
Section: 1 · Duration: 9 min · Type: Video
Objective
Internalise the three MCP roles and how they communicate.
Core concepts
Host = user-facing application, Client = per-session connection, Server = capability provider
Initialization handshake and capability negotiation
One host can talk to many servers through many clients
MCP Primitives — Resources, Tools, Prompts8:02
Lecture 04 — MCP primitives: resources, tools, prompts
Section: 1 · Duration: 10 min · Type: Video
Objective
Distinguish the three MCP primitives by intent, shape, and typical use.
Core concepts
Resources are read-only context (URI-addressed)
Tools are effectful functions with typed input/output
Prompts are parameterised templates the host can render
Transports — stdio, SSE, and Streamable HTTP8:48
Lecture 05 — Transports: stdio, SSE, and Streamable HTTP
Section: 1 · Duration: 8 min · Type: Video
Objective
Pick the right MCP transport for local, server, and web deployments.
Core concepts
stdio for local subprocess hosts
Streamable HTTP for remote servers (replaces HTTP+SSE from 2024)
Trade-offs: debuggability, multi-client support, firewall posture
Building Your First FastMCP Server7:47
Lecture 06 — Building your first FastMCP server
Section: 1 · Duration: 14 min · Type: Demo
Objective
Build a minimal FastMCP server with one resource and one tool and run it over stdio.
Core concepts
FastMCP instantiation and @mcp.resource / @mcp.tool decorators
Type hints drive the generated JSON schema
mcp.run(transport='stdio') for local hosts
Connecting with the MCP Inspector7:26
Lecture 07 — Connecting with the MCP Inspector
Section: 1 · Duration: 10 min · Type: Demo
Objective
Drive your server from MCP Inspector to inspect primitives and call tools interactively.
Core concepts
Launch Inspector against a stdio command or HTTP URL
Read tool schema, invoke tools, inspect resources
Use it to debug before wiring a real host

Why A2A — Agent-to-Agent Communication Gaps7:55
Lecture 08 — Why A2A: agent-to-agent communication gaps
Section: 2 · Duration: 8 min · Type: Video
Objective
Explain the gap MCP does not fill — agents invoking other agents as peers.
Core concepts
MCP is host→server; A2A is agent↔agent
Agents advertise capabilities via an agent card
Tasks, not function calls, carry work between agents
A2A Core Concepts — Agent Cards and Capabilities7:53
Lecture 09 — A2A core concepts: agent cards and capabilities
Section: 2 · Duration: 10 min · Type: Video
Objective
Dissect an agent card and explain how discovery and capability declaration work.
Core concepts
Agent card fields: name, description, skills, endpoints
Skills expose invocable capabilities
Capability negotiation and version compatibility
Task Lifecycle — Submitted, Working, Completed, Failed8:00
Lecture 10 — Task lifecycle: submitted, working, completed, failed
Section: 2 · Duration: 9 min · Type: Video
Objective
Trace a task through the A2A state machine.
Core concepts
States: submitted → working → completed / failed / canceled
Idempotent status polling
Terminal vs resumable states
Communication Patterns — JSON-RPC, HTTP+JSON, gRPC7:48
Lecture 11 — Communication patterns: JSON-RPC, HTTP+JSON, gRPC
Section: 2 · Duration: 8 min · Type: Video
Objective
Choose a transport for A2A based on latency, tooling, and ecosystem.
Core concepts
JSON-RPC over HTTP as the default
gRPC when you need strict schemas and bidi streams
HTTP+JSON for simplicity and debuggability
A2A SDK Installation and Project Setup9:59
Lecture 12 — A2A SDK installation and project setup
Section: 2 · Duration: 10 min · Type: Demo
Objective
Create a fresh Python project with `uv`, install `a2a-sdk`, and lay out the server skeleton.
Core concepts
uv init → uv add a2a-sdk
Minimal module layout: agent card + handler
Running with python -m vs CLI entry points
Building a Minimal A2A Agent Server11:28
Lecture 13 — Building a minimal A2A agent server
Section: 2 · Duration: 14 min · Type: Demo
Objective
Build an echo A2A agent, serve it, and exercise it locally.
Core concepts
A2AServer, AgentCard, AgentSkill
Async task handler returning {'text': ...}
Running on localhost:8000 and probing the card
Companion lab
labs/lab-13/ — executable JupyterLab source. Build the upload ZIP with the udemy_build_lab tool (lab-id lab-13).
Discovering and invoking remote agents8:18
Lecture 14 — Discovering and invoking remote agents
Section: 2 · Duration: 12 min · Type: Demo
Objective
Discover an agent card and invoke the agent from a Python client.
Core concepts
Fetching .well-known/agent-card.json
Client SDK: submit task, poll, get reply
Handling unavailable agents

Sync integration design: request-response contracts8:13
Lecture 15 — Sync integration design: request-response contracts
Section: 3 · Duration: 8 min · Type: Video
Objective
Design robust synchronous contracts between hosts, tools, and agents.
Core concepts
Typed inputs and outputs reduce failure modes
Latency budgets and timeout propagation
Idempotency keys for retry safety
MCP tool invocation with structured output8:46
Lecture 16 — MCP tool invocation with structured output
Section: 3 · Duration: 12 min · Type: Demo
Objective
Return structured Pydantic models from MCP tools so hosts can consume them reliably.
Core concepts
SomeModel on the tool function
Schema exposed to the host via structuredContent
Failure modes: ValueError → MCP error
A2A synchronous task submission and polling7:54
Lecture 17 — A2A synchronous task submission and polling
Section: 3 · Duration: 12 min · Type: Demo
Objective
Submit an A2A task synchronously and poll until completion.
Core concepts
send vs sendSubscribe
Polling with exponential backoff
Reading the terminal state cleanly
Error Handling and Timeout Strategies8:38
Lecture 18 — Error handling and timeout strategies
Section: 3 · Duration: 9 min · Type: Video
Objective
Handle failures at the MCP and A2A boundary without masking real problems.
Core concepts
MCP error envelope vs Python exceptions
Timeouts as first-class — never infinite
Retries only for idempotent operations
Input Validation with Pydantic Models10:25
Lecture 19 — Input validation with Pydantic models
Section: 3 · Duration: 10 min · Type: Demo
Objective
Use Pydantic to validate inputs at the protocol boundary.
Core concepts
Field constraints (ge, le, min_length)
model_validate at the ingress
Validation errors map to protocol errors
Lab: weather service with MCP tool + A2A agent10:03
Lecture 20 — Lab: weather service with MCP tool + A2A agent
Section: 3 · Duration: 25 min · Type: Lab
Objective
Compose an MCP tool layer and an A2A agent layer that together answer a weather question.
Core concepts
Typed MCP tool returning a Pydantic model
A2A handler that calls the tool and formats a reply
Running both processes side by side
Companion lab
labs/lab-20/ — executable JupyterLab source. Build the upload ZIP with the udemy_build_lab tool (lab-id lab-20).

Why async: streaming, long tasks, and event-driven agents7:20
Lecture 21 — Why async: streaming, long tasks, and event-driven agents
Section: 4 · Duration: 8 min · Type: Video
Objective
Motivate async patterns for agent workflows that are slow, interactive, or fan-out.
Core concepts
Blocking requests do not scale to long-running work
Streaming responses keep UX responsive
Event-driven agents subscribe rather than poll
MCP async tools with progress reporting9:44
Lecture 22 — MCP async tools with progress reporting
Section: 4 · Duration: 12 min · Type: Demo
Objective
Build an async MCP tool that reports progress to the host as it works.
Core concepts
async def tools and the Context parameter
ctx.report_progress(progress, total)
Bounded concurrency with asyncio.Semaphore
A2A streaming responses with Server-Sent Events8:32
Lecture 23 — A2A streaming responses with Server-Sent Events
Section: 4 · Duration: 12 min · Type: Demo
Objective
Stream incremental tokens or events from an A2A agent over SSE.
Core concepts
A2AServer(streaming=True)
Yielding task status updates
Client consumption of the SSE stream
Callback patterns and task status subscriptions7:53
Lecture 24 — Callback patterns and task status subscriptions
Section: 4 · Duration: 10 min · Type: Video
Objective
Let callers subscribe to task lifecycle events instead of polling.
Core concepts
Subscribe with sendSubscribe
Webhook callbacks for external systems
Failure and retry semantics for subscribers
Lecture 25 — Python asyncio patterns for agent orchestration11:30
Lecture 25 — Python asyncio patterns for agent orchestration
Section: 4 · Duration: 10 min · Type: Demo
Objective
Pick the right asyncio primitive for fan-out, cancellation, and pipelining.
Core concepts
TaskGroup for structured concurrency
Semaphore for bounded concurrency
Queue for back-pressure between stages
Lab: async document processor with streaming status9:59
Lecture 26 — Lab: async document processor with streaming status
Section: 4 · Duration: 25 min · Type: Lab
Objective
Build an async MCP tool that processes a batch with bounded concurrency and live progress.
Core concepts
Concurrency cap with asyncio.Semaphore
Ordered progress notifications
Graceful shutdown on cancellation
Companion lab
labs/lab-26/ — executable JupyterLab source. Build the upload ZIP with the udemy_build_lab tool (lab-id lab-26).

Gateway pattern: single entry point for agent access7:45
Lecture 27 — Gateway pattern: single entry point for agent access
Section: 5 · Duration: 10 min · Type: Video
Objective
Centralise auth, quotas, and logging in a single MCP/A2A gateway.
Core concepts
One entry point, many downstream servers
Where to enforce tenancy and rate limits
Observability at the gateway edge
Orchestrator pattern: multi-step agent workflows8:25
Lecture 28 — Orchestrator pattern: multi-step agent workflows
Section: 5 · Duration: 10 min · Type: Video
Objective
Coordinate a chain of agents with an orchestrator that owns the plan.
Core concepts
Explicit plan vs emergent choreography
State handoff between steps
When orchestration earns its complexity
Agent mesh: peer-to-peer discovery and delegation7:47
Lecture 29 — Agent mesh: peer-to-peer discovery and delegation
Section: 5 · Duration: 9 min · Type: Video
Objective
Let agents discover and delegate to each other without a central router.
Core concepts
Registry-based discovery via agent cards
Capability-based routing
Failure isolation when peers disappear
MCP + A2A combined topology7:56
Lecture 30 — MCP + A2A combined topology
Section: 5 · Duration: 8 min · Type: Video
Objective
Decide where MCP ends and A2A begins in a real topology.
Core concepts
MCP for tool surfaces, A2A for agent peers
When the same logic belongs in both layers
Transport choices per edge
Observability: tracing agent calls with OpenTelemetry10:13
Lecture 31 — Observability: tracing agent calls with OpenTelemetry
Section: 5 · Duration: 10 min · Type: Demo
Objective
Instrument MCP and A2A calls end-to-end with OpenTelemetry.
Core concepts
Span per tool call, span per task
Context propagation across process boundaries
Reading a distributed trace to find slow hops

Project overview: multi-agent research assistant8:23
Lecture 32 — Project overview: multi-agent research assistant
Section: 6 · Duration: 6 min · Type: Video
Objective
Introduce the capstone: search papers, summarise, review, ship a reply.
Core concepts
Layers: MCP tools, A2A agents, orchestrator
Data path from query to final answer
What you will build across lectures 33-35
Building the MCP tool layer (search + retrieval)10:05
Lecture 33 — Building the MCP tool layer (search + retrieval)
Section: 6 · Duration: 15 min · Type: Demo
Objective
Implement `search_papers` and `retrieve_document` with Pydantic-validated output.
Core concepts
Typed Pydantic result models
Validation at the boundary
Tool discovery by the orchestrator
Companion lab
labs/lab-33/ — executable JupyterLab source. Build the upload ZIP with the udemy_build_lab tool (lab-id lab-33).
Building the A2A agent layer (summarizer + reviewer)10:57
Lecture 34 — Building the A2A agent layer (summarizer + reviewer)
Section: 6 · Duration: 15 min · Type: Demo
Objective
Build two composable A2A agents that an orchestrator can pipeline.
Core concepts
Agent cards for summariser and reviewer
Structured data envelope alongside text
Pipelining: reviewer reads summariser output
Companion lab
labs/lab-34/ — executable JupyterLab source. Build the upload ZIP with the udemy_build_lab tool (lab-id lab-34).
Wiring the orchestrator and running end-to-end10:50
Lecture 35 — Wiring the orchestrator and running end-to-end
Section: 6 · Duration: 14 min · Type: Demo
Objective
Compose tools and agents behind a single orchestrator that answers a user query.
Core concepts
Planner that calls MCP tools, then A2A agents
Handling reviewer rejection
Running all processes and observing the flow
Testing, debugging, and deployment considerations7:40
Lecture 36 — Testing, debugging, and deployment considerations
Section: 6 · Duration: 10 min · Type: Video
Objective
Make your multi-agent system shippable.
Core concepts
Unit tests for handlers, integration tests for wiring
Tracing and log correlation
Containerising MCP servers and A2A agents
Lecture 37 — Course wrap-up and next steps7:39
Lecture 37 — Course wrap-up and next steps
Section: 6 · Duration: 5 min · Type: Video
Objective
Consolidate what you built and point to the next things to learn.
Core concepts
What the protocols do and do not cover
Where to go next: auth, multi-tenant hosting, MCP Inspector in CI
Community spaces for MCP and A2A

Requirements

Working Python proficiency: functions, classes, decorators, and type hints. If you can read a FastAPI handler you are ready.
Basic HTTP and REST. Familiarity with gRPC helps but is optional.
Comfort with AI agents and LLM tool-calling concepts. Prior experience with LangChain, LlamaIndex, or the OpenAI SDK counts.
Async programming in Python is helpful but not required. A focused refresher on asyncio is included in the course.
A laptop with Python 3.12 or newer, VS Code, and a terminal. Windows, macOS, and Linux all work.

Description

Agent integrations are fragmenting faster than teams can keep up. Every LLM vendor ships a new tool format, every framework invents its own agent contract, and production code rots in months. Two emerging standards fix this: the Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol. This course teaches you how to use both with working Python code.

Every lecture pairs a concise video briefing with a long-form PDF extension you can inspect and return to: protocol diagrams, sequence flows, and Python reference implementations. No filler, no marketing slides. You read the spec, build the server, and connect a client.

You will implement a FastMCP server with resources, tools, and prompts, then consume it from an MCP client using stdio and Streamable HTTP transports. You will build A2A servers and clients using the a2a-sdk, model the agent card, and walk through the task lifecycle. You will design synchronous integrations with proper error handling and asynchronous, event-driven workflows with streaming and callbacks.

By the final section, you combine MCP and A2A in a single end-to-end project: an orchestrator agent that exposes MCP tools, consumes a remote A2A worker, and handles retries and timeouts cleanly. You leave with a reference architecture you can adapt to your codebase on Monday.

Enroll now and move from protocol confusion to protocol fluency. The specs are stabilizing fast. Being the engineer who already knows them is the advantage.

Who this course is for:

Backend engineers wiring AI agents into existing services who are tired of bespoke one-off integrations.
Platform engineers standardizing LLM tooling across multiple teams and vendors.
Software architects designing multi-agent communication layers and evaluating MCP or A2A for their stack.
Senior developers who want protocol fluency instead of framework lock-in.

MCP and A2A in Python: The Agent Protocol Course

What you'll learn

Explore related topics

Course content

Protocol Foundations8 lectures • 1hr 2min

Agent-to-Agent Protocol7 lectures • 1hr 1min

Synchronous Integrations6 lectures • 54min

Asynchronous Patterns6 lectures • 55min

Architecture Patterns5 lectures • 42min

End-to-End Build6 lectures • 56min

Requirements

Description

Who this course is for: