Skip to main content
Glama
deenesjakoruzh
inventer-dev

mcp-internet-speed-test

by inventer-dev
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

Trust Score

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-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.

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-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 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-test

Option 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-test

Option 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-test

Option 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.main

Dependencies

The package automatically installs these dependencies:

  • mcp[cli]>=1.25.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)

{
    "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

  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) using samples, reports minimum value

  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 (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 LFS

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

  • 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

  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 mcp[cli] 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 (includes methodology reference)
ā”œā”€ā”€ Dockerfile          # Container configuration
ā””ā”€ā”€ pyproject.toml      # Python project configuration

Key Components

Configuration Constants

  • GITHUB_MEDIA_URL: Base URL for test files repository (Git LFS media endpoint)

  • UPLOAD_ENDPOINTS: Prioritized list of upload test endpoints

  • SIZE_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 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:

# 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:

  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

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

  1. Begin by downloading the smallest sample size (128 KB).

  2. Measure the download duration in real time.

  3. If the download takes less than 8 seconds, move to the next larger sample size.

  4. If the download takes 8 seconds or more, stop the progression.

  5. 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:

  1. Start with a small sample and gradually increase in size.

  2. Continue until uploading a sample takes more than 8 seconds.

  3. 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:

  1. 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.

  2. 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.

  3. 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

measure_download_speed() iterates SIZE_PROGRESSION, breaks when elapsed ā‰„ sustain_time (default 8 s)

Incremental upload

measure_upload_speed() streams chunks and breaks when elapsed ā‰„ sustain_time

8-second threshold

Configurable via sustain_time parameter (1ā€“8 s, default 8)

Latency ā€” 10 samples, min

measure_latency(samples=10) reports min_latency

Jitter ā€” variation

measure_jitter(samples=5) reports average deviation from mean

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 inventer-dev/speed-test-files (Git LFS)

Automatic server selection

CDN handles geographic routing; PoP detected from response headers

Available Tools

6 tools
get_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.
ParametersJSON Schema
NameRequiredDescriptionDefault
url_downloadNohttps://media.githubusercontent.com/media/inventer-dev/speed-test-files/main/128KB.bin
url_uploadNohttps://httpi.dev/post
url_latencyNohttps://httpi.dev/get

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but the description explains it returns server info (POP, CDN) and clarifies no speed tests are performed, setting expectations for a read-only operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one sentence plus clear Args/Returns, no superfluous content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers purpose, parameters, and return value, though lacks explicit sibling differentiation. Sufficient for a low-complexity tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The Args section in the description adds meaning to each parameter (e.g., 'URL to download data from'), which the schema lacks (0% coverage).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves server information for URLs without speed tests, distinguishing it from sibling tools that measure speeds.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says 'without performing speed tests', implying when not to use it, but lacks explicit positive guidance or alternative naming.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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
ParametersJSON Schema
NameRequiredDescriptionDefault
size_limitNo128MB
sustain_timeNo

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so description must disclose behavioral traits. It mentions 'incremental file sizes' implying bandwidth usage but does not explicitly state whether the tool is safe, destructive, or has rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Docstring format with Args and Returns sections is structured but the Returns description is vague. Could be more concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With two optional parameters and no output schema, the description covers parameter semantics adequately but the return value is underspecified. For a simple tool, it is somewhat complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Explains size_limit as maximum file size and sustain_time as duration per test (1-8 seconds). The schema has 0% description coverage, so this adds essential meaning beyond types and defaults.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool measures download speed using incremental file sizes, distinguishing it from siblings like measure_latency and measure_upload_speed.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. Sibling tools exist but no comparative information is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

measure_jitterD

Jitter is the variation in latency, so we need multiple measurements.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlNohttps://httpi.dev/get
samplesNo

TDQS

D1.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must convey behavioral traits. It mentions 'multiple measurements,' but fails to disclose side effects, system impact, or any constraints beyond the name.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, but it is not concise in a useful wayā€”it provides a definition of jitter rather than a tool description. It under-specifies the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and two parameters with defaults, the description should provide usage context. It is completely inadequate, offering no help for a correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any parameters (url, samples). It adds no semantic value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose2/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description defines jitter but does not explicitly state that the tool measures jitter. It says 'we need multiple measurements,' which implies the tool's function but remains vague and indirect.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus its siblings (e.g., measure_latency). The description lacks context for appropriate usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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)
ParametersJSON Schema
NameRequiredDescriptionDefault
urlNohttps://httpi.dev/get
samplesNo

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only mentions that multiple samples are taken and the minimum is reported, but lacks details on network usage, timeouts, or side effects. It also claims 'most accurate representation' without justification.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a summary, elaboration, and parameter/return documentation. It is front-loaded with the main action. However, there is slight redundancy between the first two sentences.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with two parameters and no output schema, the description adequately explains what it does, how it works (multiple samples, minimum), and the inputs/outputs. It lacks potential error handling or network constraints, but overall is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It describes the 'url' and 'samples' parameters in the Args section, including defaults. While this adds basic context, it does not elaborate on format constraints or validation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it measures latency using multiple samples and reports the minimum. The verb 'measure' and resource 'latency' are specific. However, it does not differentiate from sibling tools like measure_jitter, which may measure related metrics.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as measure_jitter or run_complete_test. It only explains the methodology, not the contextual usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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
ParametersJSON Schema
NameRequiredDescriptionDefault
url_uploadNohttps://httpi.dev/post
size_limitNo128MB
sustain_timeNo

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits, but it only describes the measurement function. It does not mention whether it sends real data, requires permissions, or has any side effects like network traffic or temporary files.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is relatively concise at 6 lines with a clear structure: purpose, Args, Returns. It front-loads the main purpose, though the Args section repeats schema information unnecessarily.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of output schema and annotations, the description covers basic purpose and parameters but lacks detail on return format specifics, usage context, and behavioral implications of a network-uploading tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds meaningful parameter details beyond the schema via the Args section, explaining each parameter's purpose and constraints (e.g., sustain_time range 1-8). However, the size_limit format (e.g., allowed units) is not specified.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Measure upload speed using incremental file sizes,' providing a specific verb and resource. It distinguishes itself from sibling tools like measure_download_speed, but could be more explicit about what 'incremental file sizes' entails.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives like measure_download_speed or run_complete_test. The description lacks context for appropriate usage scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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
ParametersJSON Schema
NameRequiredDescriptionDefault
max_sizeNo128MB
url_uploadNohttps://httpi.dev/post
url_latencyNohttps://httpi.dev/get
sustain_timeNo

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should fully disclose behavior. It outlines the test steps (download, upload, latency, jitter) and the incremental approach, but lacks details on potential side effects, time consumption, or failure modes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a brief title, a paragraph on approach, and an Args/Returns section. Some phrases (e.g., 'inspired by SpeedOf.Me') are slightly extraneous, but overall concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of an output schema, the description should fully explain return values. It mentions 'download, upload, latency and jitter metrics' but lacks details on format, units, or structure. Parameter documentation is adequate but not exhaustive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds basic meaning to parameters (e.g., 'max_size: Maximum file size to test') but does not cover all nuances (e.g., format of max_size string). With 0% schema coverage, it partially compensates but remains incomplete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Run a complete speed test returning all metrics in a single call', specifying the action and resource. It distinguishes itself from siblings like 'measure_download_speed' by emphasizing comprehensiveness.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for obtaining all metrics at once but does not explicitly state when to choose this over individual measurement tools or provide exclusion criteria. Usage context is implied but not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: server info, download speed, jitter, latency, upload speed, and a combined test. No overlap or ambiguity.

Naming Consistency5/5

All tool names follow a consistent verb_noun snake_case pattern (get_, measure_, run_). Even though 'measure' appears multiple times, the nouns are distinct.

Tool Count5/5

6 tools is ideal for an internet speed test server, covering all key metrics plus a combined test and server info without bloat.

Completeness5/5

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

ActivityInactive
ResponsivenessSyncing

Resources

Related MCP Connectors

  • anotherai
    dev.anotherai

    MCP server for building and testing AI agents with multi-model experimentation and insights.

    Agent OrchestrationAutonomous AgentsTesting & QA Tools
    2
  • Remote MCPA
    com.remote-mcp.mcp

    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.

    Developer ToolsSearchAgent Orchestration
    13
  • Mercado Pago
    com.mercadopago.mcp

    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.

    FinanceE-commerce & RetailApp Automation
    2
  • OpenMesh
    dev.openmesh.api

    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.

    Agent OrchestrationWeb3 & Decentralized TechCloud Platforms
    2

Related MCP Servers

  • Ping MCP Server

    HuzaifaIrfan-AI
    A
    license
    Not graded
    quality
    D
    maintenance
    An 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

  • Test MCP Feb4 MCP Server

    Traia-IO
    F
    license
    Not graded
    quality
    D
    maintenance
    An 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.

Appeared in Searches

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/inventer-dev/mcp-internet-speed-test'

If you have feedback or need assistance with the MCP directory API, please join our Discord server