iflow-mcp-internet-speed-test 0.1.1__py3-none-any.whl

iflow_mcp_internet_speed_test-0.1.1.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: iflow-mcp-internet-speed-test
+Version: 0.1.1
+Summary: Enables AI models and agents to perform internet speed measurements.
+Author-email: Pedro Cruz <hola@inventer.dev>
+Maintainer-email: Pedro Cruz <hola@inventer.dev>
+Project-URL: Homepage, https://github.com/inventer-dev/mcp-internet-speed-test
+Project-URL: Bug Reports, https://github.com/inventer-dev/mcp-internet-speed-test/issues
+Project-URL: Source, https://github.com/inventer-dev/mcp-internet-speed-test
+Project-URL: Documentation, https://github.com/inventer-dev/mcp-internet-speed-test#readme
+Keywords: mcp,speed-test,internet,network,ai,model-context-protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Networking :: Monitoring
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+[![Trust Score](https://archestra.ai/mcp-catalog/api/badge/quality/inventer-dev/mcp-internet-speed-test)](https://archestra.ai/mcp-catalog/inventer-dev__mcp-internet-speed-test)
+[![smithery badge](https://smithery.ai/badge/@inventer-dev/mcp-internet-speed-test)](https://smithery.ai/server/@inventer-dev/mcp-internet-speed-test)
+
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/inventer-dev-mcp-internet-speed-test-badge.png)](https://mseep.ai/app/inventer-dev-mcp-internet-speed-test)
+
+<a href="https://glama.ai/mcp/servers/@inventer-dev/mcp-internet-speed-test">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@inventer-dev/mcp-internet-speed-test/badge" alt="mcp-internet-speed-test MCP server" />
+</a>
+
+# MCP Internet Speed Test
+
+An implementation of a Model Context Protocol (MCP) for internet speed testing. It allows AI models and agents to measure, analyze, and report network performance metrics through a standardized interface.
+
+**📦 Available on PyPI:** https://pypi.org/project/mcp-internet-speed-test/
+
+**🚀 Quick Start:**
+```bash
+pip install mcp-internet-speed-test
+mcp-internet-speed-test
+```
+
+## What is MCP?
+
+The Model Context Protocol (MCP) provides a standardized way for Large Language Models (LLMs) to interact with external tools and data sources. Think of it as the "USB-C for AI applications" - a common interface that allows AI systems to access real-world capabilities and information.
+
+## Features
+
+- **Smart Incremental Testing**: Uses SpeedOf.Me methodology with 8-second threshold for optimal accuracy
+- **Download Speed Testing**: Measures bandwidth using files from 128KB to 100MB from GitHub repository
+- **Upload Speed Testing**: Tests upload bandwidth using generated data from 128KB to 100MB
+- **Latency Testing**: Measures network latency with detailed server location information
+- **Jitter Analysis**: Calculates network stability using multiple latency samples (default: 5)
+- **Multi-CDN Support**: Detects and provides info for Fastly, Cloudflare, and AWS CloudFront
+- **Geographic Location**: Maps POP codes to physical locations (50+ locations worldwide)
+- **Cache Analysis**: Detects HIT/MISS status and cache headers
+- **Server Metadata**: Extracts detailed CDN headers including `x-served-by`, `via`, `x-cache`
+- **Comprehensive Testing**: Single function to run all tests with complete metrics
+
+## Installation
+
+### Prerequisites
+
+- Python 3.12 or higher (required for async support)
+- pip or [uv](https://github.com/astral-sh/uv) package manager
+
+### Option 1: Install from PyPI with pip (Recommended)
+
+```bash
+# Install the package globally
+pip install mcp-internet-speed-test
+
+# Run the MCP server
+mcp-internet-speed-test
+```
+
+### Option 2: Install from PyPI with uv
+
+```bash
+# Install the package globally
+uv add mcp-internet-speed-test
+
+# Or run directly without installing
+uvx mcp-internet-speed-test
+```
+
+### Option 3: Using docker
+
+```bash
+# Build the Docker image
+docker build -t mcp-internet-speed-test .
+
+# Run the MCP server in a Docker container
+docker run -it --rm -v $(pwd):/app -w /app mcp-internet-speed-test
+```
+
+### Option 4: Development/Local Installation
+
+If you want to contribute or modify the code:
+
+```bash
+# Clone the repository
+git clone https://github.com/inventer-dev/mcp-internet-speed-test.git
+cd mcp-internet-speed-test
+
+# Install in development mode
+pip install -e .
+
+# Or using uv
+uv sync
+uv run python -m mcp_internet_speed_test.main
+```
+
+### Dependencies
+
+The package automatically installs these dependencies:
+- `mcp[cli]>=1.6.0`: MCP server framework with CLI integration
+- `httpx>=0.27.0`: Async HTTP client for speed tests
+
+
+## Configuration
+
+To use this MCP server with Claude Desktop or other MCP clients, add it to your MCP configuration file.
+
+### Claude Desktop Configuration
+
+Edit your Claude Desktop MCP configuration file:
+
+#### Option 1: Using pip installed package (Recommended)
+
+```json
+{
+    "mcpServers": {
+        "mcp-internet-speed-test": {
+            "command": "mcp-internet-speed-test"
+        }
+    }
+}
+```
+
+#### Option 2: Using uvx
+
+```json
+{
+    "mcpServers": {
+        "mcp-internet-speed-test": {
+            "command": "uvx",
+            "args": ["mcp-internet-speed-test"]
+        }
+    }
+}
+```
+
+## API Tools
+
+The MCP Internet Speed Test provides the following tools:
+
+### Testing Functions
+1. `measure_download_speed`: Measures download bandwidth (in Mbps) with server location info
+2. `measure_upload_speed`: Measures upload bandwidth (in Mbps) with server location info
+3. `measure_latency`: Measures network latency (in ms) with server location info
+4. `measure_jitter`: Measures network jitter by analyzing latency variations with server info
+5. `get_server_info`: Get detailed CDN server information for any URL without running speed tests
+6. `run_complete_test`: Comprehensive test with all metrics and server metadata
+
+## CDN Server Detection
+
+This speed test now provides detailed information about the CDN servers serving your tests:
+
+### What You Get
+- **CDN Provider**: Identifies if you're connecting to Fastly, Cloudflare, or Amazon CloudFront
+- **Geographic Location**: Shows the physical location of the server (e.g., "Mexico City, Mexico")
+- **POP Code**: Three-letter code identifying the Point of Presence (e.g., "MEX", "QRO", "DFW")
+- **Cache Status**: Whether content is served from cache (HIT) or fetched from origin (MISS)
+- **Server Headers**: Full HTTP headers including `x-served-by`, `via`, and `x-cache`
+
+### Technical Implementation
+
+#### Smart Testing Methodology
+- **Incremental Approach**: Starts with small files (128KB) and progressively increases
+- **Time-Based Optimization**: Uses 8-second base threshold + 4-second additional buffer
+- **Accuracy Focus**: Selects optimal file size that provides reliable measurements
+- **Multi-Provider Support**: Tests against geographically distributed endpoints
+
+#### CDN Detection Capabilities
+- **Fastly**: Detects POP codes and maps to 50+ global locations
+- **Cloudflare**: Identifies data centers and geographic regions
+- **AWS CloudFront**: Recognizes edge locations across continents
+- **Header Analysis**: Parses `x-served-by`, `via`, `x-cache`, and custom CDN headers
+
+### Why This Matters
+- **Network Diagnostics**: Understand which server is actually serving your tests
+- **Performance Analysis**: Correlate speed results with server proximity
+- **CDN Optimization**: Identify if your ISP's routing is optimal
+- **Geographic Awareness**: Know if tests are running from your expected region
+- **Troubleshooting**: Identify routing issues and CDN misconfigurations
+
+### Example Server Info Output
+```json
+{
+  "cdn_provider": "Fastly",
+  "pop_code": "MEX",
+  "pop_location": "Mexico City, Mexico",
+  "served_by": "cache-mex4329-MEX",
+  "cache_status": "HIT",
+  "x_cache": "HIT, HIT"
+}
+```
+
+### Technical Configuration
+
+#### Default Test Files Repository
+```
+GitHub Repository: inventer-dev/speed-test-files
+Branch: main
+File Sizes: 128KB, 256KB, 512KB, 1MB, 2MB, 5MB, 10MB, 20MB, 40MB, 50MB, 100MB
+```
+
+#### Upload Endpoints Priority
+1. **Cloudflare Workers** (httpi.dev) - Global distribution, highest priority
+2. **HTTPBin** (httpbin.org) - AWS-based, secondary endpoint
+
+#### Supported CDN Locations (150+ POPs)
+
+**Fastly POPs**: MEX, QRO, DFW, LAX, NYC, MIA, LHR, FRA, AMS, CDG, NRT, SIN, SYD, GRU, SCL, BOG, MAD, MIL...
+
+**Cloudflare Centers**: DFW, LAX, SJC, SEA, ORD, MCI, IAD, ATL, MIA, YYZ, LHR, FRA, AMS, CDG, ARN, STO...
+
+**AWS CloudFront**: ATL, BOS, ORD, CMH, DFW, DEN, IAD, LAX, MIA, MSP, JFK, SEA, SJC, AMS, ATH, TXL...
+
+#### Performance Thresholds
+- **Base Test Duration**: 8.0 seconds
+- **Additional Buffer**: 4.0 seconds
+- **Maximum File Size**: Configurable (default: 100MB)
+- **Jitter Samples**: 5 measurements (configurable)
+
+## Troubleshooting
+
+### Common Issues
+
+#### MCP Server Connection
+1. **Path Configuration**: Ensure absolute path is used in MCP configuration
+2. **Directory Permissions**: Verify read/execute permissions for the project directory
+3. **Python Version**: Requires Python 3.12+ with async support
+4. **Dependencies**: Install `fastmcp` and `httpx` packages
+
+#### Speed Test Issues
+1. **GitHub Repository Access**: Ensure `inventer-dev/speed-test-files` is accessible
+2. **Firewall/Proxy**: Check if corporate firewalls block test endpoints
+3. **CDN Routing**: Some ISPs may route differently to CDNs
+4. **Network Stability**: Jitter tests require stable connections
+
+#### Performance Considerations
+- **File Size Limits**: Large files (>50MB) may timeout on slow connections
+- **Upload Endpoints**: If primary endpoint fails, fallback is automatic
+- **Geographic Accuracy**: POP detection depends on CDN header consistency
+
+## Development
+
+### Project Structure
+```
+mcp-internet-speed-test/
+├── mcp_internet_speed_test/  # Main package directory
+│   ├── __init__.py      # Package initialization
+│   └── main.py          # MCP server implementation
+├── README.md           # This documentation
+├── Dockerfile          # Container configuration
+└── pyproject.toml      # Python project configuration
+```
+
+### Key Components
+
+#### Configuration Constants
+- `GITHUB_RAW_URL`: Base URL for test files repository
+- `UPLOAD_ENDPOINTS`: Prioritized list of upload test endpoints
+- `SIZE_PROGRESSION`: Ordered list of file sizes for incremental testing
+- `*_POP_LOCATIONS`: Mappings of CDN codes to geographic locations
+
+#### Core Functions
+- `extract_server_info()`: Parses HTTP headers to identify CDN providers
+- `measure_*()`: Individual test functions for different metrics
+- `run_complete_test()`: Orchestrates comprehensive testing suite
+
+### Configuration Customization
+
+You can customize the following in `mcp_internet_speed_test/main.py` if you clone the repository:
+```python
+# GitHub repository settings
+GITHUB_USERNAME = "your-username"
+GITHUB_REPO = "your-speed-test-files"
+GITHUB_BRANCH = "main"
+
+# Test duration thresholds
+BASE_TEST_DURATION = 8.0  # seconds
+ADDITIONAL_TEST_DURATION = 4.0  # seconds
+
+# Default endpoints
+DEFAULT_UPLOAD_URL = "your-upload-endpoint"
+DEFAULT_LATENCY_URL = "your-latency-endpoint"
+```
+
+### Contributing
+
+This is an experimental project and contributions are welcome:
+
+1. **Issues**: Report bugs or request features
+2. **Pull Requests**: Submit code improvements
+3. **Documentation**: Help improve this README
+4. **Testing**: Test with different network conditions and CDNs
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- MCP Framework maintainers for standardizing AI tool interactions
+- The Model Context Protocol community for documentation and examples

iflow_mcp_internet_speed_test-0.1.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+iflow_mcp_internet_speed_test-0.1.1.dist-info/licenses/LICENSE,sha256=cCb3HXf-Ls45DyPWWK5bfDo70RsI_HQ8m7H9UdOINEQ,1069
+mcp_internet_speed_test/__init__.py,sha256=tXlhYHCq2ak07-QRCC-qH_LetvZZy2vuFW4Gb-SjhxU,302
+mcp_internet_speed_test/main.py,sha256=Pjn83_jsIdZLWpc7uSYE5pLtVDhjgAv0dS8nQJR_iMk,26420
+iflow_mcp_internet_speed_test-0.1.1.dist-info/METADATA,sha256=pxJ7NhMhmB4rgFY6dgPD7CPrhup16FmX7turmB8SsnY,11956
+iflow_mcp_internet_speed_test-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iflow_mcp_internet_speed_test-0.1.1.dist-info/entry_points.txt,sha256=YyjiAwCCgQISrSi0CTUOmkGosW7AN2NHKNUVkJ0tjKQ,81
+iflow_mcp_internet_speed_test-0.1.1.dist-info/top_level.txt,sha256=xcHQxrlq-l_JmJZzg9le3dccclAscNrMOJODn45-9KA,24
+iflow_mcp_internet_speed_test-0.1.1.dist-info/RECORD,,

iflow_mcp_internet_speed_test-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

iflow_mcp_internet_speed_test-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-internet-speed-test = mcp_internet_speed_test.main:mcp.run

iflow_mcp_internet_speed_test-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Inventer Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

iflow_mcp_internet_speed_test-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcp_internet_speed_test

mcp_internet_speed_test/__init__.py

@@ -0,0 +1,12 @@
+"""
+MCP Internet Speed Test
+
+A Model Context Protocol server for internet speed testing.
+Enables AI models and agents to perform network performance measurements.
+"""
+
+__version__ = "0.1.1"
+__author__ = "Pedro Cruz"
+__email__ = "hola@inventer.dev"
+
+__all__ = ["__version__", "__author__", "__email__"]

mcp_internet_speed_test/main.py

@@ -0,0 +1,801 @@
+"""
+Model Context Protocol for the internet speed test
+
+This MCP implements an internet speed test service inspired by SpeedOf.Me methodology.
+
+## How It Works
+
+An internet speed test uses an incremental testing approach:
+
+### Download Test
+- Begins with downloading the smallest sample size (128 KB)
+- Gradually increases file size until download takes more than 8 seconds
+- Uses the last sample that took more than 8 seconds for final speed calculation
+
+### Upload Test
+- Similar incremental mechanism for uploads
+- Starts with a smaller sample file and gradually increases
+- Continues until upload takes more than 8 seconds
+
+### Test Method
+- Tests bandwidth in several passes with gradually increasing file sizes
+- Can measure a wide range of connection speeds (from 10 Kbps to 100+ Mbps)
+- Sample files sizes range from 128 KB to 512 MB
+
+"""
+
+import time
+import re
+from typing import Dict, Optional
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+# Create a singleton instance of FastMCP
+mcp = FastMCP("internet_speed_test", dependencies=["httpx"])
+
+# Default URLs for testing
+GITHUB_USERNAME = "inventer-dev"  # Replace with your GitHub username
+GITHUB_REPO = "speed-test-files"  # Replace with your repository name
+GITHUB_BRANCH = "main"  # Replace with your branch name (main or master)
+
+# Build base URL for GitHub raw content
+GITHUB_RAW_URL = (
+    f"https://raw.githubusercontent.com/{GITHUB_USERNAME}/{GITHUB_REPO}/{GITHUB_BRANCH}"
+)
+
+DEFAULT_DOWNLOAD_URLS = {
+    "128KB": f"{GITHUB_RAW_URL}/128KB.bin",
+    "256KB": f"{GITHUB_RAW_URL}/256KB.bin",
+    "512KB": f"{GITHUB_RAW_URL}/512KB.bin",
+    "1MB": f"{GITHUB_RAW_URL}/1MB.bin",
+    "2MB": f"{GITHUB_RAW_URL}/2MB.bin",
+    "5MB": f"{GITHUB_RAW_URL}/5MB.bin",
+    "10MB": f"{GITHUB_RAW_URL}/10MB.bin",
+    "20MB": f"{GITHUB_RAW_URL}/20MB.bin",
+    "40MB": f"{GITHUB_RAW_URL}/40MB.bin",
+    "50MB": f"{GITHUB_RAW_URL}/50MB.bin",
+    "100MB": f"{GITHUB_RAW_URL}/100MB.bin",
+}
+
+# Distributed upload endpoints for geographic diversity
+UPLOAD_ENDPOINTS = [
+    {
+        "url": "https://httpi.dev/",
+        "name": "Cloudflare Workers (Global)",
+        "provider": "Cloudflare",
+        "priority": 1,  # Highest priority due to global distribution
+    },
+    {
+        "url": "https://httpbin.org/",
+        "name": "HTTPBin (AWS)",
+        "provider": "AWS",
+        "priority": 2,
+    },
+]
+
+# Primary endpoints for backward compatibility
+DEFAULT_UPLOAD_URL = UPLOAD_ENDPOINTS[0]["url"] + "post"  # Use Cloudflare by default
+DEFAULT_LATENCY_URL = UPLOAD_ENDPOINTS[0]["url"] + "get"  # Use Cloudflare by default
+
+# File sizes in bytes for upload testing
+UPLOAD_SIZES = {
+    "128KB": 128 * 1024,
+    "256KB": 256 * 1024,
+    "512KB": 512 * 1024,
+    "1MB": 1 * 1024 * 1024,
+    "2MB": 2 * 1024 * 1024,
+    "5MB": 5 * 1024 * 1024,
+    "10MB": 10 * 1024 * 1024,
+    "20MB": 20 * 1024 * 1024,
+    "40MB": 40 * 1024 * 1024,
+    "50MB": 50 * 1024 * 1024,
+    "100MB": 100 * 1024 * 1024,
+}
+
+# Maximum time threshold for a test (in seconds)
+BASE_TEST_DURATION = 8.0
+ADDITIONAL_TEST_DURATION = 4.0
+
+# Size progression order
+SIZE_PROGRESSION = [
+    "128KB",
+    "256KB",
+    "512KB",
+    "1MB",
+    "2MB",
+    "5MB",
+    "10MB",
+    "20MB",
+    "40MB",
+    "50MB",
+    "100MB",
+]
+
+# Server location mapping based on Fastly POP codes
+FASTLY_POP_LOCATIONS = {
+    "MEX": "Mexico City, Mexico",
+    "QRO": "Querétaro, Mexico",
+    "DFW": "Dallas, Texas, USA",
+    "LAX": "Los Angeles, California, USA",
+    "NYC": "New York City, New York, USA",
+    "MIA": "Miami, Florida, USA",
+    "LHR": "London, United Kingdom",
+    "FRA": "Frankfurt, Germany",
+    "AMS": "Amsterdam, Netherlands",
+    "CDG": "Paris, France",
+    "NRT": "Tokyo, Japan",
+    "SIN": "Singapore",
+    "SYD": "Sydney, Australia",
+    "GRU": "São Paulo, Brazil",
+    "SCL": "Santiago, Chile",
+    "BOG": "Bogotá, Colombia",
+    "MAD": "Madrid, Spain",
+    "MIL": "Milan, Italy",
+    "STO": "Stockholm, Sweden",
+    "CPH": "Copenhagen, Denmark",
+    "ZUR": "Zurich, Switzerland",
+    "VIE": "Vienna, Austria",
+    "WAW": "Warsaw, Poland",
+    "PRG": "Prague, Czech Republic",
+    "BUD": "Budapest, Hungary",
+    "ATH": "Athens, Greece",
+    "IST": "Istanbul, Turkey",
+    "DXB": "Dubai, UAE",
+    "BOM": "Mumbai, India",
+    "DEL": "New Delhi, India",
+    "ICN": "Seoul, South Korea",
+    "HKG": "Hong Kong",
+    "TPE": "Taipei, Taiwan",
+    "KUL": "Kuala Lumpur, Malaysia",
+    "BKK": "Bangkok, Thailand",
+    "CGK": "Jakarta, Indonesia",
+    "MNL": "Manila, Philippines",
+    "PER": "Perth, Australia",
+    "AKL": "Auckland, New Zealand",
+    "JNB": "Johannesburg, South Africa",
+    "CPT": "Cape Town, South Africa",
+    "CAI": "Cairo, Egypt",
+    "LOS": "Lagos, Nigeria",
+    "NBO": "Nairobi, Kenya",
+    "YYZ": "Toronto, Canada",
+    "YVR": "Vancouver, Canada",
+    "GIG": "Rio de Janeiro, Brazil",
+    "LIM": "Lima, Peru",
+    "UIO": "Quito, Ecuador",
+    "CCS": "Caracas, Venezuela",
+    "PTY": "Panama City, Panama",
+    "SJO": "San José, Costa Rica",
+    "GUA": "Guatemala City, Guatemala",
+    "SDQ": "Santo Domingo, Dominican Republic",
+    "SJU": "San Juan, Puerto Rico",
+}
+
+# Cloudflare data center locations mapping
+CLOUDFLARE_POP_LOCATIONS = {
+    "DFW": "Dallas, Texas, USA",
+    "LAX": "Los Angeles, California, USA",
+    "SJC": "San Jose, California, USA",
+    "SEA": "Seattle, Washington, USA",
+    "ORD": "Chicago, Illinois, USA",
+    "MCI": "Kansas City, Missouri, USA",
+    "ATL": "Atlanta, Georgia, USA",
+    "MIA": "Miami, Florida, USA",
+    "EWR": "Newark, New Jersey, USA",
+    "IAD": "Washington, D.C., USA",
+    "YYZ": "Toronto, Canada",
+    "YVR": "Vancouver, Canada",
+    "LHR": "London, United Kingdom",
+    "CDG": "Paris, France",
+    "FRA": "Frankfurt, Germany",
+    "AMS": "Amsterdam, Netherlands",
+    "ARN": "Stockholm, Sweden",
+    "CPH": "Copenhagen, Denmark",
+    "OSL": "Oslo, Norway",
+    "HEL": "Helsinki, Finland",
+    "WAW": "Warsaw, Poland",
+    "PRG": "Prague, Czech Republic",
+    "VIE": "Vienna, Austria",
+    "ZUR": "Zurich, Switzerland",
+    "MIL": "Milan, Italy",
+    "FCO": "Rome, Italy",
+    "MAD": "Madrid, Spain",
+    "BCN": "Barcelona, Spain",
+    "LIS": "Lisbon, Portugal",
+    "ATH": "Athens, Greece",
+    "IST": "Istanbul, Turkey",
+    "SVO": "Moscow, Russia",
+    "LED": "St. Petersburg, Russia",
+    "HKG": "Hong Kong",
+    "NRT": "Tokyo, Japan",
+    "KIX": "Osaka, Japan",
+    "ICN": "Seoul, South Korea",
+    "PVG": "Shanghai, China",
+    "PEK": "Beijing, China",
+    "SIN": "Singapore",
+    "KUL": "Kuala Lumpur, Malaysia",
+    "BKK": "Bangkok, Thailand",
+    "CGK": "Jakarta, Indonesia",
+    "MNL": "Manila, Philippines",
+    "SYD": "Sydney, Australia",
+    "MEL": "Melbourne, Australia",
+    "PER": "Perth, Australia",
+    "AKL": "Auckland, New Zealand",
+    "BOM": "Mumbai, India",
+    "DEL": "New Delhi, India",
+    "BLR": "Bangalore, India",
+    "MAA": "Chennai, India",
+    "DXB": "Dubai, UAE",
+    "DOH": "Doha, Qatar",
+    "KWI": "Kuwait City, Kuwait",
+    "JNB": "Johannesburg, South Africa",
+    "CPT": "Cape Town, South Africa",
+    "LAD": "Luanda, Angola",
+    "CAI": "Cairo, Egypt",
+    "LOS": "Lagos, Nigeria",
+    "NBO": "Nairobi, Kenya",
+    "GRU": "São Paulo, Brazil",
+    "GIG": "Rio de Janeiro, Brazil",
+    "FOR": "Fortaleza, Brazil",
+    "SCL": "Santiago, Chile",
+    "LIM": "Lima, Peru",
+    "BOG": "Bogotá, Colombia",
+    "UIO": "Quito, Ecuador",
+    "PTY": "Panama City, Panama",
+    "SJO": "San José, Costa Rica",
+    "MEX": "Mexico City, Mexico",
+    "QRO": "Querétaro, Mexico",
+}
+
+# AWS CloudFront edge location POP codes mapping
+AWS_POP_LOCATIONS = {
+    # North America
+    "ATL": "Atlanta, Georgia, USA",
+    "BOS": "Boston, Massachusetts, USA",
+    "ORD": "Chicago, Illinois, USA",
+    "CMH": "Columbus, Ohio, USA",
+    "DFW": "Dallas, Texas, USA",
+    "DEN": "Denver, Colorado, USA",
+    "DTW": "Detroit, Michigan, USA",
+    "IAH": "Houston, Texas, USA",
+    "MCI": "Kansas City, Missouri, USA",
+    "LAX": "Los Angeles, California, USA",
+    "MIA": "Miami, Florida, USA",
+    "MSP": "Minneapolis, Minnesota, USA",
+    "BNA": "Nashville, Tennessee, USA",
+    "JFK": "New York, New York, USA",
+    "EWR": "Newark, New Jersey, USA",
+    "PHL": "Philadelphia, Pennsylvania, USA",
+    "PHX": "Phoenix, Arizona, USA",
+    "PIT": "Pittsburgh, Pennsylvania, USA",
+    "HIO": "Portland, Oregon, USA",
+    "SLC": "Salt Lake City, Utah, USA",
+    "SFO": "San Francisco, California, USA",
+    "SEA": "Seattle, Washington, USA",
+    "TPA": "Tampa, Florida, USA",
+    "IAD": "Washington, DC, USA",
+    "YUL": "Montreal, Quebec, Canada",
+    "YTO": "Toronto, Ontario, Canada",
+    "YVR": "Vancouver, British Columbia, Canada",
+    "QRO": "Querétaro, Mexico",
+    # South America
+    "BOG": "Bogotá, Colombia",
+    "EZE": "Buenos Aires, Argentina",
+    "FOR": "Fortaleza, Brazil",
+    "LIM": "Lima, Peru",
+    "GIG": "Rio de Janeiro, Brazil",
+    "SCL": "Santiago, Chile",
+    "GRU": "São Paulo, Brazil",
+    # Europe
+    "AMS": "Amsterdam, Netherlands",
+    "ATH": "Athens, Greece",
+    "TXL": "Berlin, Germany",
+    "BRU": "Brussels, Belgium",
+    "OTP": "Bucharest, Romania",
+    "BUD": "Budapest, Hungary",
+    "CPH": "Copenhagen, Denmark",
+    "DUB": "Dublin, Ireland",
+    "DUS": "Düsseldorf, Germany",
+    "FRA": "Frankfurt am Main, Germany",
+    "HAM": "Hamburg, Germany",
+    "HEL": "Helsinki, Finland",
+    "LIS": "Lisbon, Portugal",
+    "LHR": "London, United Kingdom",
+    "MAD": "Madrid, Spain",
+    "MAN": "Manchester, United Kingdom",
+    "MRS": "Marseille, France",
+    "MXP": "Milan, Italy",
+    "MUC": "Munich, Germany",
+    "OSL": "Oslo, Norway",
+    "PMO": "Palermo, Italy",
+    "CDG": "Paris, France",
+    "PRG": "Prague, Czech Republic",
+    "FCO": "Rome, Italy",
+    "SOF": "Sofia, Bulgaria",
+    "ARN": "Stockholm, Sweden",
+    "VIE": "Vienna, Austria",
+    "WAW": "Warsaw, Poland",
+    "ZAG": "Zagreb, Croatia",
+    "ZRH": "Zurich, Switzerland",
+    "IST": "Istanbul, Turkey",
+    # Middle East
+    "DXB": "Dubai, UAE",
+    "FJR": "Fujairah, UAE",
+    "JED": "Jeddah, Saudi Arabia",
+    "BAH": "Manama, Bahrain",
+    "MCT": "Muscat, Oman",
+    "DOH": "Doha, Qatar",
+    "TLV": "Tel Aviv, Israel",
+    # Africa
+    "CAI": "Cairo, Egypt",
+    "CPT": "Cape Town, South Africa",
+    "JNB": "Johannesburg, South Africa",
+    "LOS": "Lagos, Nigeria",
+    "NBO": "Nairobi, Kenya",
+    # Asia Pacific
+    "BKK": "Bangkok, Thailand",
+    "PEK": "Beijing, China",
+    "BLR": "Bengaluru, India",
+    "MAA": "Chennai, India",
+    "DEL": "New Delhi, India",
+    "HAN": "Hanoi, Vietnam",
+    "SGN": "Ho Chi Minh City, Vietnam",
+    "HKG": "Hong Kong, China",
+    "HYD": "Hyderabad, India",
+    "CGK": "Jakarta, Indonesia",
+    "CCU": "Kolkata, India",
+    "KUL": "Kuala Lumpur, Malaysia",
+    "MNL": "Manila, Philippines",
+    "BOM": "Mumbai, India",
+    "KIX": "Osaka, Japan",
+    "PNQ": "Pune, India",
+    "ICN": "Seoul, South Korea",
+    "PVG": "Shanghai, China",
+    "SZX": "Shenzhen, China",
+    "SIN": "Singapore",
+    "TPE": "Taoyuan, Taiwan",
+    "NRT": "Tokyo, Japan",
+    "ZHY": "Zhongwei, China",
+    # Australia & Oceania
+    "AKL": "Auckland, New Zealand",
+    "BNE": "Brisbane, Australia",
+    "MEL": "Melbourne, Australia",
+    "PER": "Perth, Australia",
+    "SYD": "Sydney, Australia",
+}
+
+
+def extract_server_info(headers: Dict[str, str]) -> Dict[str, Optional[str]]:
+    """
+    Extract server information from HTTP headers.
+
+    Args:
+        headers: HTTP response headers
+
+    Returns:
+        Dictionary with server information including POP location, CDN info, etc.
+    """
+    server_info = {
+        "cdn_provider": None,
+        "pop_code": None,
+        "pop_location": None,
+        "served_by": None,
+        "via_header": None,
+        "cache_status": None,
+        "server_ip_info": None,
+        "x_cache": None,
+    }
+
+    # Extract x-served-by header (Fastly specific)
+    served_by = headers.get("x-served-by", "")
+    if served_by:
+        server_info["served_by"] = served_by
+
+        # Extract POP code from served-by header
+        # Format examples: cache-mex4329-MEX, cache-qro4141-QRO, cache-dfw-kdfw8210052-DFW
+        pop_match = re.search(r"-([A-Z]{3})$", served_by)
+        if pop_match:
+            server_info["pop_code"] = pop_match.group(1)
+            server_info["pop_location"] = FASTLY_POP_LOCATIONS.get(
+                pop_match.group(1), f"Unknown location ({pop_match.group(1)})"
+            )
+            server_info["cdn_provider"] = "Fastly"
+
+    # Extract via header
+    via = headers.get("via", "")
+    if via:
+        server_info["via_header"] = via
+
+    # Extract cache status
+    cache_status = headers.get("x-cache", "")
+    if cache_status:
+        server_info["x_cache"] = cache_status
+        server_info["cache_status"] = "HIT" if "HIT" in cache_status.upper() else "MISS"
+
+    # Extract Cloudflare CF-Ray header
+    cf_ray = headers.get("cf-ray", "")
+    if cf_ray:
+        server_info["cf_ray"] = cf_ray
+        # Extract data center code from CF-Ray (format: request_id-datacenter_code)
+        cf_match = re.search(r"-([A-Z]{3})$", cf_ray)
+        if cf_match:
+            server_info["pop_code"] = cf_match.group(1)
+            server_info["pop_location"] = CLOUDFLARE_POP_LOCATIONS.get(
+                cf_match.group(1), f"Unknown location ({cf_match.group(1)})"
+            )
+            server_info["cdn_provider"] = "Cloudflare"
+
+    # Extract AWS CloudFront headers
+    cf_pop = headers.get("x-amz-cf-pop", "")
+    cf_id = headers.get("x-amz-cf-id", "")
+    if cf_pop:
+        server_info["cf_pop"] = cf_pop
+        server_info["cdn_provider"] = "Amazon CloudFront"
+
+        # Extract POP code from x-amz-cf-pop header (format: DFW56-P1, SIN5-C1)
+        cf_pop_match = re.search(r"^([A-Z]{3})", cf_pop)
+        if cf_pop_match:
+            server_info["pop_code"] = cf_pop_match.group(1)
+            server_info["pop_location"] = AWS_POP_LOCATIONS.get(
+                cf_pop_match.group(1), f"Unknown location ({cf_pop_match.group(1)})"
+            )
+
+    if cf_id:
+        server_info["cf_id"] = cf_id
+        if not server_info["cdn_provider"]:
+            server_info["cdn_provider"] = "Amazon CloudFront"
+
+    # Check for other CDN indicators
+    if not server_info["cdn_provider"]:
+        if "fastly" in headers.get("server", "").lower():
+            server_info["cdn_provider"] = "Fastly"
+        elif "cloudflare" in headers.get("server", "").lower():
+            server_info["cdn_provider"] = "Cloudflare"
+        elif (
+            "amazon" in headers.get("server", "").lower()
+            or "aws" in headers.get("server", "").lower()
+        ):
+            server_info["cdn_provider"] = "Amazon CloudFront"
+
+    return server_info
+
+
+# Register tools
+@mcp.tool()
+async def measure_download_speed(size_limit: str = "100MB") -> dict:
+    """
+    Measure download speed using incremental file sizes.
+
+    Args:
+        size_limit: Maximum file size to test (default: 100MB)
+
+    Returns:
+        Dictionary with download speed results
+    """
+    results = []
+    final_result = None
+
+    # Find the index of the size limit in our progression
+    max_index = (
+        SIZE_PROGRESSION.index(size_limit)
+        if size_limit in SIZE_PROGRESSION
+        else len(SIZE_PROGRESSION) - 1
+    )
+
+    # Test each file size in order, up to the specified limit
+    async with httpx.AsyncClient() as client:
+        for size_key in SIZE_PROGRESSION[: max_index + 1]:
+            if size_key in ["100MB", "200MB", "500MB", "1GB"]:
+                test_duration = BASE_TEST_DURATION + ADDITIONAL_TEST_DURATION
+            else:
+                test_duration = BASE_TEST_DURATION
+
+            url = DEFAULT_DOWNLOAD_URLS[size_key]
+            start = time.time()
+            total_size = 0
+
+            async with client.stream(
+                "GET",
+                url,
+            ) as response:
+                # Extract server information from headers
+                server_info = extract_server_info(dict(response.headers))
+
+                async for chunk in response.aiter_bytes(chunk_size=1024):
+                    if chunk:
+                        chunk_size = len(chunk)
+                        total_size += chunk_size
+
+                        # Check elapsed time during download
+                        current_time = time.time()
+                        elapsed_time = current_time - start
+
+                        # Update our final result continuously
+                        speed_mbps = ((total_size * 8) / (1024 * 1024)) / elapsed_time
+                        final_result = {
+                            "download_speed": round(speed_mbps, 2),
+                            "elapsed_time": round(elapsed_time, 2),
+                            "data_size": total_size,
+                            "size": size_key,
+                            "url": url,
+                            "server_info": server_info,
+                        }
+
+                        # If test duration exceeded, stop the test
+                        if elapsed_time >= test_duration:
+                            break
+
+    # Return the final result or an error if all tests failed
+    if final_result:
+        return {
+            "download_speed": final_result["download_speed"],
+            "unit": "Mbps",
+            "elapsed_time": final_result["elapsed_time"],
+            "data_size": final_result["data_size"],
+            "size_used": final_result["size"],
+            "server_info": final_result["server_info"],
+            "all_tests": results,
+        }
+    return {
+        "error": True,
+        "message": "All download tests failed",
+        "details": results,
+    }
+
+
+@mcp.tool()
+async def measure_upload_speed(
+    url_upload: str = DEFAULT_UPLOAD_URL, size_limit: str = "100MB"
+) -> dict:
+    """
+    Measure upload speed using incremental file sizes.
+
+    Args:
+        url_upload: URL to upload data to
+        size_limit: Maximum file size to test (default: 100MB)
+
+    Returns:
+        Dictionary with upload speed results
+    """
+    results = []
+    final_result = None
+
+    # Find the index of the size limit in our progression
+    max_index = (
+        SIZE_PROGRESSION.index(size_limit)
+        if size_limit in SIZE_PROGRESSION
+        else len(SIZE_PROGRESSION) - 1
+    )
+
+    # Only test up to the specified size limit
+    async with httpx.AsyncClient() as client:
+        for size_key in SIZE_PROGRESSION[: max_index + 1]:
+            if size_key in ["100MB", "200MB", "500MB", "1GB"]:
+                test_duration = BASE_TEST_DURATION + ADDITIONAL_TEST_DURATION
+            else:
+                test_duration = BASE_TEST_DURATION
+
+            data_size = UPLOAD_SIZES[size_key]
+            data = b"x" * data_size
+            start = time.time()
+
+            try:
+                response = await client.post(url_upload, data=data, timeout=30.0)
+                end = time.time()
+                elapsed_time = end - start
+
+                # Extract server information from headers
+                server_info = extract_server_info(dict(response.headers))
+
+                # Calculate upload speed in Mbps
+                speed_mbps = (data_size * 8) / (1024 * 1024) / elapsed_time
+                result = {
+                    "size": size_key,
+                    "upload_speed": round(speed_mbps, 2),
+                    "elapsed_time": round(elapsed_time, 2),
+                    "data_size": data_size,
+                    "url": url_upload,
+                    "server_info": server_info,
+                }
+
+                results.append(result)
+
+                # Set the final result to the last result
+                final_result = result
+
+                # If this test took longer than our threshold, we're done
+                if elapsed_time > test_duration:
+                    break
+
+            except (httpx.RequestError, httpx.HTTPStatusError, httpx.TimeoutException) as e:
+                results.append(
+                    {
+                        "size": size_key,
+                        "error": True,
+                        "message": f"HTTP Error: {str(e)}",
+                        "url": url_upload,
+                    }
+                )
+                # If we encounter an error, use the last successful result or continue
+                if final_result:
+                    break
+
+    # Return the final result or an error if all tests failed
+    if final_result:
+        return {
+            "upload_speed": final_result["upload_speed"],
+            "unit": "Mbps",
+            "elapsed_time": final_result["elapsed_time"],
+            "data_size": final_result["data_size"],
+            "size_used": final_result["size"],
+            "server_info": final_result["server_info"],
+            "all_tests": results,
+        }
+    return {
+        "error": True,
+        "message": "All upload tests failed",
+        "details": results,
+    }
+
+
+@mcp.tool()
+async def measure_latency(url: str = DEFAULT_LATENCY_URL) -> dict:
+    """Measure the latency
+
+    Args:
+        url (str): The URL to measure latency to
+
+    Returns:
+        Dictionary with latency result
+    """
+    start = time.time()
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+    end = time.time()
+    elapsed_time = end - start
+
+    # Extract server information from headers
+    server_info = extract_server_info(dict(response.headers))
+
+    return {
+        "latency": round(elapsed_time * 1000, 2),  # Convert to milliseconds
+        "unit": "ms",
+        "url": url,
+        "server_info": server_info,
+    }
+
+
+@mcp.tool()
+async def measure_jitter(url: str = DEFAULT_LATENCY_URL, samples: int = 5) -> dict:
+    """Jitter is the variation in latency, so we need multiple measurements."""
+    latency_values = []
+    server_info = None
+
+    async with httpx.AsyncClient() as client:
+        for i in range(samples):
+            start = time.time()
+            response = await client.get(url)
+            end = time.time()
+            latency_values.append((end - start) * 1000)  # Convert to milliseconds
+
+            # Extract server info from the first response
+            if i == 0:
+                server_info = extract_server_info(dict(response.headers))
+
+    # Calculate average latency
+    avg_latency = sum(latency_values) / len(latency_values)
+
+    # Calculate jitter (average deviation from the mean)
+    jitter = sum(abs(latency - avg_latency) for latency in latency_values) / len(
+        latency_values
+    )
+
+    return {
+        "jitter": round(jitter, 2),
+        "unit": "ms",
+        "average_latency": round(avg_latency, 2),
+        "samples": samples,
+        "url": url,
+        "server_info": server_info,
+    }
+
+
+@mcp.tool()
+async def get_server_info(
+    url_download: str = DEFAULT_DOWNLOAD_URLS["128KB"],
+    url_upload: str = DEFAULT_UPLOAD_URL,
+    url_latency: str = DEFAULT_LATENCY_URL,
+) -> dict:
+    """
+    Get server information for any URL without performing speed tests.
+
+    Args:
+        url_download: URL to download data from
+        url_upload: URL to upload data to
+        url_latency: URL to measure latency to
+
+    Returns:
+        Dictionary with servers information including POP location, CDN info, etc.
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response_url_download = await client.head(url_download, timeout=12.0)
+            server_info_url_download = extract_server_info(
+                dict(response_url_download.headers)
+            )
+
+            response_url_upload = await client.head(url_upload, timeout=12.0)
+            server_info_url_upload = extract_server_info(
+                dict(response_url_upload.headers)
+            )
+
+            response_url_latency = await client.head(url_latency, timeout=12.0)
+            server_info_url_latency = extract_server_info(
+                dict(response_url_latency.headers)
+            )
+
+            return {
+                "url_download": url_download,
+                "status_code_url_download": response_url_download.status_code,
+                "server_info_url_download": server_info_url_download,
+                "headers_url_download": dict(response_url_download.headers),
+                "url_upload": url_upload,
+                "status_code_url_upload": response_url_upload.status_code,
+                "server_info_url_upload": server_info_url_upload,
+                "headers_url_upload": dict(response_url_upload.headers),
+                "url_latency": url_latency,
+                "status_code_url_latency": response_url_latency.status_code,
+                "server_info_url_latency": server_info_url_latency,
+                "headers_url_latency": dict(response_url_latency.headers),
+            }
+        except (httpx.RequestError, httpx.HTTPStatusError, httpx.TimeoutException) as e:
+            return {
+                "error": True,
+                "message": f"Failed to get servers info: {str(e)}",
+                "url_download": url_download,
+                "url_upload": url_upload,
+                "url_latency": url_latency,
+            }
+
+
+@mcp.tool()
+async def run_complete_test(
+    max_size: str = "100MB",
+    url_upload: str = DEFAULT_UPLOAD_URL,
+    url_latency: str = DEFAULT_LATENCY_URL,
+) -> dict:
+    """
+    Run a complete speed test returning all metrics in a single call.
+
+    This test uses the smart incremental approach inspired by SpeedOf.Me:
+    - First measures download speed with gradually increasing file sizes
+    - Then measures upload speed with gradually increasing data sizes
+    - Measures latency and jitter
+    - Returns comprehensive results with real-time data
+
+    Args:
+        max_size: Maximum file size to test (default: 100MB)
+        url_upload: URL for upload testing
+        url_latency: URL for latency testing
+
+    Returns:
+        Complete test results including download, upload, latency and jitter metrics
+    """
+    download_result = await measure_download_speed(max_size)
+    upload_result = await measure_upload_speed(url_upload, max_size)
+    latency_result = await measure_latency(url_latency)
+    jitter_result = await measure_jitter(url_latency)
+
+    return {
+        "timestamp": time.time(),
+        "download": download_result,
+        "upload": upload_result,
+        "latency": latency_result,
+        "jitter": jitter_result,
+        "test_methodology": "Incremental file size approach with 8-second threshold",
+    }
+
+
+# Entry point to run the server
+if __name__ == "__main__":
+    mcp.run()