Generated from the live tool registry · protocol 2025-06-18

MyoAmigo MCP tool reference

Overview

MyoAmigo is a local-first iOS strength-training tracker with Apple Watch logging and an MCP server that lets AI assistants like Claude read and coach your training.

MCP (the Model Context Protocol) is the open standard AI assistants use to work with real applications. MyoAmigo runs a hosted, remote MCP server at https://api.myoamigo.com/mcp exposing 45 tools: 20 that read a user's training data and 25 that write to it. Every call is scoped to the authenticated account. This page is generated at build time from the same registry the server itself serves (see the machine-readable tools.json), so it cannot drift from the deployed surface.

Connecting

Pick your client on the Connect hub for step-by-step setup (Claude, ChatGPT, Cursor, and 20+ others). In short: add https://api.myoamigo.com/mcp as a remote MCP server in your client and sign in when prompted (OAuth 2.1). Headless clients can use a personal API key minted at api.myoamigo.com/connect. New here? Create an account at api.myoamigo.com/sign-up or just download the app.

Permissions & pricing

Access is gated by your sign-in and disconnectable at any time; your data never trains AI models. Reading and analysis are free: any connected assistant can use every read tool at no cost. The 23 write tools that change training data (logging, routines, plans, corrections) require MyoAmigo Pro; sending feedback and setting your profile stay free, and two synthesized coach reads (week review, session assessment) are Pro.

Example workflows

Things people actually ask a connected assistant:

• "What should I do for bench today, based on my last few sessions?"
• "Why has my squat stalled? Look at the last eight weeks."
• "Which muscles did I undertrain this month?"

A typical loop: ask your assistant to review your week and adjust Thursday's pull day. It reads your history and muscle balance, revises the plan with the write tools, and the change appears in the app, scheduled and ready to run.

Tool reference

All 45 tools, grouped by what they do:

• Reading your data (10)
• Analysis & coaching reads (9)
• Logging (4)
• Programming: routines & plans (9)
• Corrections & cleanup (11)
• Account & feedback (2)

Reading your data

get_history · Get exercise history (read · Free)

Recent logged sets for an exercise, most recent first. Unlike the write tools (log_set), read tools resolve the `exercise` LENIENTLY — a close/colloquial name or a partial match still works (it reports how it interpreted an inexact match). Optionally bound the window with `since`/`before` (ISO-8601; inclusive-start, exclusive-end). A timed hold renders as its duration (e.g. '45s hold').

• exercise (string, required): Exercise name or id (matched leniently)
• limit (integer): Max rows (default 10, max 100)
• since (string): Only sets performed at/after this ISO-8601 instant (inclusive).
• before (string): Only sets performed strictly before this ISO-8601 instant (exclusive).

get_pr · Get personal record (read · Free)

Personal record for an exercise: heaviest working set and best Epley e1RM, plus the longest single timed hold (seconds, for planks/wall sits/dead hangs). A load-less hold-only exercise reports just the hold. Like get_history, the `exercise` is resolved LENIENTLY (a close/colloquial name works), unlike the write tools which require an exact match. Mixed-unit logs are compared correctly (a 100 kg set outranks a 200 lb one).

• exercise (string, required): Exercise name or id (matched leniently)

get_user_context · Get user context (read · Free)

A dense snapshot of the user so you can act correctly: recent workouts, the user's exercise vocabulary (the exact ids/names valid for log_set), and per-exercise estimated 1RM, recent working ranges, and PRs. Call this before logging if you're unsure of the exact exercise identifier.

No parameters.

search_exercises · Search exercise catalog (read · Free)

Browse the built-in exercise catalog (896 movements) to find the EXACT id/name to pass to create_routine / log_set. Fuzzy `query` matches name, alternate names (aliases like 'skull crusher' → 'Lying Dumbbell Tricep Extension'), equipment, and muscles, tolerating typos and word order. Filter by target `muscle` (e.g. 'chest', 'quadriceps') and/or `equipment` (e.g. 'barbell', 'dumbbell', 'cable'). Use this whenever you want to program a movement the user hasn't logged before — get_user_context only covers what they've already done. Returns id | name | equipment | primary muscles (+ aka aliases when present).

• query (string): Name substring, e.g. 'press' or 'romanian deadlift'
• muscle (string): Filter by a primary muscle, e.g. 'chest', 'hamstrings', 'lats'
• equipment (string): Filter by equipment, e.g. 'barbell', 'dumbbell', 'cable', 'body only'
• limit (integer): Max results (default 20, max 100)

list_workouts · List workouts (read · Free)

List the user's COMPLETED workouts (most recent first) with full per-exercise set detail (weight × reps or timed hold, RIR, warmups, and any per-set note the lifter left). Each session shows the routine it was started from (name + [routine id]) when it had one. Use this to analyze training history before programming; for a done-vs-programmed deviation view use get_plan_adherence. Defaults to completed sessions only; pass includeInProgress to also see a session still being logged. Optionally bound the window with `since`/`before` (ISO-8601; inclusive-start, exclusive-end).

• limit (integer): Max workouts (default 10, max 100)
• includeInProgress (boolean): Include the in-progress session too (default false)
• since (string): Only workouts dated at/after this ISO-8601 instant (inclusive).
• before (string): Only workouts dated strictly before this ISO-8601 instant (exclusive).

get_export · Export all data (read · Free)

Bulk-export the user's full synced history as wire-contract JSON — EVERY category that syncs (workouts + exercises + sets, routines + items, weekly plans + days, body metrics, cardio, custom exercises, gyms, settings), so nothing is left behind. Cursor-paginated: call with no cursor for the first page, then pass back the returned `cursor` while `hasMore` is true. The machine-readable records are in structuredContent.changes (keyed by category); the text is a per-category count summary. The anti-lock-in path for quantified-self users.

• cursor (string): Opaque pagination cursor from a prior get_export response; omit for the first page.
• limit (integer): Max records per page (default 500, max 1000).

get_cardio · List cardio activities (read · Free)

List ALL the user's cardio, newest first — both standalone cardio activities (runs/rides/swims…) AND cardio logged INSIDE a strength workout (a distance/duration exercise like a treadmill or rower block). Each row: date | type | distance · time · pace (distance rounded to miles, time as H:MM:SS, pace /mi); in-workout entries are tagged with their parent workout id. The structuredContent mirror carries canonical meters/seconds plus `source` ('activity' | 'inWorkout') and `workoutId`.

• limit (integer): Max rows (default 30, max 500)

get_body_metrics · Get body metrics (read · Free)

Read the user's logged body metrics, newest first — the coaching context the workout tools can't see (relative strength, cut/bulk progress). Covers bodyweight, body-fat % (logged in the app or imported from Apple Health, type 'bodyFatPercent', unit '%'), and custom tape measurements. Optionally filter by `type` (e.g. 'bodyweight', 'bodyFatPercent', or a measurement name). Returns date | type | value unit.

• type (string): Filter to one metric type, e.g. 'bodyweight' (optional — omit for all)
• limit (integer): Max rows, newest first (default 30, max 500)

list_routines · List routines (read · Free)

List the user's training routines (programs) with each routine's id, name, and ordered exercises (exact exercise id/name + target sets, rep range, and rest). Call before update_routine to get the routine id and the current item list.

No parameters.

list_plans · List weekly plans (read · Free)

List the user's weekly plans (which routine runs on which weekday). At most one plan is ACTIVE — it steers the app's Train tab, widget, and nudges. Each plan shows its id, weekday→routine schedule, missed-day policy, and — when it was produced by the app's plan generator — the generating request (goal, days/week, experience, equipment). Call before update_plan/delete_plan to get ids.

No parameters.

Analysis & coaching reads

get_plan_adherence · Plan adherence (done vs programmed) (read · Free)

How the lifter's ACTUAL sessions compare to the routines they were started from: per session, the programmed movements they SKIPPED, the movements they ADDED, and the inferred SWAPS (a programmed exercise dropped for a same-muscle one), plus cross-session tallies of the recurring swaps and skips. Only sessions started from a routine are analyzed. IMPORTANT — read before trusting the output: the model does NOT snapshot a routine's exercises at session time, so each session is compared against the routine's CURRENT list. A session that ran BEFORE its routine was last edited is flagged (⚠) and its deviations are withheld and excluded from the tallies, because comparing it to the current list would invent skips and invert swaps. So right after editing routines the tallies may be empty — that's honest, not a bug; sessions logged after the edit repopulate them. A swap is inferred only when a skipped and an added exercise in one session share a primary muscle. The tool reports; it does not tell the user to drop or keep anything. `limit` bounds how many recent routine-based sessions to analyze (default 20).

• limit (integer): Max recent routine-based sessions to analyze (default 20).

get_stats · Get training stats (read · Free)

Aggregate training stats across all the user's logged working sets: per-exercise estimated 1RM / heaviest / total volume, total volume by muscle, and a weekly volume trend (all weights normalized to lb). The dense analytics view for spotting progress, imbalances, and fatigue before programming.

No parameters.

get_strength_standards · Get strength standards (read · Free)

Rate the user's big barbell lifts (squat / bench / deadlift / overhead press) against sex-specific population strength standards: bodyweight-relative ratio, percentile (1–99), and a Beginner→Elite level — the same assessment the app's Progress screen shows. Needs a logged bodyweight (see get_body_metrics). Sex isn't synced, so pass `sex` for accuracy; it defaults to male with a note. Only clean competition-style barbell variants count (an incline bench / RDL won't).

• sex (string): Biological sex for the standard (defaults to male if omitted).

get_muscle_balance · Get muscle balance (read · Free)

Per-muscle weekly effective working-set volume vs evidence-based hypertrophy target bands (à la Renaissance Periodization MEV–MAV), plus days since each muscle was last trained — for ALL muscle groups, so neglected ones surface too. Attribution is fractional: each set credits its primary muscles 1.0 and secondaries 0.5 (a squat credits glutes/hamstrings/erectors, not just quads), with the direct-set count reported alongside, so 'untrained' means zero contribution of any kind. Each muscle is labeled untrained / under / optimal / high. The coaching view for spotting imbalances and under/over-training before programming.

No parameters.

get_training_consistency · Get training consistency (read · Free)

Training cadence at a glance: sessions this week and this month, the current consecutive-week streak, average sessions/week, and the last 8 weeks' session counts. Use to coach consistency ('you've trained 4 weeks straight' vs 'let's rebuild the habit').

No parameters.

get_progress · Get progress (read · Free)

Progress over time, computed from history: recent PRs (estimated-1RM, top-weight, rep-at-a-held-load, session-volume, and timed-hold records — a rep or session-volume PR means double/density progression is working), stalls (lifts with NO qualifying PR of any kind in several sessions, classified regressing/holding/rebuilding/densifying — 'rebuilding' means e1RM is climbing back after a deliberate load drop and 'densifying' means session volume is climbing at held loads, neither a plateau), related-lift context (a close variant PRing or trending up while a lift is flagged), and a per-exercise trend snapshot (current e1RM, all-time best, direction over the stated span, recent e1RM series). The signal for spotting what's moving and what's stuck.

No parameters.

get_week_review · Get week review (read · Pro)

The coach's week-in-review digest for one training week (Monday–Sunday): sessions / working sets / tonnage with the prior-week trend, adherence to the active weekly plan (which scheduled days slipped), PR events that landed in the week, per-muscle weekly working sets vs the evidence bands, and 1–3 dry, evidence-cited focus pointers for next week. Honest by design — it reports what the log shows and never cheers. `week`: 'last' (default — the most recently completed week, the natural Monday read) or 'current' (the in-flight week; open days are not counted as missed and a clean read is explicitly provisional).

• week (string): 'last' (default) = the most recently completed Mon–Sun week; 'current' = the week in progress.

assess_session · Assess session (read · Pro)

An honest, evidence-based verdict on a finished session — measured against the user's OWN history (their bests, their last session, their personal volume norm). Returns a tier (breakthrough / strong / solid / light / empty), a headline + subtext, and the evidence behind it. Deliberately not generic praise: a PR is celebrated, a light/sandbagged day gets a candid nudge. Defaults to the most recent finished session; pass `sessionId` (from list_workouts) for a specific one.

• sessionId (string): A specific session id (from list_workouts). Omit for the most recent finished session.

estimate_starting_weight · Estimate starting weight (read · Free)

Estimate a sensible STARTING working weight + rep range for an exercise the user has NEVER logged, by transferring strength from the most similar lift they HAVE logged. Returns the band (lb), an estimated 1RM, the donor lift it's based on, and a confidence — an estimate with provenance, deliberately conservative (warm up toward it, never auto-load). For a lift the user already trains, use get_history / get_pr instead. `exercise` must EXACTLY match a catalog name/id or one of the user's customs.

• exercise (string, required): Exact exercise name or id of the un-logged target, e.g. 'Incline Dumbbell Press'

Logging

log_set · Log set (write · Pro)

Log one completed set onto the user's synced workout (the app sees it). The `exercise` must EXACTLY match a catalog exercise name/id or one of the user's custom exercises — call get_user_context first if unsure. Nothing is created for an unknown exercise. For a normal set pass `reps` (with `weight`). For a TIMED HOLD (plank, wall sit, dead hang) pass `durationSeconds` and omit `reps` (weight 0 unless it's a weighted hold). For a LOADED CARRY (farmers walk, yoke, sled push) pass `distanceMeters` (optionally with `durationSeconds`) and omit `reps`. Weight defaults to lb — pass `weightUnit: "kg"` to log a kilogram set (it round-trips losslessly to the app). By default the set lands on the live/most-recent session; to FIX UP A PAST WORKOUT (e.g. a movement you forgot to log earlier) pass `workoutId` from list_workouts to attach it to that exact session, or pass `date` (ISO-8601) to place it on that day. To avoid double-logging on a retry, pass a stable `idempotencyKey` and REUSE the same value if you call again for the same set.

• exercise (string, required): Exact exercise name or id, e.g. 'Barbell Deadlift' or 'Barbell_Deadlift'
• weight (number, required): Weight (≥ 0; use 0 for bodyweight movements and unweighted holds). Unit is lb unless weightUnit says otherwise.
• weightUnit (string): Unit the `weight` is given in (optional, default 'lb'). The app stores and displays the set in this exact unit.
• reps (integer): Reps completed (≥ 1). Omit for a timed hold or loaded carry — pass durationSeconds and/or distanceMeters instead.
• durationSeconds (number): Hold duration in seconds for a timed isometric exercise (plank/wall sit/dead hang), or the time a carry took. Provide this and/or distanceMeters, OR reps.
• distanceMeters (number): Distance in meters for a loaded carry (farmers walk, yoke walk, sled push). Pair with `weight`; omit reps.
• rir (integer): Reps in reserve (optional, ≥ 0)
• isWarmup (boolean): Whether this was a warmup set (optional, default false)
• workoutId (string): Attach this set to an existing session (its id from list_workouts) instead of the live/most-recent one — use it to add a forgotten movement to a past, already-finished workout.
• date (string): ISO-8601 instant the set was performed (optional). Without workoutId, also places the set on that calendar day's session (creating one if needed) so a backfilled set reads on the correct date instead of today.
• idempotencyKey (string): Optional stable key identifying this logical set; reuse the exact same value when retrying so a duplicate call doesn't log a second set.
• note (string): Optional free-text note on this set (e.g. 'felt heavy', 'grip gave out'); shown on the set in the app.

finish_workout · Finish workout (write · Pro)

Mark a workout session as COMPLETED (stamps its finishedAt). Use this after logging the final set of a session you built with log_set, so it counts as a completed workout in the app's history and stats. Get the session id from a log_set response (the `session …` it returns) or from list_workouts({ includeInProgress: true }). Idempotent: finishing an already-finished session is a no-op. Finished by mistake? unfinish_workout reverses it.

• sessionId (string, required): The workout session id (from a log_set response or list_workouts)

log_cardio · Log cardio activity (write · Pro)

Log a cardio session (run/ride/swim/…) onto the user's synced model (the app sees it). `activityType` is a name (Cycling, Elliptical, Hiking, Rowing, Running, Stair Climbing, Swimming, Walking, HIIT, Other) or a raw HKWorkoutActivityType integer. Distance is in METERS and duration in SECONDS (canonical; the app converts to mi/km for display) — both optional, but provide at least one. To avoid double-logging on a retry, pass a stable `idempotencyKey` and REUSE it if you call again for the same activity.

• activityType (string, required): Activity type name (e.g. 'running', 'cycling') or a raw HK integer
• distanceMeters (number): Distance in meters (optional, > 0)
• durationSeconds (number): Duration in seconds (optional, > 0)
• notes (string): Optional notes
• date (string): ISO-8601 date/time of the activity (optional, defaults to now)
• idempotencyKey (string): Stable key; reuse on retry so a duplicate call doesn't log twice.

log_body_metric · Log body metric (write · Pro)

Log a body metric onto the user's synced model (the app sees it): `type` 'bodyweight' (unit lb or kg), 'bodyFatPercent' (unit '%', matching the app/Apple Health), or 'measurement' (a tape measurement, unit in or cm, with a `name` for the site — e.g. 'Waist', 'Chest', 'Hips', 'Left Bicep'; reuse the user's existing names from get_body_metrics so trends stay on one chart). The value is stored verbatim in its entered unit. The coach and strength standards prefer a logged bodyweight, so log one when the user tells you their weight. To avoid double-logging on a retry, pass a stable `idempotencyKey` and REUSE it if you call again for the same sample.

• type (string, required): 'bodyweight', 'bodyFatPercent', or 'measurement'
• value (number, required): The reading, in `unit` (stored verbatim)
• unit (string, required): lb/kg for bodyweight; '%' for bodyFatPercent; in/cm for measurements
• name (string): Measurement site (required for type 'measurement', e.g. 'Waist'); omit for bodyweight/bodyFatPercent
• date (string): ISO-8601 date/time of the sample (optional, defaults to now)
• idempotencyKey (string): Stable key; reuse on retry so a duplicate call doesn't log twice.

Programming: routines & plans

create_exercise · Create a custom exercise (write · Pro)

Create a CUSTOM exercise when the movement you want isn't in the built-in catalog. ALWAYS call search_exercises first — if it's already in the catalog, use that instead (this tool rejects a name that matches a catalog exercise, and a name matching one of the user's existing customs). Only `name` is required; everything else is optional with sensible defaults (level=beginner, category=strength, trackingType=weightReps). Once created it syncs to the app and is immediately usable by log_set / create_routine (pass its name or id exactly). For non-weight×reps movements set `trackingType`: reps (bodyweight), duration (timed hold), distanceDuration (cardio), or weightedCarry (loaded carry — weight over distance). To avoid creating a duplicate on a retry, pass a stable `idempotencyKey` and REUSE the same value if you call again for the same exercise.

• name (string, required): Display name, e.g. 'Spoto Press', 'Copenhagen Plank'
• idempotencyKey (string): Optional stable key identifying this logical exercise; reuse the exact same value when retrying so a duplicate call doesn't create a second copy.
• primaryMuscles (array): Primary muscles worked, e.g. ['chest','triceps'] (optional)
• secondaryMuscles (array): Secondary muscles, e.g. ['shoulders'] (optional)
• equipment (string): Equipment, e.g. 'barbell', 'dumbbell', 'cable', 'body only' (optional)
• force (string): 'push', 'pull', or 'static' (optional)
• mechanic (string): 'compound' or 'isolation' (optional)
• level (string): 'beginner', 'intermediate', or 'expert' (optional, default 'beginner')
• category (string): e.g. 'strength', 'cardio', 'stretching' (optional, default 'strength')
• instructions (array): Step-by-step instructions (optional)
• trackingType (string): How the movement is tracked (optional, default 'weightReps')

delete_exercise · Delete a custom exercise (write · Pro)

Delete one of the user's CUSTOM exercises (soft delete, syncs to the app/watch). Only user-created customs can be deleted — a built-in catalog exercise is refused (it's regenerated identically on every device). Past workouts that logged the custom are untouched (their sets keep resolving by id); only the custom definition goes. Pass the custom's id (a `custom-…` id from get_user_context / search_exercises). Irreversible from this surface — there is no undelete tool.

• exerciseId (string, required): The custom exercise's id (a 'custom-…' id from get_user_context or search_exercises)

create_routine · Create routine (write · Pro)

Author a NEW training routine (program) for the user — the agent's primary write capability. Each exercise must EXACTLY match a catalog name/id or one of the user's customs (call get_user_context if unsure); an unknown exercise rejects the whole call (nothing is created). Per-exercise prescription is optional and defaults to 3 sets × 8–12 reps, 90s rest. The routine syncs to the app and watch, ready to start. To avoid duplicate routines on a retry, pass a stable `idempotencyKey` and REUSE the same value if you call again for the same routine.

• name (string, required): Routine name, e.g. 'Push Day A' (max 200 chars)
• notes (string): Optional coaching notes for the routine
• idempotencyKey (string): Optional stable key identifying this logical routine; reuse the exact same value when retrying so a duplicate call doesn't create a second copy.
• exercises (array, required): Ordered exercises in the routine (at least one).

update_routine · Update routine (write · Pro)

Revise an existing routine (get its id from list_routines). Optionally rename (`name`) and/or re-note (`notes`). If `exercises` is given it REPLACES the routine's full exercise list (old items removed, new ordered list written) — use it to reprogram a block. Same exact-match rule as create_routine: an unknown exercise rejects the whole call.

• routineId (string, required): The routine's id (from list_routines)
• name (string): New name (optional, max 200 chars)
• notes (string): New notes (optional)
• exercises (array): Optional FULL replacement of the routine's ordered exercises.

delete_routine · Delete routine (write · Pro)

Delete a routine and its exercise list (soft delete, same as deleting a routine in the app — past workouts logged from it are untouched). Get the id from list_routines. If a weekly plan still schedules the routine, the plan keeps the slot and the response names the affected plans so you can revise them with update_plan. Irreversible from this surface — there is no undelete tool.

• routineId (string, required): The routine's id (from list_routines)

create_plan · Create weekly plan (write · Pro)

Put a weekly schedule on the user's calendar: map routines onto weekdays (1 = Monday … 7 = Sunday). Each routine must be the user's own — pass a routine id or exact name from list_routines (create routines first with create_routine if needed). Activates by default, replacing whatever plan was steering the app (pass activate: false to save without scheduling). Syncs to the app and watch; missed days default to catching up. `name` is capped at 200 characters and `notes` at 2000. To avoid duplicate plans on a retry, pass a stable `idempotencyKey` and REUSE the same value if you call again for the same plan.

• name (string, required): Plan name, e.g. 'Push/Pull/Legs' (max 200 chars)
• days (array, required): The weekday→routine slots (at least one). Unlisted weekdays are rest days.
• missedPolicy (string): What a missed day becomes: 'catchUp' (default — it leads the week until done) or 'skip' (strict calendar).
• activate (boolean): Make this the active plan (default true; deactivates any other).
• notes (string): Optional coaching notes for the plan (max 2000 chars)
• idempotencyKey (string): Optional stable key identifying this logical plan; reuse the exact same value when retrying so a duplicate call doesn't create a second copy.

update_plan · Update weekly plan (write · Pro)

Revise a weekly plan (get its id from list_plans). Optionally rename, re-note, change the missed-day policy, REPLACE the full weekday→routine schedule (`days` swaps the whole week), and/or flip `isActive` (activating deactivates every other plan; deactivating leaves the app on rotation inference). `name` is capped at 200 characters and `notes` at 2000.

• planId (string, required): The plan's id (from list_plans)
• name (string): New name (optional, max 200 chars)
• notes (string): New notes (optional, max 2000 chars)
• missedPolicy (string): New missed-day policy (optional)
• days (array): Optional FULL replacement of the weekday→routine slots.
• isActive (boolean): Activate (true) or deactivate (false) this plan (optional)

delete_plan · Delete weekly plan (write · Pro)

Delete a weekly plan (soft delete — the routines it scheduled stay in the user's list, only the weekly schedule goes). Get the id from list_plans.

• planId (string, required): The plan's id (from list_plans)

generate_plan · Generate a training plan (read · Free)

PROPOSE a multi-day training plan for the user with the app's own plan generator — the same engine onboarding uses. Read-only: it returns a suggested week (day names, exercise picks, sets × rep range, rest) tailored to `goal` and `daysPerWeek`, ranking the catalog against the user's own history (so familiar lifts and sensible progressions surface), and persists NOTHING. For lifts the user has never logged it includes a provenance-labelled starting weight band (in lb, like the rest of the surface; the structuredContent mirror carries canonical kg). Use it to draft a program to discuss; to actually schedule it, persist the routines with create_routine and the weekly schedule with create_plan.

• goal (string, required): Training goal (drives set/rep/rest scheme).
• daysPerWeek (integer, required): Training days per week (1–6); sets the split.
• equipment (array): Lowercased equipment the user can access, e.g. ['barbell','dumbbell','cable']. Omit/empty = unconstrained ('body only' is always allowed).
• experience (string): Training experience (optional, defaults to beginner).
• avoidExerciseIds (array): Exercise ids to exclude (optional), e.g. from search_exercises.
• avoidMuscles (array): Primary-muscle strings to avoid for injury (optional), e.g. ['lower back'].
• preferFullBody (boolean): Force Full Body A/B/C at 1–3 days/week instead of the default split (optional).

Corrections & cleanup

unfinish_workout · Reopen a finished workout (write · Pro)

Reopen an accidentally finished workout session: clears its finishedAt so it reads as IN PROGRESS again in the app (the live workout UI can pick it back up) and it stops counting as completed in history/stats until it's finished again. The inverse of finish_workout. Get the session id from list_workouts or a log_set response. Idempotent: reopening a session that's already in progress is a no-op. A deleted session cannot be reopened.

• sessionId (string, required): The workout session id (from list_workouts or a log_set response)

merge_workouts · Merge two workouts (write · Pro)

Fold one workout session into another: every set from `fromSessionId` moves into `intoSessionId` (keeping its identity, performed time, warmup flag, RIR, notes, rest, and heart-rate data), and the emptied source session is then deleted. Sets of the same exercise append after the target's existing sets; other exercises are added to the target. The one-call fix for an accidental split, e.g. finish_workout fired mid-session and the remaining sets landed on a second session. The merged result syncs to the app/watch. Get both ids from list_workouts({ includeInProgress: true }). The source session's own fields (notes/date/gym) are NOT copied; only its sets move. Irreversible from this surface.

• fromSessionId (string, required): The session to empty and delete; its sets move out (from list_workouts)
• intoSessionId (string, required): The session that receives the sets and survives (from list_workouts)

delete_workout · Delete workout (write · Pro)

Delete a workout session and everything in it — its exercises and sets (soft delete, same cascade as deleting a workout in the app). History, PRs, and stats drop the sets immediately, and the deletion syncs to the app/watch. Use to remove a mis-logged or test session. Get the id from list_workouts({ includeInProgress: true }) or a log_set response. Irreversible from this surface — there is no undelete tool.

• sessionId (string, required): The workout session id (from list_workouts or a log_set response)

update_workout · Edit a workout (write · Pro)

Edit a workout session's own fields — its `date`, `notes`, `rating` (1 = thumbs-up), and/or `gymId` — WITHOUT touching its exercises or sets. Provide at least one field; omitted fields keep their current value (pass `notes`/`rating`/`gymId` as null to clear them). Works on a completed or in-progress session; the edit keeps the session's identity and syncs to the app/watch. Get the `sessionId` from list_workouts ("[id: <id>]") or a log_set response. To change the SETS in a workout use update_set / log_set / delete_set; to move a set to a different day use its `date` here or re-log it.

• sessionId (string, required): The workout session id (from list_workouts or a log_set response)
• date (string): New ISO-8601 date/time for the session (optional).
• notes (string,null): New session notes, or null to clear (optional).
• rating (integer,null): Lifter's verdict: 1 = thumbs-up, or null to clear (optional).
• gymId (string,null): The Gym.id this session was performed at, or null to clear (optional).

update_set · Edit a logged set (write · Pro)

Correct a previously logged set — change its weight, reps, RIR, warmup flag, unit, hold duration, and/or per-set note. Provide at least one field; omitted fields keep their current value (pass `rir: null` to clear an RIR). `weight` is interpreted in the set's OWN entered unit unless you also pass `weightUnit` to re-unit it. To fix a mis-logged timed hold pass `durationSeconds` (or `durationSeconds: null` to turn it back into a normal weight×reps set). The set keeps its identity, exercise, and place in the session; the edit syncs to the app/watch and re-counts in history/PRs/stats. Get the `setId` from list_workouts (each set renders as "…×… [set <id>]") or from a log_set response. To change which exercise a set belongs to, delete it and log_set under the right exercise instead.

• setId (string, required): The set id (from list_workouts — shown as "[set <id>]" — or a log_set response)
• weight (number): New weight in the set's entered unit (≥ 0; pass weightUnit to change the unit). Optional.
• weightUnit (string): Re-unit the set to lb or kg (optional; default keeps the set's current unit).
• reps (integer): New rep count (≥ 1; optional)
• rir (integer,null): New reps-in-reserve (≥ 0), or null to clear it (optional)
• isWarmup (boolean): New warmup flag (optional)
• durationSeconds (number,null): New timed-hold duration in seconds, or null to clear it (turns it back into a weight×reps set). Optional.
• distanceMeters (number,null): New carry distance in meters, or null to clear it. Optional.
• note (string,null): Set or edit the set's free-text note, or null to clear it. Optional.

reorder_exercises · Reorder exercises in a workout (write · Pro)

Reorder the exercises within an IN-PROGRESS workout. Pass the session's WorkoutExercise ids in the new order — they're rewritten in place (each set keeps its identity; nothing is deleted or recreated) and the new order syncs to the app/watch. In-progress sessions ONLY: a finished workout is rejected. Call list_workouts({ includeInProgress: true }) to get the in-progress session id and its exercises' current order — each exercise renders its handle as "[ex <id>]". `exerciseIds` must be an EXACT reordering of the session's current exercises (same ids, same count, none added or omitted). If the new order splits a superset apart (its members are no longer adjacent), that superset is automatically broken (its grouping cleared) and the response says which exercises were affected.

• sessionId (string, required): The in-progress workout session id (from list_workouts({ includeInProgress: true }))
• exerciseIds (array, required): The session's WorkoutExercise ids (the "[ex <id>]" handles from list_workouts) in the desired order — an exact reordering of the current set.

delete_set · Delete a logged set (write · Pro)

Delete a single mis-logged set (soft delete, same as removing one set in the app). History, PRs, and stats drop it immediately and the deletion syncs to the app/watch; the rest of the workout is untouched. Get the `setId` from list_workouts (each set renders as "…×… [set <id>]") or a log_set response. To remove an entire session, use delete_workout instead. Irreversible from this surface — there is no undelete tool.

• setId (string, required): The set id (from list_workouts — shown as "[set <id>]" — or a log_set response)

reassign_exercise · Relabel a set / exercise to a different movement (write · Pro)

RELABEL logged work to a different exercise WITHOUT losing anything — the fidelity-preserving fix for a mis-identified movement (e.g. sets logged as "Machine Hip Thrust" that were really the glute-kickback machine). Unlike delete + re-log, every set keeps its identity, exact performed time, rest taken, per-set heart rate, RIR, warmup flag, and note — only which exercise it counts as changes, and history/PRs/volume follow. Two modes: pass `setId` to move ONE set, or pass `fromExercise` to move EVERY set of that movement across all history (the "this was mislabeled the whole time" bulk fix). `toExercise` (required) and `fromExercise` must EXACTLY match a catalog name/id or one of the user's customs. A source exercise left with no sets by the move is cleaned up automatically. The relabel syncs to the app/watch.

• toExercise (string, required): The correct exercise to move the work onto — exact catalog name/id or a custom.
• setId (string): Move just this one set (its "[set <id>]" handle from list_workouts). Provide this OR fromExercise.
• fromExercise (string): Bulk mode: move EVERY set currently logged as this exercise (exact catalog name/id or a custom). Provide this OR setId.

remove_workout_exercise · Remove an empty exercise slot from a workout (write · Pro)

Remove an EMPTY exercise slot (a "(no sets)" row) from a workout — the leftover a relabel, a mid-workout abandon, or an app tap can strand. Refuses a slot that still has any logged set (it would be dropping real work — use delete_set / delete_workout for those), so this can only ever clear a genuinely empty row. Get the `workoutExerciseId` from list_workouts — each exercise renders its handle as "[ex <id>]", and an empty one shows "(no sets)". Soft delete; syncs to the app/watch.

• workoutExerciseId (string, required): The WorkoutExercise handle (the "[ex <id>]" from list_workouts) of the empty slot to remove.

delete_body_metric · Delete a body metric (write · Pro)

Delete a single mis-logged body metric (soft delete, same as removing one in the app) — a bodyweight, body-fat, or measurement reading. Trends drop it immediately and the deletion syncs to the app/watch. Get the `metricId` (the `[id: <id>]`) from get_body_metrics. Irreversible from this surface — there is no undelete tool.

• metricId (string, required): The body-metric id (the "[id: <id>]" from get_body_metrics)

delete_cardio · Delete a cardio activity (write · Pro)

Delete a single mis-logged standalone cardio activity (a run/ride/swim you logged with log_cardio; soft delete, same as removing it in the app). It drops from get_cardio immediately and the deletion syncs to the app/watch. Get the `cardioId` (the `[id: <id>]`) from get_cardio — only standalone activities (source 'activity') are deletable here; to remove cardio logged INSIDE a strength workout, use delete_set / delete_workout on that session instead. Irreversible from this surface — there is no undelete tool.

• cardioId (string, required): The cardio activity id (the "[id: <id>]" from get_cardio, source 'activity')

Account & feedback

set_profile · Set profile (write · Free)

Set the user's profile inputs for strength standards — biological `sex` ('male'/'female') and/or `bodyweightLb` — on their synced cloud profile. Use this when standards can't be computed because sex or bodyweight is missing (e.g. get_strength_standards reports no bodyweight), or to correct them. IMPORTANT: this writes only to the cloud profile used here for analytics. It does NOT write to Apple Health, and it does not change what the iOS app displays; the app pushes its own sex from the device and a logged bodyweight syncs separately, either of which can later supersede what you set. Prefer values the user explicitly states.

• sex (string): Biological sex for sex-specific standards.
• bodyweightLb (number): Bodyweight in lb (> 0). Stored in kg on the profile.

submit_feedback · Submit feedback (write · Free)

Send feedback, a bug report, a feature request, or a support question to the MyoAmigo team on the user's behalf. Use this only when the user explicitly asks to send feedback or report a problem — relay their words; do not invent feedback. The message is saved and the team is notified by email. Returns a reference id.

• message (string, required): The feedback / report / question, in the user's words (required, ≤ 5000 chars).
• category (string): What kind of feedback this is (default 'other').
• subject (string): Optional short subject line (≤ 200 chars).
• contactEmail (string): Optional reply-to address if the user wants a response somewhere other than their account email.

Security & privacy

Authentication is OAuth 2.1 (tokens audience-scoped to the MCP endpoint) or a per-account API key (stored hashed, rotatable, rate-limited). Every tool call is scoped to the authenticated user. See the privacy policy and the product fact sheet.

Compatibility & version

Works with any MCP client; per-client guides live on the Connect hub. MCP protocol version: 2025-06-18. Machine-readable catalog: tools.json.