speediance-mcp
A free, self-hosted MCP server that lets Claude read and manage your Speediance Gym Monster training — history, stats, planning, off-machine logging and a coaching memory — from your own machine.
Review what you did — month calendar, per-exercise session logs (sets, reps, weights), rowing/guided-cardio telemetry, heart-rate curves, training totals, strength/1RM profile, and session-to-session comparisons.
Analyze balance — muscle volume spread (main 100%, assisting 50%), push:pull and upper:lower ratios, neglected muscles, week-by-week trends per movement.
Plan workouts — build custom templates, suggest working weights (Epley from your best set), browse the exercise library and Speediance's official programs, check what equipment you own or can't use.
Manage your schedule — list, create, edit, delete and schedule/unschedule workout templates on specific days.
Train off-machine — log hotel-gym/free-weight sessions so they count toward volume and personal bests, retrieve them, or delete a day.
Keep a coaching memory — save curated facts (hard/soft constraints, preferences, goals, observations), supersede/forget/audit them, bulk-import, and have equipment, injuries and avoided moves respected in every workout it builds.
Connect anywhere — local use with Claude Desktop/Code, or remote mode over HTTPS for claude.ai with OAuth, rate limiting and revocable access.
Click on "Deploy 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., "@speediance-mcp how has my bench press volume changed over the last 3 months?"
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.
speediance-mcp
A free, open-source MCP server that lets Claude read and manage your Speediance Gym Monster training: your session history, per-set logs, exercise progress, rowing stats, heart rate, custom workouts and schedule — plus off-machine training and a coaching memory of your goals, injuries and preferences.
It's a self-hosted alternative to GM Manager. It runs on your own computer, talks directly to Speediance, and keeps everything it stores on your machine.
Unofficial. Not affiliated with or endorsed by Speediance. It uses the private API behind the Speediance mobile app, which can change without notice.
What you can do with it
Once it's connected you just talk to Claude. Things that work today:
Review what you actually did
"How was last week?" — sessions, minutes, volume and calories, with phone-health activity counted separately from gym sessions.
"What did I do in Monday's session?" — every exercise, set, rep and weight, plus rowing pace/power or guided-cardio intervals where there are any.
"Is my bench press going anywhere?" — that movement's trend, week by week.
"Compare Monday to the last time I did that workout." — per-movement deltas in top weight, reps and volume.
Plan the next one
"Build me a 40-minute upper session with the barbell, and skip anything that hits my left shoulder."
"What weight should I use for 8 reps of Romanian deadlift, leaving 2 in reserve?" — an Epley estimate from your own best set, and it tells you what it based that on.
"Which muscles have I been neglecting this month?" — volume spread across the muscles each movement works (main 100%, assisting 50%), with push:pull and upper:lower ratios.
"Put that workout on Thursday."
Train away from the machine
"At the hotel this morning I did 3×12 dumbbell bench at 40, 3×10 single-arm rows at 45 a side, and 3×20 push-ups."
Claude records it and matches each movement to the Speediance library, so it counts towards your volume-by-muscle and can set a personal best — detail Speediance itself cannot store. Backdating works, so a whole trip can be caught up in one message. See Off-machine training.
Let it remember things
"My left shoulder doesn't like overhead pressing — don't program it." → saved as a hard constraint and respected in every workout it builds afterwards.
"I've got a flat bench and a barbell, no cable attachments." → equipment it plans around.
"I hate Bulgarian split squats." → marked ⊘ avoided, and never programmed again unless you ask for it by name.
It also keeps your goal, training days and session length, so you don't repeat yourself — and it flags contradictions between saved facts instead of quietly picking one.
Related MCP server: fitness-mcp
Off-machine training
Speediance's own manual log makes a day count towards your streak, days trained, minutes and calories, but it stores no exercises — and they can't be pushed in. The session-save route is an update into a row the machine itself creates (asking it to resolve a client-invented session id returns nothing), so a workout that never ran on the hardware cannot be written at all.
So log_off_machine_workout keeps that detail locally instead, and the rest of the server treats it as
real training:
get_muscle_balanceincludes it, and reportsoffMachineDays/offMachineSetsseparately — it's training, but not a session the machine recorded.get_session_detailon a manual session serves those exercises and says where they came from.Movements resolve to the library by name, which is what makes them attributable to muscles. One that Speediance doesn't stock is still logged and reported as unmatched rather than refused.
Single-arm sets keep their side and aren't counted as both; bodyweight work is recorded, not rejected.
Install
You need Python 3.10 or newer. Check with python3 --version (Windows: py --version).
Get Python from python.org if needed.
The easiest way is pipx, which installs the command in its own isolated environment:
OS | Install pipx | Install speediance-mcp |
macOS |
|
|
Windows |
|
|
Linux |
|
|
Open a new terminal after ensurepath. Alternatives: uvx --from git+https://github.com/labatt/speediance-mcp speediance-mcp,
or pip install git+https://github.com/labatt/speediance-mcp inside a virtual environment.
Sign in
speediance-mcp loginEnter your Speediance email and password. By default the password is remembered, so an expired
session renews silently. If you'd rather not store it, use speediance-mcp login --no-remember: only the
session token is kept, and you run speediance-mcp login again when it expires.
Choose a client type (so you don't get signed out of your phone or your machine)
Speediance allows one signed-in session per client type, not per account. Every Speediance app and machine signs in as a type, and a new sign-in with a type signs out whatever was using it:
| Speediance's own user of that slot | Signing in with it signs out... |
| The Speediance phone app | your phone app (and your phone signs this server out) |
| The Gym Monster | your Gym Monster |
| Gym Nano | a Gym Nano on your account, if you have one |
| Speediance bike | a Speediance bike on your account, if you have one |
Pick a type that no device of yours uses:
Gym Monster, no Nano or bike (most people): keep the default,
bike.You also own a Speediance bike: use
--client-type nano.You own both a Nano and a bike: use
--client-type phone, and expect your phone app and this server to sign each other out. Never usegym-monsterunless you want to be signed out at the machine.Running two tools on the same account (for example this server and another Speediance tool): give them different free types, or they will sign each other out.
With nano or bike, if something else does take the slot, the server quietly signs back in (with a
remembered password). With phone or gym-monster it never does that automatically, since it would sign
your phone or machine out again; it tells you to run speediance-mcp login instead.
speediance-mcp status shows the client type you signed in with. These types were found by testing (they
aren't documented by Speediance), and a future Speediance update could change them.
Use --region EU if your account is on Speediance's EU servers, and --device-type 2 for a Gym Pal.
Login also downloads the exercise library (about 30 seconds, once a day at most).
speediance-mcp status shows who you're signed in as; speediance-mcp logout signs out and deletes the
stored credentials.
Connect Claude
Claude Desktop
Open the config file (Claude Desktop → Settings → Developer → Edit Config), or create it:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
Add:
{
"mcpServers": {
"speediance": { "command": "speediance-mcp" }
}
}Then restart Claude Desktop.
macOS: Claude Desktop doesn't see your shell's PATH, so it usually can't find commands in
~/.local/bin (where pipx puts them). Use the full path that which speediance-mcp prints:
{
"mcpServers": {
"speediance": { "command": "/Users/you/.local/bin/speediance-mcp" }
}
}Windows: if Claude can't find the command, use the full path that where speediance-mcp prints. JSON
needs forward slashes or doubled backslashes — "C:/Users/you/.local/bin/speediance-mcp.exe" or
"C:\\Users\\you\\.local\\bin\\speediance-mcp.exe", never single backslashes:
{
"mcpServers": {
"speediance": { "command": "C:/Users/you/.local/bin/speediance-mcp.exe" }
}
}With uvx instead of pipx (sign in first with
uvx --from git+https://github.com/labatt/speediance-mcp speediance-mcp login):
{
"mcpServers": {
"speediance": {
"command": "uvx",
"args": ["--from", "git+https://github.com/labatt/speediance-mcp", "speediance-mcp"]
}
}
}On macOS, use the full path from which uvx as the command for the same reason as above.
Claude Code
claude mcp add speediance -- speediance-mcpThen ask Claude something like "How did my last pull workout compare to the one before?"
Use it on claude.ai (remote mode)
claude.ai (web and mobile apps) connects to MCP servers over the internet, so this mode needs a machine that's always on and reachable over HTTPS.
On that machine, install and sign in as above (
speediance-mcp login). The remote sign-in page only accepts this same Speediance account.Run the server (keep it running with systemd, pm2 or similar):
speediance-mcp serve --http --public-url https://mcp.example.comIt listens on
127.0.0.1:8765. Put a TLS reverse proxy in front. nginx (thelimit_reqlines are optional but recommended: they slow down anyone hammering the sign-in and OAuth endpoints):# at http level (e.g. in /etc/nginx/conf.d/speediance.conf, outside the server block): limit_req_zone $binary_remote_addr zone=speediance_oauth:10m rate=10r/m; server { listen 443 ssl; server_name mcp.example.com; # ssl_certificate / ssl_certificate_key: e.g. from `certbot --nginx -d mcp.example.com` location ~ ^/(register|authorize|login|token)$ { limit_req zone=speediance_oauth burst=20 nodelay; proxy_pass http://127.0.0.1:8765; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_buffering off; proxy_read_timeout 3600s; } location / { proxy_pass http://127.0.0.1:8765; proxy_http_version 1.1; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_buffering off; proxy_read_timeout 3600s; } }Caddy (fetches the certificate itself):
mcp.example.com { reverse_proxy 127.0.0.1:8765 { header_up X-Real-IP {remote_host} } }The server reads
X-Real-IPfrom this local proxy to rate-limit sign-in attempts by the caller's real address, so whichever proxy you use must set that header.In claude.ai: Settings → Connectors → Add custom connector, URL
https://mcp.example.com/mcp. Claude opens the sign-in page; enter your Speediance email and password.
By default only clients that redirect to claude.ai, claude.com, localhost or 127.0.0.1 can
connect. To let another MCP client connect (for example a self-hosted or third-party one), add its
redirect host with --allow-redirect-host, repeatable:
speediance-mcp serve --http --public-url https://mcp.example.com --allow-redirect-host client.exampleTo disconnect claude.ai and every other remote client, run speediance-mcp revoke.
speediance-mcp logout also stops the server using your Speediance account until you sign in again.
Security:
Only clients that redirect to
claude.ai,claude.com,localhostor127.0.0.1can connect; add others with--allow-redirect-host.After repeated wrong sign-ins, the sign-in page locks for up to 15 minutes.
Someone who knows the server's address can keep new sign-ins locked out by repeatedly failing (20 failed attempts per 15 minutes overall lock everyone out). Existing connections keep working; the nginx
limit_reqlines above make this slower.Only the account the server was set up with can connect; tokens are stored hashed; access tokens last an hour and refresh automatically.
The --client-type you pass to speediance-mcp login (see
Choose a client type)
is also the slot every remote sign-in through this server uses — with phone, a claude.ai sign-in
through it signs your phone app out, the same as it would locally. Give a local copy of the server
a different free slot if you run both.
Tools
All weights are in your account's display unit (kg or lb) — nothing is converted.
⊘ avoided marks (with an optional reason) are shared with the companion web app when both use the same
data dir; create_workout and update_workout flag any avoided exercise they were asked to include.
Tool | What it does |
| Verify the Speediance login is live |
| A month's scheduled and completed sessions |
| One session's per-exercise log — sets, reps, weights; rowing pace/power; guided-cardio intervals |
| A watch-paired session's heart-rate curve and summary |
| Totals between two dates |
| Profile, coaching memory and recent sessions in one call |
| Estimated 1RM per recently trained movement |
| Which muscles the recent work loaded, push:pull and upper:lower, and what's been missed |
| A session versus the previous one, per movement |
| A working weight for a rep target, with its reasoning |
| Search the exercise library (body part, equipment, what you own) |
| One movement's muscles, equipment, form cues and media |
| Mark a movement ★ preferred or ⊘ avoided |
| Speediance's accessories, flagged with what you own |
| One movement's week-by-week trend, oldest to newest (Speediance buckets this by week, not by session) |
| Your saved custom workouts |
| One workout's full prescription |
| Create a workout (verified by reading it back) |
| Edit a workout in place |
| Delete a workout |
| Put a workout on a day |
| Take a workout off a day |
| Speediance's official programs |
| The coaching memory |
| Goal, training days, session length, load anchors, owned and unusable equipment |
| Save one curated fact: a hard/soft constraint, preference, goal or observation (max 600 characters; near-duplicates are refused; |
| Archive a fact that no longer applies (kept in the history) |
| Audit the facts, optionally with the full history of superseded, forgotten and expired ones |
| Save many facts at once under the same rules, with a |
| Record a workout done away from the machine (hotel gym, free weights) so it counts towards volume and personal bests |
| Off-machine workouts logged between two dates |
| Remove one day from the off-machine log (never touches Speediance) |
19 of these use GM Manager's tool names and, for most, its parameter names (template_id, groupId,
add...), so prompts written for GM Manager keep working: check_connection, get_calendar,
get_session_detail, get_exercise_history, get_athlete_snapshot, get_strength_profile, list_exercises,
mark_exercise, list_my_workouts, get_workout, create_workout, update_workout, delete_workout,
schedule_workout, suggest_load, get_preferences, set_preferences, remember_fact and forget_fact.
The other 13 are new: get_heart_rate, get_training_stats, compare_sessions, get_exercise,
list_accessories, unschedule_workout, browse_programs, list_facts, import_facts,
get_muscle_balance, log_off_machine_workout, get_off_machine_log and delete_off_machine_day.
set_preferences,
suggest_load and create_workout take simpler inputs: typed preference fields instead of one JSON blob, and
no Dynamic Weight modes or RM presets yet. remember_fact and forget_fact differ from GM Manager's (see
below).
Coaching facts are curated rather than free text. Each fact has a kind — a constraint (with severity
hard or soft), a preference, a goal or an observation — and a category (injury, equipment,
schedule, body, nutrition, note), an optional scope (e.g. location:tampa-hotel) and a source
(user or inferred). A fact is at most 600 characters: longer ones are refused with the count, never
truncated. A new fact that nearly repeats an active one isn't saved; you get the near-match back and can re-send
it with supersedes to replace the old one, which is archived in the same write. forget_fact(id) archives
rather than deletes, and expired facts archive themselves. get_preferences and get_athlete_snapshot return
only active facts, grouped as constraints (hard, soft), preferences, goals, the 10 most recent
observations, and conflicts: pairs of active facts in the same category that look like the same topic but
differ on a number or a negation, with both ids, so Claude asks you instead of picking one. list_facts shows
the full history. Facts with different scopes (e.g. location:home and location:tampa-hotel) never count as
duplicates or conflicts. When a refused near-match differs in kind, severity, scope, a number or a negation, the
reply names the difference so an upgrade isn't lost. Facts saved before this change are kept as legacy facts:
reads list them as legacyUnreviewed (and count them in legacyToReview) until each one is re-saved with
supersedes (via remember_fact or import_facts; a long one can be split into several pieces in one import)
or forgotten. Until then they may still bind, and Claude treats injury ones as hard constraints.
create_workout and update_workout replies repeat your hardConstraints and legacyUnreviewed facts so
Claude re-checks the workout against them.
Rowing: every rowing session gets distance, pace per 500m, speed, average power and calories per minute.
Guided cardio sessions (like "Aerobic Rowing") also get per-interval rows. Rowing done as a course or custom
workout gets a rowing block instead: the machine records a sample every few seconds, so each programmed
piece reports its stroke rate, pace, watts, and how much of it stayed inside the target stroke-rate band.
Troubleshooting
"Not signed in to Speediance, or the session expired." Run
speediance-mcp login. A remembered password (the default) renews an expired session automatically; after--no-remember, sign in again.Your phone app or Gym Monster keeps getting signed out. You're signed in with the
phoneorgym-monsterclient type. Runspeediance-mcp login --client-type bike(ornano) — see Choose a client type.A tool still says to sign in after you ran
speediance-mcp login. Restart Claude so the server starts fresh with the new login.Claude doesn't list the tools. Check the config JSON is valid, use the command's full path, and restart Claude.
The first exercise search is slow. The library downloads once (about 30 seconds) and is then cached for a day.
A workout comes back
verified: false. Speediance stored something different from what was sent. Check the workout in the Speediance app before training and please open an issue with your unit (kg or lb).
Companion project: the web app
SmartGym Workout Manager for Speediance is a separate, free Flask app over the same Speediance data — a browser UI rather than a conversation. The two projects are independent and each works alone.
speediance-mcp (this) | The web app | |
Interface | Conversation with Claude | Browser UI you click through |
Best at | Asking questions, planning, "log what I did at the hotel" | Charts, the workout builder, scanning history, schedule grids |
Per-rep telemetry | — | Power/resistance charts per rep, form scores |
Personal bests | — | Dashboard cards, all-time |
Coaching memory | Full curated facts: injuries, goals, schedule, equipment | Avoided exercises |
Off-machine logging |
| A form at |
Runs as | A local process Claude launches, or a remote server | A Flask site you host |
This server works on its own. It never imports the web app and never calls it over the network.
If you run both, they share one SQLite file in this server's data folder, so they can't disagree:
Exercises you mark ⊘ avoided here are respected there, and vice versa.
Off-machine workouts you log through Claude show up immediately in the web app's dashboard, history and personal bests.
Owned/unusable equipment and coaching preferences are shared.
Both projects declare the shared tables identically, and a test fails if the two definitions ever drift. One asymmetry worth knowing: the web app maintains a cache of per-session stats used for its personal-best cards. This server neither writes nor reads it, so nothing here depends on the web app being installed.
Running both? Use different client types. Speediance allows one live session per client type, so point them at different ones — e.g. this server on
nanoand the web app onbike— or signing in with one signs the other out. See Choose a client type.
Your data
Everything lives in one folder (run speediance-mcp status to see it):
Windows:
%APPDATA%\speediance-mcpmacOS:
~/Library/Application Support/speediance-mcpLinux:
~/.config/speediance-mcp
It holds credentials.json (your token, and your password unless you signed in with --no-remember), speediance-mcp.db
(the coaching memory) and the exercise-library cache. On macOS and Linux the credentials file is readable only
by you; on Windows it relies on your user profile folder's permissions. Delete the folder to erase everything.
Set SPEEDIANCE_MCP_HOME to use a different folder.
Nothing is sent anywhere except Speediance's own servers. Requests are paced at one per second.
Security notes
Unofficial API. This uses the private API behind the Speediance app. It isn't supported by Speediance and can change or break without notice.
Credentials stay on your computer.
credentials.jsonin the data folder holds your session token — and your password unless you used--no-remember. On macOS and Linux it (and a newly created data folder) is readable only by you.One session per client type. Speediance signs out whoever last used the same client type. With the default
biketype (ornano), this server doesn't share a slot with your phone or your Gym Monster — see Choose a client type.Nothing is sent anywhere but Speediance. No telemetry, no third-party services; tokens and passwords are never logged.
Development
python3 -m venv .venv
.venv/bin/pip install -e .
.venv/bin/python -m unittest discover -s tests -t . -vTests are offline and use synthetic data only. Maintainers can run this manual check against a real account before a release:
sign in and run
get_athlete_snapshot;create, verify and delete a throwaway workout;
create a workout with a Vita (level) exercise and confirm the level shows correctly in the Speediance app;
call
get_heart_rateon a watch-paired session.
Acknowledgments
The Speediance client is ported from hbui3/UnofficialSpeedianceWorkoutManager (MIT).
API findings — the session-type routes, Free Lift scaling and template write rules — come from the notes of pookey/speediance-cli and stozo04/speediance-cli (both MIT).
License
MIT — see LICENSE.
Available Tools
29 toolsbrowse_programsA
Speediance's official multi-week programs. Without program_id, lists programs (filtered by
query); with program_id, returns that program's details and structure.
Inputs: query, program_id.
check_connectionA
Verify the Speediance login is live. Call this FIRST in a session, before any other tool, and stop if it reports connected:false — relay its message (the user must sign in again). A merely expired token is renewed silently when the password was remembered.
Inputs: no named parameters.
compare_sessionsB
Compare a session with an earlier one, per movement: top weight, total reps and volume deltas. previous_training_id=0 picks the most recent earlier session that shares a movement.
Inputs: training_id (required), previous_training_id.
create_workoutA
Create a custom workout template. exercises is an ordered list of
{"name": "..." or "group_id": N, "sets": [...], "rest_seconds": 60}. Sets by movement kind:
reps -> {"reps": 10, "weight": 50}; timed -> {"seconds": 45}; Vita (level) -> {"seconds": 30, "level": 12}.
Optional per set: "side" 1=left / 2=right (unilateral moves alternate automatically), "rest".
Weights are in displayUnit. The template is read back after saving; verified:false means Speediance
stored something different — tell the user. Never program a ⊘avoided movement unless asked by name.
The reply carries the user's hardConstraints and legacyUnreviewed facts when there are any.
Re-check these against the workout before telling the user it's done.
Inputs: name (required), exercises (required).
delete_workoutA
Permanently delete a custom template, by code (preferred) or numeric id. Not reversible —
only when the user asked for it.
Inputs: template_id (required).
forget_factA
Archive a fact that no longer applies (ids come from get_preferences facts or list_facts). It
stays in list_facts(include_archived=true) but leaves every default read. For a fact that changed,
prefer remember_fact(..., supersedes=[id]). Forgetting a legacy fact marks it reviewed.
Inputs: id (required).
get_athlete_snapshotA
Everything needed before planning: profile (bodyweight, age, watch), the coaching memory (active facts grouped as constraints{hard, soft} / preferences / goals / observations / conflicts, preferences, ★preferred / ⊘avoided exercises, owned equipment) and recent sessions, plus otherActivities imported from the phone health app (off-machine work — include it in load). Check memory.facts.constraints.hard before building any workout and respect it; raise any memory.facts.conflicts with the user rather than picking one. memory.facts.legacyUnreviewed holds old free-form facts not yet curated: they may still bind — treat injury ones as hard constraints until curated, and curate them promptly with the user.
Inputs: days.
get_calendarA
What's scheduled and trained in a month (month = 'YYYY-MM'). Each day carries its
trainingPlanList. The raw calendar feed hides completed custom-template sessions, so completed
sessions from the history feed are merged in with source:"history"; pass their trainingId to
get_session_detail. Reservations (isReservation:true) are scheduled templates. Activity imported
from the user's phone health app (walks, rides, other off-machine work that reached Speediance)
is listed per day under otherActivities — count it in weekly load, but it isn't a gym session.
Speediance only holds what the phone synced; other sources (e.g. a wellness app) may have more.
Inputs: month (required).
get_exerciseB
One movement's details: muscles, equipment, whether it's unilateral (one side at a time — matters when building workouts), form description and cues, image and video.
Inputs: group_id (required).
get_exercise_historyA
EVERY time the user has done ONE movement, oldest -> newest: the "how is my bench press going?" tool. Give the name as the user says it, or a groupId. If several exercises match, nothing is fetched and the reply is {needsPick:true, matches:[...]} — ask which one. One entry per training DAY (same-day sessions combined): topWeight, volume, and minWeight when the day had a range.
Inputs: limit, groupId, exercise.
get_heart_rateB
Second-by-second heart rate for a watch-paired session: average, max, min and a series (downsampled to at most 600 points). available:false when no watch recorded it.
Inputs: training_id (required).
get_muscle_balanceA
Which muscles the recent training actually loaded, and how balanced it was.
Spreads each weighted set's volume over the muscles the library says a movement works:
a MAIN muscle takes the full volume, an ASSISTING muscle half. Attributed totals
therefore exceed the weight actually lifted — they are shares of attention, not a
decomposition of load. Timed and level work (Vita, planks, rowing) carries no volume
and is reported as unweightedExercises rather than silently counted as zero.
pushPull and upperLower are ratios: 1.0 is balanced, above 1.0 favours push/upper.
notTrained lists muscles with no volume in the window — useful, but read it next to
unweightedExercises before concluding a muscle was neglected.
Inputs: days.
get_preferencesA
The coaching memory: goal, training days, session length, load anchors, owned equipment,
unusable_equipment (gear they own but CANNOT use — never plan a movement needing it),
★preferred / ⊘avoided exercises, and the ACTIVE curated facts grouped as facts:
constraints{hard, soft}, preferences, goals, observations (10 most recent), conflicts, legacyToReview and
legacyUnreviewed (old free-form facts not yet curated — they may still bind: treat injury ones as hard
constraints until curated, and curate them promptly with the user).
Check facts.constraints.hard before building any workout; resolve any conflicts with the user.
Inputs: no named parameters.
get_session_detailA
The actual per-exercise log — sets, reps and weight per movement — for ONE completed session.
type is optional and advisory: the session type is always resolved from this account's own
history, so only sessions you own can be read. resolvedType:false means the id isn't in your
history. Rowing/ski sessions add cardio (pace per 500m, speed, watts, calories/min); guided
cardio adds per-interval rows, and rowing with recorded telemetry adds rowing — per-block
stroke rate, pace, watts and how much of each block stayed inside its target stroke-rate band.
Weights are already in displayUnit — never convert.
Inputs: training_id (required), type.
get_strength_profileB
Per movement trained recently: estimated 1RM (Epley) from its best set, that set, and how the top weight moved across the window. Scans up to the 10 most recent weighted sessions.
Inputs: days, limit.
get_training_statsA
Totals between two dates (YYYY-MM-DD, inclusive): gym sessions, strength sessions, training minutes, calories, volume and energy — for questions like "how was my week?".
Inputs: end (required), start (required).
get_workoutB
A template's full prescription: exercises in order, each set's reps (or seconds), weight, Vita level, side and rest. Weights are in displayUnit.
Inputs: code (required).
import_factsA
Bulk-save facts (up to 200), e.g. to curate the legacy facts. Each item is an object with the same fields as remember_fact: text, kind, category, and optional severity, scope, supersedes, expires_days, source. Every single-write rule applies to every item, in order (an item is also deduped against items accepted earlier in the batch). Returns {accepted, deduped: [{input, matched_existing_id}], rejected: [{input, reason}], superseded: [ids], dryRun}. dry_run=true returns the identical report and writes nothing — use it first, show the user, then run it for real.
Inputs: facts (required), dry_run.
list_accessoriesA
Speediance's accessory catalog (bars, handles, rope, benches, AeroRow...), deduplicated by name,
each flagged owned and usable. Save what the user owns with set_preferences(owned_equipment=[names]).
Inputs: no named parameters.
list_exercisesA
Search the Speediance exercise library. Filters: name words (query), body part or muscle
(muscle, e.g. "chest", "biceps"), library tab (category), equipment name, kind
("reps", "timed" or "level" for Vita), and
owned_only (only moves whose equipment you own — set it with set_preferences(owned_equipment)).
Movements needing equipment listed in set_preferences(unusable_equipment) are ALWAYS hidden.
⊘avoided movements are hidden unless include_avoided=true; ★preferred ones sort first.
The first call downloads the library (~30 s); later calls use a 24-hour cache.
Inputs: kind, limit, query, muscle, +4 more.
list_factsA
The audit surface for the curated facts, oldest first, with each fact's status, supersedes / supersededBy chain, source and legacy flag. Default: active facts only. include_archived=true returns the full history (superseded, forgotten, expired and legacy facts). Filter by kind (constraint | preference | observation | goal) or category (injury | equipment | schedule | body | nutrition | note).
Inputs: kind, category, include_archived.
list_my_workoutsA
The user's saved custom workout templates. Use a template's code with get_workout,
update_workout, delete_workout or schedule_workout.
Inputs: no named parameters.
mark_exerciseA
Mark a movement ★preferred, ⊘avoided, or clear it ("none"). Identify it by group_id, or by
name when you have no id (an ambiguous name marks nothing and lists candidates). Use when the
user makes a LASTING per-exercise preference clear (it always hurts / they love it). Avoided moves
are never programmed unless the user asks for them by name.
reason: optional short note on why (e.g. 'left shoulder'), shown to you and in the web app.
Inputs: mark (required), name, reason, group_id.
remember_factA
Save ONE durable training fact (max 600 characters — split longer ones; nothing is truncated) and tell the user you saved it. kind: constraint (a rule a workout must obey — needs severity: hard = never violate, soft = avoid if possible) | preference (a weight on exercise choice) | goal (a target) | observation (a dated finding, no forward authority). category: injury | equipment | schedule | body | nutrition | note. scope: optional context such as "location:tampa-hotel". supersedes: ids this fact replaces (they are archived in the same write) — use it for corrections and updates instead of adding a second version. expires_days: only for temporary things ("travelling next week" ~7). source: "user" when the user stated it directly, else "inferred" (default). If a near-identical active fact exists nothing is saved and the near-match comes back (saved=false): re-send with supersedes=[its id] if the new one replaces it. Don't store bodyweight/unit (Speediance knows) or load numbers (use set_preferences).
Inputs: kind (required), text (required), category (required), scope, +4 more.
schedule_workoutA
Put a saved template (by code, from list_my_workouts) on a day (YYYY-MM-DD), or take it off
with add=false.
Inputs: code (required), date (required), add.
set_preferencesA
Update structured preferences (only the fields given change). load_anchors maps group_id -> a known working weight in displayUnit and is MERGED into the saved anchors (other anchors are kept); a weight of null or 0 removes that anchor. owned_equipment is a list of accessory names from list_accessories (it replaces the saved list). unusable_equipment names gear the user OWNS but cannot use (an injury, a bench they can't lie on): movements needing it are hidden from list_exercises and must never be planned. Free-text facts go in remember_fact instead.
Inputs: goal, load_anchors, training_days, owned_equipment, +2 more.
suggest_loadA
Suggest a working weight for reps reps leaving rir reps in reserve, from the movement's most
recent best set (Epley estimate), falling back to the user's saved load anchor. Reports its basis.
Inputs: reps (required), rir, groupId, exercise.
unschedule_workoutC
Take a scheduled template off a day (YYYY-MM-DD).
Inputs: code (required), date (required).
update_workoutA
Edit a template in place (an edit never uses a new slot). template_id is its code (preferred)
or numeric id. Omitted fields keep their current value; exercises, when given, replaces the whole
list (same format as create_workout) — start from get_workout. Verified by read-back.
The reply carries the user's hardConstraints and legacyUnreviewed facts when there are any.
Re-check these against the workout before telling the user it's done.
Inputs: template_id (required), name, exercises.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 29 tools
Most tools have clearly distinct purposes (workout CRUD, calendar, analytics, library, fact management). Minor overlaps exist: schedule_workout with add=false duplicates unschedule_workout, and get_athlete_snapshot overlaps get_preferences/get_training_stats, but descriptions explicitly clarify the boundaries. An agent can reliably tell tools apart.
All 29 tools use a consistent snake_case verb_noun pattern (list_my_workouts, get_session_detail, create_workout, remember_fact, etc.). No camelCase or mixed-convention outliers. Predictable and readable throughout.
29 tools is heavy for the rubric's ideal range, though the server spans several genuinely broad domains (workout CRUD, calendar/sessions, analytics, exercise library, and a full fact/memory subsystem). Each tool is defensible, but the surface is large enough to feel sprawling, and the fact subsystem alone consumes five tools.
Coverage is exceptional: full workout CRUD plus scheduling, calendar and session detail, heart rate, multiple analytics tools, complete exercise-library browse/detail/mark/history, accessories, preferences get/set, and a full fact lifecycle (remember/forget/list/import with audit and supersede chains). No obvious dead ends for the stated coaching purpose.
Maintenance
Related MCP Connectors
tri-train is a training platform for triathletes that syncs activities from Strava and Garmin and exposes them to Claude through a remote MCP server. Ask Claude how your last block went, why your run pace dropped, or whether you are fresh enough for Sunday's race, and it answers from your real data: activities with laps and grade-adjusted pace, weekly load and the performance management chart (CTL/ATL/TSB), sleep, HRV and resting heart rate, and your race calendar with predictions. Claude can also act: create and adjust planned workouts with structured intervals, push them to your Garmin watch, add races and write notes. Every change is journaled and can be undone. Read and write access are separate OAuth scopes, and the server enforces them on every call. Built and hosted in Switzerland by a triathlete; data stays on our own servers (Swiss revDSG / GDPR).
Connect Claude to your Intervals.icu watch data for fitness, workout review, and plan writing.
WHOOP recovery, strain, sleep and workouts in Claude via official WHOOP OAuth. Free, open source.
Talk to your own gym log. Reps: Gym Workout Log (repsworkout.com) is a workout log for iPhone and Android. Connect it to Claude, ChatGPT or any MCP client to read your workout history, PRs, lift progression, weekly summaries, routines and training plan, and to save routines and plans after you confirm them. It never logs a workout for you and can’t delete your history. Sign in with an e-mail code, Apple or Google; new users can create a free account while connecting, then get the app to log workouts.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides Claude with real-time access to local health data including sleep, recovery, strain, and workouts from WHOOP and Apple Health, enabling informed context-aware interactions.61MIT
- AlicenseNot gradedqualityCmaintenanceA personal remote MCP server that lets Claude read your Hevy workout data and MacroFactor nutrition data directly in conversation, with read-only tools for workouts, body measurements, macros, and weight trends.MIT
- AlicenseAqualityBmaintenanceDaash 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.266MIT
- AlicenseNot gradedqualityCmaintenanceEnables Claude to securely read your own WHOOP account data — recovery, HRV, resting heart rate, sleep, strain, workouts and body profile — through the official WHOOP developer API on a self-hosted server. Supports natural-language questions such as whether you are ready to train hard today.14 npmMIT