Airline Flight Delays MCP Server

AI-Powered Customer Service Automation for Weather-Related Flight Disruptions

📋 Overview

This project presents a Model Context Protocol (MCP) server-based system designed to reduce customer support costs for Indigo airline during weather-related flight delays. The airline operates a major hub in Mumbai with over 5,000 daily flights and faces peak support demand, long wait times, customer dissatisfaction, and high operational costs during delays.

Key Innovations

• Mood-Aware Communication: Adapts tone based on passenger sentiment (frustrated, concerned, calm, excited)

• Proactive Engagement: Entertainment activities scaled to delay duration (30min to 3+ hours)

• Personalized Service: Prioritizes frequent flyer members and provides customized recommendations

• Seamless Human Handoff: Full conversation context preservation for specialist escalation

• Real-Time Intelligence: Live flight status, rebooking options, and destination insights

Expected Results

• 60-70% reduction in routine customer service inquiries through automation

• Instant response times for common queries

• Intelligent routing of complex cases to human specialists

• Enhanced customer satisfaction through personalized, empathetic service

🏗️ Architecture

The solution uses a microservices architecture with six specialized MCP servers coordinated by a main orchestrator:

┌─────────────────────────────────────────────────────────────┐
│                   Main MCP Orchestrator                      │
│                  (FastMCP Server - Python)                   │
└─────────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        │                     │                     │
        ▼                     ▼                     ▼
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│Authentication│    │   Flight     │    │    Mood      │
│   Server     │    │ Information  │    │  Analysis    │
│              │    │   Server     │    │   Server     │
└──────────────┘    └──────────────┘    └──────────────┘
        │                     │                     │
        ▼                     ▼                     ▼
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ Engagement/  │    │ Itinerary/   │    │    Human     │
│   Games      │    │    Food      │    │    Agent     │
│   Server     │    │   Server     │    │   Transfer   │
└──────────────┘    └──────────────┘    └──────────────┘

1. Authentication Server

• Secure passenger login and session management

• PNR/email/frequent flyer number authentication

• JWT token generation

• Passenger profile retrieval

2. Flight Information Server

• Real-time flight status and delay information

• Gate details and terminal navigation

• Alternative flight options for rebooking

• Connection impact analysis

• Weather delay notifications

3. Mood Analysis Server

• Sentiment detection using VADER and TextBlob

• LLM-powered emotional intelligence analysis

• Communication tone recommendations

• Escalation trigger detection

• Sentiment trend tracking

4. Engagement/Games Server

• Delay-appropriate entertainment activities

• Interactive games, trivia, and quizzes

• Destination virtual tours

• Relaxation and mindfulness exercises

• Airport exploration suggestions

5. Itinerary/Food Server

• Airport restaurant recommendations

• Destination dining guides

• Attraction and activity planning

• Personalized itinerary generation

• Dietary restriction handling

6. Human Agent Transfer Server

• Context-aware escalation to specialists

• Complete conversation history preservation

• Priority queue management

• Passenger profile and sentiment handoff

• Intelligent routing based on issue complexity

🚀 Quick Start

Prerequisites

• Python: 3.9 or higher

• PostgreSQL: 12+ with pgvector extension

• Redis: 6+ (optional, for caching)

• LLM API: OpenAI, Azure OpenAI, or Anthropic API key

Installation

1. Clone the Repository

cd /path/to/your/workspace
git clone <repository-url>
cd airline-delays-mcp-server

2. Create Virtual Environment

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install Dependencies

pip install -r requirements.txt

4. Setup Database

-- Connect to PostgreSQL
psql -U postgres

-- Create database
CREATE DATABASE airline_delays_db;

-- Connect to database
\c airline_delays_db

-- Enable pgvector extension (if using vector operations)
CREATE EXTENSION IF NOT EXISTS vector;

5. Configure Environment

Create a .env file (copy from env.example):

cp env.example .env

Edit .env with your configuration:

# Database
DB_HOST=localhost
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=your_password
DB_NAME=airline_delays_db

# OpenAI (or use Azure/Anthropic)
OPENAI_API_KEY=your_openai_api_key
OPENAI_MODEL=gpt-4-turbo-preview

# Server
PORT=3003
TRANSPORT=httpStream
ENVIRONMENT=development

6. Initialize Database Schema

python -c "import asyncio; from src.config.database import init_database; asyncio.run(init_database())"

7. Run the Server

python run.py

The server will start on http://localhost:3003/mcp

💻 Usage

Available Tools

The MCP server exposes 6 tools that can be called by AI assistants:

1. authenticate_passenger

Authenticate a passenger and create a session.

{
  "pnr": "ABC123",
  "last_name": "Smith",
  "email": "smith@example.com"
}

2. get_flight_information

Get real-time flight status and rebooking options.

{
  "flight_number": "6E-123",
  "passenger_id": "P12345",
  "include_alternatives": true
}

3. analyze_mood

Analyze passenger sentiment and get communication recommendations.

{
  "session_id": "session_abc123",
  "message": "This delay is completely unacceptable!",
  "analyze_trend": true
}

4. suggest_engagement

Suggest entertainment activities for delayed passengers.

{
  "delay_minutes": 120,
  "passenger_mood": "frustrated",
  "destination": "DEL",
  "activity_type": "any"
}

5. recommend_services

Recommend airport/destination dining and activities.

{
  "service_type": "airport_food",
  "airport_code": "BOM",
  "dietary_restrictions": ["vegetarian"],
  "budget": "moderate"
}

6. transfer_to_human

Transfer to human agent with full context.

{
  "session_id": "session_abc123",
  "reason": "high_frustration",
  "urgency": "high",
  "summary": "Passenger frustrated with long delay and missed connection"
}

📁 Project Structure

airline-delays-mcp-server/
├── src/
│   ├── config/
│   │   ├── __init__.py
│   │   ├── environment.py      # Environment variable management
│   │   ├── database.py         # PostgreSQL connection pool
│   │   └── llm.py              # LLM client (OpenAI/Azure/Anthropic)
│   ├── tools/
│   │   ├── __init__.py
│   │   ├── authentication.py   # Authentication Server
│   │   ├── flight_information.py  # Flight Information Server
│   │   ├── mood_analysis.py    # Mood Analysis Server
│   │   ├── engagement_games.py # Engagement/Games Server
│   │   ├── itinerary_food.py   # Itinerary/Food Server
│   │   └── human_handoff.py    # Human Agent Transfer Server
│   ├── utils/
│   │   ├── __init__.py
│   │   ├── logger.py           # Structured logging
│   │   └── helpers.py          # Utility functions
│   ├── interfaces/
│   │   └── __init__.py         # Type definitions
│   ├── __init__.py
│   └── server.py               # Main MCP server orchestrator
├── docs/
│   └── ARCHITECTURE.md         # Detailed architecture documentation
├── tests/
│   └── (test files)
├── .env                        # Environment configuration (create from env.example)
├── env.example                 # Example environment configuration
├── requirements.txt            # Python dependencies
├── run.py                      # Server startup script
├── Dockerfile                  # Docker container definition
├── docker-compose.yml          # Docker Compose configuration
└── README.md                   # This file

🔧 Configuration

Environment Variables

See env.example for all available configuration options.

Key variables:

Feature Flags

Enable/disable features via environment:

ENABLE_MOOD_ANALYSIS=true
ENABLE_GAMES=true
ENABLE_FOOD_RECOMMENDATIONS=true
ENABLE_HUMAN_HANDOFF=true

🐳 Docker Deployment

Build Docker Image

docker build -t airline-delays-mcp-server .

Run with Docker Compose

docker-compose up -d

This starts:

• MCP Server (port 3003)

• PostgreSQL database

• Redis cache

Stop Services

docker-compose down

🧪 Testing

Run tests:

pytest tests/ -v

Run with coverage:

pytest tests/ --cov=src --cov-report=html

📊 Monitoring & Observability

Logging

The server uses structured JSON logging. Set log level via:

LOG_LEVEL=INFO  # DEBUG, INFO, WARNING, ERROR, CRITICAL
LOG_FORMAT=json # json or text

Metrics

Key metrics tracked:

• Tool execution times

• Sentiment scores and trends

• Escalation rates

• Response times

• Database query performance

🔐 Security

• JWT Authentication: Secure session management

• Input Sanitization: XSS and injection prevention

• Rate Limiting: Prevent abuse (configure via environment)

• Database SSL: Encrypted connections to database

• API Key Management: Secure credential storage

🎯 Use Cases

1. Weather Delay Scenario

Passenger: "My flight is delayed. What's happening?"

System Flow:

1. ✅ Authenticate passenger (Authentication Server)

2. ✅ Get flight status (Flight Information Server)

3. ✅ Analyze mood (Mood Analysis Server)

4. ✅ Provide alternatives and rebooking options

5. ✅ Suggest activities if long delay (Engagement Server)

6. ✅ Recommend airport dining (Itinerary/Food Server)

2. Frustrated Passenger Escalation

Passenger: "This is unacceptable! I demand to speak to a manager!"

System Flow:

1. ✅ Detect high frustration (Mood Analysis Server)

2. ✅ Attempt to de-escalate with empathetic response

3. ✅ Offer compensation/alternatives

4. ✅ If frustration persists → Transfer to human (Human Handoff Server)

5. ✅ Agent receives full context, no repetition needed

3. Multi-Hour Delay

Delay: 3+ hours

System Actions:

1. ✅ Proactive engagement with entertainment options

2. ✅ Destination planning assistance

3. ✅ Airport restaurant recommendations

4. ✅ Meal voucher information

5. ✅ Regular status updates

6. ✅ Hotel arrangements if needed

🤝 Integration

Claude Desktop Integration

Add to Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "airline-delays": {
      "command": "python",
      "args": ["/path/to/airline-delays-mcp-server/run.py"],
      "env": {
        "TRANSPORT": "stdio"
      }
    }
  }
}

API Integration

For HTTP integration:

import requests

response = requests.post(
    "http://localhost:3003/mcp",
    json={
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {
            "name": "get_flight_information",
            "arguments": {
                "flight_number": "6E-123"
            }
        }
    }
)

print(response.json())

📚 Additional Documentation

• Architecture Guide - Detailed system architecture

• API Reference - Complete API documentation

• Deployment Guide - Production deployment

• Troubleshooting - Common issues and solutions

🛣️ Roadmap

• Multi-language support (Hindi, regional languages)

• Voice integration for phone-based support

• Mobile app integration

• Advanced analytics dashboard

• ML-powered delay prediction

• Integration with more airlines

• Automated compensation processing

📄 License

MIT License - see LICENSE file for details

👥 Contributors

• Development Team

• Airline Operations Team

• Customer Service Specialists

📞 Support

For issues and questions:

• GitHub Issues: Create an issue

• Email: support@example.com

• Documentation: Full docs

🙏 Acknowledgments

Built with:

• FastMCP - MCP server framework

• OpenAI API - LLM capabilities

• TextBlob - Sentiment analysis

• VADER Sentiment - Social media sentiment

• PostgreSQL - Database

• asyncpg - Async PostgreSQL driver

Made with ❤️ for better customer experiences during travel disruptions