mcp-internet-speed-test
The MCP Internet Speed Test server provides a standardized interface for AI models to measure, analyze, and report network performance metrics.
Measure Download Speed: Test download bandwidth using an incremental approach with various file sizes.
Measure Upload Speed: Test upload bandwidth to specified endpoints.
Measure Latency: Measure network response time to a specified URL.
Measure Jitter: Analyze network stability by measuring variations in latency.
Get Server Info: Retrieve detailed CDN information (provider, POP location, cache status) without performing a full speed test.
Run Complete Test: Execute all tests in a single call for comprehensive performance analysis.
Smart Testing Methodology: Uses incremental file sizes and time-based optimization for accurate results.
Geographic Awareness: Maps CDN Points of Presence to physical locations worldwide.
Provides containerization support for running the MCP Internet Speed Test server in an isolated environment, with Docker configuration for building and deploying the service.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-internet-speed-test run a complete internet speed test"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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:
pip install mcp-internet-speed-test
mcp-internet-speed-testWhat 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.
Related MCP server: Test MCP Feb4 MCP Server
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 128MB from GitHub repository (Git LFS)
Upload Speed Testing: Tests upload bandwidth using streaming data from 128KB to 128MB
Latency Testing: Measures network latency using multiple samples, reports minimum value
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-cacheComprehensive Testing: Single function to run all tests with complete metrics
Installation
Prerequisites
Python 3.12 or higher (required for async support)
pip or uv package manager
Option 1: Install from PyPI with pip (Recommended)
# Install the package globally
pip install mcp-internet-speed-test
# Run the MCP server
mcp-internet-speed-testOption 2: Install from PyPI with uv
# Install the package globally
uv add mcp-internet-speed-test
# Or run directly without installing
uvx mcp-internet-speed-testOption 3: Using docker
# 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-testOption 4: Development/Local Installation
If you want to contribute or modify the code:
# 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.mainDependencies
The package automatically installs these dependencies:
mcp[cli]>=1.25.0: MCP server framework with CLI integrationhttpx>=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)
{
"mcpServers": {
"mcp-internet-speed-test": {
"command": "mcp-internet-speed-test"
}
}
}Option 2: Using uvx
{
"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
measure_download_speed: Measures download bandwidth (in Mbps) with server location infomeasure_upload_speed: Measures upload bandwidth (in Mbps) with server location infomeasure_latency: Measures network latency (in ms) using samples, reports minimum valuemeasure_jitter: Measures network jitter by analyzing latency variations with server infoget_server_info: Get detailed CDN server information for any URL without running speed testsrun_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, andx-cache
Technical Implementation
Smart Testing Methodology
Incremental Approach: Starts with small files (128KB) and progressively increases (powers of 2)
Time-Based Threshold: Uses configurable sustain_time (1-8 seconds, default: 8). Stops when a sample exceeds the threshold
Accuracy Focus: The speed from the last sample that took ā„ 8 seconds is used as the final measurement
Multi-Provider Support: Tests against geographically distributed endpoints
Full methodology: See SpeedOf.Me Testing Methodology
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
{
"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
URL: https://media.githubusercontent.com/media/inventer-dev/speed-test-files/main/
File Sizes: 128KB, 256KB, 512KB, 1MB, 2MB, 4MB, 8MB, 16MB, 32MB, 64MB, 128MB
Storage: Git LFSUpload Endpoints Priority
Cloudflare Workers (httpi.dev) - Global distribution, highest priority
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
Test Duration Threshold: 8.0 seconds (stops when a sample exceeds this)
Maximum File Size: Configurable (default: 128MB)
Latency Samples: 10 measurements, reports minimum (configurable)
Jitter Samples: 5 measurements (configurable)
Sustain Time: 1-8 seconds (configurable, default: 8)
Troubleshooting
Common Issues
MCP Server Connection
Path Configuration: Ensure absolute path is used in MCP configuration
Directory Permissions: Verify read/execute permissions for the project directory
Python Version: Requires Python 3.12+ with async support
Dependencies: Install
mcp[cli]andhttpxpackages
Speed Test Issues
GitHub Repository Access: Ensure
inventer-dev/speed-test-filesis accessibleFirewall/Proxy: Check if corporate firewalls block test endpoints
CDN Routing: Some ISPs may route differently to CDNs
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 (includes methodology reference)
āāā Dockerfile # Container configuration
āāā pyproject.toml # Python project configurationKey Components
Configuration Constants
GITHUB_MEDIA_URL: Base URL for test files repository (Git LFS media endpoint)UPLOAD_ENDPOINTS: Prioritized list of upload test endpointsSIZE_PROGRESSION: Ordered list of file sizes for incremental testing (powers of 2)*_POP_LOCATIONS: Mappings of CDN codes to geographic locations
Core Functions
extract_server_info(): Parses HTTP headers to identify CDN providersmeasure_*(): Individual test functions for different metricsrun_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:
# GitHub repository settings
GITHUB_USERNAME = "your-username"
GITHUB_REPO = "your-speed-test-files"
GITHUB_BRANCH = "main"
# Test duration threshold
DEFAULT_TEST_DURATION = 8.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:
Issues: Report bugs or request features
Pull Requests: Submit code improvements
Documentation: Help improve this README
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
SpeedOf.Me team for their incremental testing methodology (How It Works). See methodology reference below
For the official SpeedOf.Me MCP server, see @speedofme/mcp
SpeedOf.Me Testing Methodology
Source: SpeedOf.Me ā How It Works
This section preserves the SpeedOf.Me testing methodology as referenced by this project. Retrieved on March 8, 2026.
Overview
SpeedOf.Me tests an internet connection by downloading and uploading sample files. It reflects actual browsing and download performance by using a single HTTP connection and large continuous files ā the same way real web content is delivered.
Download Test
Begin by downloading the smallest sample size (128 KB).
Measure the download duration in real time.
If the download takes less than 8 seconds, move to the next larger sample size.
If the download takes 8 seconds or more, stop the progression.
The final speed measurement is based on that last sample ā the one that took 8 seconds or more.
Upload Test
When the download test is complete, a similar incremental process is used to send data back to the test server:
Start with a small sample and gradually increase in size.
Continue until uploading a sample takes more than 8 seconds.
The upload speed is based on that final sample.
Latency & Jitter
Latency (ping): The time it takes for data to travel to the server and back. Measured over 10 samples with the lowest value reported.
Jitter: The variation between latency samples. Lower jitter means a more stable connection, which is important for video calls and gaming.
Adaptive Testing Method
To ensure the internet connection is thoroughly tested, bandwidth is measured in several passes. Sample file sizes gradually increase until one takes longer than 8 seconds to download.
This approach automatically measures connection speeds ranging from very slow mobile networks (10 Kbps GPRS / 2G) to gigabit fiber connections (1 Gbps or more).
Sample File Sizes
# | Size |
1 | 128 KB |
2 | 256 KB |
3 | 512 KB |
4 | 1 MB |
5 | 2 MB |
6 | 4 MB |
7 | 8 MB |
8 | 16 MB |
9 | 32 MB |
10 | 64 MB |
11 | 128 MB |
Test Servers
SpeedOf.Me hosts its sample files on a CDN. It uses servers called PoPs (Points of Presence) in 106+ cities. Each PoP may consist of multiple servers and is located in key regions around the world, near major internet exchange points.
When the test begins, SpeedOf.Me automatically selects the most reliable and responsive server. This may not be the closest one ā several factors are taken into account to determine the best option. CDN technology handles this process to provide the most accurate and consistent test results.
Accuracy
Key differences that make this methodology accurate:
Single continuous download ā Downloads large, continuous sample files, similar to how web pages or media files are typically delivered. Other speed tests use small chunks transferred in parallel and apply adjustments to estimate speed.
Multiple global servers ā Uses PoPs in different regions, producing more realistic results. Other services often choose the nearest physical server (sometimes inside the ISP network), which can give inflated results.
No plugins required ā Tests run directly from the client with no extra software.
How This Project Implements the Methodology
SpeedOf.Me Concept | Implementation in this project |
Incremental download |
|
Incremental upload |
|
8-second threshold | Configurable via |
Latency ā 10 samples, min |
|
Jitter ā variation |
|
CDN with PoPs | Download files served from GitHub via Fastly CDN; upload via Cloudflare Workers |
Sample file sizes (powers of 2) | 128 KB ā 128 MB stored in |
Automatic server selection | CDN handles geographic routing; PoP detected from response headers |
Available Tools
6 toolsget_server_infoA
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.
Inputs: url_download, url_upload, url_latency.
measure_download_speedB
Measure download speed using incremental file sizes.
Args:
size_limit: Maximum file size to test (default: 128MB)
sustain_time: Duration in seconds for each test (1-8, default: 8)
Returns:
Dictionary with download speed results
Inputs: size_limit, sustain_time.
measure_jitterD
Jitter is the variation in latency, so we need multiple measurements.
Inputs: url, samples.
measure_latencyB
Measure the latency using multiple samples and report the minimum.
Takes a number of samples and reports the lowest
value for the most accurate representation of network latency.
Args:
url (str): The URL to measure latency to
samples (int): Number of samples to take (default: 10)
Returns:
Dictionary with latency result (minimum of all samples)
Inputs: url, samples.
measure_upload_speedB
Measure upload speed using incremental file sizes.
Args:
url_upload: URL to upload data to
size_limit: Maximum file size to test (default: 128MB)
sustain_time: Duration in seconds for each test (1-8, default: 8)
Returns:
Dictionary with upload speed results
Inputs: url_upload, size_limit, sustain_time.
run_complete_testA
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: 128MB)
url_upload: URL for upload testing
url_latency: URL for latency testing
sustain_time: Duration in seconds for each test (1-8, default: 8)
Returns:
Complete test results including download, upload, latency and jitter metrics
Inputs: max_size, url_upload, url_latency, sustain_time.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogā¦
TDQS
Scored across 6 tools
Each tool has a clearly distinct purpose: server info, download speed, jitter, latency, upload speed, and a combined test. No overlap or ambiguity.
All tool names follow a consistent verb_noun snake_case pattern (get_, measure_, run_). Even though 'measure' appears multiple times, the nouns are distinct.
6 tools is ideal for an internet speed test server, covering all key metrics plus a combined test and server info without bloat.
The set covers all standard speed test metrics: download, upload, latency, jitter, and server info. A combined test is also provided. No obvious gaps.
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
The Remote MCP server acts as a standardized bridge between LLM applications (like Claude, ChatGPT, and Cursor) and external services, enabling AI agents to access external tools and resources. Its primary capability is providing a centralized search tool to discover other MCP servers and their respective tools. Unlike local implementations, it runs remotely with OAuth authentication and permission controls for security.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
The OpenMesh MCP Server provides decentralized, permissionless cloud infrastructure that integrates AI assistants with Web2 and Web3 applications without middlemen. It offers intelligent service discovery to identify MCP servers, acts as a universal proxy for routing requests to discovered services, implements performance optimization through usage feedback, and provides automatic fault tolerance with alternative services when servers become unavailable.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that allows users to ping other hosts to check network connectivity and diagnostic information. It enables LLMs to perform network latency tests and host availability checks through a standardized interface.MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that provides standardized tools for AI agents to interact with the Test MCP Feb4 API. It enables LLMs to access API endpoints through asynchronous operations and standardized Model Context Protocol tools.-
- FlicenseNot gradedqualityDmaintenanceA standardized MCP server designed for testing integration with the Des MCP Server Testing API. It allows AI agents to interact with testing endpoints using tools implemented via the Model Context Protocol.-
- AlicenseAqualityDmaintenanceA Model Context Protocol server providing network diagnostic tools for AI agents, including connectivity testing, batch operations, local network info, and pcap analysis.346MIT