Content
List
## Overview
Flight Ticket MCP Server implements tools and resources for flight ticket related queries. It acts as a bridge between AI assistants and flight service systems, focusing on real-time flight dynamic query functionality.
The server adopts a modular architecture, separating core functions, tools, and utilities, making it highly maintainable and scalable.
## Features
### Flight Route Query
- Query available flights based on departure, destination, and departure date
- Supports 282 domestic city and airport codes
- Intelligent city name parsing (supports city names, airport codes, and complete formats)
- Real-time flight prices and flight schedule information
- Airline and aircraft type information
- Terminal 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 filtering of flight combinations that meet transfer time requirements
- Provides complete two-legged journey information
- Supports domestic and international route transfer queries
- Detailed transfer time calculation and verification
### Weather Information Query
- **Query by latitude and longitude**: precise geographic location weather query
- **Query by city name**: supports direct query for major cities
- Supports historical, current, and future weather data
- Provides detailed information such as temperature, humidity, wind speed, and weather conditions
- Automatic processing of time zones and date ranges
- Supports presets for major cities like Wuhan, Beijing, and Shanghai
### Flight Information Query Query detailed flight information based on flight number
- Includes flight status, seat configuration, and price information
- Provides weather information (departure and destination)
- Displays basic flight information (airline, aircraft type, route type)
- Detailed terminal and boarding gate information
- Real-time dynamic status (on-time, boarding, flying, etc.)
- Seat price and availability information
- Additional service information (meals, WiFi,, 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 flights within a specified geographic area
- **Batch flight tracking**: track the real-time status of multiple flights simultaneously
- Supports over 70 major airport codes in China (PEK, PVG, CAN, etc.)
- Provides detailed flight position, speed, altitude, and status information
- Public API without authentication, with real-time updates
### Date and Time Tools
- Get current system date (in YYYY-MM-DD format)
- Get current system date and time (in YYYY-MM-DD HH:mm:ss format)
- Provides standardized date and time support for other functions
- Automatic processing of time zones and format conversions
### Data Processing and Intelligence
- **Intelligent city parsing**: supports multiple city input formats (city names, airport codes, complete formats)
- **Parameter validation**: comprehensive input parameter validation and error handling
- **Result formatting**: unified JSON format output for easy parsing by AI assistants
- **Error recovery**: complete exception handling and degradation mechanism
- **Log recording**: detailed operation logs and debugging information
## Technical Architecture
### Core
- Flight data model and structure definition
- Data models for airports, airlines, flights, prices, etc.
- Data structures for flight transfers and seat configurations
### Tools
- **Flight search tools** (`flight_search_tools.py`) - flight route query functionality
- **Flight transfer tools** (`flight_transfer_tools.py`) - multi-legged journey and transfer queries
- **Flight information tools** (`flight_info_tools.py`) - query detailed information by flight number
- **Real-time flight tracking tools** (`simple_opensky_tools.py`) - real-time flight tracking based on OpenSky Network
- **Weather query tools** (`weather_tools.py`) - weather queries based on latitude and longitude and city
- **Date and time tools** (`date_tools.py`) - date and time acquisition and processing
### Utilities
- **City dictionary** (`cities_dict.py`) - mapping of 282 city and airport codes
- **Data validator** (`validators.py`) - input parameter validation and format checking
- **Date utilities** (`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 invocation 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 runtime tool that can run PyPI packages directly without installing them to the system environment:
```bash
# Install uv (includes 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 to 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 SSE mode, listening on 127.0.0.1:8000)
python flight_ticket_server.py
# Or run main.py directly
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 Startups
#### 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 don't use the `.env` file, you can also set environment variables directly:
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 a successful startup, you will see output similar to:
```
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
After the server starts, the following log files will be generated in the `logs/` directory:
- `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 a SIGTERM signal
## Usage
### MCP Client Configuration
#### Method 1: Using uvx (recommended)
Run the MCP server using uvx without pre-installing, 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
If installed via pip, you can use the command-line tool directly:
```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`
#### Apply 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 as follows:
1. **Claude Desktop test**:
- Restart Claude Desktop
- Check if the status bar shows "flight-ticket-server" connected successfully
- Try asking in the conversation: "What tools are available now?"
2. **Command-line test**:
```bash
# Use uvx for direct testing
uvx flight-ticket-mcp-server --help
# Or use an installed package for testing
flight-ticket-mcp-server --help
# Test modular operation
python -m flight_ticket_mcp_server --help
```
3. **MCP protocol test**:
```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** - latitude and longitude weather query
- 🏙️ **getWeatherByCity** - city weather query
- ℹ️ **getFlightInfo** - flight information query
- 📡 **getFlightStatus** - real-time flight status query
- 🛫 **getAirportFlights** - airport surrounding flight query
- 🗺️ **getFlightsInArea** - regional 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 operation
x flight-ticket-mcp-server@latest
```
2. **Package version**:
```bash
# Force use of the latest version
uvx flight-ticket-mcp-server@latest
# Clear uvx cache and retry
uv cache clean
uvx flight-ticket-mcp-server@latest
### 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 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"
- "How is the weather 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 is 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 flying near Pudong Airport"
- "Where is this plane now? What is its altitude and speed?"
#### Date and Time Query
- "What is the date today"
- "What is 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, can you check the flight status and seat information"
- "Query the real-time location of flight CCA1234 and tell me the destination weather"
- "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, destination, 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 (in YYYY-MM-DD format)
Output Information:
- Flight list (including flight number, airline, departure and arrival times, airport, terminal, and price)
- Price statistics (minimum, maximum, and average prices)
- Airline distribution statistics
- Formatted query results
- Supported cities: 282 domestic cities and airports
Supported city formats:
- City name: Shanghai, Beijing, Chongqing, Guangzhou, etc.
- Airport code: SHA, BJS, CKG, CAN, etc.
- Full 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 (in hours), default 2.0 hours
- `max_transfer_time`: Maximum transfer time (in 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 (in YYYY-MM-DD format), optional
- `end_date`: End date (in 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 (in YYYY-MM-DD format), optional
- `end_date`: End date (in YYYY-MM-DD format), optional
Output Information:
- Weather condition description
- Temperature information (highest, lowest, and current temperature)
- Humidity, wind speed, and wind direction
- Precipitation probability and amount
- Sunrise and sunset time
- UV index
### Flight Information Query
```python
getFlightInfo(flight_number) # Query detailed flight information by 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 seats in economy, business, and first class)
- Price information (price and availability for 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
- Country of origin information
#### Airport Surrounding Flights Query
```python
getAirportFlights(airport_code, flight_type="departure") # Query flights around an airport
```
Input Parameters:
- `airport_code`: Airport code (e.g., "PEK", "PVG", "CAN", "CTU", "XIY")
- `flight_type`: Flight type (this parameter is for compatibility, OpenSky returns all flights)
Output Information:
- All flights within 30 kilometers around 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
#### Area 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 flight information (location, speed, altitude, etc.)
- Boundary box coordinates and query range
#### Batch Flight Tracking
```python
trackMultipleFlights(flight_numbers, date=None) # Track multiple flights in batch
```
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 for multiple flights
- Detailed query results for each flight
- Number of successful queries
- Execution time for batch queries
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 (in 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 a specific test
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
# Monitor logs in real-time
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