Complete FastMCP AI Agents Masterclass - update to V3

Provide an overview of the basics in the FastMCP masterclass, covering servers and clients, creation, functionality, transport methods, and startup to establish the foundation.

Learn how servers form the core of fast MCP apps, exposing tools, resources, and prompts to clients. See how to create and start servers via stdio or http transport.

Create and test clients that access server functionality through in-memory, stdio, or http transports. Learn to run multiple servers within a single client and explore server tools, resources, and prompts.

Discover how to start a client and multiple servers from a json configuration, using stdio and http transports, with prefixed tools like math and text.

Explore tools for building servers, including decorators, arguments, return values, structured output, and error handling, plus client tool interactions and output schemas.

Explore how tools form the core of FastMCP, enabling llm to interact with data, files, and code via a tool schema, decorators, and synchronous or asynchronous functions.

Explore mcp.tool decorator for tools, configuring name, description, tags, icons, enable status, and meta information like version and author. See how description overrides the doc string and affects client calls.

Learn how function arguments work in FastMCP tools, including supported types, optional parameters, and basic validation tips, such as JSON dictionaries for models, file paths, and ISO dates.

Explore return values in FastMCP, including regular and structured outputs. Learn how strings, images, files, lists, and media helpers convert to content blocks and JSON structures.

Discover how structured output attaches metadata to returns, enabling clients to process dictionaries, data classes, Pydantic models, and primitive types with a return type.

Explore how the output schema defines server tools, how the LLM uses it to select tools, and how the client can access schema details such as result, required, and type.

Learn how to handle server-side errors in FastMCP by raising exceptions, converting them to MCP errors, optionally masking details, and handling validation errors on the client with the tool error.

Explore the client side by listing tools with ListTools, calling tools by name with a parameters dictionary, and using timeout, progress handler, and metadata to manage execution.

Explore the resources section by introducing how static, dynamic, and template resources work, with an in-action example and an overview of error handling on the client side.

Explore read-only resources accessed by uri via the get pattern, highlighting idempotent, cacheable behavior and strict path validation, while distinguishing static, dynamic, and template resources, with async preferred.

Register static resources with addResource and expose text, binary, file, http, and directory resources via a server. Clients access content by URI and MIME type, forming a simple server–client workflow.

Explore dynamic resources with the mcp.resource decorator, defining uri-driven resources and metadata. Learn they return string, bytes, or a resource result with examples like active connections and server time.

Learn how resource templates add flexibility by using dynamic and wildcard URI parameters, creating new resources for each parameter combination, with optional query parameters and defaults.

Explore error handling for resources by distinguishing standard Python errors from FastMCP resource errors, and controlling detail exposure with mask_error_details. See client-side error reporting for value and not found errors.

Explore prompts as the third major component of an MCP server, including how prompts work in practice, client-server interactions, input arguments, and return values for multi-turn LLM conversations.

Explore prompts as parameterized message templates for LLMs, and use the mcp.prompt decorator to define name, description, title, and version, then deploy prompts to the MCP server.

Learn how FastMCP converts string arguments to declared server types, handles optional parameters with defaults, and converts complex types from JSON, illustrated by a client example.

Explore return types for prompts, including strings, lists of strings, lists of messages, and prompt results, with messages carrying role and content and optional metadata.

Explore context in FastMCP, including what it is, how to access it, and its relation to state, plus elicitation, logging, prompts, notifications, and server resources.

Access context to reach underlying server functionality per request, not a session, via tools, resources, or prompts, using current context as the preferred parameter or getContext for nested calls.

Discover how state persists across a client session and differs from context. Learn to use setState, getState, and deleteState to track username and visit counts through startSession, visit, and endSession.

Learn elicitation in FastMCP, where the server asks the client for information, enabling multi-turn conversations with an elicitation handler and options like none, scalar, lists, and dictionaries.

Showcases server-to-client logging with debug and info levels, using a client-side log handler and log message objects, while illustrating asynchronous communication and server-side log storage.

Use a flexible progress reporting system to update clients during long server tasks, via report progress with progress and total and optional messages, implemented with a client progress handler.

discover how to access server resources and prompts via list and read operations, using URIs and parameters to fetch resources and prompt content with async calls from a client tool.

Learn how a server automatically signals three notification types—tool list, resource list, and prompt list changes—to connected clients, and how the client uses a message handler to process them.

Access server and transport data via ctx.fastmcp and context.transport to tailor functionality for HTTP, standard input/output, SSE, or streamable HTTP, demonstrated with a transport-based report.

Access request information such as request id, client id, and session id, and learn how context.meta stores user id and trace id while session id stays constant across calls.

Explore the built-in middleware in FastMCP, learn how it adds a layer between server components, and apply logging, caching, rate limiting, pinging, timing, injection, and error handling to improve reliability.

Learn built-in middleware and how pre- and post-processing adds functionality to requests and responses through an ordered a, b, c chain around tool calls.

Learn how to use the built-in logging middleware to generate human-readable request and response logs, including payloads, durations, and console output for server and client interactions.

Explore server-side caching and the caching middleware to speed repeated operations, using time to live and included tools, illustrated by a slow add example with cache hits and expiration.

Implement rate-limiting middleware to protect servers from bursts and unauthorized requests, configuring max requests per second, burst capacity, and client ID, and compare standard and sliding window approaches.

Learn how ping middleware keeps HTTP connections alive by sending pings every 500 milliseconds between a local server and client, enabling long-lived sessions.

Observe how the timing middleware logs execution duration for every request, using a simple sleep example to show timing of list and tool calls, alongside the detailed timing middleware.

Inject tools, resources, and prompts at runtime on a FastMCP server using middleware types: tool injection, resource tool, and prompt tool, and inject a function-created tool to extend server behavior.

Learn to implement error handling middleware in FastMCP, including retry with exponential backoff, and see a practical division by 0 error example on server and client.

Combine multiple middlewares to manage the MCP server components, honoring the execution order for requests and responses, with early infrastructure and security middleware and later timing, logging, and error handling.

Build your own custom middleware for FastMCP, using message and operation hooks to intercept and modify requests, access metadata and state, leverage constructors, and handle errors within the middleware.

Develop and implement custom middleware to add domain-specific functionality, override select hooks such as on call tool, and log before, during, and after tool execution.

Explore the basics of hooks in custom middleware, how they fire at different times in a defined order, and how a single request may trigger multiple hooks.

Explore the three message hooks—on message, on request, and on notification—and learn how to trigger them within client-server middleware, with logs illustrating their flow.

Explore operation hooks in a server with tools, resources, and prompts, covering onCallTool, onReadResource, onGetPrompt, onListTools, onListResources, onListPrompt, onInitialize, and the double underscore generic hook, plus a raw middleware demo.

Learn to check request context and session availability to prevent null access and runtime errors. The lecture demonstrates getSession checks in initialization and tool calls, showing conditional session access.

Explore constructors in custom middleware to initialize configuration, separate environment from settings, and decouple policy from logic, with a production‑only restriction on reset database.

Explore how custom middleware accesses and modifies requests, injecting missing arguments and default values to maintain compatibility, demonstrated by a tool that adds a B parameter when A is provided.

Explore how to modify server responses with middleware after tool execution, annotating structured content JSON without breaking client expectations, and applying safe, responsible response modification.

Learn how filtering in middleware controls tool visibility and execution based on user roles, using onListTools and onCallTools to gate actions like delete all.

Access tool metadata on the server via middleware by inspecting the FastMCP server context and tool tags, then expose slow tool information to the client during tool invocation.

Learn how middleware sets and accesses state stored in the session, persisting across requests, with an async counter update and final summary.

Propagate errors through middleware for observability and logging, letting the client see the error; illustrated with a divide-by-zero example and error logging middleware.

Explore sampling by requesting text generation from the LLM, on the client or server side, and learn to use anthropic and openai handlers, parameters, tools, multi-turn conversations, and structured outputs.

Learn how to implement sampling for LLM text generation using client and server fallbacks, configure Anthropic and OpenAI, use the sample function, and handle results and history.

Explore built-in sampling handlers for Anthropic and OpenAI, load the API key from the environment, and run randomized handler selection to generate text from either CloudSonic4 or GPT 4.0.

Explore client-side sampling parameters for LLM access, including messages, system prompts, temperature, max tokens, and model preferences, with guidance on single or multi-turn inputs and masking errors.

Learn how to enable tool use in llm sampling, creating server-side tools and a multi-turn workflow where the llm calls lookups and shipping quotes to generate a final item quote.

Learn to enforce structured output from an LLM using FastMCP, returning validated data with defined types (Pydantic models or data classes) and a summary with title, summary, and key points.

Learn to implement multi-turn conversations for FastMCP by using a structured message history with sampling messages and alternating user and assistant roles, via the Anthropic Sampling Handler.

Explore how to implement a server-side fallback for llm sampling when clients lack an llm, using an openai sampling handler with fallback or always modes to ensure continued responses.

Explore advanced control of sampling steps in the Fast API by using a sample step instance to manage history, text, tool calls, and isToolUse. Generally, built-in handlers suffice.

Explore background tasks, dependencies, lifespan, pagination, storage backends, and versioning in FastMCP v3, with automatic dependency injection, server lifecycle hooks, and multi-page data handling.

Master background tasks by enabling non-blocking execution, issuing a task ID, and polling for progress updates with configurable poll intervals and optional or required modes on the server.

Explore dependency injection in FastMCP, injecting built-in and custom dependencies at runtime with depends, to power the describe environment tool using context, server, http requests, and get config.

Explore lifespan in FastMCP to run code once at server startup and on shutdown using the atLifespan decorator, compose multiple handlers with the pipe operator, and manage server state.

Explore pagination basics, including setting a page size and using a cursor to fetch subsequent pages. See a practical example listing tools in three-item pages.

Examine storage backends for caching and OAuth tokens, moving from in-memory to disk and database storage with a caching middleware, demonstrated by a Python example of an expensive operation.

Explore FastMCP versioning: assign version numbers to components, support multiple versions, default to the latest when no version is specified, and enable explicit version requests with backward-compatible optional parameters.