Skip to main content
Glama
coros-workout-mcp

coros-workout-mcp

by wtcollote

coros-workout-mcp

⚠️ Unofficial, community-led project — not affiliated with COROS. COROS now offers an official MCP server at coroslab/COROS-MCP. If you want a supported, first-party option, use that. This project remains an independent, community-built tool.

MCP server for creating and managing COROS strength, running and cycling workouts through the Training Hub API. It includes calendar management, weekly planning, validation and backups. This fork adds a Streamable HTTP endpoint for a private ChatGPT plugin while preserving stdio compatibility.

Try it in 2 minutes — no credentials required

Want to see the training analytics before connecting any account? Start the synthetic demo provider:

npm ci
npm run demo

Then check the installation safely:

npm run doctor

Demo mode uses synthetic running, cycling and trail activities only. It never reads COROS, Strava or Garmin accounts.

Quick start: English · Español
Free/self-host connection guide: English · Español
Deployment: render.yaml is included for a simple Render Docker deployment.

What you can try in demo mode

Use the stable coros_read bridge with providerId: "demo" to explore athlete_snapshot, training_trends, weekly_training_summary, personal_bests, activity_anomalies, similar_activities and the rest of the provider-neutral analytics.

Zero-cost connection guide: English · Español

Related MCP server: garmin-mcp-triathlon

Version 2.0 — Adaptive Coaching Engine

Version 2.0 keeps the 56 visible MCP tools stable but turns the compatibility bridge into a complete long-term coaching layer. It can build athlete-specific baselines, make an explainable daily decision, simulate training changes before calendar writes, place the current week inside a season strategy, and evaluate what happened after prior decisions. See docs/RELEASE-2.0.0.md and docs/V2-SMOKE-TEST.md.

Private ChatGPT setup

This is a tool-only plugin: it does not add a widget. It exposes the MCP endpoint at /mcp and a health response at /.

  1. Deploy the included Docker image to a host with persistent storage and HTTPS.

  2. Configure these secrets in the host (do not commit them):

    • COROS_EMAIL

    • COROS_PASSWORD

    • COROS_REGION=eu

    Leave COROS_ALLOW_UNOFFICIAL_MOBILE_LOGIN unset or set it to false. This prevents the private connector from opening a competing COROS mobile session and allows the official COROS phone app to remain signed in.

  3. In ChatGPT, enable Developer mode and create a private plugin using:

    https://YOUR-HOST.example/mcp

The host sets PORT automatically on most platforms. Locally it defaults to 8787.

npm install
npm run build
npm start

For a Docker smoke test:

docker build -t coros-workout-chatgpt .
docker run --rm -p 8787:8787 --env-file .env coros-workout-chatgpt

Important: the upstream project uses a reverse-engineered COROS API. API login can invalidate an active COROS Training Hub web session. This private deployment is intended for one COROS account; do not expose the endpoint publicly without an authentication layer.

See the MCP in action: YouTube walkthrough

Disclaimer

This is an unofficial, community-driven project. It is not affiliated with, endorsed by, or connected to COROS in any way. For an official, COROS-supported MCP server, see coroslab/COROS-MCP.

This server communicates with the COROS Training Hub using a reverse-engineered, undocumented API that may change or break without notice. Use it at your own risk.

COROS is a trademark of COROS Wearables, Inc. This project is provided as-is with no warranty — see LICENSE for details.

Setup

cd coros-workout-mcp
npm install
npm run build

Usage with Claude Code

claude mcp add coros-workout -- node /path/to/coros-workout-mcp/dist/src/index.js

To use env var auth (avoids typing credentials in conversation):

claude mcp add coros-workout -e COROS_EMAIL=you@example.com -e COROS_PASSWORD=yourpass -e COROS_REGION=eu -- node /path/to/coros-workout-mcp/dist/src/index.js

Usage with Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "coros-workout": {
      "command": "/path/to/node",
      "args": ["/path/to/coros-workout-mcp/dist/src/index.js"],
      "env": {
        "COROS_EMAIL": "you@example.com",
        "COROS_PASSWORD": "yourpass",
        "COROS_REGION": "eu"
      }
    }
  }
}

Node.js 18+ required — this server uses native fetch() which was added in Node 18.

Troubleshooting fetch is not defined: Claude Desktop is a GUI app that doesn't inherit your shell PATH, so node binaries installed via version managers (mise, nvm, fnm, volta) won't be found. Use the full absolute path to your node binary in "command":

which node        # e.g. /Users/you/.mise/shims/node
node --version    # confirm it's 18+

Common locations:

  • mise: ~/.local/share/mise/installs/node/<version>/bin/node

  • nvm: ~/.nvm/versions/node/<version>/bin/node

  • fnm: ~/.local/share/fnm/node-versions/<version>/installation/bin/node

  • Homebrew: /opt/homebrew/bin/node

Tools

Tool

Description

authenticate_coros

Log in with email/password (or auto-login from env vars)

check_coros_auth

Verify current auth status

search_exercises

Search ~383 exercises by name, muscle, body part, equipment

create_workout

Build and push a strength workout to COROS

update_exercises

Fetch the latest exercise catalog from COROS and rebuild locally

list_workouts

List existing workouts

assign_workout_to_calendar

Assign an existing workout after a professional ±14-day context guard

create_structured_workout

Create and optionally schedule structured run/bike workouts

list_scheduled_workouts

Read the COROS calendar and return management IDs

move_scheduled_workout

Move a scheduled workout after the same context guard

remove_scheduled_workout

Remove one occurrence from the calendar

delete_workout

Delete a saved workout from the library

duplicate_workout

Copy any workout and optionally schedule the copy

update_workout

Create an edited replacement clone; optionally delete the original

create_week_plan

Validate, create and schedule up to 14 run/bike workouts

check_calendar_conflicts

Detect days containing multiple scheduled workouts

summarize_planned_load

Summarize planned duration and distance by sport

swap_calendar_workouts

Exchange two scheduled workouts between dates

validate_structured_workout

Validate structure and totals without writing to COROS

export_coros_backup

Export workout metadata and raw calendar data as JSON

get_workout_details

Inspect every step and target of one workout

replace_scheduled_workout

Safely replace one calendar occurrence

shift_calendar_range

Preview or shift a date range by N days

copy_calendar_range

Preview or copy a scheduled period to new dates

clear_calendar_range

Preview or clear a range with explicit confirmation

audit_calendar

Audit conflicts, management IDs and planned volume

get_hrv_data

Read recent nightly HRV and baseline

get_daily_metrics

Read resting HR, fatigue, load and fitness metrics

get_sleep_data

Legacy mobile sleep read; safely disabled by default in v1.16.0

list_activities

List completed activities and principal metrics

get_activity_detail

Read laps, zones and detailed activity metrics

analyze_aerobic_decoupling

Compare speed/HR efficiency between both halves of an endurance activity

analyze_completed_activity

Return compact metrics, zones, representative laps and decoupling

analyze_training_day

Classify recorded strength, endurance, walking, mobility and active-recovery sessions for one day

daily_training_briefing

Combine seven-day sleep, HRV, load, activities, calendar and decoupling in one call

preview_daily_adjustment

Preview maintain/reduce/recovery using transparent conservative thresholds

calculate_fueling_plan

Estimate carbohydrate, fluid and sodium ranges for an endurance session

compare_activity_history

Compare normalized metrics and decoupling across similar activities

weekly_training_report

Compare the latest seven days with the preceding week across training and recovery

analyze_workout_execution

Compare planned blocks with the completed activity when COROS exposes linkage

taper_readiness

Review load decline, recovery signals and planned work before an event

connector_status

Report version, authentication and expected tool count

get_activity_export_url

Get a temporary FIT / GPX / TCX / KML / CSV download URL for a completed activity

analyze_fit_activity

Analyze record-level FIT data without returning bulky raw samples

get_athlete_profile_metrics

Consolidate VO₂max, thresholds, fitness, training indices, HRV and resting HR

analyze_gpx_route

Analyze distance, elevation, grade, bearing and fixed-distance GPX sectors

analyze_route_weather

Add forecast weather, wind components, daylight and risks to GPX sectors

simulate_ultra_route

Produce three transparent timing scenarios and checkpoint ETAs from a GPX route

plan_operational_route

Build cycling, running, trail, walking or hiking scenarios with stops, terrain, daylight, fueling and weather

calibrate_sport_performance

Fit effective speed/pace and ascent cost from comparable COROS history

analyze_multisport_load

Separate COROS cardiovascular load, impact exposure, strength duration and recovery activity

get_readiness_summary

Combine sleep, HRV, load, activities and calendar for one day

compare_plan_to_actual

Compare planned and completed volume by date

coros_capabilities

Return the live compatibility-bridge operation catalog and input contracts

coros_read

Execute allowlisted read operations through a stable schema for older chats

coros_write

Execute allowlisted writes through a stable schema with explicit confirmation

The stable coros_read bridge exposes professional_coaching_analysis, coaching_methodology_catalog, get_athlete_profile, training_context_analysis, validate_calendar_change and the v2 operations adaptive_coaching_engine, longitudinal_athlete_model, simulate_training_change, season_strategy and evaluate_prior_decision. The coaching analysis performs a multisource review of sleep, HRV, resting heart rate, COROS load and fitness fields, completed activities, impact exposure, strength, active recovery and the future calendar. The context analysis uses a default 14-day lookback and 14-day lookahead. Results deliberately separate observed evidence, coaching interpretation, practical recommendation and missing-data uncertainty for cycling, running, trail and ultra-endurance.

Stable compatibility bridge

ChatGPT conversations can retain an older MCP tool catalog. Version 1.13.0 added a stable bridge so future server capabilities can be used without adding another top-level tool name. Versions 1.14.x through 1.16.0 added coaching, context and safe recovery-data ingestion. Version 2.0.0 adds adaptive decision-making, longitudinal athlete modeling, season strategy, pre-write simulation and post-decision evaluation while the visible tool count remains 56. Call coros_capabilities, then use coros_read or coros_write with the returned operation and input contract.

The bridge does not replace the dedicated tools. It is a compatibility fallback. Its operation field intentionally remains a free string so adding server-side operations does not change the cached schema. Writes are allowlisted and require CONFIRM or DELETE as specified by coros_capabilities.

An old conversation must load version 1.13.0 once before it can use the bridge. A conversation that never loaded this plugin cannot be updated by the MCP server itself.

See docs/NEXT-IMPROVEMENTS.md for the prioritized roadmap. For zero-cost hosting and connection options, see docs/FREE-CONNECTION-GUIDE.md.

update_workout uses clone-and-replace semantics because COROS does not expose a stable documented in-place editing API. The original is retained by default. summarize_planned_load reports planned volume; it is not COROS physiological Training Load.

Mobile-app coexistence and sleep data

Version 1.16.0 disables the reverse-engineered COROS mobile login by default. ChatGPT should read sleep through the official COROS MCP OAuth connector, normalize those records and pass them to coros_read(operation="professional_coaching_analysis") as officialSleepRecords. COROS Workout then combines them with Training Hub load, HRV, activities and calendar data for the professional interpretation. OAuth credentials remain managed by the calling ChatGPT connector and are not copied into this service.

The compatibility escape hatch COROS_ALLOW_UNOFFICIAL_MOBILE_LOGIN=true restores the old get_sleep_data behavior, but it is not recommended: it can compete with or invalidate the phone application's session. Daily summaries expose COROS' raw fatigue and load fields; the server deliberately does not manufacture its own recovery score.

daily_training_briefing is optimized for a scheduled morning report: it performs the required COROS reads in parallel, reports partial-source errors, summarizes seven-day trends and includes decoupling for the latest run or ride when sufficient auto-lap data exists. analyze_aerobic_decoupling compares time-weighted speed/heart-rate efficiency after trimming 10% from both ends by default; the result is unavailable rather than estimated when COROS lacks enough valid laps.

preview_daily_adjustment never writes to COROS. It applies explicit conservative thresholds to sleep, HRV, resting heart rate and training-load ratio, requires at least two available signals and returns the exact reasons behind its suggestion. Subjective symptoms and user confirmation always take precedence. analyze_completed_activity keeps the useful summary, zones and a maximum of roughly 20 representative laps instead of returning COROS' very large raw activity payload.

professional_coaching_analysis keeps exhaustive measurement and professional interpretation as two separate layers. Its coaching hierarchy gives priority to reported pain or illness, then acute recovery, multisport load and impact, calendar purpose, event proximity and discipline specificity. It supports multiple periodization and intensity-distribution models but never selects one automatically from a single metric. Known constraints and subjective state must be passed in because they are not reliably stored by COROS. It provides decision support, not medical diagnosis, and calendar changes remain separate confirmed writes.

Persistent athlete profile and calendar safety

Version 1.15.0 supports a versioned athlete profile so stable facts do not depend on chat memory. The public repository ships only a generic example profile with unknown values left unset. Supply your own private profile with ATHLETE_PROFILE_PATH or ATHLETE_PROFILE_JSON, and inspect it with coros_read(operation="get_athlete_profile").

Override the bundled profile with ATHLETE_PROFILE_PATH or ATHLETE_PROFILE_JSON. Do not place credentials in this profile. Current pain, illness, fatigue, equipment changes and other time-varying facts must still be supplied at decision time.

Calendar assignments, moves, swaps, structured-workout scheduling, duplication, week plans, range shifts and range copies are preflighted against the preceding and following 14 days. A missing COROS activity or calendar source makes a proposed write fail closed. Hard conflicts are blocked; warnings remain visible and never silently change another session.

If COROS invalidates the Training Hub access token, API calls automatically authenticate once with the configured environment credentials and retry. Concurrent refresh attempts are coalesced to avoid tokens invalidating each other.

Calendar swaps use three verified single-entry moves through a temporary empty day because COROS rejects simultaneous two-entry updates. If an intermediate move fails, the server attempts to roll both entries back to their original dates.

Example conversation

"Search for chest exercises with bodyweight"

"Create a workout called 'Quick Push' with 4x15 Push-ups, 3x10 Diamond Push-ups, and 3x20 Decline Push-ups with 45s rest"

Updating the exercise catalog

The bundled exercise catalog (data/exercises.json) is a static snapshot. If COROS adds new exercises, use the update_exercises tool to refresh it. This fetches the latest exercises from the COROS API and i18n strings from the CDN, rebuilds the catalog, and reloads the in-memory cache — all in a single tool call. Requires authentication.

Auth notes

  • Region: eu (Europe) or us (US). Defaults to eu.

  • Session conflict: Logging in via this API invalidates your COROS web app session, and vice versa.

  • Auth tokens are stored at ~/.config/coros-workout-mcp/auth.json (mode 0600).

Development

npm test           # Run unit tests
npm run test:watch # Watch mode
npm run build      # Compile TypeScript

v2.1.0 — Athlete Intelligence

v2.1 extends the stable compatibility bridge without increasing the 56-tool MCP catalog. New read operations are available through coros_read:

  • athlete_intelligence — combined intelligence report.

  • personal_recovery_model — observed 24/48/72 h recovery response by session type.

  • residual_fatigue_model — decaying residual planning stress from recent sessions.

  • session_fingerprints — athlete-specific session distributions.

  • performance_trend — recent vs prior endurance trend with terrain/weather caveat.

  • training_dose_optimizer — conservative personalized dose factor.

  • event_readiness — explainable event-preparation index, not an outcome probability.

  • anomaly_data_quality — personal-baseline anomaly and source-completeness checks.

The season engine now enters taper at <=14 days before a dated objective. Athlete Intelligence never imputes missing physiological fields and labels heuristic/associational outputs explicitly.

Deployment verification

After deploying, verify connector_status.version === 2.1.0, call coros_capabilities, then smoke-test athlete_intelligence for a recent date. Existing write operations and the 56 visible MCP tools are unchanged.

v2.1.1 precision patch

Performance trends are discipline-specific; event readiness separates current state from projected event-date freshness; priority-A late long sessions are blocked by simulation in the final 10 days. Official sleep remains supplied through the official COROS MCP OAuth calling platform via officialSleepRecords; the server never re-enables unofficial mobile login.

Available Tools

56 tools
analyze_aerobic_decouplingA
Read-only

Calculate aerobic decoupling for a completed running or cycling activity by comparing time-weighted speed/heart-rate efficiency in both halves. Trims warm-up and cool-down by default and reports when data is insufficient.

Inputs: sportType (required), activityId (required), trimPercent.

analyze_completed_activityA
Read-only

Return a compact coach-ready analysis of any completed activity. Supports endurance metrics and explicit context for strength, walking, hiking, mobility and active recovery. Supply date to allow summary fallback if COROS rejects detailed strength data.

Inputs: sportType (required), activityId (required), date.

analyze_fit_activityA
Read-only

Download and analyze the FIT file for a completed COROS activity. Returns bounded summaries of record-level HR, cadence, speed, power, temperature, stops, climbs, aerobic decoupling and finish quality; raw samples are not returned.

Inputs: sportType (required), activityId (required), targetCadenceMax, targetCadenceMin, +6 more.

analyze_gpx_routeA
Read-only

Analyze a GPX track or route without external writes. Returns distance, elevation, endpoints and compact fixed-distance sectors with coordinates, grade and bearing.

Inputs: gpxXml (required), segmentDistanceKm.

analyze_multisport_loadA
Read-only

Aggregate a date range across cycling, running, trail, walking, hiking, strength and mobility. Keeps COROS cardiovascular load separate from heuristic impact exposure and recorded strength duration.

Inputs: endDate (required), startDate (required).

analyze_route_weatherB
Read-only

Combine a GPX route with Open-Meteo hourly forecasts. Estimates arrival per sector and reports temperature, rain, wind, gusts, headwind/crosswind components, daylight and explicit risks.

Inputs: gpxXml (required), startTimeIso (required), averageMovingSpeedKmh (required), totalStopMinutes, +1 more.

analyze_training_dayA
Read-only

Analyze every completed COROS activity on one date, including strength, walking, hiking, mobility and recovery sessions. Classifies only the recorded training day using transparent rules and also returns the planned calendar.

Inputs: date (required).

analyze_workout_executionA
Read-only

Compare a planned COROS workout with the completed activity linked to its program blocks. Reports duration and HR/cadence target compliance when COROS exposes programExerciseIndex.

Inputs: sportType (required), workoutId (required), activityId (required).

assign_workout_to_calendarA

Assign an existing COROS Training Hub workout to a date in the COROS training calendar. Use list_workouts first to obtain the workout ID.

Inputs: date (required), workoutId (required).

audit_calendarB
Read-only

Audit a calendar range for duplicate days, missing management IDs and planned-volume totals without changing COROS.

Inputs: endDate (required), startDate (required).

authenticate_corosA

Log in to COROS Training Hub. Stores auth token for subsequent calls. Also checks COROS_EMAIL/COROS_PASSWORD env vars for auto-login. WARNING: Logging in via API invalidates the web app session.

Inputs: email, region, password.

calculate_fueling_planA
Read-only

Calculate practical carbohydrate, fluid and sodium ranges for an endurance session. Uses duration, intensity, temperature and optional measured sweat/sodium loss. This is a planning estimate, not medical advice.

Inputs: intensity (required), durationMinutes (required), temperatureC, sweatRateMlPerHour, +1 more.

calibrate_sport_performanceA
Read-only

Fit an effective base speed/pace and ascent penalty from comparable COROS activity summaries. Excludes indoor cycling for outdoor-route calibration and reports fit error, confidence and limitations.

Inputs: sport (required), endDate (required), lookbackDays.

check_calendar_conflictsB
Read-only

Find dates containing more than one scheduled COROS workout.

Inputs: endDate (required), startDate (required).

check_coros_authA
Read-only

Check if COROS authentication is available (from stored token or env vars).

Inputs: no named parameters.

clear_calendar_rangeA
Destructive

Preview or remove every scheduled workout occurrence in a date range. Applying requires confirm=DELETE.

Inputs: endDate (required), startDate (required), apply, confirm.

compare_activity_historyA
Read-only

Compare up to eight similar completed COROS activities over a date range using normalized summary metrics and aerobic decoupling. Filter by exact COROS sport type and optional name text.

Inputs: endDate (required), sportType (required), startDate (required), nameContains, +1 more.

compare_plan_to_actualB
Read-only

Compare planned COROS calendar volume with completed activities by date for a selected range.

Inputs: endDate (required), startDate (required).

connector_statusA
Read-only

Return the deployed connector version, expected tool count, authentication state and enabled feature groups. Use this to detect stale ChatGPT tool catalogs.

Inputs: no named parameters.

copy_calendar_rangeA

Preview or copy all scheduled workouts from one date range to dates shifted by a fixed number of days. Copies are new library workouts.

Inputs: days (required), endDate (required), startDate (required), apply, +1 more.

coros_capabilitiesA
Read-only

Use this when a COROS function is missing from the chat catalog or before calling the stable compatibility bridge. Returns current read/write operation names, input contracts and required confirmations.

Inputs: no named parameters.

coros_readA
Read-only

Use this when a specific COROS read-only tool is absent from an older chat. Call coros_capabilities first, then pass its operation name and input object. The schema stays stable while server-side operations evolve.

Inputs: operation (required), input.

coros_writeB
Destructive

Use this when a specific COROS write tool is absent from an older chat. Call coros_capabilities first. Writes use an allowlist, validate inputs and require the exact confirmation returned for that operation.

Inputs: operation (required), confirmation (required), input.

create_structured_workoutA

Create a structured running or cycling workout with time, distance or open steps, optional HR/pace/power/cadence/speed targets, and repeat groups. Optionally schedule it on a COROS calendar date.

Inputs: name (required), sport (required), steps (required), date, +1 more.

create_week_planA

Create and schedule several structured running/cycling workouts in one request. All entries are validated and calendar conflicts are checked before writing.

Inputs: workouts (required), conflictPolicy.

create_workoutA

Create a strength workout on COROS Training Hub. Resolves exercise names from the catalog, builds the full API payload, calculates metrics, and saves the workout. The workout will sync to the user's COROS watch.

Inputs: name (required), exercises (required), overview.

daily_training_briefingB
Read-only

MANDATORY SLEEP ROUTING: first call COROS_MCP_2 querySleepData for the last seven wake-up days and pass normalized results as officialSleepRecords. Then build the daily briefing from sleep, HRV, resting heart rate, load, activities and calendar.

Inputs: date (required), officialSleepRecords.

delete_workoutA
Destructive

Delete a saved workout from the COROS Training Hub library. This does not remove already scheduled calendar entries.

Inputs: workoutId (required).

duplicate_workoutA

Duplicate any COROS library workout. Optionally rename it, change its description, and schedule the copy.

Inputs: workoutId (required), date, newName, overview.

export_coros_backupB
Read-only

Export COROS workout-library metadata and raw calendar data as JSON for backup or inspection. Does not include account credentials.

Inputs: endDate (required), startDate (required), workoutLimit.

get_activity_detailA
Read-only

Read the detailed metrics, laps and zones for one completed COROS activity. Large graph arrays are omitted.

Inputs: sportType (required), activityId (required).

get_activity_export_urlA
Read-only

Request a temporary COROS download URL for one completed activity in FIT, GPX, TCX, KML or CSV format. Read-only; the URL may expire.

Inputs: sportType (required), activityId (required), format.

get_athlete_profile_metricsA
Read-only

Return a consolidated COROS physiological profile and period trends: VO2max, lactate threshold HR/pace, base fitness, training indices, HRV and resting HR. Missing data is explicit and never estimated.

Inputs: asOfDate (required), lookbackDays.

get_daily_metricsB
Read-only

Read COROS daily HRV, resting heart rate, fatigue, training load, load ratio and fitness metrics for a date range.

Inputs: endDate (required), startDate (required).

get_hrv_dataA
Read-only

Read recent nightly HRV, baseline and variability from the COROS Training Hub dashboard.

Inputs: no named parameters.

get_readiness_summaryB
Read-only

MANDATORY SLEEP ROUTING: first call COROS_MCP_2 querySleepData for this wake-up date and pass the normalized result as officialSleepRecords. Then combine sleep, HRV, load, completed activities and calendar. Do not invent a readiness score.

Inputs: date (required), officialSleepRecords.

get_sleep_dataB
Read-only

MANDATORY: before calling this tool, first read the same date range with the installed official COROS MCP OAuth sleep tool (COROS_MCP_2 querySleepData), normalize its result, and supply it as officialSleepRecords. Do not call this tool with officialSleepRecords omitted unless the official COROS MCP read failed.

Inputs: endDate (required), startDate (required), officialSleepRecords.

get_workout_detailsA
Read-only

Return the complete COROS definition of one library workout, including every step and target.

Inputs: workoutId (required).

list_activitiesB
Read-only

List completed COROS activities with duration, distance, heart rate, training load, power and elevation.

Inputs: endDate (required), startDate (required), page, size.

list_scheduled_workoutsA
Read-only

List workouts scheduled in the COROS calendar, including IDs required to move or remove them.

Inputs: endDate (required), startDate (required).

list_workoutsB
Read-only

List workouts from COROS Training Hub.

Inputs: name, limit, sportType.

move_scheduled_workoutA

Move a COROS calendar workout to another date without changing its contents. Use list_scheduled_workouts first.

Inputs: newDate (required), idInPlan (required), sourceDate (required).

plan_operational_routeB
Read-only

Build an operational GPX plan for cycling, road running, trail running, walking or hiking: three timing scenarios, named stops, climbs, daylight, fueling and optional weather. Read-only.

Inputs: gpxXml (required), startTimeIso (required), activityType, flatSpeedKmh, +16 more.

preview_daily_adjustmentB
Read-only

MANDATORY SLEEP ROUTING: first call COROS_MCP_2 querySleepData for the required recent wake-up days and pass normalized results as officialSleepRecords. Then preview the daily adjustment. Never change the calendar.

Inputs: date (required), officialSleepRecords.

remove_scheduled_workoutA
Destructive

Remove one workout occurrence from the COROS calendar. Use list_scheduled_workouts first.

Inputs: planId (required), idInPlan (required), planProgramId.

replace_scheduled_workoutB
Destructive

Replace one calendar occurrence with another library workout. The replacement is scheduled before the old occurrence is removed.

Inputs: idInPlan (required), sourceDate (required), replacementWorkoutId (required).

search_exercisesA
Read-only

Search the COROS exercise catalog (~383 strength exercises). Filter by name, muscle group, body part, and/or equipment. Returns exercise names, muscles, equipment, and default sets/reps.

Inputs: limit, query, muscle, bodyPart, +1 more.

shift_calendar_rangeB

Preview or move every scheduled workout in a date range by a fixed number of days.

Inputs: days (required), endDate (required), startDate (required), apply.

simulate_ultra_routeB
Read-only

Build optimistic, probable and conservative timing scenarios from a GPX route, departure time, flat-terrain speed, planned stops and an explicit climbing penalty. Returns sector checkpoints and finish times.

Inputs: gpxXml (required), flatSpeedKmh (required), startTimeIso (required), totalStopMinutes (required), +2 more.

summarize_planned_loadB
Read-only

Summarize planned workout count, duration and distance by sport for a date range. This is planned volume, not physiological COROS Training Load.

Inputs: endDate (required), startDate (required).

swap_calendar_workoutsC

Swap two scheduled COROS workout occurrences between dates while preserving their calendar identities.

Inputs: firstDate (required), secondDate (required), firstIdInPlan (required), secondIdInPlan (required).

taper_readinessA
Read-only

MANDATORY SLEEP ROUTING: first call COROS_MCP_2 querySleepData for the required wake-up-date range and pass normalized results as officialSleepRecords. Then assess taper readiness from load, sleep, HRV and resting heart rate.

Inputs: asOfDate (required), raceDate (required), officialSleepRecords.

update_exercisesB

Fetch the latest exercise catalog from COROS APIs and rebuild the local catalog. Requires authentication. Fetches exercises from the COROS API and i18n strings for human-readable names.

Inputs: sportType.

update_workoutA
Destructive

Safely edit a workout by creating an updated clone. For running/cycling, steps can be replaced. The original is retained unless deleteOriginal=true.

Inputs: workoutId (required), name, sport, steps, +2 more.

validate_structured_workoutA
Read-only

Validate and calculate a structured workout locally without writing anything to COROS.

Inputs: name (required), sport (required), steps (required), overview.

weekly_training_reportA
Read-only

MANDATORY SLEEP ROUTING: first call COROS_MCP_2 querySleepData for the required wake-up-date range and pass normalized results as officialSleepRecords. Then build the seven-day report and comparison.

Inputs: endDate (required), officialSleepRecords.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 56 tools

    Disambiguation3/5

    Several tools cluster under shared prefixes (eight analyze_* tools, six get_* metrics tools) with overlapping analytical territory, such as analyze_completed_activity vs analyze_training_day and analyze_aerobic_decoupling vs analyze_fit_activity. The descriptions are detailed enough to disambiguate most pairs, but the compatibility bridge (coros_read/coros_write) and the multiple MANDATORY sleep-routing tools add selection risk.

    Naming Consistency4/5

    The vast majority of tools follow a consistent snake_case verb_noun pattern (list_workouts, create_workout, analyze_fit_activity, clear_calendar_range). A handful deviate with noun-first or adjectival names (weekly_training_report, daily_training_briefing, taper_readiness, connector_status, coros_capabilities), which breaks the pattern slightly but does not cause confusion.

    Tool Count2/5

    At 56 tools, the server is well past the heavy threshold. Many tools could be consolidated (the eight analyze_* tools, the six calendar range tools, and the four compatibility/bridge tools). While the domain is broad, the surface area feels bloated rather than tightly scoped.

    Completeness4/5

    The domain coverage is exceptionally thorough: full workout library CRUD, calendar scheduling with swaps/shifts/copies, activity retrieval and export, analytics, route planning, fueling, and backup. The notable gap is that sleep-dependent tools explicitly require an external COROS_MCP_2 OAuth tool for official sleep data, meaning the server is not fully self-contained for its stated readiness/reporting workflows.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables Claude to design strength workouts and push them directly to COROS watches via the Training Hub API. It supports searching an exercise catalog, creating workout routines, and listing existing workouts.
      28
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables triathlon coaches and athletes to interact with Garmin Connect, including retrieving health/activity data, building and uploading structured workouts (cycling, running, swimming, brick), and accessing coaching analytics like readiness, load, and performance trends.
      172
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables MCP clients to connect to a privacy-first, self-hostable workout planning and training log, allowing coaching agents to preview and apply program changes while accessing training data through OAuth-protected endpoints.
      AGPL 3.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to find coach-built training programs, coaching brains, races, gyms, classes and sports clinics, preview and build workouts with exercise demos, swap exercises, and plan around a sport or race. With OAuth it can also save workouts and programs, send coach notes to members, and read a member's logged history, planned sessions and lift progress.
      MIT