mcp-garmin-connect
The mcp-garmin-connect server is an LLM-agnostic Model Context Protocol (MCP) server that provides access to personal Garmin Connect health and fitness data, enabling AI assistants to analyze real training, recovery, and health metrics. It can run locally via stdio or as an HTTP server, keeps credentials local, and supports optional demo bridges for DeepSeek, OpenAI, Claude, OpenRouter, and Gemini with opt-in health data sharing.
Key capabilities:
Recovery & health: current recovery status (readiness, HRV, sleep, body battery, training status), sleep duration/scores, daily stress levels, and a compact health summary.
Activities & training: recent activities with summaries and detailed activity info, training volume by sport, native Garmin Training Load status.
Fitness & performance: VO2 Max, FTP, race predictions, heart-rate/power zones, personal records.
Running analytics: 90-day running summary and monthly running stats.
Holistic snapshots: compact health summary or full multi-section Garmin data snapshot.
Prompt templates:
recovery_check,weekly_training_review,activity_analysis,race_plan_context.Developer/privacy: Windows-first CLI with cross-platform Python, local credentials, mocked tests plus optional live smoke tests.
Provides tools to retrieve Garmin Connect data including recovery, sleep, stress, activities, training load, fitness, zones, personal records, and running summaries.
Allows sending Garmin health and activity data to OpenAI's Chat Completions API for natural language queries about training and recovery.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-garmin-connectWhat should my training focus be this week based on my recovery?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-garmin-connect
LLM-agnostic Garmin Connect MCP server for training, recovery, sleep, stress, VO2 Max, race predictions, and running summaries.
Use the same local Garmin tools from MCP clients such as Claude Desktop, Claude Code, Cursor, Continue, Hermes, or from provider-backed demo agents using DeepSeek, OpenAI, or Claude API.
Why This Exists
Most fitness advice from LLMs is generic. This server lets an LLM inspect your real Garmin Connect data first, then answer with context from your activities, recovery markers, HRV, sleep, stress, VO2 Max, and running history.
The core server is provider-neutral. DeepSeek, OpenAI, and Claude integrations are optional demo bridges for clients that do not speak MCP directly.
Related MCP server: claude-garmin
Features
Local MCP server for Garmin Connect over
stdioor Streamable HTTP.14 Garmin tools and 4 prompt templates.
Provider demo bridge for
deepseek,openai,claude,openrouter, andgemini.Windows-first CLI, with cross-platform Python project structure.
Explicit opt-in before Garmin health/activity data is sent to any external LLM provider.
Mocked test suite plus optional live Garmin smoke tests.
Languages And Stack
Area | Technology |
Main language | Python 3.11+ |
Package manager | uv |
MCP server |
|
Garmin access |
|
Provider API calls |
|
Tests | pytest |
Linting | ruff |
Client config examples | JSON, YAML, PowerShell |
Quick Start
uv sync
Copy-Item .env.example .env
notepad .envSet Garmin credentials:
GARMIN_EMAIL=you@example.com
GARMIN_PASSWORD=your-passwordAuthenticate once:
uv run garmin-mcp login
uv run garmin-mcp doctor --liveList available MCP tools:
uv run garmin-mcp toolsRun as a local MCP server:
uv run garmin-mcp serve --transport stdioRun as an HTTP MCP server:
uv run garmin-mcp serve --transport http --host 127.0.0.1 --port 8765HTTP clients can connect to:
http://127.0.0.1:8765/mcpProvider Demo Agents
Provider API access may require a paid account or credits even if the provider's web app has a free tier.
DEEPSEEK_API_KEY=sk-...
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
OPENROUTER_API_KEY=sk-or-...
GEMINI_API_KEY=...Provider | Env key | Default model | API style |
DeepSeek |
|
| OpenAI-compatible Chat Completions |
OpenAI |
|
| OpenAI Chat Completions |
Claude |
|
| Anthropic Messages API |
OpenRouter |
|
| OpenAI-compatible Chat Completions |
Gemini |
|
| Gemini Generate Content API |
Ask through a provider bridge:
uv run garmin-mcp ask "How is my recovery today?" --provider deepseek --allow-external-health-data
uv run garmin-mcp ask "Summarize my running for 90 days." --provider openai --allow-external-health-data
uv run garmin-mcp ask "What should I focus on this week?" --provider claude --allow-external-health-data
uv run garmin-mcp ask "Summarize my monthly running." --provider openrouter --allow-external-health-data
uv run garmin-mcp ask "Check my fitness trend." --provider gemini --allow-external-health-dataThe --allow-external-health-data flag is required because Garmin tool results can be sent to the selected provider.
MCP Tools
Tool | Purpose |
| Readiness, HRV, sleep, body battery, resting HR, training status if available |
| Sleep duration and sleep score trends |
| Daily RHR with 7-day and 30-day trend summaries, up to 30 days |
| Daily stress buckets and average stress |
| Recent normalized activity summaries |
| One activity with training effect fields |
| Volume by sport based on recent activities |
| Native Garmin Training Load when the device/account exposes it |
| VO2 Max, FTP, and race predictions |
| Heart-rate and power zones when available |
| Garmin personal records |
| 90-day running summary with pace, HR, longest and fastest run |
| Monthly running breakdown |
| Compact recovery, sleep, RHR, and stress snapshot |
| Broad multi-section Garmin snapshot |
MCP Prompts
recovery_checkweekly_training_reviewactivity_analysisrace_plan_context
Client Setup
See docs/clients for examples covering:
Claude Desktop
Claude Code
Cursor
Continue
Hermes
Generic stdio MCP clients
Generic HTTP MCP clients
Minimal stdio config:
{
"mcpServers": {
"garmin": {
"command": "uv",
"args": [
"--directory",
"C:\\path\\to\\mcp-garmin-connect",
"run",
"garmin-mcp",
"serve",
"--transport",
"stdio"
]
}
}
}Testing
uv run garmin-mcp doctor
uv run garmin-mcp doctor --live
uv run garmin-mcp tools
uv run ruff check .
uv run pytestOptional live tests are gated and do not run in CI by default:
$env:GARMIN_LIVE_TEST = "1"
uv run pytest tests/liveCurrent local validation target:
ruff: All checks passed
pytest: all mocked tests pass, live test skipped unless enabledPrivacy And Safety
Your .env file and Garmin token cache stay local and are ignored by git.
MCP clients that run locally can call Garmin tools without sending provider API keys to this project. Provider demo commands such as garmin-mcp ask can send Garmin health/activity results to the selected LLM provider, so the CLI requires --allow-external-health-data.
Garmin Disclaimer
This project uses the community garminconnect Python package and Garmin Connect endpoints. Garmin Connect is not a public API for individual open-source projects, and authentication or endpoint behavior may change without notice.
Some metrics depend on Garmin device capabilities. For example, a device may expose VO2 Max and Training Effect but not native Garmin Training Load or Training Status.
Star History
License
This project is licensed under the MIT License.
Publish
Codex does not push this repo. To publish it yourself:
git remote add origin https://github.com/kavakoss/mcp-garmin-connect.git
git push -u origin mainMade by kavakoss.
Inspired by Jack-Abyss/claude-garmin, with a clean-room implementation focused on LLM-agnostic MCP usage.
Available Tools
14 toolsget_activity_detailC
Detailed summary for one activity by Garmin activity ID.
| Name | Required | Description | Default |
|---|---|---|---|
| activity_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only says 'detailed summary' without disclosing what metrics are included, whether any side effects exist, or the response format. This is minimal behavioral disclosure for a data-retrieval tool.
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?
One concise sentence with no redundant words. It is front-loaded with 'Detailed summary' and immediately clarifies the key identifier, making it easy to scan.
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?
While an output schema exists, the description is otherwise minimal. It lacks usage guidance, behavioral detail, and sufficient parameter semantics. For a tool with one parameter and no annotations, this is adequate but leaves clear gaps in when and how to use it.
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 schema has one parameter with 0% description coverage. The description clarifies that the parameter is a Garmin activity ID, adding meaning beyond the bare schema. However, it does not provide format, range, or examples, so it only partially compensates for the coverage gap.
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 indicates the tool returns a detailed summary for one activity, and specifies the unique identifier (Garmin activity ID). It distinguishes this from sibling tools like get_recent_activities, though it lacks an explicit verb like 'retrieves' or 'gets'.
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, such as get_recent_activities for listing activities. The description implies you need a specific activity ID but does not state prerequisites, use cases, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_fitnessB
VO2 max, cycling FTP, and race predictions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description should disclose behavioral traits like read-only nature, data source, or units. It merely lists output metrics without any behavioral context. There is no contradiction, but the description fails to carry the transparency burden.
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 concise phrase, listing three key metrics. It is front-loaded and contains no fluff. However, it's so brief that it verges on being a title rather than a descriptive sentence, so it doesn't earn a 5.
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?
The tool is simple (0 params, output schema present), but the description could offer more context about what these metrics represent or how they're calculated. It's enough to know the tool returns fitness data, but it lacks clarity on scope or source. An output schema may fill the gap, but the description alone is minimal.
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 tool has zero parameters, and the input schema is empty. Per the rubric, a baseline of 4 applies for 0 params. The description doesn't need to explain parameters, and it doesn't, which is acceptable.
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 identifies the tool's purpose: it provides VO2 max, cycling FTP, and race predictions. These specific metrics distinguish it from sibling tools like get_recovery or get_sleep. Though it's a noun phrase rather than a full sentence, the meaning is unambiguous.
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?
There is no guidance on when to use this tool versus alternatives. It doesn't state 'for fitness metrics' or recommend get_recovery for recovery data. The agent must infer usage solely from the listed metrics and sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_full_snapshotC
Comprehensive Garmin data snapshot for holistic analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| load_days | No | ||
| activity_days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description must disclose behavioral traits. It only says 'snapshot' which implies a read-only aggregate, but it does not describe what data is fetched, whether it is expensive, how the load_days and activity_days parameters affect the result, or what the response structure looks like.
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 one-sentence description is technically concise, but it is under-specified and acts as a vague label rather than an informative summary. It uses words that sound comprehensive without actually conveying any concrete details, so the space is not well utilized.
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 an aggregation tool that could replace many sibling calls, the description is severely incomplete. It lacks scope details, parameter semantics, usage context, and relationship to the sibling tools. The existence of an output schema does not compensate for the missing behavioral and usage guidance.
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 load_days or activity_days. The parameter names hint at time ranges, but the agent cannot determine their precise meaning, acceptable units, or how they alter the snapshot without additional documentation.
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 'Comprehensive Garmin data snapshot for holistic analysis' conveys an all-encompassing data retrieval, but it lacks an explicit action verb and doesn't specify which data domains are included. It does not meaningfully distinguish itself from sibling tools like get_sleep or get_stress, other than by the generic 'full' label.
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 instead of or in combination with the sibling tools. The description does not mention scenarios such as 'when you need all data at once' or contrast with single-domain tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_health_summaryC
Compact health snapshot combining recovery, sleep, and stress.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it provides minimal detail. It does not explain what 'compact' means, how the combination works, or what the output structure is, leaving the agent to guess about the tool's behavior.
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, concise sentence with no wasted words. It is front-loaded and easy to parse. However, it omits important contextual details, so it is efficient but not fully comprehensive.
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?
Despite having an output schema, the description is incomplete. It does not provide usage guidelines or parameter semantics, and the tool has multiple similar siblings. More context is needed for an agent to confidently select and invoke this 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 schema has one parameter 'days' with 0% description coverage. The tool description does not mention this parameter at all, so the agent gets no additional semantic context about how 'days' affects the result. The parameter name alone is insufficient.
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 that this tool provides a compact health snapshot combining recovery, sleep, and stress. It uses a specific verb ('get' implied) and resource ('health summary'), and the combined scope distinguishes it from sibling tools like get_recovery, get_sleep, and get_stress.
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 when-to-use guidance is provided. The description implies a combination use case but does not explicitly mention alternatives or when not to use this tool. Given the large sibling set, this lack of guidance could confuse an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_monthly_running_statsC
Monthly running stats for the last N calendar-ish months based on recent activities.
| Name | Required | Description | Default |
|---|---|---|---|
| months | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits itself. It mentions that stats are 'based on recent activities,' which hints at computation from activity data, but it does not explain how activities are aggregated, what 'calendar-ish' means, or whether historical data is required. No side effects or data dependencies are described, leaving significant gaps.
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, efficient sentence with no redundant words. It leads with the core purpose ('Monthly running stats') and conveys the essential time scope, making it well-structured and appropriately sized for the tool's simplicity.
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?
Although an output schema exists, the description lacks sufficient context for an agent to confidently use the tool. It does not clarify the semantics of 'calendar-ish' or 'recent activities,' and with no annotations, the agent cannot assess safety or prerequisites. The sparse description leaves notable gaps in usage and behavioral understanding.
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 schema has 0% description coverage for the 'months' parameter, so the description must compensate. It uses 'N' in the text, which likely corresponds to the months parameter, but it does not explicitly confirm this mapping or explain the default value. The agent cannot be certain how to set this parameter correctly.
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 that the tool provides monthly running statistics over a recent time range, which distinguishes it from sibling tools like get_running_summary or get_recent_activities. However, 'calendar-ish months' is vague and the specific metrics included are not mentioned, leaving some ambiguity about the exact output.
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 gives no explicit guidance on when to use this tool versus alternatives such as get_running_summary or get_recent_activities. It lacks any mention of prerequisites, exclusions, or comparative context, so the agent receives no direction for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_personal_recordsC
Personal records returned by Garmin Connect.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior but only says data is 'returned'. It does not explain whether the data is live, filtered, or what scope personal records cover, nor any side effects or limitations.
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 very brief—a single fragment—but this brevity results in under-specification. It lacks a clear verb or complete sentence structure, making it less useful despite being short.
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 rich set of sibling tools and no annotations, the description is inadequate. It fails to clarify what 'personal records' means, when to use this tool, or what distinguishes it from similar health/fitness tools.
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?
With zero parameters, the schema fully covers the invocation contract (none required). The description adds no parameter info, but no params minimizes the need; baseline 4 is appropriate.
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 states that personal records are returned from Garmin Connect, giving a resource and source, but uses no imperative verb and lacks specificity about what constitutes 'personal records'. It does not distinguish from siblings like get_fitness or get_running_summary.
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. The description only identifies the resource, offering no context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recent_activitiesC
Recent Garmin activities with normalized sport-aware summary fields.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'normalized sport-aware summary fields', which gives some insight into the response structure, but does not disclose important aspects like whether this is a read-only operation, how pagination works (though limit/days params exist), or any rate limits. The absence of side-effect warnings is a gap since mutation tools would need such disclosure, but here the tool appears read-only; still, the description does not explicitly state that.
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, front-loaded with the core purpose ('Recent Garmin activities') and adds a meaningful qualifier about the output fields. It is efficient and avoids redundancy. However, it is arguably too sparse, sacrificing essential details for brevity, but the conciseness itself is well-executed.
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?
The tool has an output schema, so the description need not explain return values, but it should still provide enough context for an agent to know when to invoke it. The description lacks usage guidelines and parameter semantics, and while the output schema may cover the return shape, the description does not connect the tool's purpose to the available parameters. The low parameter coverage and missing guidance make it incomplete for a tool with only two optional parameters.
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 mention the 'days' or 'limit' parameters at all. The description only says 'recent', which implies a time window but does not explain how the 'days' parameter controls that window or what 'limit' does. With no parameter documentation in either the schema or description, the agent has no way to know how to set these parameters correctly.
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 identifies that the tool returns recent Garmin activities, and the phrase 'normalized sport-aware summary fields' adds specificity about the output format. It distinguishes from sibling tools like get_activity_detail (which likely returns a single activity's detail) by implying a summary-level list. However, it lacks an explicit verb like 'retrieve' or 'list', and the differentiation from siblings is only implicit.
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 get_activity_detail or get_training_load. It does not mention any prerequisites, exclusions, or scenarios where this tool is preferred. The only hint is 'recent', which is vague. Without explicit usage context, an agent may not know if this is the right tool for a given query.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recent_loadB
Training volume aggregated by sport over the last N days.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the transparency burden. It only states that data is aggregated, without disclosing whether this is a safe read operation, what data sources are involved, or any potential side effects or limitations. The description is too sparse to inform the agent about behavioral traits beyond the basic aggregation.
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 concise sentence that is front-loaded with the key concept ('Training volume aggregated by sport') and avoids any wasted words. It is appropriately sized for a simple tool with one parameter.
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?
The tool is relatively simple with one parameter and an output schema present, so the description does not need to explain return values. However, it lacks context about how this relates to sibling tools (e.g., get_training_load) and what 'training volume' specifically means (units, sport types). The output schema may fill some gaps, but the description alone is minimally 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?
The schema has one parameter 'days' with a default of 28 but no description field (0% coverage). The description's 'last N days' implies that 'days' represents the time window, adding meaning that the schema lacks. However, it does not explain the default value, allowed range, or format, leaving some ambiguity.
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 the tool's function: 'Training volume aggregated by sport over the last N days.' It specifies the resource (training volume), the aggregation dimension (by sport), and the time window (last N days). This distinguishes it from siblings like get_training_load, which likely focuses on overall load without sport breakdown.
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 explicit guidance on when to use this tool vs alternatives. It does not mention exclusions or refer to sibling tools like get_training_load or get_recent_activities. The usage context is only implied by the description, offering no help for an agent deciding between similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recoveryB
Current recovery state: readiness, HRV, sleep, body battery, and status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full responsibility. It discloses the data content but does not indicate whether this is a read-only operation, whether it has any latency or prerequisites, or any other behavioral traits. A simple getter like this would benefit from a statement about it being a read-only snapshot.
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, front-loaded phrase that directly names the resource and its key components. Every word adds value, with no filler or unnecessary elaboration.
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 tool with zero parameters and an output schema present, the description adequately identifies the resource and enumerates the main data points. It could optionally clarify that it returns only the current state, but the tool's simplicity makes the description 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?
The tool has zero parameters, and the schema coverage is 100% with empty properties. Since there are no parameters to explain, the description is not required to compensate; per the baseline for zero-parameter tools, a score of 4 is appropriate.
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 identifies the specific resource (recovery state) and lists its components (readiness, HRV, sleep, body battery, and status), which distinguishes it from sibling tools like get_sleep and get_fitness. However, it uses a noun phrase rather than an explicit verb like 'Gets', making it slightly less direct than ideal.
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?
There is no guidance on when to use this tool versus its many siblings. The description simply states what it returns, leaving the agent to infer the appropriate context without any exclusions or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_running_summaryC
Running summary: sessions, distance, pace, HR, longest run, fastest run, monthly split.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It does not state that the tool is read-only, nor does it describe any behavioral characteristics such as data range, aggregation, or limitations. The 'days' parameter that controls the summary window is not mentioned, leaving the agent uninformed about how the operation behaves.
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, concise sentence that immediately lists the key contents of the summary. It is well-structured and front-loaded with the most important information, with no unnecessary words.
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?
While an output schema exists to cover return values, the description is incomplete given the available context. It does not explain the 'days' parameter, does not distinguish from sibling tools like get_monthly_running_stats, and lacks usage guidance. The tool is simple, but the missing parameter semantics and context leave significant gaps.
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 only parameter 'days' has zero description coverage in the tool description. The schema provides type and default but no semantic meaning. The description fails to explain what 'days' represents or how it affects the summary, offering no 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 clearly indicates a running summary with specific metrics (sessions, distance, pace, HR, etc.). The purpose is evident but lacks an explicit verb like 'get' or 'list' in the description itself. It doesn't explicitly distinguish it from siblings like get_monthly_running_stats, but the metric list provides some differentiation.
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. There is no mention of preferred scenarios, prerequisites, or exclusions. The description is purely a noun phrase without any usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_sleepB
Sleep duration and sleep scores for the last N days.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it returns sleep data for the last N days, but does not clarify whether it returns per-day values, aggregates, or any details about the output format or data source. This leaves significant behavioral ambiguity.
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, front-loaded sentence with no superfluous words. It efficiently conveys the core purpose within 10 words.
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 read tool with one parameter and an output schema, the description provides the essential purpose. However, it lacks guidance on how to interpret 'sleep scores' and does not differentiate when to use this tool relative to closely related siblings, leaving some contextual gaps.
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. The phrase 'last N days' directly explains the sole parameter (days), indicating its purpose. However, it does not provide details like valid range, inclusion of today, or behavior with edge cases, so it only partially compensates.
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 indicates the tool returns sleep duration and sleep scores for a specified period, distinguishing it from sibling tools like get_recovery and get_stress. Though lacking an explicit verb, the noun phrase accurately conveys the tool's purpose and scope.
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 usage guidance is provided. The description does not mention when to use this tool versus alternatives such as get_recovery or get_health_summary, nor does it offer any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_stressC
Daily all-day stress levels and stress duration buckets.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool returns daily all-day stress levels and stress duration buckets, which is useful behavioral context. However, it does not explain what 'stress duration buckets' mean, whether there are any side effects, or any time-related nuances like timezone handling.
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 concise sentence with no filler words. 'Daily all-day' is slightly redundant, and the phrase lacks a verb, but overall it is appropriately short and front-loaded with the key term 'stress'.
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?
The tool is simple, but the description fails to provide enough context for the meaning of 'stress duration buckets' or how the 'days' parameter works. Given the presence of many sibling tools, it does not help the agent decide when to select this tool over others. While an output schema exists, the description still leaves gaps in parameter semantics and usage context.
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 schema includes one optional parameter 'days' with a default of 7, and schema description coverage is 0%. The description says 'Daily' which hints that the parameter likely controls the number of days of data, but it never explicitly explains the parameter's meaning or format. Since coverage is low, the description should compensate, but it only indirectly relates to the parameter.
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 identifies the resource (stress) and the scope (daily all-day levels, duration buckets), which distinguishes it from siblings like get_recovery and get_sleep. However, it lacks an explicit verb such as 'retrieves' or 'returns', instead using a noun phrase.
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. With sibling tools for related metrics (recovery, sleep, activities), it does not mention when stress data is needed or when other tools would be more appropriate, nor does it note any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_training_loadB
Garmin training load status, acute/chronic load, and load focus.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the full burden of disclosing behavioral traits. It only lists the data categories, but does not mention whether the operation is safe/read-only, whether any authentication is required, or any rate limits. It also doesn't describe the time period or units, though the output schema may cover those details. This falls short of the transparency expected for a tool with no annotation support.
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, compact phrase that lists exactly the essential data elements. Every word earns its place, with no filler or repetition. It is appropriately sized for a simple no-parameter getter and is easily scanned.
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 tool's simplicity (no parameters) and presence of an output schema, the description is nearly complete. It conveys the core purpose and the kind of data returned. It does not elaborate on edge cases or typical use contexts, but for a basic read-only getter, this is sufficient. A slightly more explicit statement about data scope would push it to 5.
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 tool has zero parameters, and the schema coverage is 100% (vacuously). The baseline for 0 params is 4. The description adds no parameter-specific explanation, but none is needed since there are no parameters to clarify. The short description does not detract from schema adequacy.
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 identifies the resource as Garmin training load and lists specific components (status, acute/chronic load, load focus), which distinguishes it from sibling tools like get_recovery or get_sleep. However, it lacks an explicit verb (e.g., 'returns' or 'gets'), relying on the tool name to imply the action, so it falls just short of a perfect score.
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. It does not mention any prerequisites, typical use cases, or cases where another sibling tool (e.g., get_recent_load) would be more appropriate. The only context is the data content, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_zonesA
Heart-rate and power zones from Garmin profile data when available.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must convey behavior. It adds the caveat 'when available,' which hints that data may be absent, but does not explain what happens in that case (e.g., empty response, error). There are no details on data freshness or other behavioral traits.
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, front-loaded sentence with no wasted words. It states the key subject and the availability caveat immediately, making it highly concise and well-structured.
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 no-parameter read tool with an output schema, the description is compact but sufficient. It names the data type and source, and the 'when available' qualifier alerts the agent to potential non-availability. The output schema likely covers return structure.
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 tool has zero parameters and complete schema coverage, so no parameter explanation is needed. The description adds value by specifying the types of zones (heart-rate, power) and their source (Garmin profile), enriching understanding beyond the empty 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 clearly identifies the resource (Garmin profile data) and content (heart-rate and power zones), distinguishing it from sibling tools focused on recovery, sleep, or stress. The verb is implied by the tool name but not explicitly stated, which is a minor gap.
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 gives no guidance on when to use this tool versus alternatives like get_recovery or get_training_load. It lacks context on typical scenarios or exclusions, leaving the agent to infer usage solely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Tools generally target distinct data types (recovery, sleep, stress, activities, load, fitness). However, composite tools like get_health_summary and get_full_snapshot overlap with individual metrics, and get_running_summary vs get_monthly_running_stats could be confused. Descriptions provide guidance, so most tools are distinguishable.
All tools follow a consistent 'get_' prefix with clear noun suffixes (e.g., get_recovery, get_sleep, get_activity_detail). The naming pattern is uniform and predictable.
14 tools is within the expected range for a Garmin Connect server and covers all major data domains. However, some redundancy (e.g., get_health_summary and get_full_snapshot) means a few tools could be consolidated, slightly reducing focus.
The server provides comprehensive read-only coverage of Garmin Connect: recovery, sleep, stress, activities, activity details, training load, fitness metrics, zones, records, and running-specific summaries. There are no obvious missing data types for a read-only health/fitness API.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Remote MCP server for training, nutrition, wellness, and performance data with OAuth 2.0.
Garmin data in Claude & ChatGPT via the Garmin Health API. OAuth sign-in, no password sharing.
Multi-tenant hosted MCP server for Oura Ring — 21 read-only tools, OAuth per user.
Pace is a remote MCP server that exposes wearable and fitness data to Claude via the Model Context Protocol. It connects to Garmin, Oura, Whoop, Polar, Fitbit and 20+ devices and provides 15 tools for querying sleep, activity, recovery, and training data. Hosted on Google Cloud Run, OAuth 2.1 authentication, Streamable HTTP transport. Instructions: First you need to create an account at: https://pacetraining.co and connect your wearables. After that you can connect the remote Server via Custom Connector in Claude and OAuth 2.1 Flow startet.
Related MCP Servers
- FlicenseBqualityDmaintenanceA Model Context Protocol server that integrates Garmin Connect data with LLMs to provide personalized running analysis and training plans. It enables users to monitor performance metrics, manage training loads, and receive data-driven workout suggestions based on health indicators like VO2 Max and recovery status.435
- AlicenseNot gradedqualityBmaintenanceMCP server that connects Garmin Connect data to Claude, enabling training analysis, recovery checks, and personalized plans based on real metrics like HRV, training load, and activities.14MIT
- AlicenseAqualityBmaintenanceA Model Context Protocol (MCP) server for Garmin Connect integration. Access your activities, health data, training metrics, and more through Claude and other LLMs.2261MIT
- AlicenseNot gradedqualityCmaintenanceMCP server to interact with Garmin Connect, enabling retrieval of health, activity, and device data through natural language.63MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/kavakoss/mcp-garmin-connect'
If you have feedback or need assistance with the MCP directory API, please join our Discord server