Module 1: Core Concepts

​

Learning Objectives

• Understand the MCP client-server architecture
• Identify roles and responsibilities of Hosts, Clients, and Servers
• Analyze the core features that make MCP a flexible integration layer
• Learn how information flows within the MCP ecosystem
• Gain practical insights through code examples in .NET, Java, Python, and JavaScript

​

Architecture Overview

Your Computer
├── Host (VS Code, Claude Desktop, IDEs, AI Tools)
│   ├── MCP Client A  ←→  MCP Server A  ←→  Local Data Source A
│   ├── MCP Client B  ←→  MCP Server B  ←→  Local Data Source B
│   └── MCP Client C  ←→  MCP Server C  ←→  Remote Services (Internet)

​

The Three Participants

​

Hosts

• Claude Desktop, Visual Studio Code, Claude Code
• IDEs and code editors with MCP integration
• Custom-built AI agents and tools

• Orchestrate AI models — execute or interact with LLMs to generate responses
• Manage client connections — create and maintain one MCP client per server connection
• Control user interface — handle conversation flow and response presentation
• Enforce security — control permissions and authentication
• Handle user consent — manage approval for data sharing and tool execution

​

Clients

• Send JSON-RPC 2.0 requests to servers with prompts and instructions
• Negotiate supported features and protocol versions during initialization
• Manage tool execution requests from models and process responses
• Handle real-time notifications and updates from servers
• Process and format server responses for the user interface

​

Servers

• Register and expose available primitives (resources, prompts, tools) to clients
• Receive and execute tool calls, resource requests, and prompt requests
• Provide contextual information and data to enhance model responses
• Maintain session state and handle stateful interactions when needed
• Send notifications about capability changes to connected clients

​

Server Primitives

file://documents/project-spec.md
database://production/users/schema
api://weather/current

Generate a {{task_type}} for {{product}} targeting {{audience}}
with the following requirements: {{requirements}}

server.tool(
  "search_products",
  {
    query: z.string().describe("Search query for products"),
    category: z.string().optional().describe("Product category filter"),
    max_results: z.number().default(10).describe("Maximum results to return")
  },
  async (params) => {
    return await productService.search(params);
  }
);

​

Client Primitives

​

Information Flow in MCP

​

Protocol Architecture and Layers

​

Data Layer

• JSON-RPC 2.0 Protocol — all communication uses standardized message formats for method calls, responses, and notifications
• Lifecycle Management — handles connection initialization, capability negotiation, and session termination
• Server Primitives — tools, resources, and prompts
• Client Primitives — sampling, elicitation, roots, and logging
• Real-time Notifications — asynchronous updates without polling
• Date-based versioning — uses YYYY-MM-DD format (current: 2025-11-25)

​

Transport Layer

​

Core Message Types

​

Tasks (Experimental)

• Long-Running Operations — track expensive computations, workflow automation, and batch processing
• Deferred Results — poll for task status and retrieve results when operations complete
• Status Tracking — monitor task progress through defined lifecycle states
• Multi-Step Operations — support complex workflows spanning multiple interactions

​

Security Principles

• User Consent and Control — users must provide explicit consent before any data is accessed or operations are performed, with clear control over what is shared
• Data Privacy — user data is only exposed with explicit consent and must be protected by appropriate access controls throughout the interaction lifecycle
• Tool Safety — before invoking any tool, explicit user consent is required with clear understanding of the tool’s functionality and potential impact
• Transport Layer Security — all communication channels must use appropriate encryption and authentication mechanisms

• Implement fine-grained permission systems controlling which servers, tools, and resources are accessible
• Use secure authentication methods (OAuth, API keys) with proper token management and expiration
• Validate all parameters according to defined schemas to prevent injection attacks
• Maintain comprehensive audit logs for all operations

​

Code Examples

import asyncio
from fastmcp import FastMCP
from fastmcp.transports.stdio import serve_stdio

mcp = FastMCP(name="Weather MCP Server", version="1.0.0")

@mcp.tool()
def get_weather(location: str) -> dict:
    """Gets current weather for a location."""
    return {
        "temperature": 72.5,
        "conditions": "Sunny",
        "location": location
    }

if __name__ == "__main__":
    asyncio.run(serve_stdio(mcp))

​

Key Takeaways

• MCP uses a client-server architecture where Hosts manage multiple Client connections to Servers
• The ecosystem has three participants: Hosts (AI applications), Clients (protocol connectors), and Servers (capability providers)
• Transport mechanisms: STDIO (local) and Streamable HTTP with optional SSE (remote)
• Server primitives: Tools (functions), Resources (data), and Prompts (templates)
• Client primitives: Sampling (LLM completions), Elicitation (user input), Roots (filesystem), and Logging
• Experimental: Tasks provide durable execution wrappers for long-running operations
• Built on JSON-RPC 2.0 with date-based versioning (current: 2025-11-25)
• Security first: explicit user consent, data privacy, and secure transport are core requirements

​

Exercise

1. What the tool would be named
2. What parameters it would accept (and their types)
3. What output it would return
4. How a model might use this tool to solve user problems
5. Whether it should carry a readOnlyHint or destructiveHint annotation

​

What’s Next