Build AI Agents with MCP - Model Context Protocol - TS/PY

Overview of MCP as a standardized protocol connecting AI agents to external tools and data, replacing per-platform custom tool integrations across ChatGPT, Claude, and Copilot.

Explains MCP as an HTTP-like standard letting any AI agent call any tool; covers LLM tool-calling limitations, extending assistants with real-time data, and cross-platform tool reuse.

Defines MCP hosts, clients, and servers; host-to-client one-to-many relationships, client-to-server one-to-one mapping, and why most development work centers on building MCP servers.

Configuring MCP servers in VS Code GitHub Copilot and Claude Desktop via the mcp.json configuration file; comparing supported features like tools, resources, and prompts across hosts.

Sources for MCP servers: the official Model Context Protocol GitHub servers repository, Docker MCP catalog, VS Code extensions MCP search, MCP Market, and Glama; server security and vetting.

Installing the MCP Compass and a Python calculator MCP server via npx and uv in VS Code and Claude Desktop mcp.json configs; testing tool calls in GitHub Copilot agent mode.

Configuring the Spotify MCP server with OAuth client ID and secret, cloning and running it locally with uv sync, and setting up src paths in VS Code and Claude Desktop.

Section overview building a quote-service MCP server with multiple tools in both TypeScript and Python, tested inside VS Code and Claude Desktop via GitHub Copilot prompts.

Comparing Python and TypeScript MCP SDKs by GitHub stars, documentation, and examples; explains the dual-language course structure and following either track through to certificate completion.

npm project initialization, installing @modelcontextprotocol/sdk, Zod, TypeScript, @types/node, and TSX for running TypeScript MCP servers directly without a separate compile step.

Building an MCP server with McpServer, registerTool, and StdioServerTransport in TypeScript; implementing a quote-service tool, connecting via mcp.json, and testing in GitHub Copilot.

Adding multiple registerTool calls with Zod input schemas, extracting LLM-provided parameters like count, try-catch error handling, and returning structured text content and error flags.

Initializing a Python MCP project with uv init and installing the mcp[cli] dependency; verifying the MCP development tools with uv run mcp for Python-based server development.

Building a FastMCP server in Python with the @mcp.tool decorator, quote-service functions, mcp.run() startup, and configuring the server in VS Code via mcp.json with uv run.

Adding a parameterized MCP tool in Python with @mcp.tool, function arguments like count, try-except error handling with ValueError, and returning meaningful error messages to the LLM.

Using the @modelcontextprotocol/inspector via npx and uv run mcp dev to test tools, resources, and prompts for both STDIO and SSE transports in TypeScript and Python MCP servers.

Section overview covering MCP transport protocols and the tools, resources, and prompts primitives, implemented in a new Transport Primitives project in TypeScript and Python.

Comparing STDIO transport for local process communication with Streamable HTTP transport for internet-hosted MCP servers; covers use cases, authentication needs, and mcp.json URL configuration.

Recap of MCP project setup with npm init and uv add mcp[cli]; structuring separate server logic and STDIO entry-point files, and testing a hello-name tool in GitHub Copilot.

Serving a TypeScript MCP server over Streamable HTTP using Express, StreamableHTTPServerTransport, a POST /mcp endpoint, and configuring the client with a URL instead of a launch command.

Switching a Python MCP server to streamable-http transport by passing transport="streamable-http" to mcp.run(), and connecting via URL in mcp.json instead of a STDIO command.

Overview of the three MCP server primitives: tools for LLM-invoked actions, resources for application-controlled context data, and prompts for user-controlled instruction templates.

Explains MCP resources as URI-addressed context data exposed from files, APIs, and databases; covers resource templates for dynamic parameter extraction and attaching resources to AI chat prompts.

Implementing static and dynamic MCP resources in TypeScript with server.registerResource, ResourceTemplate, file:// URIs, readFileSync, and returning content with URI, text, and mimeType fields.

Building static and dynamic MCP resources in Python with the @mcp.resource decorator, file-based URIs, item-price lookup by ID, and mimeType configuration for text content.

Comparing MCP resources and tools for efficiency: converting a log-reading resource into a get-error-logs tool that filters data server-side to reduce LLM token usage and cost.

Explains MCP prompts as user-controlled, pre-built instruction templates for interacting with tools and resources, selected explicitly by the user rather than invoked automatically by the LLM.

Implementing a history-report MCP prompt with topic and paragraphs arguments in TypeScript and Python, and invoking it via slash commands in GitHub Copilot and Claude Desktop.

Introduces the Awesome Pizza practice project: an MCP server for menu lookup, pizza ordering, and order-status checks via Claude Desktop and GitHub Copilot, split into TypeScript and Python sections.

Cloning the Awesome Pizza Node.js demo store, running npm install and npm start to host the REST API and web UI on localhost:3000, required for testing the MCP server.

Using Chrome DevTools Network tab to inspect fetch requests for the daily menu and order placement, analyzing request URLs, methods, payloads, and responses before replicating them via MCP.

Preview of the completed TypeScript Awesome Pizza MCP server implementation before building the API client, menu tools, order tool, and order-status tool in the following lectures.

Building a fetch-based apiClient.ts for the Awesome Pizza REST API, generating TypeScript types from JSON responses, and registering a get-pizza-menu tool with server.registerTool.

Returning image content from an MCP tool by fetching menu images, converting them to base64 with Buffer, and building a content array with type text and type image entries plus mimeType.

Building a make-order MCP tool with Zod inputSchema and outputSchema for sender and pizza items, POSTing order details to the REST API, and returning structuredContent with the order ID.

Implementing a check-order-status tool with a Zod orderId input schema, a GET request to the orders API, and returning the order status as text content from the MCP server.

Preview of the completed Python Awesome Pizza MCP server before building the requests-based API client, menu and image tools, order tool, and order-status tool with FastMCP.

Reviewing the starter FastMCP project structure with a test tool, mcp.server.fastmcp import, and a separate main_stdio.py entry point configured via VS Code mcp.json and uv run.

Building a requests-based api_client.py get_daily_menu function with error handling, and registering a get_pizza_menu MCP tool with the @mcp.tool decorator for the Awesome Pizza menu.

Returning TextContent and ImageContent from a get-pizza-menu-with-images MCP tool using base64 encoding, CallToolResult, and PNG mimeType for menu images fetched via requests.

Defining TypedDict OrderItem and OrderDetails types, a make_order function POSTing to the orders API, and a make-order MCP tool that extracts pizza names and quantities from the LLM.

Implementing a check_order_status function with a GET request to the orders API and a check-order-status MCP tool decorated with @mcp.tool for order-ID-based status lookups.

End-to-end demo of the Awesome Pizza MCP server: menu retrieval, order placement, and order-status lookup via GitHub Copilot, plus generating a project README with AI assistance.

Introduces MCP authorization as HTTP-based OAuth security for MCP servers, covering the scope and complexity of implementing authentication and authorization for AI agent access.

Explains the MCP OAuth 2.0 flow: unauthorized 401 responses with WWW-Authenticate headers, token requests to an authorization server, and comparing options like Keycloak, Scalekit, and Stytch.

Testing a sample Express OAuth server with authorize, approve, token, and introspect endpoints using the REST Client VS Code extension to generate auth codes and access tokens.

Planning MCP OAuth integration: authentication middleware, an OAuth client calling the introspect endpoint, and the well-known OAuth-protected-resource and authorization-server discovery endpoints.

Resetting VS Code's cached OAuth authentication state via Authentication: Remove Dynamic Authentication Providers and a window reload when testing changes to an MCP OAuth server.

Setting up a TypeScript Express MCP server with StreamableHTTPServerTransport, a POST /mcp endpoint, and mcp.json URL configuration, as the base project for adding OAuth 2.0 security.

Implementing Express authentication middleware, CORS middleware, an OAuth client with a check-token introspect call, and well-known OAuth-protected-resource and authorization-server endpoints in TypeScript.

Mounting a FastMCP Streamable HTTP app inside FastAPI with uvicorn, building a hello-name tool, and configuring the unsecured base server in VS Code mcp.json before adding OAuth.

Implementing FastAPI auth middleware, CORS middleware, an OAuth client with a check_token introspect call, and well-known OAuth-protected-resource and authorization-server endpoints in Python.

Closing lecture thanking students for completing the Model Context Protocol course, with a request for a course review and links to the instructor's other courses.