Master Generative AI: MCP Developer Bootcamp

Explore the history of ai from machine learning to deep learning and large language models, then examine ai clients and retrieval augmented generation to understand the model context protocol.

Explore how machine learning infers outputs from labeled data and detects patterns to predict housing prices and recommendations. Compare supervised and reinforcement learning with algorithms linear regression and neural networks.

Deep learning, a subset of machine learning, uses artificial neural networks with neurons and layers to learn from data, powering transformers, ChatGPT, DALL-E, and self-driving and speech applications.

Explore generative AI and large language models that create original content across text, images, code, and audio, powered by transformer foundations and pre-trained models fine-tuned for specific tasks.

Learn how retrieval augmented generation (RAG) lets you augment LLMs with external and internal company data using embeddings and a vector database, yielding up-to-date, citable responses.

The lecture surveys AI clients—apps, assistants, and autonomous agents—showing how tools and APIs enable function calling, with a registry, execution engine, and chained workflows via model context protocol.

Learn how function calling connects large language models to external tools, using official and third-party SDKs, with a weather example, execution logic, and the need for a modal context protocol.

Build a weather assistant with the GPT Script SDK, using function calls and a built-in HTTP get tool to fetch current weather for a city and return a final response.

Explore implementing function calling with the LangChain SDK to build a weather tool that retrieves current conditions, powered by an agent executor and OpenAI API.

Explore how the model context protocol, an open standard, standardizes secure ai data connections via MCP clients and servers, enabling tool discovery and granular permissions.

Dive into the MCP server architecture, model context protocol, and streamable http, with tools, authorization flows, and how a client can access local or remote data and services.

Connecting to an MCP server creates an MCP client object for each server, yielding one-on-one connections and isolation in cloud desktop. Clients remain objects, not separate processes.

Explore MCP security fundamentals, including authentication, authorization, and encryption, guard against on-path attacks, and implement secure idp integrations with the resource server model.

Understand the MCP transport protocol and its transport layers, including standard io, server-sent events, and streamable http, and how they handle message delivery, connection management, and security considerations.

Develop an MCP weather tool server in Python, implement get current weather, and demonstrate tool listing, two client versions, and OpenAI GPT four integration via standard IO and decorators.

Explore MCP tools and how to extend the LLM with external systems by turning Python functions into tools via the MCP decorator, using structured input and output schemas.

Set up an isolated MCP client and server environment, install MCP and OpenAI SDK via the UV package manager, and initialize the weather MCP server project.

Develop a weather MCP server in Python using async http and the model context protocol, implementing tools to fetch current weather from an API.

Develop a simple MCP client that launches and tests a weather server via standard IO, using asynchronous IO and pathlib, verifying connectivity to the City of London weather tool.

Presenting MCP server version two, a high-level, slimmer approach that uses decorators to automate listing and calling tools, with dynamic permissions and notification capabilities for flexible server behavior.

Test the weather MCP server directly via the command line interface in dev mode, then explore the inspector UI to interact with prompts, routes, and tools.

Connect an MCP server with an OpenAI GPT LLM to create a weather-aware AI assistant, test a Python client for get current weather, and enable tool-driven queries.

Connect Claude Desktop to an MCP weather service by configuring the server path in the Claude settings, starting the server, and using the weather assistant tool to fetch current conditions.

Configure logging to standard error for MCP transport, ensuring the server writes logs there while reading JSON-RPC messages from standard input and sending responses to standard out.

Learn to build a flight booking simulation with an MCP server and integrated tools, enabling search, booking, cancellation, and logging via a cloud desktop interface.

Explore a fake flight booking MCP server with in-memory data, simulated airlines and airports, and tools for search flights, flight details, book, status, and cancel.

Set up a cloud desktop flight booking system by editing the config, renaming the server and Python file, restarting, and monitoring Claude logs as the system boots.

Learn to run an MCP server remotely on port 3000 with a single http endpoint and streamable http transport, enabling json rpc calls and real-time bidirectional updates.

Set up the MCP server for remote connections by configuring MCP host and port, starting on port 3000, enabling streamable HTTP, and testing with the MCP inspector.

Run the model context protocol inspector with a Node.js tool to test a remote MCP server by posting JSON RPC messages and binding to port 3000 with the MCP path.

Learn to test an MCP remote proxy from cloud desktop by configuring a remote server, handling authentication, and using the proxy to reach weather service integrations.

Secure the MCP server with api key authentication and a scalable architecture. Learn fast api, Starlette, uvicorn, api key middleware, and health and docs endpoints.

Re-implement the MCP server with API key middleware, set up logging and FastAPI app, explore health and tool endpoints, and test via docs and curl to verify API key.

Connect to the MCP inspector server by providing the API key and secret key, setting streamable http, and testing weather tools. Then preview the Claude client.

Update the Python MCP client to connect to a remote server using an API key, header authentication, and the Streamable HTTP client, with code changes and usage examples.

Learn how OAuth enables secure cross-service data sharing with authorization servers, access tokens, authorization codes, and scopes, plus machine-to-machine flows using Keycloak in an MCP context.

Learn to implement a client credentials OAuth flow with Keycloak as the authorization server, issuing JSON web tokens and bearer tokens for an MCP resource server.

Start a local Keycloak IdP with Docker, expose port 8080, and set admin credentials; create an MCP realm with MCP up and MCP server clients, and import their JSON configurations.

Re-implement the MCP server with oauth resource server security, validating tokens via jwks or introspection and with Keycloak and OpenAPI discovery supporting bearer-protected endpoints.

Update a Python MCP client to connect to a remote server via OAuth, token discovery, and automatic token retrieval with Keycloak, featuring a click-based command line interface for interactive chat.

Test the MCP server with auth via the MCP inspector, obtain an access token for the authorization header, and verify access using the inspector tools.

Discover how to enable cors in web apps by implementing cors middleware, handling preflight options request, and configuring Keycloak web origins to enforce same-origin policy in development and production.

Learn how to enable CORS and handle HTTP options requests on the MCP server, including origin checks, allowed headers, and the new course middleware for secure API access.

Test the course server by running a python http server on localhost and performing an options request. Authenticate with keycloak and test MCP calls to OpenAI GPT-4 and weather data.

Explore building end-user focused MCP servers as front ends for a to-do management system, implement authentication with api keys, design end-user tools and prompts, and map flows to REST endpoints.

Set up and run the to-do rest API with FastAPI, explore endpoints, Swagger and OpenAPI JSON, then test readiness for the MCP server.

Launch and test the todo MCP server as a front end for the todo API, using tools and CLI to manage todos and verify health.

Connect the Claud Desktop client to the MCP server and to-do rest API, using API key authentication, configure the proxy, and explore search and tools to manage to-dos and projects.

Explore MCP resources to give the LLM read-only context from text or binary data, expanding knowledge bases with document content and database lookups.

Add resources to the MCP server, including an about markdown, a todo management guide PDF, and dynamic templates for meeting tasks; fetch metadata and PDFs from storage like S3.

Test the todo MCP server resources with the cloud desktop, restart the server to load resources, add the PDF guide for extra context, and note templates are not yet testable.

Master MCP prompts and templates to standardize on-demand conversations with dynamic parameters and the three LM roles—system, user, and assistant—for reliable LLM workflows.

Learn to craft three prompts for to-do writing, analysis, and prioritization using conversation templates, and test a prompt-driven workflow with Moscow-based prioritization.

Test the todo MCP server prompts using cloud desktop, exploring tool workflows for resources, prompts, and templates, and performing table-based prioritization analyses.

Refactor the MCP server for production by separating concerns, enhancing logging with human and json formats, and implementing robust error handling and a shutdown mechanism, including auth and RBAC.

Run the refactored MCP server and REST API from a downloaded zip, set up a Python uv environment, and test unauthenticated endpoints with curl before using the API key.

Test the refactor to the server with Claude Desktop, verify loading and proxy configurations, create and manage football to-dos, and browse source code to verify functionality.

Explore a refactored MCP server through a practical code walkthrough, detailing environment setup, rest API integration, token validation with keycloak, auth flows, logging, graceful shutdown, and modular MCP components.