Model Context Protocol-MCP for Devs: Hands-On for beginners

1. Build and run your first MCP server using FastMCP and Cursor AI.

2. Create simple MCP tools/functions that respond to user input.

3. Configure the server in mcp.json for integration into an MCP environment.

4. Test and debug your Hello World server with hands-on exercises.

1. Set up a new MCP project and configure it for development.

2. Write MCP tools/functions that handle requests and return structured responses.

3. Integrate the server with mcp.json for proper environment configuration.

4. Run, test, and debug the server to ensure it functions correctly in a hands-on, practical workflow.

Transforming external data sources into AI-accessible tools through the MCP protocol, enabling AI assistants to fetch real-time weather information for any supported city.

A simple Model Context Protocol (MCP) server that provides weather data as a tool for AI assistants. The server integrates with the free Open-Meteo weather API to fetch real-time temperature and wind speed data.

What you'll learn?

MCP Server Basics - How to create an MCP server using FastMCP framework?

Tool Definition - How to define tools that AI assistants can call using the @app.tool() decorator?

External API Integration - How to integrate with third-party APIs (Open-Meteo) using the requests library?

Data Validation - How to handle invalid inputs (unknown cities) with proper error messages?

Coordinate Mapping - How to map city names to geographic coordinates for API calls?

Response Formatting - How to structure API responses in a clean, consistent format?

Develop MCP server using python, Install and Manage Packages with pip, Upgrade/Remove Packages, Create and Use Virtual Environments

1. Work in an AI-Assisted Coding Environment

2. Develop and Manage MCP Server Projects

3. Debug and Test Code Efficiently

4. Manage Dependencies and Environments

5. Improve Productivity & Best Practices

   
   

Why do we need virtual environment while developing the MCP server in cursor IDE?

What are the advantages of creating virtual environment?

Benefits of virtual environment

1. Developing simple MCP servers , its configuration in Cursor and running it.

2. MCP Skills: Server creation, API integration, error handling, response formatting

3. Cursor AI Advantages: Accelerated learning, real-time feedback, integrated testing environment

4. Solid foundation for advanced MCP servers & AI-tool integration

1. MCP architecture fundamentals : What Model Context Protocol is, how servers, tools, and resources interact.

2. Designing MCP tools : How to define clear actions (add, list, mark-done) with strict schemas.

3. State and persistence: Storing todos locally (e.g., JSON file), ensuring durability and readability.

4. Idempotency and safe updates: Preventing duplicates, consistent task identification, and reliable “mark done.”

5. Error handling contracts: Returning helpful, structured errors for invalid input or missing tasks.

6. Validation and typing: Constraining inputs (required fields, string types) to avoid runtime surprises.

7. Separation of concerns: Keeping storage logic, command handlers, and protocol wiring cleanly isolated.

8. Integration with MCP clients: Exposing capabilities that agents like Cursor can call seamlessly.

9. Testing and observability: Simple local tests, logging, and behaviors that are easy to verify end-to-end.

This minimal MCP (Model Context Protocol) server exposes a single tool, `image_info`,

that reads a local image file and returns basic metadata such as format, mode, and size.

What you'll learn by studying this server:

- How to initialize a simple MCP server using FastMCP

- How to expose a function as an MCP tool with type annotations

- How to perform basic input validation (file path existence)

- How to use Pillow (`PIL.Image`) to open images and extract metadata

- How to return structured data (a serializable `dict`) to MCP clients

Practical MCP usage: How to call a local MCP tool (`text-summarizer`) with parameters (e.g., sentences=3–4) and consume its output.

Summarization fundamentals: Turning long text into concise, coherent summaries and selecting appropriate summary lengths for context.

Prompt design: Framing inputs clearly and controlling outputs (sentence count, brevity vs. coverage).

• MCP = Protocol (JSON-RPC over stdio).

• Cursor AI = Orchestrator, not executor.

• Tools = Exposed by MCP Server.

• LLM = Optional helper for natural language → tool selection.

1. MCP-Based Application:
   Built using the Model Context Protocol (MCP) so that AI clients (like Cursor) can call server-side tools programmatically.

2. FastMCP Framework:
   Uses the FastMCP library to quickly define tools, resources, and expose them as an ASGI application.

3. Persistent To-Do Storage:
   All tasks are stored in a local todos.json file, enabling data persistence across sessions.

4. Core MCP Tools Provided:

   • add_todo(task) → adds a new task

   • list_todos() → lists all tasks

   • mark_todo_done(task) → marks a task as completed

     
     

5. Server-Sent Events (SSE) Integration:
   Uses SSE to stream real-time updates from the MCP server to connected clients — enabling live notifications or progress updates.

6. ASGI + Uvicorn Runtime:
   Runs as an ASGI application served by Uvicorn, making it asynchronous and production-ready.

7. Endpoints Defined:

   • /todos → main HTTP endpoint for MCP message exchange

   • /sse → dedicated endpoint for Server-Sent Events streaming

8. Local and AI-Client Compatible:
   Can be registered in mcp.json so AI tools (e.g., Cursor or VS Code AI) can interact with it directly via JSON-RPC.

9. Learning Value:
   Demonstrates how to build a real-time, event-driven MCP server that combines AI tool integration, persistent data handling, and SSE communication.

This example demonstrates how to build MCP (Model Context Protocol) servers using streamable HTTP transport instead of the traditional stdio transport.

- Modern web architecture and HTTP protocols

- JSON-RPC 2.0 communication standards

- Scalable server design patterns

- Real-world API integration techniques

• Read-Only Data Catalog - MCP Resources provide a standardized way to expose read-only data that AI assistants can browse and fetch. Unlike tools (which perform actions), resources are for retrieving information through a URI-based catalog system (e.g., `todos://list`).

• Resource Metadata Structure - Each Resource must define key metadata: `uri` (unique identifier), `name` (human-readable title), `description` (explains what the resource contains), and `mimeType` (data format like `application/json`, `text/plain`, or `image/png`).

• Content Array with TextContent - Resources return their data through a `content` array containing `TextContent` objects. Each TextContent has a `type` field (set to `"text"`) and a `text` field containing the actual data payload.

• Dynamic Data at Call Time - Resource functions are executed when requested, meaning they return the current state of the underlying data. In this example, `get_todos_resource()` reads from `todos.json` each time it's called, ensuring clients always get fresh data.

• Client Discovery via resources/list - MCP clients (like Cursor) can discover available resources by calling `resources/list`, then fetch specific resources by their URI. This creates a browsable interface where AI assistants can explore and access structured data from your server.

What are FastMCP Prompts?

==========================

FastMCP Prompts are special functions in the Model Context Protocol (MCP)

that provide natural language interfaces for AI assistants.

Unlike regular MCP tools that require structured parameters, prompts accept natural language input

and intelligently process it to perform complex operations.

DATA FLOW

=========

User Input → Prompt Selection → Input Processing → Data Analysis →

Response Generation → Data Storage → User Feedback

KEY BENEFITS

============

• Natural Language Understanding

• Intelligent Data Processing

• Context-Aware Responses

• Error Handling & Validation

• User Experience Enhancement

• Analytics & Insights

• Batch Processing Capabilities

• Interactive Guidance

USAGE SCENARIOS

===============

• Personal Task Management

• Project Planning

• Data Entry Automation

• Content Analysis

• User Onboarding

• Quality Assurance

• Productivity Tracking

• Smart Recommendations

Powerful feature of the Model Context Protocol that allows your MCP server to request LLM completions through the MCP client

1. Universal MCP configuration

2. Consistent experience with different AI clients.

3. MCP is client agnostic

4. Multiple server connection with cursor AI and Claude AI

5. MCP is not just for IDE it's a universal protocol

6. Unified data access

7. Protocol standardization

1. MCP server talking to SQLite Database

2. Modular architecture for better code organization, maintainability, and scalability.

3. Tools and Resources which serves the requests by communicating with the database.

4. Benefits of Modular Architecture

1. Add required packages in visual studio to develop local MCP server.

2. Microsoft.Extensions.Hosting package for hosting the startup infrastructure of the application.

3. ModelContextProtocol (pre-release) : Which is .Net SDK for MCP Development.

1. Automated SQL Schema Analysis

2. Metadata Extraction and Search

3. Relationship and Constraint Discovery

4. SQL Statement and Procedure Generation

5. Schema Export and Integration

1. Entry point for the DB Interaction MCP Server application.

2. Configures logging, dependency injection, and starts the MCP server with standard I/O transport.

3. Register MCP server services and tools, and configure the server to use standard input/output for communication.

4. Run the host asynchronously.

1. McpServerToolType : To define a type of class to declare it contains MCP tools

2. McpServerTool : To define this method is a MCP server tool.

1. How to add mcp.json file?

2. How to configure your MCP Server?

3. How to run the prompts in Copilot and test your mcp server?