Content
# Tool List
## Overview
Flight Ticket MCP Server is a model context protocol (MCP) based server for querying flight tickets. This server provides AI assistants with standardized, real-time flight dynamic query function interfaces.
## Features
### Flight Route Query
- Query available flights based on departure, destination, and departure date
- Supports 282 domestic city and airport codes
- Intelligent city name resolution (supports city name, airport code, complete format)
- Real-time flight price and flight schedule information
- Airline and aircraft type information
- Terminal and boarding gate information
- Price statistics and airline distribution
- Formatted output results
### Flight Transfer Route Query
- Query connecting flights based on departure, transfer, and destination
- Supports custom minimum and maximum transfer time (default 2-5 hours)
- Intelligent screening of flight combinations that meet transfer time requirements
- Provides complete two-legged journey information
- Supports domestic and international route transfers
- Detailed transfer time calculation and verification
### Weather Information Query
- **Query by longitude and latitude**: precise geographic location weather query
- **Query by city name**: supports major city direct query
- Supports historical, current, and future weather data
- Provides temperature, humidity, wind speed, weather conditions, and other detailed information
- Automatic processing of time zone and date range
- Supports presets for major cities such as Wuhan, Beijing, Shanghai
### Flight Information Query
- Query detailed flight information based on flight number
- Includes flight status, seat configuration, price information
- Provides weather information (departure and destination)
- Displays basic flight information (airline, aircraft type, route type)
- Detailed terminal, boarding gate information
- Real-time dynamic status (on-time, delayed, boarding, flying, etc.)
- Seat price and availability information
- Additional service information (meal, WiFi, entertainment system, etc.)
### Real-time Flight Tracking
- **Real-time flight status query**: query real-time flight position and status
- **Airport surrounding flight query**: query all flights within 30 kilometers of a specified airport
- **Regional flight query**: query all real-time flights within a specified geographic area
- **Batch flight tracking**: track multiple flights' real-time status simultaneously
- Supports over 70 major airport codes in China (PEK, PVG, CAN, etc.)
- Provides detailed flight position, speed, altitude, status information
- Public API with no authentication required, real-time updates flight data
### Date and Time Tools
- Get current system date (YYYY-MM-DD format)
- Get current system date and time (YYYY-MM-DD HH:mm:ss format)
- Provides standardized date and time support for other functions
- Automatic processing of time zone and format conversion
### Data Processing and Intelligence
- **Intelligent city parsing**: supports multiple city input formats (city name, airport code, complete format)
- **Parameter verification**: comprehensive input parameter verification and error handling
- **Result formatting**: unified JSON format output, easy for AI assistants to parse
- **Error recovery**: complete exception handling and degradation mechanism
- **Log recording**: detailed operation log and debugging information
## Technical Architecture
### Core Module (Core)
- Flight data model and structure definition
- Airport, airline, flight, price, and other data models
- Flight transfer and seat configuration data structure
### Tool Module (Tools)
- **Flight Search Tool** (`flight_search_tools.py`) - Flight route query function
- **Flight Transfer Tool** (`flight_transfer_tools.py`) - Multi-leg journey and transfer query
- **Flight Information Tool** (`flight_info_tools.py`) - Query detailed information based on flight number
- **Real-time Flight Tracking Tool** (`simple_opensky_tools.py`) - Real-time flight tracking based on OpenSky Network
- **Weather Query Tool** (`weather_tools.py`) - Weather query based on longitude and latitude and city
- **Date and Time Tool** (`date_tools.py`) - Date and time acquisition and processing
### Utility (Utils)
- **City Dictionary** (`cities_dict.py`) - 282 city and airport code mappings
- **Data Validator** (`validators.py`) - Input parameter verification and format checking
- **Date Tool** (`date_utils.py`) - Date formatting and time zone processing
- **API Client** (`api_client.py`) - HTTP request encapsulation and error handling
### MCP Integration Layer
- **FastMCP Server** - MCP protocol implementation based on FastMCP framework
- **Multi-transport protocol support** - stdio, SSE, HTTP transport protocols
- **Tool registration management** - Unified tool registration and calling mechanism
- **Environment configuration management** - Flexible configuration and environment variable support
## Supported Transport Protocols
This server supports three transport protocols:
1. **sse** - Server-Sent Events (default, suitable for web applications)
2. **stdio** - Standard input and output (suitable for Claude Desktop)
3. **streamable-http** - Streamable HTTP (suitable for HTTP clients)
## Installation
### Prerequisites
- Python 3.11 or higher
- pip package manager (or uvx tool)
### Method 1: Install from PyPI (Recommended)
```bash
# Install using pip
pip install flight-ticket-mcp-server
# Or use uvx to run directly (no installation required)
uvx flight-ticket-mcp-server
# Or use uvx to install and run
uvx --install flight-ticket-mcp-server
```
### Method 2: Local Development Installation
```bash
# Clone or download the project
cd FlightTicketMCP
# Install dependencies
pip install -r requirements.txt
# Or install from local source code
pip install -e .
```
### uvx Usage Instructions
uvx is a modern Python package running tool that can run PyPI packages directly without installing them in the system environment:
```bash
# Install uv (including uvx tool)
pip install uv
# Run MCP server directly (no installation required)
uvx flight-ticket-mcp-server
# Use the latest version (recommended)
uvx flight-ticket-mcp-server@latest
# Run with parameters
uvx flight-ticket-mcp-server --help
# Specify version to run
uvx flight-ticket-mcp-server==1.0.1
# Force reinstall the latest version
uvx flight-ticket-mcp-server@latest --help
```
**Advantages of uvx:**
- 🚀 No need to pollute the global Python environment
- 📦 Automatic management of virtual environments
- 🔄 Supports running the latest version directly
- 🛡️ Isolated dependencies, avoiding conflicts
## Startup Methods
### 1. Direct Startup (Default SSE Mode)
```bash
# Use the main startup file (default startup SSE mode, listening on 127.0.0.1:8000)
python flight_ticket_server.py
# Or directly run main.py
python main.py
```
### 2. Debug Mode Startup
```bash
# Enable debug mode, which will output detailed logs
set MCP_DEBUG=true
python flight_ticket_server.py
# Linux/macOS
export MCP_DEBUG=true
python flight_ticket_server.py
```
### 3. Different Transport Protocol Startup
#### SSE Mode (Default)
```bash
# Start directly using default SSE configuration (127.0.0.1:8000)
python flight_ticket_server.py
```
#### stdio Mode
```bash
# Windows
set MCP_TRANSPORT=stdio
python flight_ticket_server.py
# Linux/macOS
export MCP_TRANSPORT=stdio
python flight_ticket_server.py
```
#### HTTP Mode
```bash
# Windows
set MCP_TRANSPORT=streamable-http
set MCP_HOST=127.0.0.1
set MCP_PORT=8000
python flight_ticket_server.py
# Linux/macOS
export MCP_TRANSPORT=streamable-http
export MCP_HOST=127.0.0.1
export MCP_PORT=8000
python flight_ticket_server.py
```
### 4. Environment Variable Configuration
#### Using .env File (Recommended)
The project provides a `.env.example` file as a configuration template:
1. **Copy configuration template**:
```bash
# Copy configuration template
cp .env.example .env
```
2. **Edit configuration file**:
Open `.env` file and modify configuration values as needed:
```env
# MCP server configuration
MCP_TRANSPORT=sse
MCP_HOST=127.0.0.1
MCP_PORT=8000
MCP_SSE_PATH=/sse
# Log configuration
LOG_LEVEL=INFO
LOG_FILE_PATH=logs/flight_server.log
LOG_MAX_SIZE=10
LOG_BACKUP_COUNT=5
# Development configuration
MCP_DEBUG=false
```
3. **Configuration instructions**:
- `.env` file contains sensitive configurations and will not be submitted to version control
- `.env.example` is a safe template file that can be submitted to Git
- Environment variable priority: system environment variables > .env file > program defaults
#### Directly Set Environment Variables
If you do not use the `.env` file, you can directly set environment variables:
Supported environment variables:
| Variable Name | Description | Default Value | Optional Values |
|--------------|-------------|---------------|-----------------|
| `MCP_TRANSPORT` | Transport protocol type | `sse` | `stdio`, `sse`, `streamable-http` |
| `MCP_HOST` | Server host address | `127.0.0.1` | Any valid IP address |
| `MCP_PORT` | Server port | `8000` | 1-65535 |
| `MCP_PATH` | HTTP path | `/mcp` | Any valid path |
| `MCP_SSE_PATH` | SSE path | `/sse` | Any valid path |
| `MCP_DEBUG` | Debug mode | `false` | `true`, `false`, `1`, `0` |
| `LOG_LEVEL` | Log level | `INFO` | `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL` |
| `LOG_FILE_PATH` | Log file path | `logs/flight_server.log` | Any valid path |
| `LOG_MAX_SIZE` | Log file maximum size (MB) | `10` | Positive integer |
| `LOG_BACKUP_COUNT` | Log backup count | `5` | Positive integer |
| `FASTMCP_LOG_LEVEL` | FastMCP log level | `INFO` | `DEBUG`, `INFO`, `WARNING`, `ERROR` |
### 5. Startup Verification
After successful startup, you will see similar output:
```
Transport: sse
Logging enabled - logs will be saved to logs/ directory
Flight Ticket MCP Server starting...
Transport: sse
All tools registered successfully
Starting SSE transport on 127.0.0.1:8000/sse
```
### 6. Log Files
The server will generate the following log files in the `logs/` directory after startup:
- `flight_server.log` - General log (INFO level and above)
- `flight_server_error.log` - Error log (ERROR level)
- `flight_server_debug.log` - Debug log (only generated in debug mode)
### 7. Stop Server
- **stdio mode**: Press `Ctrl+C` to stop
- **HTTP/SSE mode**: Press `Ctrl+C` or send SIGTERM signal
## Usage
### MCP Client Configuration
#### Method 1: Using uvx (Recommended)
Use uvx to run the MCP server without pre-installation, simple and elegant:
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "uvx",
"args": ["flight-ticket-mcp-server@latest"]
}
}
}
```
**Advantages of uvx configuration:**
- 🚀 No need to pre-install packages
- 📦 Automatic dependency and virtual environment management
- 🔄 Always run the latest version
- 🛡️ Isolated environment, avoiding conflicts
#### Method 2: Using pip Installation and Running
If installed via pip, you can directly use the command-line tool:
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "flight-ticket-mcp-server"
}
}
}
```
#### Method 3: Local Development Version
For local development or custom versions:
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "python",
"args": ["D:\\FlightTicketMCP\\flight_ticket_server.py"],
"env": {
"MCP_TRANSPORT": "stdio"
}
}
}
}
```
#### Configuration File Location
Add the above configuration to the Claude Desktop configuration file:
- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
- **Linux**: `~/.config/claude/claude_desktop_config.json`
#### Application Configuration
1. Save the configuration file
2. Restart Claude Desktop
3. You should see the flight-ticket-server connection successful in Claude Desktop
### Different Transport Protocol Configurations
#### SSE Mode (Default)
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "python",
"args": ["D:\\FlightTicketMCPServer\\flight_ticket_server.py"],
"env": {
"MCP_TRANSPORT": "sse",
"MCP_HOST": "127.0.0.1",
"MCP_PORT": "8000",
"MCP_SSE_PATH": "/sse"
}
}
}
}
```
#### stdio Mode
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "python",
"args": ["D:\\FlightTicketMCPServer\\flight_ticket_server.py"],
"env": {
"MCP_TRANSPORT": "stdio"
}
}
}
}
```
#### HTTP Mode
```json
{
"mcpServers": {
"flight-ticket-server": {
"command": "python",
"args": ["D:\\FlightTicketMCPServer\\flight_ticket_server.py"],
"env": {
"MCP_TRANSPORT": "streamable-http",
"MCP_HOST": "127.0.0.1",
"MCP_PORT": "8000",
"MCP_PATH": "/mcp"
}
}
}
}
```
### MCP Client Testing
#### Test Connection
After configuration, you can test the MCP server connection using:
1. **Claude Desktop Testing**:
- Restart Claude Desktop
- Check if the status bar shows "flight-ticket-server" connection successful
- Try asking in conversation: "What tools are available now?"
2. **Command-line Testing**:
```bash
# Use uvx for direct testing
uvx flight-ticket-mcp-server --help
# Or use installed package for testing
flight-ticket-mcp-server --help
# Test module-based running
python -m flight_ticket_mcp_server --help
```
3. **MCP Protocol Testing**:
```bash
# Use MCP inspector tool for testing (if installed)
npx @modelcontextprotocol/inspector uvx flight-ticket-mcp-server
```
#### Verify Tool Registration
After successful connection, your Claude should be able to access the following tools:
- ✈️ **searchFlightRoutes** - Flight route query
- 📅 **getCurrentDate** - Get current date
- 🔄 **getTransferFlightsByThreePlace** - Flight transfer query
- 🌤️ **getWeatherByLocation** - Longitude and latitude weather query
- 🏙️ **getWeatherByCity** - City weather query
- ℹ️ **getFlightInfo** - Flight information query
- 📡 **getFlightStatus** - Flight real-time status query
- 🛫 **getAirportFlights** - Airport surrounding flight query
- 🗺️ **getFlightsInArea** - Area flight query
- 📊 **trackMultipleFlights** - Batch flight tracking
#### Troubleshooting
If the connection fails, please check:
1. **uvx configuration**:
```bash
# Check if uv/uvx is installed
uvx --version
# Manually test package running
uvx flight-ticket-mcp-server@latest
# Clear uvx cache and retry
uv cache clean
uvx flight-ticket-mcp-server@latest
```
2. **Package version**:
```bash # Force use the latest version
uvx flight-ticket-mcp-server@latest
# Clear uvx cache and retry
uv cache clean
uvx flight-ticket-mcp-server@latest
```
3. **Configuration file syntax**:
- Ensure JSON format is correct
- Check quote and bracket matching
- Verify configuration file path
4. **Log check**:
- View Claude Desktop's log output
- Check server startup logs
### Example Operations
After configuration, you can ask Claude to perform the following operations:
#### Flight Route Query
- "Query tomorrow's flights from Chongqing to Guangzhou"
- "Search for all flights from Shanghai to Beijing the day after tomorrow"
- "Check the flight prices from Shenzhen to Chengdu on July 20, 2024"
- "What are the flight options from Beijing to Sanya"
- "Help me find the flight information from Chengdu to Hangzhou next Tuesday"
#### Flight Transfer Query
- "Query the transfer flights from Beijing to New York via Hong Kong"
- "Search for connecting flights from Shanghai to London via Dubai with a transfer time of 3-6 hours"
- "Find flights from Guangzhou to Sydney via Singapore with a minimum transfer time of 2 hours"
- "What are the flights from Beijing to Los Angeles with a transfer in Tokyo"
#### Weather Information Query
- "Query today's and tomorrow's weather in Beijing"
- "What's the weather like in Shanghai"
- "Query the weather at latitude 39.9042, longitude 116.4074 (Beijing coordinates)"
- "What's the weather forecast for Wuhan this week"
- "Query the weather from July 15 to July 17, 2024, in Chongqing"
#### Flight Information Query
- "Query detailed information about flight CA1234"
- "What's the current status of flight MU5678"
- "Help me check the seat and price information for flight HU7890"
- "What are the gate and terminal information for flight CZ3691"
#### Real-time Flight Tracking Query
- "Query the real-time status and location of flight CCA1234"
- "Check which flights are around Beijing Capital Airport"
- "Query all flights within the Beijing area (latitude 39-41, longitude 115-118)"
- "Track the real-time status of flights CCA1234, CSN5678, and MU9876 simultaneously"
- "View flights near Pudong Airport"
- "Where is this plane now? What is its altitude and speed"
#### Date and Time Query
- "What's today's date"
- "What's the current date and time"
- "Help me get the current date"
#### Comprehensive Query Examples
- "I'm flying from Chengdu to Beijing tomorrow, and can you also tell me the weather in Beijing"
- "Query flights from Shanghai to Guangzhou and the weather in Guangzhou"
- "Help me plan a trip from Chongqing to Tokyo with a transfer and check the destination weather"
- "Query flight CA1234 information and the weather at the departure and destination airports"
- "My flight is MU5678, help me check the flight status and seat information"
- "Query the real-time location of flight CCA1234 and the weather at the destination"
- "I want to know which flights are departing from Beijing Airport now and the weather conditions in Beijing"
## API Reference
### Flight Route Query
```python
searchFlightRoutes(departure_city, destination_city, departure_date) # Query available flights based on departure city, destination city, and date
```
Input Parameters:
- `departure_city`: Departure city name or airport code (e.g., "Chongqing", "CKG", "Chongqing(CKG)")
- `destination_city`: Destination city name or airport code (e.g., "Guangzhou", "CAN", "Guangzhou(CAN)")
- `departure_date`: Departure date (YYYY-MM-DD format)
Output Information:
- Flight list (including flight number, airline, departure and arrival times, airport, terminal, price)
- Price statistics (lowest price, highest price, average price)
- Airline distribution statistics
- Formatted query result output
- Supported cities: 282 domestic cities and airports
Supported city formats:
- City name: Shanghai, Beijing, Chongqing, Guangzhou, etc.
- Airport code: SHA, BJS, CKG, CAN, etc.
- Complete format: Shanghai(SHA), Beijing(BJS), etc.
### Flight Transfer Route Query
```python
getTransferFlightsByThreePlace(from_place, transfer_place, to_place, min_transfer_time, max_transfer_time)
```
Input Parameters:
- `from_place`: Departure city name or airport code (e.g., "Beijing", "BJS")
- `transfer_place`: Transfer city name or airport code (e.g., "Hong Kong", "HKG")
- `to_place`: Destination city name or airport code (e.g., "New York", "NYC")
- `min_transfer_time`: Minimum transfer time (hours), default 2.0 hours
- `max_transfer_time`: Maximum transfer time (hours), default 5.0 hours
Output Information:
- List of transfer flights that meet the conditions
- Detailed information of the first leg (departure to transfer city)
- Detailed information of the second leg (transfer city to destination)
- Actual transfer time calculation
- Flight number, time, airport, and other detailed information
### Weather Information Query
#### Query by Latitude and Longitude
```python
getWeatherByLocation(latitude, longitude, start_date, end_date)
```
Input Parameters:
- `latitude`: Latitude (e.g., 39.9042)
- `longitude`: Longitude (e.g., 116.4074)
- `start_date`: Start date (YYYY-MM-DD format), optional
- `end_date`: End date (YYYY-MM-DD format), optional
#### Query by City Name
```python
getWeatherByCity(city_name, start_date, end_date)
```
Input Parameters:
- `city_name`: City name (e.g., "Beijing", "Shanghai", "Wuhan")
- `start_date`: Start date (YYYY-MM-DD format), optional
- `end_date`: End date (YYYY-MM-DD format), optional
Output Information:
- Weather condition description
- Temperature information (highest temperature, lowest temperature, current temperature)
- Humidity, wind speed, wind direction
- Precipitation probability and precipitation amount
- Sunrise and sunset time
- UV index
### Flight Information Query
```python
getFlightInfo(flight_number) # Query detailed flight information based on flight number
```
Input Parameters:
- `flight_number`: Flight number (e.g., "CA1234", "MU5678", "CZ3691")
Output Information:
- Basic flight information (airline, aircraft type, route type)
- Route information (departure and arrival airports, terminals, gates)
- Real-time status (on-time, delayed, boarding, in-flight, arrived, etc.)
- Seat configuration (number of economy, business, and first-class seats)
- Price information (price and availability of each class)
- Weather information (current weather at departure and destination airports)
- Additional services (check-in counters, baggage allowance, meals, WiFi, etc.)
Supported flight number formats:
- China International Airlines: CA1234, CA8901
- China Eastern Airlines: MU5678, MU2468
- China Southern Airlines: CZ3691, CZ1357
- Hainan Airlines: HU7890
- Xiamen Airlines: MF8123
- Spring Airlines: 9C8765
- Juneyao Airlines: HO1288
- International airlines: UA858, NH955, etc.
### Real-time Flight Tracking
#### Flight Real-time Status Query
```python
getFlightStatus(flight_number, date=None) # Query real-time flight status
```
Input Parameters:
- `flight_number`: Flight call sign (e.g., "CCA1234", "CSN5678", "MU9876")
- `date`: Date parameter (OpenSky only supports real-time data, this parameter is ignored)
Output Information:
- Real-time flight location (latitude, longitude, altitude)
- Flight speed (ground speed, vertical speed)
- Flight status (in-flight, on ground, taxiing, stationary)
- Heading angle and altitude information
- Last contact time
- Origin country information
#### Airport Surrounding Flights Query
```python
getAirportFlights(airport_code, flight_type="departure") # Query flights around the airport
```
Input Parameters:
- `airport_code`: Airport code (e.g., "PEK", "PVG", "CAN", "CTU", "XIY")
- `flight_type`: Flight type (this parameter is only for compatibility, OpenSky returns all flights)
Output Information:
- All flights within 30 kilometers of the airport
- Real-time location and status of each flight
- Flight call sign, speed, altitude information
- Airport coordinates and search range
Supported airport codes (70+):
- Beijing: PEK (Capital), PKX (Daxing)
- Shanghai: PVG (Pudong), SHA (Hongqiao)
- Guangzhou: CAN, Shenzhen: SZX, Chengdu: CTU/TFU
- Chongqing: CKG, Xi'an: XIY, Kunming: KMG
- Hangzhou: HGH, Nanjing: NKG, Wuhan: WUH
- And other major city airports
#### Regional Flight Query
```python
getFlightsInArea(min_lat, max_lat, min_lon, max_lon) # Query flights within a specified area
```
Input Parameters:
- `min_lat`: Minimum latitude (e.g., 39.0)
- `max_lat`: Maximum latitude (e.g., 41.0)
- `min_lon`: Minimum longitude (e.g., 115.0)
- `max_lon`: Maximum longitude (e.g., 118.0)
Output Information:
- All real-time flights within the specified geographic area
- Detailed information of each flight (location, speed, altitude, etc.)
- Boundary box coordinates and query range
#### Batch Flight Tracking
```python
trackMultipleFlights(flight_numbers, date=None) # Batch track multiple flights
```
Input Parameters:
- `flight_numbers`: List of flight call signs (e.g., ["CCA1234", "CSN5678", "MU9876"])
- `date`: Date parameter (OpenSky only supports real-time data)
Output Information:
- Summary of real-time status of multiple flights
- Detailed query results for each flight
- Number of successful queries
- Execution time of batch query
Notes:
- OpenSky Network only provides real-time data and does not support historical flight queries
- API has frequency limits, and batch queries will automatically add delays
- Some flights may not have call sign information or incomplete location data
- Data accuracy and availability depend on ADS-B signal coverage
### Date and Time Tools
```python
getCurrentDate() # Get the current date (YYYY-MM-DD format)
```
Output Information:
- Current system date string
## Development
### Project Structure
```
FlightTicketMCPServer/
├── flight_ticket_server/
│ ├── core/ # Core business logic
│ ├── tools/ # MCP tool implementation
│ ├── utils/ # Utility functions
│ └── main.py # Server entry point
├── office_flight_ticket_server/ # Additional module
├── tests/ # Test files
├── logs/ # Log file directory
├── pyproject.toml # Project configuration
├── requirements.txt # Project dependencies
├── flight_ticket_server.py # Main startup file
├── mcp-config.json # MCP configuration example
└── README.md # Project documentation
```
### Testing
```bash
# Run all tests
python -m pytest tests/ -v
# Run basic function tests
python -m pytest tests/test_basic.py -v
# Run specific tests
python -m pytest tests/test_basic.py::TestFlightSearch::test_searchFlightsByNumber -v
```
### Logs and Debugging
- Log file location: `logs/` directory
- Enable debug mode: set `MCP_DEBUG=true`
- View real-time logs: `tail -f logs/flight_server.log`
## Troubleshooting
### Common Issues
1. **Port occupied**
```bash
# Change port
set MCP_PORT=8001
python flight_ticket_server.py
```
2. **Import error**
```bash
# Ensure in the correct directory
cd FlightTicketMCPServer/flight_ticket_server
python flight_ticket_server.py
```
3. **Permission issue**
```bash
# Check file permissions
ls -la flight_ticket_server.py
chmod +x flight_ticket_server.py
```
### Log Analysis
View log files for detailed error information:
```bash
# View general logs
cat logs/flight_server.log
# View error logs
cat logs/flight_server_error.log
# Real-time log monitoring
tail -f logs/flight_server.log
```
## License
MIT License - See [LICENSE](LICENSE) file for details.
## Contribution
Feel free to submit issues and pull requests to improve this project.
## Support
If you encounter issues or have feature suggestions, please create an issue on GitHub.
MCP Config
Below is the configuration for this MCP Server. You can copy it directly to Cursor or other MCP clients.
mcp.json
Connection Info
You Might Also Like
No recommendations available