# Building Your First MCP Server and Client Course (Self-Paced)

Canonical URL: <https://www.graduateschool.edu/courses/building-your-first-mcp-server-and-client-course-self-paced>

## Overview

This hands-on workshop introduces the Model Context Protocol (MCP) through a practical, end-to-end build. Participants learn what MCP is, why it matters, and how to design MCP servers for AI agents instead of treating them as thin wrappers over REST APIs. Using Python and FastMCP, participants build a working MCP server around the SpaceX API, test it locally, connect it to an MCP-compatible host, and then build a minimal MCP client that can discover and call server tools.

The course emphasizes both implementation and design judgment. In addition to building a functioning server and client, participants learn how to reduce tool sprawl, design around agent workflows, manage context-window costs, and produce tool descriptions and outputs that work well for large language models.

## What you'll learn

- Explain the purpose of MCP and describe the host-client-server architecture.
- Distinguish between tools, resources, and prompts, and identify when each is appropriate.
- Describe how context windows affect MCP server design.
- Recognize common anti-patterns in MCP server design, especially endpoint-for-endpoint REST wrappers.
- Build a local MCP server in Python using FastMCP.
- Design tools around outcomes and workflows rather than API structure.
- Test an MCP server using the MCP Inspector and an MCP-compatible host.
- Build a minimal MCP client that connects to a server, lists tools, and calls them.
- Describe the basics of deploying a remote MCP server and the security considerations involved.

## Curriculum

#### Module 1: Introduction to MCP and Agent-Facing Design

- Examine the integration problem MCP is designed to solve and how it standardizes connections between AI applications and external tools, resources, and workflows.
- Review MCP architecture, including the roles of the host, client, and server.
- Explore how context windows affect tool design and output design.
- Identify the three main server primitives: tools, resources, and prompts.

#### Module 2: Why Many MCP Servers Perform Poorly

- Analyze why MCP servers should not be designed as one-to-one REST wrappers and the cost of excessive tool discovery for agents.
- Evaluate why agent iteration is slower and more expensive than human trial and error.
- Assess how output format and schema size affect context efficiency.
- Apply principles of outcome-based tool design to improve server performance.

#### Module 3: Build an MCP Server with FastMCP

- Initialize a new FastMCP project, create a simple tool, and inspect the server with the MCP Inspector.
- Review the SpaceX API and identify likely user workflows for tool design.
- Build a naive version to observe anti-patterns, then refactor into a smaller, more effective toolset.
- Format outputs for LLM consumption using Markdown and improve tool descriptions, matching logic, and error handling.

#### Module 4: Build a Minimal MCP Client

- Connect to the server from a local client, discover tools via tools/list, and call tools programmatically.
- Examine the handshake and tool-call lifecycle between client and server.
- Observe how an LLM-driven host uses the same pattern to interact with MCP servers.

#### Module 5: Deployment, Security, and Ecosystem Overview

- Transition from local stdio development to remote deployment, including remote transport and hosting basics.
- Review security and authorization considerations for remote MCP servers.
- Survey the broader MCP ecosystem, including documentation, SDKs, and registries.

## Pricing

**Tuition:** $649