Skip to main content
Glama
Umayrkaleem

Garmin Local MCP

by Umayrkaleem

Garmin Local MCP

Create and manage Garmin Connect workouts through an AI app that supports local MCP servers. Runs on your computer, uses your own Garmin session, and exposes a small set of tools rather than the full Garmin API.

Status: local alpha. Python 3.12, macOS and Linux. No Windows support, hosted connector, or multi-user service in this release. This is an unofficial project, not affiliated with Garmin. Garmin authentication and endpoints can change.

What it does

  • Preview structured workouts without login or uploading.

  • Search Garmin's bundled strength exercise catalog.

  • Read compact activity, workout-library and calendar summaries.

  • Create, update in place, schedule and unschedule workouts when writes are enabled.

  • Support timed warmups, left/right steps, supersets, exercise notes and rest timers.

Supports running, cycling, cardio and strength. Swimming/multisport are outside v1. The pinned library says walking/hiking workout models cannot be uploaded. Strength loads accept pounds only (weight_lb). Kilogram input is disabled until the upstream representation is independently verified. Do not supply kg values in the pound field.

Related MCP server: Garmin Workouts MCP Server

Install and connect

Install uv, download or clone this repository, and enter its directory. Then:

uv sync --locked
uv run --locked garmin-mcp login

Enter your email, password and MFA code in the terminal, never in an AI chat. Every interactive login authenticates a fresh session; it replaces any previous local session only after successful authentication and saving. Each person should use their own computer/user account or a separate private token directory.

Add the following to an AI client's local MCP server configuration, replacing the command with the absolute path to your checkout:

{
  "mcpServers": {
    "garmin-local": {
      "command": "/ABSOLUTE/PATH/garmin-local-mcp/.venv/bin/garmin-mcp",
      "args": ["serve"]
    }
  }
}

The client starts this process when it needs it. Preview and exercise search work without login. There is no HTTP listener. This local process configuration is not an installable phone connector; phone-only use needs a separately built remote service or a supported connection to a running computer.

To enable writes, change the arguments to ["serve", "--allow-writes"] and restart the MCP connection. Configure your AI client to ask for approval for write calls. The flag enables tools; it is not per-call human approval. Tool annotations are hints and cannot enforce a client's approval UI.

Example prompt:

Search for the exact Garmin names, then preview a strength workout with three sets of ten dumbbell rows per arm at 15 lb per dumbbell and 60 seconds rest after both arms. Wait for me to review before creating it.

Tokens are saved to ~/.local/share/garmin-local-mcp/garmin_tokens.json. The parent directory must be owned by you with mode 700 and the token file with mode 600. Symlinks in the token path are rejected. Use --token-dir /absolute/private/path on both login and serve for another location. Tokens are plaintext files protected by permissions, not encrypted or stored in a system keychain.

MCP tools

Tool

Behavior

preview_workout

Validate/build a typed workout; return compact steps and totals without uploading

search_exercises

Search the bundled catalog for exact exercise names

list_activities

Paginated date, type, distance, duration, average HR and training effects

list_workouts

Paginated ID, name, sport and estimated duration

list_scheduled_workouts

Schedule and workout IDs over up to 31 days

create_workout

Write-enabled only: create a new [AI] workout

update_workout

Write-enabled only: replace an [AI] workout's complete definition while keeping its ID

schedule_workout

Write-enabled only: schedule an [AI] workout

unschedule_workout

Write-enabled only: verify the calendar entry and its [AI] workout, then remove the entry

No delete, generic API, raw payload, filesystem or shell tools are exposed. Read tools return summaries, not full workout definitions. The MCP write guard requires a name beginning [AI] ; this reduces accidental edits but is not proof of ownership. Untagged workouts can be updated using the explicit saved-plan CLI below. The tools do not push workouts to a watch: send them from Garmin Connect.

See the exported tool schemas. Unknown inputs are rejected. Repeats are one level deep, with at most 500 expanded steps. The local validator's bounds do not guarantee a watch will accept every possible workout.

Workout input

{
  "workout": {
    "name": "Easy intervals",
    "sport": "running",
    "steps": [
      {"kind": "warmup", "duration_seconds": 300},
      {"kind": "repeat", "count": 3, "skip_last_rest": true, "steps": [
        {"kind": "interval", "distance_meters": 500,
         "target": {"kind": "pace_seconds_per_km", "low": 300, "high": 330}},
        {"kind": "recovery", "duration_seconds": 60}
      ]},
      {"kind": "cooldown", "duration_seconds": 300}
    ]
  }
}

Pace uses seconds/km (300 means 5:00/km). HR targets use heart_rate_bpm with low/high values. Each executable step has exactly one of duration, distance, or reps. Strength steps use an exact exercise name from search; add weight_lb and notes as needed. Omit a load when unknown; zero is an explicit value.

Use notes to distinguish total weight, per dumbbell, per side, or added plate weight. For unilateral exercises, use separate left/right steps with notes, followed by one rest. A superset is a repeat group with both exercises and then rest. skip_last_rest omits the group's final rest. Notes also support exercise aliases when the catalog lacks an exact movement; the caller must review them.

Workout and step notes are preserved. There is no automatic weight progression. Preview duration sums fixed-time steps and programmed rests, accounting for skipped final rests. It excludes distance and repetition time, is marked partial when appropriate, and supplies that partial value to Garmin's estimate field.

Reusable saved plans

The synthetic example demonstrates the plan format. It is not a recommended training program and its ID is a placeholder.

mkdir -p private-workouts
cp examples/saved-workout.json private-workouts/my-workout.json
# Edit workout_id, expected_name and the complete workout definition.
# Obtain the actual ID/name using list_workouts or Garmin Connect.
uv run --locked python scripts/saved_workout.py private-workouts/my-workout.json

The command above only previews. After reviewing the plan, apply explicitly:

uv run --locked python scripts/saved_workout.py private-workouts/my-workout.json --apply

This CLI can update an existing untagged workout. It checks the exact ID, current name and sport, preserves the name/ID, skips writes when the definition already matches, and verifies the result. It replaces the full routine, not individual steps. Never apply the example unchanged. Private routines are gitignored and excluded from release archives. They still contain personal information: keep local copies and backups private.

Reuse the saved workout each week; re-uploading is unnecessary. To change it, edit the plan, preview, apply once, then send the updated version to your watch. Calendar scheduling, recurring jobs, and automatic progression are not created by this workflow.

Security, reliability and verification

  • Your AI provider receives the data returned by tools. Activity summaries omit GPS and account/profile fields. Treat Garmin text as data, not instructions.

  • Logging goes to stderr; upstream Garmin response logging is suppressed and API errors are sanitized. No application payload logs or recordings are created.

  • Tokens grant broader account access than the tool allowlist. Removing a local token file is not server-side revocation. See SECURITY.md.

  • Preview is a dry run, not an authorization token. Review actual write arguments.

  • Calls are serialized. The wrapper does not retry writes. Upstream may refresh authentication and repeat a request rejected with 401. Network failures can occur after a write succeeds; inspect Garmin before repeating create/schedule.

  • Unscheduling fails closed if it cannot identify the schedule's workout using workoutScheduleId and workoutId. That response shape still needs live testing.

  • Login, creation, and in-place strength updates with pound values, timed steps, repeats, supersets and notes have been read-back verified on one account. Device display/execution, other accounts, running/cycling uploads, and scheduling are not comprehensively live-tested. Read-back does not prove watch compatibility.

  • Offline tests use synthetic data and exercise validation, privacy filtering, write guards, token permissions and the real stdio protocol. CI does not contact Garmin. See CONTRIBUTING.md for commands.

The underlying API is provided by python-garminconnect, with FastMCP handling MCP. Runtime dependencies are pinned and uv.lock captures the full environment. Review updates deliberately.

License

MIT. Dependency licenses remain their own.

Available Tools

5 tools
list_activitiesB
Read-only

Recent activities, newest first. Returns selected metrics without GPS, account fields, or raw responses.

NameRequiredDescriptionDefault
limitNo
startNo

Output Schema

NameRequiredDescription

No output parameters

TDQS

B3/5.0
Behavior4/5

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description still adds genuine information beyond that: the ordering guarantee ('newest first') and an explicit statement of what is excluded from the payload (GPS, account fields, raw responses), which tells the agent the result is a trimmed projection rather than full records.

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?

Two short sentences with no filler; the 'newest first' ordering is front-loaded. The brevity is efficient, though it borders on under-specification given how little else is said.

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?

An output schema exists, so return-value detail is not required, and annotations cover the safety profile. However, for a paginated list tool with two undocumented parameters and an ambiguous boundary against list_workouts, the definition leaves gaps an agent would need filled before calling it confidently.

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

Parameters2/5

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

Schema coverage is 0% and the description never mentions the two parameters. 'limit' and 'start' have defaults, ranges, and obvious pagination intent from their names, but the description offers no clarification of offset behavior or page-size semantics, so it fails to compensate for the documentation gap.

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

Purpose3/5

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

The description names the resource ('Recent activities, newest first') and the shaping of the payload, but it never states an explicit retrieval verb and never distinguishes 'activities' from the sibling 'list_workouts' / 'list_scheduled_workouts'. An agent must guess whether an activity and a workout are the same entity here.

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?

There is no when-to-use guidance, no prerequisite context, and no reference to any of the four sibling tools. The agent gets no signal about when this tool is preferred over list_workouts or search_exercises.

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

list_scheduled_workoutsB
Read-only

List workout schedule IDs and associated workout IDs in a range of up to 31 days.

NameRequiredDescriptionDefault
end_dateYes
start_dateYes

Output Schema

NameRequiredDescription

No output parameters

TDQS

B3.3/5.0
Behavior3/5

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds genuinely new behavioral context in the 31-day maximum range, but it does not say what happens when the range is exceeded (error vs. truncation) or how results are ordered.

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?

A single front-loaded sentence with no filler; every clause (schedule IDs, workout IDs, 31-day cap) carries information an agent needs.

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?

An output schema exists, so return-shape explanation is unnecessary, and annotations cover the safety profile. However, for a tool whose main risk is the range limit, the definition omits the over-limit behavior and any differentiation from list_workouts, leaving meaningful gaps.

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 carry the param burden. It does clarify that the two date parameters define a bounded range capped at 31 days, but adds nothing about date format, inclusivity of endpoints, or timezone handling beyond the schema's 'format: date'.

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?

Names a specific verb and resource ('List workout schedule IDs and associated workout IDs'), which is clearly narrower than the sibling list_workouts. It does not explicitly contrast itself with list_workouts or preview_workout, so an agent must infer the distinction from the entity names alone.

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 only usage constraint given is the 31-day range cap; there is no statement of when to choose this over list_workouts or preview_workout, nor any stated precondition for the date inputs. Usage is implied rather than guided.

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

list_workoutsB
Read-only

List workout names, IDs, sport and duration. Other workouts can be read but only [AI] workouts can be changed.

NameRequiredDescriptionDefault
limitNo
startNo

Output Schema

NameRequiredDescription

No output parameters

TDQS

B3/5.0
Behavior3/5

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds a genuinely useful caveat about workout mutability ("only [AI] workouts can be changed"), though it sits oddly on a list tool and doesn't explain pagination behavior or coverage across the account.

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?

Two short sentences with the returned-fields summary front-loaded; nothing is padded. The second sentence is slightly tangential to a listing operation but is short enough to earn its place as context.

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?

An output schema exists, so return values needn't be explained, and the annotations cover safety. However, the pagination contract (defaults, max page size, how to page through) is absent from both the description and the schema, leaving a real gap for an agent listing potentially many workouts.

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

Parameters2/5

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

Schema description coverage is 0% for the two parameters (limit, start), so the description carries the burden of explaining paging — and it says nothing about limit, offset, or defaults. An agent must infer from parameter names alone that this is a paginated endpoint capped at 50 items.

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?

Clear verb+resource ("List workout names, IDs, sport and duration") and it enumerates the returned fields, so an agent knows exactly what comes back. It does not explicitly contrast with siblings like list_activities or list_scheduled_workouts, so differentiation relies on the word "workouts" alone.

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 statement of when to call this versus list_activities, list_scheduled_workouts, or preview_workout, and no prerequisites. The second sentence about which workouts can be changed hints at a downstream workflow but never says to use this tool for that purpose.

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

preview_workoutA
Read-only

Validate and preview a workout without authentication or uploading. Pace is seconds/km; HR is bpm. Repeats have one level. Duration totals exclude distance/repetition steps.

NameRequiredDescriptionDefault
workoutYes

Output Schema

NameRequiredDescription

No output parameters

TDQS

A3.9/5.0
Behavior4/5

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

Annotations already declare readOnly/non-destructive/closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: no auth or upload side effects, and that duration totals deliberately exclude distance and repetition steps, which explains computed output rather than restating annotations.

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?

Four short sentences, each carrying a distinct piece of information (purpose, auth/upload behavior, units, nesting and totals rules). Front-loaded with the action and free of filler.

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?

An output schema exists, so return values need no explanation, and the description covers the tricky structural rules an agent could get wrong. Slight gap: nothing warns about the 50-step/20-item limits or what a validation failure looks like, though the output schema likely covers the latter.

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?

Schema description coverage is 0%, so the description must carry the load, and it delivers the highest-risk semantics: pace is seconds/km and HR is bpm for target ranges, and repeats nest only one level deep. It leaves other nested fields (reps, skip_last_rest, weight_lb, sport) undocumented, but their names and enum values are largely self-explanatory.

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?

States a specific verb pair (validate and preview) against a specific resource (a workout), so the agent knows exactly what happens. It is clearly not a lister like the sibling tools, but the description never names those siblings or explicitly contrasts itself with them.

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?

"Without authentication or uploading" implies this is the dry-run path before a real create, which is useful implied usage guidance. However, no explicit when-to-use/when-not-to-use statement or named alternative is given, so the agent must infer the workflow position.

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

search_exercisesA
Read-only

Search the bundled strength catalog. Use the exact returned name in an exercise step.

NameRequiredDescriptionDefault
termYes
limitNo

Output Schema

NameRequiredDescription

No output parameters

TDQS

A3.5/5.0
Behavior4/5

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

Annotations already declare readOnly/closed-world/non-destructive, so the safety profile is covered. The description adds two facts annotations cannot: the catalog is bundled (static, not external) and results must be reused verbatim downstream. It does not say how matching works or whether results are ranked.

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?

Two short sentences, no filler, and the operational constraint is front-loaded after the purpose. Nothing is wasted.

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?

The output schema exists, so return values need no explanation, and the exact-name contract is covered. But with two undocumented parameters at 0% schema coverage, the search semantics an agent needs to call this correctly are absent.

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

Parameters2/5

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

Schema description coverage is 0%, so the description carries the full burden, yet it never mentions 'term' (is it substring, prefix, fuzzy?) or 'limit'. An agent must guess whether 'bench' matches 'bench press' or only exact tokens.

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?

States a specific verb and resource ('Search the bundled strength catalog'), which is unambiguous. Sibling tools are all list_*/preview_* on different domains, so the resource alone differentiates it, though the description never names them.

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 second sentence implies downstream usage ('use the exact returned name in an exercise step'), which is genuinely useful routing context. However, there is no statement of when to search versus when the catalog is unnecessary, and no alternative is named.

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

Tool Schema Changelog

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

  1. 5 tool updatesv0.1.0
    • First observedlist_activities
    • First observedlist_scheduled_workouts
    • First observedlist_workouts
    • First observedpreview_workout
    • First observedsearch_exercises

TDQS

A3.5/5.0

Scored across 5 tools

Disambiguation5/5

Each tool has a clearly distinct target: activities, workout definitions, scheduled workouts, workout preview/validation, and exercise catalog search. The two workout-listing tools are related but their descriptions make the distinction clear.

Naming Consistency5/5

All tool names use consistent snake_case verb_noun conventions: list_*, preview_*, and search_*. The pattern is predictable and easy to reason about.

Tool Count5/5

Five tools is a compact, well-scoped set for a local Garmin companion server. Each tool covers a distinct read or validation capability without excessive surface area.

Completeness2/5

The set only lists activities/workouts/schedules and previews workouts; it lacks tools to create, update, delete, or actually schedule/upload workouts despite implying changes to [AI] workouts. This leaves major lifecycle gaps for an agent trying to manage Garmin workouts.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    Exposes Garmin Connect data and workout management to AI agents, supporting tools, resources, and prompts for health data, workout creation, and coaching workflows.
    1
    -
  • A
    license
    A
    quality
    D
    maintenance
    Brings Garmin training data into Claude via Intervals.icu, enabling querying of activities, wellness, and planned workouts, as well as creating structured workouts that sync back to the Garmin watch.
    9
    1
    MIT