Esta es una implementación experimental de un servidor de Protocolo de Contexto de Modelo (MCP) para pruebas de velocidad de internet. Permite que los modelos y agentes de IA midan, analicen e informen métricas de rendimiento de la red mediante una interfaz estandarizada.
Related MCP server: Test MCP Feb4 MCP Server
El Protocolo de Contexto de Modelo (MCP) proporciona una forma estandarizada para que los Modelos de Lenguaje Grandes (LLM) interactúen con herramientas externas y fuentes de datos. Considérelo como el "USB-C para aplicaciones de IA": una interfaz común que permite a los sistemas de IA acceder a capacidades e información del mundo real.
Prueba de velocidad de descarga : mide el ancho de banda de descarga
Prueba de velocidad de carga : mida el ancho de banda de carga con tamaños de archivos configurables
Prueba de latencia : mide la latencia de la red en varios servidores
Análisis de fluctuación : Calcule la fluctuación de la red analizando las variaciones de latencia
Informes completos : proporcione informes detallados en formato JSON
Python 3.12 o superior
Gestor de paquetes uv (recomendado)
El comando uvx es una forma conveniente de ejecutar paquetes de Python directamente sin instalación explícita:
# Run the MCP server directly
uvx /path/to/mcp-internet-speed-test# 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-testPara utilizar este servidor MCP con Claude Desktop u otros clientes MCP, agréguelo a su archivo de configuración de MCP.
Edite su archivo de configuración MCP de Claude Desktop:
{
"mcpServers": {
"mcp-internet-speed-test": {
"command": "uv",
"args": [
"--directory",
"/ABSOLUTE/PATH/TO/mcp-internet-speed-test",
"run",
"main.py"
]
}
}
}La prueba de velocidad de Internet MCP proporciona las siguientes herramientas:
measure_download_speed : Mide el ancho de banda de descarga (en Mbps)
measure_upload_speed : Mide el ancho de banda de carga (en Mbps)
measure_latency : mide la latencia de la red (en ms)
measure_jitter : mide la fluctuación de la red analizando las variaciones de latencia
run_complete_test : ejecuta todas las pruebas y proporciona un informe completo
Si tiene problemas para conectarse al servidor MCP:
Asegúrese de que la ruta en su configuración de MCP sea correcta
Comprueba que tienes los permisos necesarios para el directorio
Verifique que Python 3.12+ esté instalado y en su PATH
Asegúrese de que los paquetes mcp[cli] y requests estén instalados
Este es un proyecto experimental y se agradecen las contribuciones. Para contribuir:
Abrir un problema o enviar una solicitud de extracción
Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.
Mantenedores del marco MCP para estandarizar las interacciones de las herramientas de IA
La comunidad del Protocolo de Contexto Modelo para documentación y ejemplos
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.
| Name | Required | Description | Default |
|---|---|---|---|
| url_download | No | https://media.githubusercontent.com/media/inventer-dev/speed-test-files/main/128KB.bin | |
| url_upload | No | https://httpi.dev/post | |
| url_latency | No | https://httpi.dev/get |
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.
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.
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.
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.
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.
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 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
| Name | Required | Description | Default |
|---|---|---|---|
| size_limit | No | 128MB | |
| sustain_time | No |
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.
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.
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.
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.
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.
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.
Jitter is the variation in latency, so we need multiple measurements.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | https://httpi.dev/get | |
| samples | No |
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.
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.
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.
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.
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.
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 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)
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | https://httpi.dev/get | |
| samples | No |
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.
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.
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.
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.
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.
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 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
| Name | Required | Description | Default |
|---|---|---|---|
| url_upload | No | https://httpi.dev/post | |
| size_limit | No | 128MB | |
| sustain_time | No |
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.
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.
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.
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.
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.
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 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
| Name | Required | Description | Default |
|---|---|---|---|
| max_size | No | 128MB | |
| url_upload | No | https://httpi.dev/post | |
| url_latency | No | https://httpi.dev/get | |
| sustain_time | No |
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.
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.
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.
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.
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.
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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.4get_server_info1 field changedInput schema / properties / url_download / defaultPrevious value: -"https://raw.githubusercontent.com/inventer-dev/speed-test-files/main/128KB.bin"New value: +"https://media.githubusercontent.com/media/inventer-dev/speed-test-files/main/128KB.bin"measure_download_speed2 fields changedInput schema / properties / size_limit / defaultPrevious value: -"100MB"New value: +"128MB"Input schema / properties / sustain_timeAdded value: +{
+ "default": 8,
+ "title": "Sustain Time",
+ "type": "integer"
+}measure_latency1 field changedInput schema / properties / samplesAdded value: +{
+ "default": 10,
+ "title": "Samples",
+ "type": "integer"
+}measure_upload_speed2 fields changedInput schema / properties / size_limit / defaultPrevious value: -"100MB"New value: +"128MB"Input schema / properties / sustain_timeAdded value: +{
+ "default": 8,
+ "title": "Sustain Time",
+ "type": "integer"
+}run_complete_test2 fields changedInput schema / properties / max_size / defaultPrevious value: -"100MB"New value: +"128MB"Input schema / properties / sustain_timeAdded value: +{
+ "default": 8,
+ "title": "Sustain Time",
+ "type": "integer"
+}get_server_infomeasure_download_speedmeasure_jittermeasure_latencymeasure_upload_speedrun_complete_testScored 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.
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.
