FastMCP Demo Server

A demonstration server built with FastMCP framework that showcases how to create Model Context Protocol (MCP) servers with custom tools.

What is MCP?

Model Context Protocol (MCP) is an open protocol that enables AI assistants and applications to securely access external data sources and tools. It provides a standardized way for AI models to:

• Access external APIs and services
• Interact with databases and file systems
• Execute custom functions and tools
• Retrieve context from various sources
• Perform actions on behalf of users

MCP acts as a bridge between AI applications and external resources, allowing models to extend their capabilities beyond their training data.

Why is MCP Useful?

MCP solves several critical problems in AI application development:

1. Standardization: Provides a common protocol for AI-to-external-service communication
2. Security: Enables secure, controlled access to external resources
3. Extensibility: Allows developers to add custom capabilities without modifying core AI models
4. Separation of Concerns: Keeps AI logic separate from external service integrations
5. Real-time Data: Enables AI models to access up-to-date information from external sources
6. Tool Execution: Allows AI models to perform actions (not just retrieve information)

Architecture of MCP

MCP follows a client-server architecture:

┌─────────────┐         MCP Protocol         ┌─────────────┐
│             │ ◄──────────────────────────► │             │
│ MCP Client  │     (JSON-RPC over stdio)   │ MCP Server  │
│  (AI App)   │                              │  (This App) │
│             │                              │             │
└─────────────┘                              └─────────────┘
                                                      │
                                                      │
                                              ┌───────┴───────┐
                                              │               │
                                         External APIs    Databases
                                         File Systems    Services

Key Components:

1. MCP Client: The AI application (e.g., Claude Desktop, custom AI app) that makes requests
2. MCP Server: This application that exposes tools and resources
3. Transport Layer: JSON-RPC 2.0 protocol over stdio (standard input/output)
4. Tools: Functions exposed by the server that the client can call
5. Resources: Data sources that can be accessed by the client
6. Prompts: Pre-defined prompt templates

Communication Flow:

1. Client sends a JSON-RPC request to the server
2. Server processes the request (calls tools, fetches resources)
3. Server sends a JSON-RPC response back to the client
4. Client uses the response in its AI context

Lifecycle of MCP

The MCP server lifecycle follows these stages:

1. Initialization

• Server starts and listens on stdio
• Server registers available tools, resources, and prompts
• Server sends initialization message to client

2. Handshake

• Client and server exchange capabilities
• Client requests server information (name, version, available tools)
• Server responds with its capabilities

3. Operation

• Client sends tool execution requests
• Server processes requests and executes tools
• Server returns results to client
• This cycle repeats for each interaction

4. Shutdown

• Client sends shutdown signal
• Server cleans up resources
• Server terminates gracefully

Example Lifecycle Flow:

Start Server → Initialize FastMCP → Register Tools → Listen on stdio
                                                          │
                                                          ▼
Client Connects → Handshake → Request Tool → Execute Tool → Return Result
                                                          │
                                                          ▼
                                              Continue Listening...

How to Use This Demo Server

Prerequisites

• Python 3.12 or higher
• uv package manager (or pip)

Installation

1. Install dependencies:

uv sync
# or
pip install fastmcp>=2.14.0 requests

Running the Server

Using uv (Recommended)

uv provides a fast and reliable way to manage dependencies and run Python projects:

# Install dependencies (creates virtual environment automatically)
uv sync

# Run the server using uv
uv run python main.py

# Or activate the virtual environment first
source .venv/bin/activate  # On macOS/Linux
# or
.venv\Scripts\activate  # On Windows
python main.py

Using Standard Python

python main.py

The server will start and listen on standard input/output for MCP protocol messages.

Available Tools

This demo server exposes two tools:

1. add: Simple addition function

   • Parameters: a (int), b (int)
   • Returns: Sum of a and b
   • Example: add(5, 3) returns 8

2. weather_api: Fetches weather data for a city

   • Parameters: city (str) - Name of the city
   • Returns: Weather data as text
   • Note: Requires a weather API running at http://127.0.0.1:8080

Connecting from an MCP Client

To use this server with an MCP client (like Claude Desktop):

1. Configure the client to use this server
2. The client will communicate via stdio using JSON-RPC
3. The client can call add or weather_api tools as needed

What are the Business or Real Pain Points MCP Server Resolves?

MCP servers address several real-world challenges:

1. Data Freshness

• Problem: AI models have training cutoffs and can't access real-time data
• Solution: MCP servers provide access to live APIs, databases, and services

2. Custom Business Logic

• Problem: Generic AI models don't know your specific business processes
• Solution: MCP servers can expose domain-specific tools and workflows

3. Security & Access Control

• Problem: Direct API access from AI models raises security concerns
• Solution: MCP servers act as a controlled gateway with proper authentication

4. Integration Complexity

• Problem: Each AI application needs custom integration code
• Solution: Standardized MCP protocol works across different AI applications

5. Resource Management

• Problem: AI models need access to files, databases, and services
• Solution: MCP servers provide unified access to various resources

6. Action Execution

• Problem: AI models can only generate text, not perform actions
• Solution: MCP servers execute tools on behalf of the AI model

Can We Build Something Useful?

Absolutely! Here are practical MCP server ideas:

1. Database Query Server

• Expose SQL queries as tools
• Allow AI to query databases safely
• Use case: Business intelligence, data analysis

2. API Integration Server

• Connect to multiple third-party APIs
• Provide unified interface for AI
• Use case: CRM integration, payment processing

3. File Management Server

• Read/write files securely
• Search and organize documents
• Use case: Document management, code editing

4. Workflow Automation Server

• Execute business processes
• Trigger actions in other systems
• Use case: Task automation, notifications

5. Knowledge Base Server

• Access internal documentation
• Search company wikis
• Use case: Internal support, onboarding

6. Development Tools Server

• Run tests, deploy code
• Check logs, monitor systems
• Use case: DevOps automation, debugging

Project Structure

fastmcp-demo-server/
├── main.py           # Main server file with tool definitions
├── pyproject.toml    # Project dependencies and metadata
├── README.md         # This file
└── uv.lock          # Dependency lock file

Code Overview

The server uses FastMCP framework which simplifies MCP server creation:

• @mcp.tool decorator registers functions as MCP tools
• Tools automatically get type hints and documentation
• Server handles JSON-RPC protocol automatically
• mcp.run() starts the server and listens for requests

Next Steps

1. Add more tools to extend functionality
2. Implement error handling and validation
3. Add logging for debugging
4. Create resources and prompts (MCP features)
5. Deploy the server for production use
6. Integrate with real APIs and services

Resources

• FastMCP Documentation
• Model Context Protocol Specification
• MCP GitHub Repository

How to seyup an mcp server using uv which is a package manager

create a folder -->fastmcp-demo-server uv init . uv add fastmcp

create asimple server run the sever uv run main.py

tio run the mcp server in dev

uv run fastmcp dev main.py

to run the server

uv run fastmcp run main.py

to install server to claude desktop

uv run fastmcp install claude-desktop main.py