Skip to main content
Glama

Nolio

Server Details

Endurance, strength and Hyrox coaching platform

Ownership verified
Status
Healthy
Uptime
100.0% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
ChatGPT
–
Claude
Nolio

TDQS

A4.1/5.0

Scored across 39 tools

Disambiguation4/5

Most tools map cleanly to a distinct resource+action, and overlapping cases are explicitly defused in the descriptions (e.g. list_planned_trainings says to use get_calendar(mode='planned') for the full palette; apply_training_frame vs create_planned_training vs create_planned_event are separated by template/workout/event type). The main residual risk is create_training_frame vs apply_training_frame vs create_planned_training, and the generic nolio_api_read/write vs curated reads, but the redirects are stated. Minor ambiguity only.

Naming Consistency4/5

Nearly all tools follow snake_case verb_noun (get_calendar, create_planned_event, update_planned_training, delete_event, list_metrics), which is predictable. Deviations are few: read_conversations uses 'read' where peers use get/list, and nolio_api_read/nolio_api_write invert to noun_verb, though their generic-gateway role explains it.

Tool Count2/5

39 tools is well above the practical ceiling for reliable agent selection, and the surface spans many sub-domains (calendar, library folders, templates, metrics, records, stats, load, conversations, billing, undo, raw API). The scope is genuinely broad and each tool has a purpose, but the count is heavy and some curated tools could be absorbed by the generic API gateway plus search_nolio_api_docs.

Completeness4/5

Lifecycle coverage is strong: create/read/update/delete across planned trainings, planned events, library templates and folders, plus calendar reads, records, stats, load, conversations, review, undo and billing. Gaps are minor and intentional (folder deletion and exercise creation are app-only, no tag creation), and nolio_api_write/nolio_api_read provide an escape hatch for the rest.

Publisher details

Operator
Nolio
Operator website
https://www.nolio.io
Vendor relationship
First-party
Privacy policy
Not provided
Restrictions
Need a paid plan

Available Tools

39 tools
apply_training_frameApply a template to the calendarAInspect

Schedule a library template on the calendar — the same gesture as dragging a template onto the calendar in the app. Use this to schedule an existing library template — do not copy its content manually via create. No content overrides here: to adjust the result, call update_planned_training afterwards. At most one of "athletes" or "group" — never both. Omit both to target your own calendar (self). If a request expands to more than 3 creations, updates or deletions, do not call this tool in a loop: send them all as one POST batch/ via nolio_api_write with dry_run=true (PATCH and DELETE on planned// and library// included), get the user's go-ahead on a plain-language recap of what will change on whose calendar, then resend the same operations with the returned confirm_token. Before scheduling anything on a period, read what is already there in one call: get_calendar with mode='planned' over the window (and athlete for a managed athlete) renders the workouts, competitions, cycles, notes and quizzes at once; surface the conflicts before proposing.

Inputs: frame (required), date_start (required), time, group, +3 more.

create_library_categoryCreate a library folderAInspect

Create a folder in your template library, or in a club's library.

type: what the folder holds: 'event' (workout, note and questionnaire templates), 'plan' (plan templates) or 'exercise' (exercises). Defaults to 'event', or to the parent's type. parent: the cat_… handle of a root folder from list_library_categories, to create a sub-folder in it. Folders nest one level only. Under a club folder, pass that club's team too. team: a team_… handle from list_athletes, to create the folder in that club's library instead of yours ('event' and 'plan' folders only). File templates in it with create_training_frame or update_training_frame (category).

Inputs: name (required), team, type, parent. Returns: object

create_planned_eventPlan a race, cycle, note or questionnaireAInspect

Plan a competition, a cycle, a note or a questionnaire on a planned calendar. Planned workouts go through create_planned_training instead.

Audience: athlete (one managed athlete's usr_… handle) or group (a grp_… you manage, one event the whole group sees), never both; neither plans it on your own calendar. name is required, except for a questionnaire planned from a template (it takes the template's name). Undo a creation with delete_event on the returned id.

Fields by type (any other field is refused):

  • competition (a race, the A-race being the main objective): sport (spt_… from list_sports, required), goal_type ('a' main goal, 'b' secondary), event (the race name), time (HH:MM) or moment (morning, noon, afternoon, evening), duration_minutes, distance_km, elevation_gain_m, elevation_loss_m, rpe (0-10), color.

  • cycle (a training block shown as a banner): date_end (YYYY-MM-DD, required on creation, on or after date_start), color. One cycle per period per athlete: an overlap is refused.

  • note (a marker on one day, or over a period with date_end): date_end (YYYY-MM-DD, on or after date_start, omitted = one day), note_type (rest, availability, unavailability, goal, menstruation), hour_start, hour_end (HH:MM), color. An availability also takes duration_minutes (the time available) and sports (spt_… from list_sports, [] clears them).

  • quiz (a questionnaire the athlete answers that day): hour_start (HH:MM, when it is sent, required for a group), and on creation exactly one of quiz_template (qzf_… from list_quiz_templates) or questions. Each question: {"question", "type", "is_mandatory", "choices", "unit", "metric"}; type is short_text, long_text, boolean, number (unit: kg, km, bpm, W… or a short free text), datetime (has_date, has_time), unique_choice (choices {"choices": [...]}, 2 or more), multiple_choices, range (choices {"start": 0 or 1, "advanced_captions": false, "captions": [...]}), metric_number or metric_range (metric: mti_… from list_metrics). Never an empty questionnaire. Every type takes name, date_start (YYYY-MM-DD) and description (plain text, accepted only while the event has no description).

Inputs: type (required), date_start (required), rpe, name, +20 more. Returns: object

create_planned_trainingCreate a planned workoutAInspect

Create a planned training workout on the calendar of one or more athletes, of a group, or of yourself. Required: date_start, name, sport. Audience is optional — At most one of "athletes" or "group" — never both. Omit both to target your own calendar (self). Express targets portably (zone, % of metric): the server resolves absolute values per athlete. If no schema field expresses a detail of the coach's intent, put it in the comment of the relevant node — never approximate it into another field, never drop it. If a request expands to more than 3 creations, updates or deletions, do not call this tool in a loop: send them all as one POST batch/ via nolio_api_write with dry_run=true (PATCH and DELETE on planned// and library// included), get the user's go-ahead on a plain-language recap of what will change on whose calendar, then resend the same operations with the returned confirm_token. Before scheduling anything on a period, read what is already there in one call: get_calendar with mode='planned' over the window (and athlete for a managed athlete) renders the workouts, competitions, cycles, notes and quizzes at once; surface the conflicts before proposing. Returns the normalized event with a human-readable summary: check it against the request. A multi-week plan is more than isolated workouts: the calendar also carries the A-race goal (posted first, the plan hangs off it), cycles (mesocycles of one to several weeks, on planned/cycles/) that structure the base/build/peak/taper phases, and notes as markers (reminders, rest days, key dates). A hand-built plan usually combines all of these, not workouts alone.

Inputs: name (required), sport (required), date_start (required), rpe, +18 more.

create_training_frameCreate a workout templateAInspect

Create a reusable workout template in the coach's library (personal by default, or a team library via "team"). A template has no date and no athletes — schedule it later with apply_training_frame. Zone and % targets stay portable and are resolved per athlete when the template is applied. If no schema field expresses a detail of the coach's intent, put it in the comment of the relevant node — never approximate it into another field, never drop it. If a request expands to more than 3 creations, updates or deletions, do not call this tool in a loop: send them all as one POST batch/ via nolio_api_write with dry_run=true (PATCH and DELETE on planned// and library// included), get the user's go-ahead on a plain-language recap of what will change on whose calendar, then resend the same operations with the returned confirm_token. Returns the normalized template with a human-readable summary.

Inputs: name (required), sport (required), category (required), rpe, +14 more.

delete_eventDelete a calendar event or a templateA
Destructive
Inspect

Delete one event from either calendar (planned or realized workout, competition, cycle, note, quiz, applied plan) or one library template (workout, note, quiz, competition, message, exercise, plan). The id says what it is, so pass the id you read back and nothing else. Deleting an applied plan or a plan template takes its whole content with it. This operation is destructive, always confirm with the user first. One event per call, never in a loop: several deletions of planned events or templates go in one POST batch/ (dry run first). Use recurrence_action only for planned events. If a request expands to more than 3 write operations, list the computed dates/targets and get explicit confirmation before writing.

Inputs: id (required), confirm (required), plan, group, +3 more.

get_calendarRead training calendarA
Read-only
Inspect

Read a training calendar: your own, a managed athlete's with athlete, or a group's with group.

mode: 'real' (workouts actually done, the default) or 'planned' (the prescription). Both modes render the whole calendar palette over the window, each type its own list, plus has_more per type: planned gives trainings, competitions (with goal_type), cycles (with date_end), notes and quizzes; real gives trainings, competitions (the races actually run, so a realized calendar read without them misses every race), notes (injuries, sicknesses, discomforts and other notes of the realized calendar) and quiz_results (the questionnaires answered, Hooper included, with every answer in items: value is the answer; a choice or a point on a scale reads against choices). An availability note carries duration (the time available) and sports. Every real training and competition carries the athlete's debrief (rpe, feeling, comment, answers to the coach's debrief questions); a coach's comments on a session are in its conversation (read_conversations with event), its laps and curves in get_training. Read it before scheduling anything on a period and surface the conflicts (a race in the window, a cycle already covering it, a duplicate) before proposing. If one type cannot be read the whole call fails (failed names the types): never treat that as an empty calendar. has_more[type]=true means that type's window is incomplete. Read the next page with types=[<type>] and starting_after set to the last returned item's id, keeping the same date_from/date_to/athlete/group/limit: drop group on the next page and you silently switch to your own calendar. Continue until has_more=false before concluding or scheduling. Each mode makes one API request per type (planned five, real four), each subject to the API quota: narrow with types when the question is about one type. types: read only these types of the mode's palette (e.g. ['competitions']). starting_after: next page of a single type, with types naming that one type. athlete: a managed athlete's usr_… handle (from list_athletes) to read their calendar; omit to read your own. An athlete you do not coach is refused (403). group: a grp_… handle (from list_athletes) to read what a group you manage has planned together: the workouts posted on the group itself, not the individual ones of its members. Never pass it with athlete. Planned mode only; a group you do not manage is refused (404). date_from / date_to: 'YYYY-MM-DD' window (omit for the most recent events). limit: max rows per type. Planned defaults to 100 with date_from or date_to, 10 without; real defaults to 10 even with a window. time_in_zones: add the per-zone seconds of every training. Off by default because it is heavy; turn it on only when the question is about intensity distribution. For a whole period, prefer the zones_duration_* chart of get_stats_chart. full_descriptions: planned descriptions are cut to their first 250 characters, flagged description_truncated. Read a planned workout with get_planned_training for its full text, or turn this on over a narrow window; it returns every text of the window. with_description_html: planned mode only, add description_html (the stored description in HTML, never cut) to every event. Read it over the event's date before changing a description that is already set.

Inputs: mode, group, limit, types, +7 more. Returns: object

get_endpoint_schemaGet API endpoint schemaA
Read-only
Inspect

Get the exact request/response schema of one API v2 endpoint (params, body, responses).

Call after search_nolio_api_docs to learn how to shape a nolio_api_read / nolio_api_write call. path may include or omit the /api/v2 prefix (e.g. 'metrics/records/'); method is the HTTP verb. Returns the operation plus the component schemas it references. tool: instead of path, the name of one of this server's tools (e.g. 'get_records'), to read the exact arguments it takes.

Inputs: path, tool, method. Returns: object

get_planned_trainingRead a planned workoutA
Read-only
Inspect

Read a planned training workout in the curated form. Returns the event exactly as update_planned_training takes it: every writable field, the workout nodes carrying their "id", plus read-only fields to leave out of a patch ("id", "revision", "summary", "has_structured_workout"...). A field sent back unchanged changes nothing, and the "resolved" values inside targets are ignored on write. "summary" is a human-readable text of the content, in the units of the caller; "revision" is the optimistic-concurrency token to pass back to update_planned_training. A step with neither "duration" nor "distance" is a note: not sent to watches, not an effort, skip it when counting intervals.

Inputs: id (required), group, athlete, recurrence_action, +1 more.

get_recordsRead personal recordsA
Read-only
Inspect

Read personal records: the best power, pace, heart rate, torque, vertical speed or cadence held over a duration or a distance.

Call it without category first: it returns no record, only the catalog of categories and windows (windows). Then read records with: category: ppr (power, W), phrr (heart rate, bpm), par (pace), ptr (torque, N.m), pvar (vertical speed, m/h), pcadr (cadence). axis: 'time' (best over a duration) or 'distance' (best over a distance covered). windows: durations in seconds or distances in metres, taken from the catalog only. sports: spt_… handles from list_sports. top: records per window, best first (max 10). Pace reads in seconds per km (running), per 100 m (swimming), per 500 m (rowing), km/h otherwise: format it for the person (238 s/km is 3:58 per km).

Inputs: top, axis, sports, athlete, +4 more. Returns: object

get_stats_chartRead a stats chartA
Read-only
Inspect

Read one statistics breakdown aggregated over a date window (the /statistic page data).

chart: an id from list_stats_charts, e.g. 'zones_duration_heartrate' (time in heart-rate zones), 'sport_duration' (volume by sport). date_from / date_to: 'YYYY-MM-DD' window (default: the last 365 days). athlete: a managed athlete's usr_… handle; omit for yourself. sport: an optional spt_… catalog handle to filter to one exact sport.

Returns rows ({label, value, color}, value is seconds for a duration/zones chart, a count of trainings, or the measure unit (distance, elevation_gain, kilojoules)) and total, the sum of the rows. A count chart counts the trainings carrying its dimension: sport_count every confirmed training of the window (competitions included, so it is the fill-rate denominator; a real/trainings listing hides competitions), rpe_count only those whose rpe is set (a null rpe is skipped, 0 counts as N/A), feeling_count every training (a missing feeling is the N/A row), tag_count counts a training once per tag it carries. For a month-by-month evolution, call this on several sub-windows and compare; a single call is the aggregate over the whole window. RPE/feeling rows also carry their numeric note in rpe/feeling (null for N/A). Use the numeric notes and counts for distributions; exclude null notes from statistics.

Inputs: chart (required), sport, athlete, date_to, +1 more. Returns: object

get_trainingRead a completed workoutA
Read-only
Inspect

Read one completed workout or race in full: duration, distance, load, heart rate, power, the athlete's debrief, and on request its laps and its sensor curves.

id: the trn_… (workout) or cmp_… (race) handle of a row returned by get_calendar(mode='real'). athlete: the managed athlete's usr_… handle when the workout is not yours. laps: add every lap, the ones recorded by the device first, then the ones drawn in Nolio, each with its stats as {value, unit}. When the connector's terms withhold them, only the laps drawn in Nolio come, with null stats, and laps_restriction says why. streams: the sensor curves to add, among heartrate, watts, cadence, torque, pace (a speed in m/s), altitude, distance, or the key of another curve of the file. time (seconds from the start) always comes with them, units gives each curve's unit. Ask only for the curves the question needs; a file-less workout returns available: false. Each curve is sampled evenly to max_points (default 600), every_nth_sample says the step; max_points can go higher, within 6000 points across the curves requested (time aside). from_index / to_index keep one window of samples, both included: a lap's start_index and end_index give exactly that lap. The response then carries from_index: point i of a curve is sample from_index + i * every_nth_sample. Files often hold more curves than these seven: ground contact time, vertical oscillation and ratio, stride length, running form power and leg stiffness, breathing rate, muscle oxygen (SmO2, THb), core and skin temperature, glucose, pedal smoothness and torque effectiveness, gears, stroke rate. Their keys vary by device: whenever you request a curve, other_streams lists the ones this file holds (key, name, unit); request them by key. A requested curve the file does not hold comes back in unknown_streams.

Inputs: id (required), laps, athlete, streams, +3 more. Returns: object

get_training_frameRead a workout templateA
Read-only
Inspect

Read a library workout template in the curated form. Returns the event exactly as update_training_frame takes it: every writable field, the workout nodes carrying their "id", plus read-only fields to leave out of a patch ("id", "revision", "summary", "has_structured_workout"...). A field sent back unchanged changes nothing, and the "resolved" values inside targets are ignored on write. "summary" is a human-readable text of the content, in the units of the caller; "revision" is the optimistic-concurrency token to pass back to update_training_frame. A step with neither "duration" nor "distance" is a note: not sent to watches, not an effort, skip it when counting intervals.

Inputs: id (required), with_description_html.

get_training_loadRead training-load curveA
Read-only
Inspect

Read the training-load curve (Coggan fitness / fatigue / form) over time.

mode: 'real' (the realized curve, bounded to today, the default) or 'planned' (the forward projection from the athlete's planned calendar, after today). Real and planned are the two temporal halves of one curve, ask for the one the question is about. date_from / date_to: 'YYYY-MM-DD' window (omit for a default 90-day window). athlete: a managed athlete's usr_… handle (from list_athletes) to read their curve; omit to read your own.

Each point carries fitness (CTL, long-term load), fatigue (ATL, short-term load), form (TSB = fitness - fatigue) and load (that day's training stress, TSS). Derive any ratio or trend the user asks for from these; the curve itself stays server-computed (it needs the athlete's own PMC time constants).

Inputs: mode, athlete, date_to, date_from. Returns: object

list_athletesList my athletesA
Read-only
Inspect

List the people you can target: your athletes (usr_…), plus your groups (grp_…) for collective targeting and the teams (team_…) of those groups: cite these ids verbatim, never guess. Pass q to filter by name (case/accent-insensitive fragment of an athlete or group name); bare call = the full roster. Former (archived) athletes are absent: their data is not readable through the API. Each group lists its athletes (usr_… ids) and its parent group if it is a sub-group; a parent group also holds its sub-groups' athletes, so never add groups up. An athlete with has_api_access: false has turned off access to their data from outside Nolio: say so plainly and do not try to read or plan for them.

Inputs: q.

list_athlete_subscriptionsList coaching subscriptionsA
Read-only
Inspect

List coaching subscriptions (a coach billing an athlete monthly via Stripe).

Returns the living subscriptions you can see: the ones you bill as a coach, and your own when you are billed as an athlete. An ended subscription is not listed: for who paid you over a period, former athletes included, read billing/payments/ with nolio_api_read. athlete: a managed athlete's usr_… handle (from list_athletes) to narrow to that athlete's subscription with you; omit to list all of yours. limit: max rows.

Read-only. Each row carries amount, status ('active', 'past_due', 'suspended', 'waiting', 'scheduled', 'incomplete', 'unknown'), date_start and date_end (the scheduled end when suspended).

Inputs: limit, athlete. Returns: object

list_exercisesList exercisesA
Read-only
Inspect

Search the exercises the coach can use: their OWN exercises, the team libraries they can see (never a team they are only an assistant of), and the shared Nolio global library, by name. Each result carries the public exercise id, name, type, is_load, laterality (none / alternate / left / right / fifty_fifty — whether the move is one-sided or bilateral), a scope (self / team / nolio), and an is_nolio flag (true = read-only Nolio exercise). Always reference an exercise by an id returned here; the search is the disambiguation step, never guess an id. When the exact phrase misses, the search falls back to word-level matching (a hint marks the fallback); if the exercise truly does not exist, tell the user and propose creating it (explicit, user-confirmed; creation is out of scope here), never invent one.

Inputs: query (required), type, is_load.

list_library_categoriesList library categoriesA
Read-only
Inspect

The folders of one section of your template library, like the web library tabs: type event, plan or exercise. Folders come grouped by owner: perso (yours), team (shared by a team), nolio (Nolio built-ins, listed to show how the Nolio library is organised: no tool serves their content, never file a template in them). An event folder holds training (competitions included), note, quiz and scheduled message templates (scheduled messages only ever land on the planned calendar). Cite a folder id (cat_…) to file a template: create_training_frame(category=…) takes an event folder of perso or team. Each entry carries parent (null at top level): sub-folder names repeat across parents, so cite parent when naming a folder to the coach. Pass q to search a folder by name.

Inputs: type (required), q.

list_metricsList metricsA
Read-only
Inspect

The metrics available to one person (yours by default, an athlete's when athlete is passed), including Nolio metrics hidden from their personal display: definitions only, not values. Each entry carries id (mti_…), key, unit and is_wb_compatible. Its values are on metrics/values/ with item=<id> via nolio_api_read, except an entry with a non-null computation: it is aggregated from workouts and never stored, read it on metrics/computed/ with item=<id>. metrics/records/ is another world, the best efforts held over a duration or a distance (power profile, best 10 km pace). A metric of yours missing from an athlete's list is not enrolled yet: write its value for them anyway (metrics/values/ with athlete), the first value enrolls them, unless it is aggregated from workouts (a count, sum or average over sessions), which is refused. A %-metric workout target cites the key (e.g. "FTP") of an entry with is_wb_compatible true; the athlete does not need a value yet, the target resolves once they have one. Check unit fits how the sport is targeted (a W metric on a pace-based run is usually a mismatch). A catalogue runs to hundreds of entries: pass q when you look for one.

Inputs: q, athlete, is_wb_compatible.

list_metric_valuesRead metric valuesA
Read-only
Inspect

Read the daily values of a metric (HRV, resting heart rate, sleep, weight, Hooper…), newest first.

metric: the mti_… handle of the metric from list_metrics; omit for every metric. athlete: a managed athlete's usr_… handle; omit for your own values. date_from / date_to: 'YYYY-MM-DD' window. limit (max 100) and starting_after (the last returned id) page through while has_more is true. A value withheld by its device maker's terms comes back empty with a restriction naming the maker: say so, never treat it as missing.

Inputs: limit, metric, athlete, date_to, +2 more. Returns: object

list_my_invoicesList my Nolio invoicesA
Read-only
Inspect

List your own Nolio invoices (charges Nolio issued you for your platform subscription).

Use it when the user asks for their Nolio billing history, receipts or a downloadable invoice. Read-only, most recent first. limit: max rows.

Each row carries number (the legal invoice number), date, total (invoice amount), amount_paid (the amount billed, settled or not), status ('paid', 'open', 'draft', 'void') and pdf_url (a downloadable PDF link, null when Stripe has no PDF for it yet or is unreachable). These are your invoices only, never an athlete's.

Inputs: limit. Returns: object

list_planned_trainingsList planned workoutsA
Read-only
Inspect

Find planned training workouts on the calendar over a date window — the location step before reading or editing an existing workout ("Marie's tempo session on Thursday"). COMPETITIONS ARE NOT IN THIS LIST: races are a separate resource, so this alone never answers "what is on her calendar". use get_calendar in planned mode for the whole palette, or read planned/competitions/ with nolio_api_read. Returns rows {id, name, date_start, athletes, group, sport, has_structured_workout, …} without the workout itself: read a candidate with get_planned_training before editing it. Narrow the window to the dates the user implies.

Inputs: group, limit, athlete, date_to, +3 more.

list_quiz_templatesList questionnaire templatesA
Read-only
Inspect

List the questionnaire templates you can plan: yours, your teams' and Nolio's Hooper wellness questionnaire. Pass one's qzf_… handle as quiz_template to create_planned_event.

hooper_only: only the Hooper questionnaire, which feeds the Hooper metric. limit (max 100) and starting_after (the last returned id) page through while has_more.

Inputs: limit, hooper_only, starting_after. Returns: object

list_recent_deletionsList undoable deletionsA
Read-only
Inspect

List the deletions you made through this API that can still be undone.

Use this after a delete the user regrets, or whenever they ask to undo, cancel or restore something they removed. Entries are most recent first and carry the label of what was deleted, so you can name it back to the user.

Only your own deletions appear here, and only for a limited window (30 days). To undo one, read it with undo_deletion after the user has confirmed that exact entry.

Inputs: limit. Returns: object

list_sportsList sportsA
Read-only
Inspect

The sports of one person (settings/sports rows): yours by default, an athlete's when athlete (usr_… from list_athletes) is passed. Active sports only by default. To plan an event, file a template or filter, cite an entry's sport field (spt_…). Its id (spu_…, the settings row) serves only settings/sports/{id}/activate/ and deactivate/ (with ?athlete=usr_… in the path for an athlete): list the hidden ones with is_active=false to switch one back on. A structured workout (workout tree) needs is_structured_workout_enabled true; any other event takes any listed sport. Call list_zones next for the numbered zones of a (person, sport) couple.

Inputs: athlete, is_active.

list_stats_chartsList available stats chartsA
Read-only
Inspect

List the statistics breakdowns available for an athlete (the /statistic page charts).

Each entry has a chart id to pass to get_stats_chart, a dimension (what it groups by: sport, tag, zones, feeling, rpe, details) and a measure (duration in seconds, distance, elevation_gain, kilojoules, count). The list is filtered to charts the athlete has data for: a tag breakdown only appears when the athlete has tags, a zones_duration_<stream> only when a slice exists on that stream. athlete: a managed athlete's usr_… handle; omit for yourself.

Inputs: athlete. Returns: object

list_tagsList tagsA
Read-only
Inspect

Your tags (tag_…) for labelling the workouts you author — cite ids verbatim, existing tags only (no creation in this channel). Tags always belong to the author: when you tag a workout for an athlete, you use YOUR tags, so omit athlete. Pass athlete only to read the tags an athlete keeps for themselves.

Inputs: athlete.

list_training_framesSearch workout templatesA
Read-only
Inspect

Search the reusable training templates you can apply — your OWN and your teams', minus any team you are only an assistant of. Each entry is {id, name, sport, category, family, is_wb_enabled, duration, distance}: cite id (tfr_…) in apply_training_frame; is_wb_enabled means the structured content is valid and watch-ready; family is personal / team. Results are capped: has_more=true means more match — refine with q, category or sport. Full content (workout tree) via get_training_frame.

Inputs: q, sport, family, category.

list_zonesList intensity zonesA
Read-only
Inspect

The FINAL resolved training zones (numbered, with min/max bounds) of one person (yours by default, an athlete's when athlete is passed). Bounds come converted in the declared unit (pace zones as "m:ss" strings, e.g. "3:07"); zones are ordered by rising intensity (first = easiest, recovery/endurance; last = hardest, e.g. neuromuscular). Bare call = ALL their zones, grouped by stream (heartrate / pace / watts…): each zone set lists the sports it applies to — the natural answer to "my zones". Pass sport (the sport field of a list_sports entry, spt_…) to filter to one sport. For %-metric targets (e.g. %FTP), cite a key from list_metrics — zones only here. Set template_mode=true ONLY when authoring a reusable training_frame: returns your zone CONFIGURATIONS instead, each with its name and its zones per stream (coach-scoped, sport required, never combine with athlete). A coach can have several zone configurations; a training_frame's zone targets must all come from one of them. Zone/% targets stay portable and are resolved per athlete server-side at write time.

Inputs: sport, athlete, template_mode.

nolio_api_readRead Nolio API (generic)A
Read-only
Inspect

Read any Nolio API v2 GET endpoint. Use when no curated read tool fits.

path is a v2 path WITHOUT the /api/v2 prefix, e.g. 'real/trainings/', 'metrics/records/', 'settings/profile/', 'team/teams/'. params are query params, e.g. {'date_from': '2026-06-01', 'date_to': '2026-06-30', 'limit': 20}. Collection responses carry {data, has_more}: check has_more before analyzing a whole period. While true, request the next page with starting_after set to the last returned id, keeping the same filters. Default page size is 10, maximum 100. Calendar event collections support fields, e.g. {'fields': 'id,date_start,sport,duration'}, to avoid unnecessary descriptions and computed values. A second-level name ('rpe' or 'debrief.rpe') selects its whole parent object. GPS and location curves are never returned.

Inputs: path (required), params. Returns: object

nolio_api_writeWrite Nolio API (generic)A
Destructive
Inspect

Write to any Nolio API v2 endpoint (POST/PATCH/PUT/DELETE). Use when no curated tool fits.

path is a v2 path WITHOUT the /api/v2 prefix, e.g. POST 'real/notes/', POST 'metrics/values/', DELETE 'real/trainings/{id}/'. body is the JSON payload — check the exact shape (audience fields included) with get_endpoint_schema first. Several writes go through one POST batch/: dry run first, show the person the recap and wait for their explicit yes before the commit, even when their request already sounded explicit.

Inputs: path (required), method (required), body. Returns: object

read_conversationsRead conversationsA
Read-only
Inspect

Read the messages between a coach and athletes.

Three uses, one at a time:

  • event: the comments on one workout or race, a completed trn_…/cmp_… or a planned ptrn_…/pcmp_… handle from get_calendar. Returns each conversation hanging off it with its last 100 messages, oldest first; has_more on a conversation means older ones remain: read them with thread and starting_after set to its first message's id.

  • thread: the messages of one conversation (its handle from a previous call), newest first.

  • neither: your conversations, newest first; unread_only keeps the unread ones. limit (max 100) and starting_after (the last returned id) page through a list while has_more is true.

Inputs: event, limit, thread, unread_only, +1 more. Returns: object

review_trainingReview a completed workoutA
Destructive
Inspect

Coach only: mark a managed athlete's completed workout or race as viewed and, with comment, post a message the athlete is notified of on that workout.

id: the trn_… (workout) or cmp_… (race) handle from get_calendar(mode='real'). Show the athlete's name and the exact comment, and get the coach's go-ahead before posting: a sent message cannot be taken back here.

Inputs: id (required), comment. Returns: object

search_nolio_api_docsSearch Nolio API docsA
Read-only
Inspect

Find the best tool for a task — curated tools first, raw API paths below.

Ranks the curated tools and the raw OpenAPI endpoints for your keywords together. A curated result names a tool: call it directly (it carries the right defaults and guardrails). A raw result gives a /api/v2 path to reach with the call_with generic tool (nolio_api_read / nolio_api_write); pass it to get_endpoint_schema for its exact shape. A raw route a curated tool already covers never appears — its tool surfaces instead. query may be one or several keywords, e.g. 'records', 'hrv metric', 'plan a workout'.

Inputs: query (required). Returns: object

undo_deletionUndo a deletionAInspect

Restore data deleted earlier. id is a rcv_… handle from list_recent_deletions.

Call it once WITHOUT confirm to read what would come back: the response carries impact (how many rows, by model) and blocked_reason. A deletion often cascades well beyond the object that was named — removing a group also removed its events. State that number to the user, get an explicit yes, then call again with confirm=true.

Never infer the target: undo only the entry the user pointed at. Never undo an entry whose blocked_reason is non-empty.

Inputs: id (required), confirm. Returns: object

update_library_categoryUpdate a library folderA
Destructive
Inspect

Rename a library folder, move it under another root folder, or collapse it. A change cannot be undone: say what will change and get the go-ahead first.

id: its cat_… handle from list_library_categories. Nolio's own folders cannot be changed. parent: the cat_… handle of another root folder of the same owner and type. is_visible: false collapses the folder in the library sidebar; it stays listed. Deleting a folder is done in the Nolio app only: it also deletes every template inside.

Inputs: id (required), name, parent, is_visible. Returns: object

update_planned_eventUpdate a race, cycle, note or questionnaireA
Destructive
Inspect

Change a planned competition, cycle, note or questionnaire. Only the fields you pass change. A change cannot be undone: say what will change and get the go-ahead first.

id: its pcmp_…, pcyc_…, pnot_… or pqz_… handle from get_calendar(mode='planned'). Name whose calendar carries it: athlete for a managed athlete's event, group for a group's event, neither for your own. The questions of a questionnaire cannot be changed here, and a questionnaire already answered cannot be changed at all. To change a description that is already set, send description_html: read the event first with get_calendar(mode='planned', with_description_html=true) over its date, edit only what must change, keep every other tag, and send the whole HTML back. Plain text description is refused there, because it would erase the coach's formatting.

Fields by type (any other field is refused):

  • competition (a race, the A-race being the main objective): sport (spt_… from list_sports, required), goal_type ('a' main goal, 'b' secondary), event (the race name), time (HH:MM) or moment (morning, noon, afternoon, evening), duration_minutes, distance_km, elevation_gain_m, elevation_loss_m, rpe (0-10), color.

  • cycle (a training block shown as a banner): date_end (YYYY-MM-DD, required on creation, on or after date_start), color. One cycle per period per athlete: an overlap is refused.

  • note (a marker on one day, or over a period with date_end): date_end (YYYY-MM-DD, on or after date_start, omitted = one day), note_type (rest, availability, unavailability, goal, menstruation), hour_start, hour_end (HH:MM), color. An availability also takes duration_minutes (the time available) and sports (spt_… from list_sports, [] clears them).

  • quiz (a questionnaire the athlete answers that day): hour_start (HH:MM, when it is sent, required for a group), and on creation exactly one of quiz_template (qzf_… from list_quiz_templates) or questions. Each question: {"question", "type", "is_mandatory", "choices", "unit", "metric"}; type is short_text, long_text, boolean, number (unit: kg, km, bpm, W… or a short free text), datetime (has_date, has_time), unique_choice (choices {"choices": [...]}, 2 or more), multiple_choices, range (choices {"start": 0 or 1, "advanced_captions": false, "captions": [...]}), metric_number or metric_range (metric: mti_… from list_metrics). Never an empty questionnaire. Every type takes name, date_start (YYYY-MM-DD) and description (plain text, accepted only while the event has no description).

Inputs: id (required), type (required), rpe, name, +20 more. Returns: object

update_planned_trainingUpdate a planned workoutA
Destructive
Inspect

Update a planned training workout. Read it first with get_planned_training, apply your changes in reasoning, then send the patch — nodes kept from the read keep their "id" (the server preserves everything the web editor set on them; a node without id is created new). The audience (athletes XOR group) is patchable with recurrence_action one only. If no schema field expresses a detail of the coach's intent, put it in the comment of the relevant node — never approximate it into another field, never drop it. If a request expands to more than 3 write operations, list the computed dates/targets and get explicit confirmation before writing.

Inputs: id (required), patch (required), group, athlete, +2 more.

update_training_frameUpdate a workout templateA
Destructive
Inspect

Update a library workout template. Read it first with get_training_frame, apply your changes in reasoning, then send the patch — nodes kept from the read keep their "id" (the server preserves everything the web editor set on them; a node without id is created new). If no schema field expresses a detail of the coach's intent, put it in the comment of the relevant node — never approximate it into another field, never drop it. If a request expands to more than 3 write operations, list the computed dates/targets and get explicit confirmation before writing.

Inputs: id (required), patch (required), revision.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Turns your own wearable data into coaching for hybrid fitness races by exposing readiness, running coach plans, fitness trends and training summaries as tools an agent can query. Keeps your data read-only at the provider and lets you log the station work and race profile your watch can't see in a local database.
      9
      1
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables reading Garmin sleep, HRV, resting heart rate, load, and activity data; maintaining a versioned training contract in D1; and writing structured workouts to a Garmin watch. It also supports protected injury rules and a training diary for symptoms and pain.
      PolyForm Noncommercial 1.0.0
    • A
      license
      B
      quality
      B
      maintenance
      Provides deterministic sports-science calculators for Hyrox pacing/splits, 1RM and RPE-based working loads, Karvonen Zone 2 heart rate, 17-muscle weekly volume audits, and hybrid interference checks, so AI agents stop improvising exercise math. An optional OAuth-secured ledger also lets agents read profiles, review sessions, and log or plan workouts.
      12
      Apache 2.0
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.

    Resources