Daash
Server Details
Daash connects Garmin Connect to ChatGPT and Claude. Your assistant reads your runs, splits, sleep, HRV, Body Battery and recovery, and writes structured workouts and whole training plans to your Garmin calendar, so they're on your watch at the next sync. Free, hosted, open source. Works on free Claude.
- Status
- Healthy
- Uptime
- 95.5% over the last 24 hours
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 23 tools
Almost every tool pairs a distinct verb with a distinct resource (workout CRUD, plan lifecycle, activity reads, health reads, crew management). The few soft edges are get_plan vs get_progress (both render an 'interactive plan card', one forward-looking and one retrospective) and create_workout vs create_strength_workout, which have different schemas but adjacent purposes. The detailed descriptions resolve these in practice, so an agent can pick correctly with care.
Every name is snake_case verb_noun (create_plan, get_sleep_data, unschedule_workout, update_crew), with a small predictable verb vocabulary: create/get/list/update/delete/remove/schedule/unschedule/join/leave/find. The noun matches the resource being acted on, so names sort into obvious families (plan, workout, crew, activity, health).
23 tools is on the heavy side, but the server spans three genuinely separate surfaces (Garmin workout library/calendar, training plan lifecycle, health/activity reads, plus crew/social), and each surface needs its CRUD set. No tool looks like filler, though a couple (get_progress alongside get_plan) sit near the edge of necessity.
Workout CRUD is fully covered (create, list, get, update, delete, schedule, unschedule) and crew management covers join, leave, update, and read. The main gap is the plan lifecycle: create, read, and remove exist but there is no update_plan, so tweaking an existing block means removing and recreating it. Read-only activity and health tools are appropriate given the Garmin API constraints.
Available Tools
23 toolscreate_planAInspect
Create a whole training block at once: each session built as a structured workout and scheduled on its date in the user's Garmin calendar. Every session is checked before anything is created, so a mistake leaves no half plan. Each workout's name ends with the plan code after a middle dot, "Threshold 5x1k · HM"; nothing is stored outside Garmin. The result is the new block drawn as an interactive plan card.
Args: goal: What the block is for, e.g. "Half marathon, 1:40, 15 November". sessions: One per session, any order, at most 150: "date" (YYYY-MM-DD, today to 30 weeks out), "name" (short, as on the watch: "Long run 18k"), "steps" (as for a single workout), and optional "sport" (running by default; "cycling", "swimming" or "strength" too, for a triathlon block or a runner's gym days), "description", "pool_length_meters" (25 by default) and "phase" (one short word such as "Base", "Build", "Peak" or "Taper", the taper included; the card bands the weeks by it). A strength session has "exercises" (as for a strength workout) instead of "steps". Days without a session are rest days. label: 2 or 3 letters or digits for the plan code, e.g. "HM", "10K", "MAR". From the goal when omitted. name: A short name for the block, shown as the card's title, e.g. "Marathon build". method: The methodology in a few words, shown under the name, e.g. "80/20". milestones: Up to 4 points on the way to the goal, drawn as a timeline: {"label": "Half check", "date": "2026-11-29", "target": "1:22"}, date and target optional.
Inputs: goal (required), sessions (required), name, label, +2 more. Returns: object
create_strength_workoutAInspect
Create a new strength workout in the user's Garmin workout library. It never edits an existing one. Exercise names come from Garmin's catalogue; when a name matches more than one exercise, the result lists the candidates and nothing is created.
Args: name: Shown in Garmin Connect and on the watch. exercises: Ordered list of blocks, each with "exercise" (catalogue name, e.g. "Barbell Bench Press"), "sets" (default 3), "reps" (default 10), "rest_seconds" (rest after each set, default 90) and optional "weight_kg". Example: [{"exercise": "Barbell Bench Press", "sets": 4, "reps": 8, "rest_seconds": 120, "weight_kg": 70}, {"exercise": "Cable Triceps Pushdown", "sets": 3, "reps": 12, "rest_seconds": 60}] description: Optional note stored with the workout.
Inputs: name (required), exercises (required), description. Returns: object
create_workoutAInspect
Create a new structured workout in the user's Garmin workout library. It never edits an existing one. A workout reaches the watch once it is scheduled on a date.
Args: name: Shown in Garmin Connect and on the watch. steps: Ordered steps, each with "type" (warmup, interval, recovery, rest, cooldown or repeat) and exactly one of "duration_seconds", "distance_meters" or "until_lap": true (the step ends on the lap button). A repeat is {"type": "repeat", "times": 5, "steps": [...]} and can't contain another repeat. Optional target on a step: "pace" (min/km, "4:05" or ["4:00", "4:10"]), "hr" (bpm [150, 165], or a Garmin zone such as "z2" or "z3-z4") or "power" (watts, 250 or [240, 260]; a share of the FTP set in Garmin, "95%" or ["88%", "94%"]; or a power zone, "z3"). A pace target narrower than 5 s/km either side is widened to that, and a single power value becomes a range 5% either side. Example, 15 min warm-up, 5 x 1 km at 4:05 with 90 s recoveries, 10 min cool-down: [{"type": "warmup", "duration_seconds": 900}, {"type": "repeat", "times": 5, "steps": [{"type": "interval", "distance_meters": 1000, "pace": "4:05"}, {"type": "recovery", "duration_seconds": 90}]}, {"type": "cooldown", "duration_seconds": 600}] sport: running (default), cycling, swimming, walking or hiking. description: Optional note stored with the workout. pool_length_meters: For a swim, 25 (default) or 50.
A swim's steps are whole pool lengths (100, 200...), each with an optional "stroke": freestyle, backstroke, breaststroke, butterfly, im, drill or any. Its "pace" is per 100 m ("1:45") and shows on the step as a note rather than an alert. A "rest" with no duration waits for the lap button; "duration_seconds" fixes its length. A "note" (e.g. "kick with board") shows on the step.
Inputs: name (required), steps (required), date, sport, +2 more. Returns: object
delete_workoutADestructiveInspect
Delete a workout from the user's Garmin workout library, permanently. Recorded activities can't be deleted here. The first call deletes nothing: it returns the workout's name, and only a second call passing that exact name as confirm deletes it.
Args: workout_id: The workout's id. confirm: The workout's exact name, as the first call returns it.
Inputs: workout_id (required), confirm. Returns: object
find_exercisesARead-onlyInspect
Search Garmin's strength exercise catalogue by name. Matching ignores hyphens and spacing, so "pull up" and "pull-up" both match.
Args: query: Part of an exercise name, e.g. "bench press" or "row". limit: How many matches to return. Defaults to 25.
Inputs: query (required), limit. Returns: object
get_activitiesARead-onlyInspect
Recent runs, rides, swims and other activities, with distance, duration, pace or speed and heart-rate zones. Swims carry pace per 100 m, pool length, SWOLF and stroke rate.
Args: limit: Most activities to return, 1-50. Defaults to 10. start_date: Optional first day of a range, YYYY-MM-DD. end_date: Optional last day of the range. Defaults to today when start_date is given.
Inputs: limit, end_date, start_date. Returns: object
get_activity_detailsBRead-onlyInspect
One activity in detail: laps and splits with pace and heart rate. A run also carries the weather during it, the terrain (climbs, pace uphill, flat and downhill, heart-rate drift), earlier runs of the same route and a link to an image of the run to post. A ride carries power figures, best efforts, time in power zones and climbs. A swim carries pace per 100 m, SWOLF, strokes and each interval with its rest.
Args: activity_id: The activity's id.
Inputs: activity_id (required). Returns: object
get_connection_statusARead-onlyInspect
Whether Daash is connected to the user's Garmin account through Garmin's official API, and whether Garmin allows it to write workouts. Never returns a token.
Inputs: no named parameters. Returns: object
get_crewARead-onlyInspect
The user's Daash crew this week, drawn as a card: a few friends' easy and long runs (day and distance), the crew's standing club run, and the days members are already running the same kind of run at a usual time they share. Hard sessions show only as "hard". Each member's runs are as of the last time they looked at their own plan ("updated_on"). The result includes group_message, the week as text for a group chat, and, when the crew's page is on, page_url. Says so when the user isn't in a crew.
Args: week_of: Any date in the week to show. Defaults to this week, or on a Sunday to the week ahead.
Inputs: week_of. Returns: object
get_daily_summaryARead-onlyInspect
One day's health summary: steps, calories, resting heart rate, Body Battery and stress, with what charged or drained Body Battery and the longest stressful spells.
Args: date: The day. YYYY-MM-DD, 'today', 'yesterday' or an offset like '-3'. Defaults to today.
Inputs: date. Returns: object
get_planTraining plan and progressARead-onlyInspect
The user's training plan week by week, drawn as an interactive plan card: each session done, missed, moved or ahead, and the next session with its steps and target paces. With nothing scheduled, it shows the user's recent weeks of running and riding instead. Sessions carry workout_id and schedule_id. A session counts as done when run within a day either side of its date, or any day that week when started from its workout on the watch; a strength session counts when any strength activity is recorded in its week. The result also says where the user is: a block under way, about to start or just done, a race ahead with nothing scheduled, regular running, or getting going.
Args: label: The code of a plan Daash created, e.g. "HM". Omit it for the plan running now, or the calendar around this week.
Inputs: label. Returns: object
get_progressARead-onlyInspect
Which planned sessions got done, week by week, drawn as an interactive plan card. A session counts as done when an activity happened within a day either side of its date and ran at least roughly as long as planned. Each completed session carries a plain-English reason for the match. Effort is not judged.
Args: weeks: How many weeks back to report, including this one, 1-12.
Inputs: weeks. Returns: object
get_readinessARead-onlyInspect
A recovery check for a day: last night's sleep, overnight HRV, resting heart rate, Body Battery gained overnight and the last week's training, each against the user's own recent normal, with a call of ready_for_hard, fine_with_care, go_easy or not_enough_data (no call until a week of nights gives an HRV baseline; an early one until about three weeks). It is Daash's read of those figures; Garmin's own readiness score isn't shared through its official API.
Args: date: The day. YYYY-MM-DD, 'today', 'yesterday' or an offset like '-1'. Defaults to today.
Inputs: date. Returns: object
get_sleep_dataARead-onlyInspect
One night's sleep: stages, sleep score, and overnight breathing rate and SpO2 against the user's usual.
Args: date: The date the user woke up on. YYYY-MM-DD, 'today', 'yesterday' or an offset like '-3'. Defaults to today.
Inputs: date. Returns: object
get_workoutARead-onlyInspect
The steps of one saved or scheduled workout: each step with its distance or time and target. Repeats keep their structure, e.g. 8 x [1 km at a target, 60 s recovery].
Args: workout_id: The workout's id.
Inputs: workout_id (required). Returns: object
join_crewAInspect
Join a friend's Daash crew with an invite code, or start a new crew. Members see each other's chosen name, usual running times, and the day and distance of their easy and long runs for the next two weeks; hard sessions show only as "hard", and nothing else from Garmin is shared.
Args: your_name: What the crew calls the user. code: The invite code, like "DC-7Q4M", to join a friend's crew. start_new_crew: True to start a crew instead of joining one. crew_name: Optional, when starting. Defaults to the user's name, "Bart's crew". usual_times: When the user usually runs, as any of weekday_morning, weekday_afternoon, weekday_evening, weekend_morning, weekend_afternoon, weekend_evening. Runs on the same day are matched by these. goes_to_club_run: Whether the user usually goes to the crew's club run. club_run_day: Optional, when starting: the day of a run the crew already does together every week, e.g. "fri". It shows on everyone's week and is never offered as a match. club_run_time: Its start time, "HH:MM". club_run_km: Its distance in km. club_run_place: Where it starts, a few words.
Inputs: your_name (required), code, crew_name, club_run_km, +6 more. Returns: object
leave_crewADestructiveInspect
Leave the user's Daash crew and delete what it kept of their runs. The crew stops seeing their runs at once; the last member to leave deletes the crew. Nothing happens unless confirm is true.
Args: confirm: True to leave.
Inputs: confirm. Returns: object
list_workoutsBRead-onlyInspect
The structured workouts saved in the user's Garmin workout library.
Args: limit: Most workouts to return, 1-100. Defaults to 20.
Inputs: limit. Returns: object
remove_planADestructiveInspect
Take the rest of a plan off the user's Garmin calendar and out of the workout library. Only sessions from today onward are removed; past ones stay. The first call removes nothing and reports what would go; a second call with confirm set to the plan code removes it.
Args: label: The plan code, e.g. "HM". confirm: The plan code again, to go ahead.
Inputs: label (required), confirm. Returns: object
schedule_workoutAInspect
Put a saved workout on a date in the user's Garmin calendar, which is what sends it to the watch.
Args: workout_id: The workout's id. date: The day. YYYY-MM-DD, 'today', 'tomorrow' or an offset like '+3'.
Inputs: date (required), workout_id (required). Returns: object
unschedule_workoutADestructiveInspect
Take a workout off a day in the user's Garmin calendar. The workout itself stays in the library and can be scheduled again. When more than one workout sits on the day, they are listed back and nothing is removed.
Args: date: The day to clear. YYYY-MM-DD, 'today', 'tomorrow' or an offset like '+3'. schedule_id: One specific calendar entry to remove. Takes precedence over date.
Inputs: date, schedule_id. Returns: object
update_crewADestructiveInspect
Change the user's details in their Daash crew, or the crew's settings. Anyone can change their own name, usual times and club-run attendance; whoever started the crew can also rename it, change its club run, remove a member, and turn its page link on or off. Only what is passed changes. Turning the page link on or replacing it takes confirm=true; anyone with the link sees members' first names, the days they run, the time of day, and whether each run is easy, long or hard.
Args: your_name: A new name for the user in the crew. usual_times: When the user usually runs, in the same values as when joining. goes_to_club_run: Whether the user usually goes to the club run. crew_name: A new name for the crew. club_run_day: The club run's day, e.g. "fri", or "none" to drop it. club_run_time: Its start time, "HH:MM". club_run_km: Its distance in km. club_run_place: Where it starts. remove_member: The name of a member to take out of the crew. group_link: "on" for a page link the group can open to see this week and next, "new" to replace it (the old one stops working), "off" to stop it. confirm: True to turn the page link on or replace it.
Inputs: confirm, crew_name, your_name, group_link, +7 more. Returns: object
update_workoutADestructiveInspect
Change an existing workout in place: its name, steps, description or pool length. It keeps its id, so dates it is already scheduled on stay scheduled and the watch gets the new version at its next sync. New steps replace the whole old list, and the result carries the steps that were replaced.
Args: workout_id: The workout's id. name: New name. Omit to keep the current one. steps: New step list, in the same shape as when creating a workout, replacing the old one entirely. Omit to keep it. sport: Only with steps, and only to change the sport. description: New note. Omit to keep the current one. pool_length_meters: For a swim, a new pool length. Omit to keep it.
Inputs: workout_id (required), name, sport, steps, +2 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceRemote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.MIT
- AlicenseCqualityCmaintenanceCompetitor Monitor AI - MCP server providing AI-powered tools and automation by MEOK AI Labs117 npm46 PyPIMIT
- AlicenseAqualityDmaintenanceEnables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.169 npm1MIT

industrylens-mcpofficial
AlicenseNot gradedqualityCmaintenanceBrowse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.