AI · AIC-09

Agentic AI with FastMCP and A2A

Agentic AI with FastMCP and A2A is a hands-on course in using Python to build MCP servers and clients with FastMCP, then using the A2A standard so several agents work together as a multi-agent system. It suits developers, students and automation practitioners with basic Python, and you leave able to deploy an MCP server to the cloud.

Updated
From 5,310 THB / person 5,900 −10% excl. VAT 7% · group rates available
PDFDownload the course outline
  • Duration12 hours · 2 days
  • FormatOnsite / live online
  • Next roundOn request
  • CertificateIncluded

Course overview

AI today is more than a chatbot that answers questions. Agentic AI can plan and carry out work for us, built around two open standards: MCP (Model Context Protocol), which gives AI a single standard way to use tools, files and databases, and A2A (Agent2Agent), which lets agents from different systems discover each other and hand work over. Both standards move quickly, so many examples from a year ago still use SSE or older APIs that have since been retired.

This course shows learners how to build an agentic AI system in Python from scratch with FastMCP 3: creating MCP servers with tools, resources and prompts, connecting files and databases, using them from Claude Desktop, serving them over Streamable HTTP and building an MCP client that works with Gemini or OpenAI. Learners then build agents to the A2A 1.0 standard with the Python SDK, make several agents work together safely and deploy an MCP server to the cloud. The course closes with a multi-agent trip planner workshop. (2 days, 6 hours per day, 12 hours in total, Intermediate level.)

What you’ll gain

  • Explain agentic AI architecture and the different roles of MCP and A2A
  • Build MCP servers with tools, resources and prompts using FastMCP 3
  • Serve MCP over STDIO and Streamable HTTP and connect it to Claude Desktop
  • Build a Python MCP client that lets Gemini or OpenAI call tools
  • Build A2A agents with the Python SDK, including Agent Cards, tasks and artifacts
  • Design a multi-agent system with an orchestrator that uses MCP tools safely
  • Deploy an MCP server to the cloud and connect to it from an external client

Who this course is for

  • Software and AI developers who want to build agentic AI that works in practice
  • Automation practitioners who want AI to use their organisation's systems
  • Students and AI beginners who can write basic Python
  • Tech leads setting standards for connecting AI to internal tools

Prerequisites

  • Basic Python, such as variables, functions and importing libraries
  • Able to use a terminal and VS Code
  • Basic Git and GitHub help with deployment (not required)
  • Your own Google Gemini or OpenAI account and API key

Curriculum

Course Details

This course is the 2026 edition of Building Agentic AI with FastMCP and A2A. It has been rewritten for FastMCP 3, Streamable HTTP in place of SSE, the 2026-07-28 MCP specification and A2A 1.0. Deployment now uses Prefect Horizon, and a new topic covers agent security. It runs for 2 days, 6 hours per day (12 hours in total, 09:00-16:00), as lectures with Python labs in every topic. Intermediate level. Learners use their own Gemini or OpenAI API key and take home the code for every lab.

Day 1 Building MCP Servers and Clients with FastMCP

Section 1: Foundations of Agentic AI, MCP and A2A

  • What agentic AI is, with real examples from organisations
  • The perception, reasoning and action loop of an agent
  • MCP connects AI to tools, while A2A connects agents to agents
  • The latest status of the MCP and A2A specifications in 2026

Section 2: Lab: A First MCP Server with FastMCP 3

  • Create tools with @mcp.tool, with type hints that become the schema
  • Run over STDIO and test with MCP Inspector
  • Connect our MCP server to Claude Desktop
  • Lab: calculator and unit-conversion tools that AI can call

Section 3: Lab: Resources, Prompts and Context

  • Resources and resource templates that provide data for AI to read
  • Ready-made prompts that users can choose to run
  • Use Context to send logs and progress while working
  • Lab: an MCP server that reads CSV and PDF files

Section 4: Lab: Connecting Databases Safely

  • Tools that query MySQL or PostgreSQL
  • Restrict to read-only access and use parameters instead of building SQL strings
  • Combine several servers with mounting and namespaces
  • Lab: AI answers questions from a product database through MCP

Section 5: Lab: Streamable HTTP and Authentication

  • How STDIO and Streamable HTTP differ, and why SSE was retired
  • The stateless design of the latest MCP specification
  • Protect a server with a bearer token, plus an overview of OAuth
  • Lab: move a server from STDIO to HTTP

Section 6: Lab: An MCP Client in Python

  • Use the FastMCP Client to call tools and read resources
  • Design a config file that supports several MCP servers
  • Connect the client to the Gemini API or OpenAI API with tool calling
  • Lab: a terminal chatbot that can use all our MCP servers
Day 2 A2A, Multi-Agent Systems and Deployment

Section 7: Meet the A2A Protocol 1.0

  • The Agent Card at /.well-known/agent-card.json, and skills
  • Tasks, messages, parts and artifacts in the workflow
  • JSON-RPC, gRPC and HTTP+JSON bindings
  • Streaming and push notifications for long-running work

Section 8: Lab: A First A2A Agent with the Python SDK

  • Write an AgentExecutor and declare the Agent Card
  • Build a client that discovers an agent from its card and sends a message
  • Receive streamed results and track task status
  • Lab: a translation agent that other agents can call

Section 9: Lab: An A2A Agent That Uses MCP Tools

  • Split responsibilities: A2A between agents, MCP for tools
  • Let an agent call MCP servers internally through the FastMCP Client
  • Return results as artifacts the receiving agent can use
  • Lab: a product search agent that uses the MCP server from Day 1

Section 10: Designing Multi-Agent Systems Safely

  • Orchestrator agent and specialist agent architecture
  • Points where a person reviews and approves high-impact actions
  • The risks of prompt injection and untrusted tools
  • Least privilege for tools and secrets

Section 11: Lab: Deploying an MCP Server to the Cloud

  • Deploy from GitHub to Prefect Horizon on the personal tier
  • Alternatively deploy as a container on the learner's own cloud
  • Connect clients and tools such as n8n to the cloud server
  • Lab: call the cloud MCP server from our own client

Section 12: Workshop: Multi-Agent Trip Planner

  • Design agents for finding places, budgeting and scheduling
  • Let an orchestrator hand work to each agent over A2A
  • Combine the results into a trip plan with a user confirmation step
  • Present the work and plan how to extend it to company systems

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

For organisations — in-house / private

  • Tailor the content to your team’s tools and projects
  • Your dates, at your office or live online
  • Quotation with tax ID for procurement
Corporate training quote

Instructors

Frequently asked questions

How do MCP and A2A differ, and when is each used?

MCP, the Model Context Protocol, is a standard that lets AI applications use tools, files and databases through servers in one consistent way, rather like plugging devices into the AI. A2A, Agent2Agent, is a standard that lets agents built on different frameworks or by different organisations find each other through Agent Cards, then hand over work and receive results as tasks and artifacts. Real systems often use both: agents talk to each other over A2A, and each agent uses its tools through MCP.

How do I build an MCP server with FastMCP?

Install FastMCP with uv or pip, create a FastMCP object with a server name, then write ordinary Python functions decorated with @mcp.tool. FastMCP turns type hints and docstrings into a schema the AI understands. Add @mcp.resource for data the AI can read and @mcp.prompt for ready-made prompts, then call mcp.run() to run over STDIO, or pass transport="http" to serve it on the web. You can test it with MCP Inspector or connect it to Claude Desktop.

How do STDIO and Streamable HTTP differ in MCP, and can SSE still be used?

With STDIO, the AI application runs the server as a program on the same machine and talks to it through standard input and output, which suits personal tools such as Claude Desktop. Streamable HTTP serves the server as a web service that many clients can reach over the network, which suits cloud deployment. SSE is the older web transport that Streamable HTTP replaced, and FastMCP marks it as deprecated, so use it only when connecting to legacy systems.

Who is the Agentic AI with FastMCP and A2A course for, and what should I know beforehand?

It suits software and AI developers who want to build agentic AI that works in practice, automation practitioners who want AI to use their organisation's systems, AI students, and tech leads setting standards for connecting AI to tools. You should write basic Python, be able to use a terminal and VS Code, and have your own Gemini or OpenAI API key. No web development background is needed.

What will I be able to do after the Agentic AI with FastMCP and A2A course?

You will be able to build MCP servers with tools, resources and prompts using FastMCP 3, connect files and databases safely, serve over Streamable HTTP, build an MCP client that lets Gemini or OpenAI call tools, build A2A agents with the Python SDK, design a multi-agent system with an orchestrator and deploy an MCP server to the cloud. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.

What do I need to prepare for the Agentic AI with FastMCP and A2A course?

Bring a Windows, macOS or Linux laptop with permission to install software, able to run Python, uv and VS Code. You need your own Google Gemini or OpenAI account and API key, which may incur usage charges, and a GitHub account is useful for deploying to Prefect Horizon on its free personal tier. Claude Desktop and MCP Inspector are installed together in class.