Praetorium
Server Details
Read-only access to Praetorium’s verified game reference. Search missions, rules, factions, and datasheets, or retrieve structured data for roster planning with source attribution.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- Praetorium
- Claude
- Praetorium
TDQS
Scored across 118 tools
The tools are mostly separated into clear domains such as rosters, battles, events, leagues, collection, reference, and simulation, and descriptions clarify organizer-vs-player variants. A few pairs, including add_event_entrants/admit_event_entrants, check_in_event/check_in_tournament_entrant, and the combat-simulation tools, still require careful reading to distinguish.
Every tool name uses snake_case with a leading verb such as get_, list_, set_, create_, join_, or report_, including consistent get_my_ and list_my_ patterns. There is no mixed camelCase or chaotic verb style.
118 tools is far beyond a practical MCP surface and creates a severe tool-selection burden. Even for a broad Warhammer platform, this should be split into narrower servers for rosters, events, battles, reference, and collection.
Coverage is extensive: rosters, collections, tournaments, leagues, battles, reference lookup, simulation, stats, and skills all have substantive lifecycle operations. Minor gaps remain, such as no clear delete/cancel operation for groups or tournaments and limited public event discovery, but core workflows are covered.
Available Tools
118 toolsadd_event_entrantsAdd players to a tournamentBInspect
A tournament organizer adds the selected Praetorium players by id. Confirm the player names and tournament before calling. Requires mcp:manage.
Inputs: token (required), userIds (required), llm_model, eventToken, +1 more.
admit_event_entrantsAdmit tournament entrantsBDestructiveInspect
A tournament organizer accepts entrant requests for the listed player ids from get_my_event. Requires mcp:manage.
Inputs: token (required), userIds (required), llm_model, eventToken, +1 more.
assign_event_teamAssign an event teamBDestructiveInspect
An organizer forms an allied side from two entrants, or sends one entrant id to separate them. Confirm all affected players before changing seats. Requires mcp:manage.
Inputs: token (required), userIds (required), llm_model, eventToken, +1 more.
change_roster_foldersOrganize my roster foldersADestructiveInspect
Adds, renames, moves or removes a folder, or files rosters in one. Use ids from list_roster_folders and list_my_rosters. For add, supply a new UUID and reuse it if retrying. Use parentId null for the top level or folderId null to unfile rosters. Requires mcp:manage.
Inputs: change (required), llm_model, conversation_id.
change_rosters_in_bulkApply an action to multiple rostersADestructiveInspect
Archives, restores, locks, unlocks, changes visibility or deletes a named set of owned rosters in one operation. Confirm each roster and the exact action, especially deletion or publishing. Requires mcp:manage.
Inputs: ids (required), action (required), llm_model, conversation_id.
check_in_eventCheck in to a tournamentADestructiveInspect
Marks the signed-in player as arrived at a Swiss tournament, or not, before round 1 is paired; an organizer may drop players who haven't checked in. Requires mcp:write.
Inputs: token (required), checkedIn, llm_model, eventToken, +1 more.
check_in_tournament_entrantCheck in a tournament entrantADestructiveInspect
An organizer marks an entrant from get_my_event as present or undoes their check-in before the first round is paired. Requires mcp:manage.
Inputs: token (required), userId (required), checkedIn (required), llm_model, +2 more.
check_rosterCheck a rosterARead-onlyIdempotentInspect
Prices a roster and lists every problem that stops it being fielded, without saving it or needing an account: the same summary get_my_roster gives a saved list. summary names each unit with its points, models, wargear, enhancements, Warlord and attachments, and gives the total; problems is empty when the list is legal. unchecked names restrictions Praetorium could not evaluate, which the player must check in the source rules before playing. freeWargearLeftOut names optional wargear that costs no points and replaces nothing but is not taken; take it with get_unit_options unless the player left it out on purpose.
Inputs: roster (required), llm_model, conversation_id.
compare_enhancementsCompare enhancements against a unitARead-onlyIdempotentInspect
Simulates the attacking unit once with each enhancement its characters, including attached leaders, can take in the attacker's detachment, and once with none, against the defender, as simulate_combat does. Takes the same sides as simulate_combat; name the attacker's detachment, since enhancements come from it. Any enhancement the sides name is replaced by the one being compared. points keeps only enhancements costing that much or less, such as the points a list has spare. mode ranks shooting followed by melee (combined), or one phase. Returns without, the result with no enhancement, and enhancements, best first, each with its bearer, points and outcome. An enhancement with notCalculated has rules the simulator cannot estimate, so its outcome leaves them out; say so rather than ranking it. It compares damage against this one defender only, never what an enhancement does for movement, durability elsewhere or scoring.
Inputs: attacker (required), defender (required), mode, points, +3 more.
compare_rostersCompare two rosters in combatARead-onlyIdempotentInspect
Runs every unit of one roster, with its attached units, against every unit of another in Praetorium's exact combat simulator, as the simulator's whole-roster table does: one call instead of a simulate_combat call per pairing. attackers and defenders list the units in roster order, entries giving their 1-based roster entries as check_roster numbers them. Each phase's cells[attacker][defender] holds the measures in the order measures names, or null when that pairing could not be calculated; notCalculated groups those by phase and reason. bestTargetOf[attacker] lists the defenders that attacker does most to, and bestAttackerOf[defender] the attackers that do most to that defender, by rankBy; each is judged alone, ignores pairings it could not calculate, and is empty while any pairing in its row or column is unfinished or nothing does damage. Units start at full strength in default conditions: passive rules apply, while stratagems, conditional rules, cover and range bonuses stay off, and each weapon choice takes the option that does most against that target. A partial status means the table stopped early, as stoppedBy says; its finished pairings stand. Two 2,000-point lists take a second or two, and the table stops after 30 seconds. Drill into one pairing with simulate_combat to choose rules, modifiers or losses.
Inputs: attacker (required), defender (required), phases, rankBy, +3 more.
copy_rosterCopy a rosterAInspect
Saves a copy of a roster to the signed-in player's account: one of their own from list_my_rosters, or a public or unlisted one they can open. variant true keeps the copy grouped with the original as an alternative version, which only works on their own rosters; false makes a standalone copy. The copy takes the player's default visibility, which is public unless they changed it, whatever the original's. Returns the new roster's id, url and visibility: tell the player when it is public, and offer set_roster_visibility. Requires mcp:write.
Inputs: id (required), variant, llm_model, conversation_id.
create_battleCreate a battleADestructiveInspect
Creates a battle in setup and returns its token. With nobody named it starts a draft with only you at the table, reusing your untouched draft with the same mission pack, and returns joinUrl: anyone with an account who opens it joins the open place, and the draft becomes a battle once every place is filled and every army chosen. opponentId seats one opponent from list_my_opponents for a duel; opponentIds seats one or two, and allyId seats a friend on your side, for a 2v1 or doubles. bothSides: true starts a duel you play alone instead: you hold both places and choose both armies from your own rosters, and it stays out of your record and the leaderboard. limit is the battle size in points (1000, 2000, 3000, or 600 for King of the Colosseum); omit it to take the size from the rosters, as a draft always does. missionPackId is a mission pack id from list_reference. casual: true plays it outside a tournament both players are entered in. manual: true tracks by hand without mission cards, stratagems or CP automation. groupToken counts it for a group both players are in, and fixture names that group's league fixture. Then set it up with submit_battle_action, following get_my_battle's next. Requires mcp:write.
Inputs: limit, allyId, casual, manual, +8 more.
create_groupCreate a groupAInspect
Creates a group with the specified name, listing visibility and admission policy. Confirm those choices before creating it. Requires mcp:manage.
Inputs: name (required), admission (required), visibility (required), llm_model, +2 more.
create_tournamentCreate a tournamentBInspect
Creates a tournament using the chosen format, roster limits, listing, admission and schedule. Confirm those choices with the organizer. Requires mcp:manage.
Inputs: name (required), admission (required), visibility (required), teams, +15 more.
delete_battleDelete my battleADestructiveInspect
Permanently deletes a battle the signed-in player created, for every player in it, with its result. Only the creator can. Confirm with the player first. Requires mcp:write.
Inputs: token (required), llm_model, conversation_id.
delete_rosterDelete my rosterADestructiveIdempotentInspect
Permanently deletes one of the signed-in player's saved rosters, by an id from list_my_rosters, and ends any loan of it to a friend. Battles it was fielded in keep their own record. It cannot be undone, so confirm the roster's name with the player first; set_roster_archived hides a list without losing it. Requires mcp:write.
Inputs: id (required), llm_model, conversation_id.
delete_unit_loadoutDelete a saved unit loadoutADestructiveInspect
Deletes a loadout by id from list_saved_unit_loadouts. Confirm its name before deleting. Requires mcp:manage.
Inputs: id (required), llm_model, conversation_id.
draw_leagueStart a league draftAInspect
A group organizer starts a round-robin league draft. Read the draft fixtures with get_my_group before publishing. Requires mcp:manage.
Inputs: token (required), llm_model, conversation_id.
drop_tournament_no_showsDrop tournament no-showsADestructiveInspect
Drops sealed entrants who have not checked in at a revealed solo Swiss tournament before the first round. If get_my_event returns a nonempty noShowIds list, confirm those players with the organizer before calling. Requires mcp:manage.
Inputs: token (required), expectedUserIds (required), llm_model, eventToken, +1 more.
end_roster_loanEnd a roster loanADestructiveInspect
Revokes a loan if the player owns the roster, or returns it if the player is the borrower. Confirm who loses access before calling. Requires mcp:manage.
Inputs: id (required), borrowerId (required), llm_model, conversation_id.
export_rosterExport a roster as textARead-onlyIdempotentInspect
Writes a roster as the site's text export, the official app's layout that tournament organizers and other list builders read, without saving it or needing an account. Takes the shape save_roster takes, such as import_roster's draft or get_my_roster's roster. text is the export; code is a Praetorium exchange code that carries the exact list into Praetorium, or null when the list is too large for one. omittedUnitCount counts entries the current army data no longer prices, which the text leaves out. omittedSelectionCount counts the saved detachments and options of printed units that the current army data no longer offers, which the text also leaves out. An empty name exports the title Praetorium generates from the army. Fails while the army data is unavailable.
Inputs: roster (required), llm_model, conversation_id.
get_battlebase_link_codeGet a BattleBase account verification codeARead-onlyIdempotentInspect
Returns the code the player must put in their BattleBase profile tagline before importing games for this username. The player updates the tagline on BattleBase. Requires mcp:read.
Inputs: username (required), llm_model, conversation_id.
get_battle_inviteRead a battle inviteARead-onlyIdempotentInspect
Shows who is at the table, the open places on each side and whether the battle has begun. Side indexes start at 0. Use before join_battle. Requires mcp:read.
Inputs: invite (required), llm_model, conversation_id.
get_event_rosterRead an entrant’s sealed rosterBRead-onlyIdempotentInspect
Reads a sealed roster the signed-in player may see, by event token and entrant id from get_my_event. The site applies its rules for access before and after reveal. Requires mcp:read.
Inputs: token (required), userId (required), llm_model, eventToken, +1 more.
get_league_fixturesRead a league round’s fixturesARead-onlyIdempotentInspect
Lists the pairings, fixture keys and results in one round of a group’s league. The first open round is the default. Only organizers can read a draft draw. Requires mcp:read.
Inputs: token (required), round, llm_model, conversation_id.
get_linked_battlebase_accountRead my linked BattleBase accountARead-onlyIdempotentInspect
Returns the BattleBase username previously verified by this player, or null. Requires mcp:read.
Inputs: llm_model, conversation_id.
get_mission_matchupResolve a mission matchupARead-onlyIdempotentInspect
Resolves two force dispositions, in the current mission pack or a named one, to the primary mission each side plays (its card: scoring awards, caps, actions, timing), the terrain layouts and deployments for the pairing, and canonical URLs and reference ids for each. Pass each value by id, slug, or name; an unknown or ambiguous value is refused with the valid options. Rules text is withheld: award criteria and card text come back empty, and the textSources of each award names the upstream file and the record id holding its scoring condition, so fetch that file to say what an award scores.
Inputs: yourDisposition (required), opponentDisposition (required), pack, llm_model, +1 more. Returns: url, you, pack, terrain, +4 more
get_my_battleRead one of my battlesARead-onlyIdempotentInspect
Returns the signed-in player's seated view of a battle (battle) and what it expects next (next). next says what the battle expects: in setup, each step in table order with done and the command that answers it, the battlefields and secondary cards on offer, and begin.refusal until begin-battle would be accepted; in play, the round, phase, active player, a pending settlement of the previous turn, cards scoring now, the turn commands allowed now and why advance is refused, stratagems usable now per side, and the undoable seq. Requires mcp:read.
Inputs: token (required), llm_model, conversation_id.
get_my_battle_reportRead my battle reportARead-onlyIdempotentInspect
Returns a battle's log as its report reads it, oldest first and 200 entries a page: each entry's seq, round, phase, the player id that recorded it (by) and a sentence saying what happened. Pass nextAfter as after for the next page. Totals and the result are in get_my_battle. Requires mcp:read.
Inputs: token (required), after, llm_model, conversation_id.
get_my_collectionRead my model collectionARead-onlyIdempotentInspect
Returns the models the signed-in player owns, as their collection page keeps them, grouped by faction. Each entry's id and slug are the datasheet's, the same as list_units gives, with the models owned, how many are built and painted, and countsAs: other datasheets the player says those models can also be fielded as. A datasheet the current army data no longer has is named "A datasheet from earlier rules". Pass faction to read one army; a collection of more than 200 datasheets without one returns only each faction's totals. Requires mcp:read.
Inputs: faction, llm_model, conversation_id.
get_my_collection_wishlistRead my model wishlistARead-onlyIdempotentInspect
Returns the models the player wants, with the datasheet id, name and wanted count. Includes models the player does not yet own. Requires mcp:read.
Inputs: llm_model, conversation_id.
get_my_eventRead a tournament or hidden-list gameARead-onlyIdempotentInspect
Returns a tournament or hidden-list game as the signed-in player may see it: rules (format, size, points, what lists may break), dates, entrants with whether each sealed, your entry, Swiss rounds with your table and opponent (and at a team tournament each team meeting's revealed picks), standings once lists are revealed (and team standings, whose score is games won or victory points), your battles in it, and todo: what you still need to do. Organizers also see entrants’ check-in, noShowIds before the first solo Swiss round, and table results. Pass tableRound to inspect an earlier round’s tables. If a tracked battle has unknown status in a partial event, read it by token with get_public_battle. Before the reveal nobody's list is shown but your own name for it. Requires mcp:read.
Inputs: token (required), llm_model, eventToken, tableRound, +1 more.
get_my_groupRead one of my groupsARead-onlyIdempotentInspect
Returns a group as its page shows it to the signed-in player: members (ids for create_battle's opponentIds), the leaderboard, recent finished games and your unfinished ones, its current hidden-list games, and its league with the table, your fixtures, and once every game is played its winners. An open fixture names the tool in startTool and its arguments in start. A private group shows only its name until you are a member. Requires mcp:read.
Inputs: token (required), llm_model, conversation_id.
get_my_rosterRead my saved rosterARead-onlyIdempotentInspect
Returns one roster owned by the signed-in player, by an id from list_my_rosters. summary names each unit with its points, models, wargear, enhancements, Warlord and attachments, and gives the total, any problems that stop the list being fielded, and unchecked restrictions Praetorium could not evaluate; it is null while army data is unavailable. roster holds the saved choices by catalogue id, the shape save_roster takes; its name is empty while the title is generated from the list, so saving it back keeps that. Requires mcp:read.
Inputs: id (required), llm_model, conversation_id.
get_my_statsRead my battle statisticsARead-onlyIdempotentInspect
Returns the signed-in player's record as their profile shows it, over their latest 200 finished battles except practice games, optionally narrowed. record: battles, won, lost, drawn, rate (win rate 0 to 1, a draw counting half), going first and second, average points, streaks, command points, stratagems and secondary cards used, primary missions, opposing factions and opponents. performance: the same split per detachment, primary mission and battle size. facets: the values each filter takes, with battle counts. rankings: leaderboard places from rated public battles, overall and per faction, unaffected by the filters. List the battles themselves with list_my_battles. Requires mcp:read.
Inputs: limit, faction, llm_model, detachment, +5 more.
get_public_battleRead a battle as a spectatorARead-onlyIdempotentInspect
Returns any battle by a token from list_public_battles or its link, as a spectator sees it on the site: battle holds its settings, round, phase, result and each player's army, score, command points and secondary cards; missions the mission each side plays; report its log as the report reads it, oldest first and 200 entries a page: each entry's seq, round, phase, the player id that recorded it (by) and a sentence saying what happened. Pass nextAfter as after for the next page. Practice battles are left out of list_public_battles but still open from their link.
Inputs: token (required), after, llm_model, conversation_id.
get_public_rosterRead a public rosterARead-onlyIdempotentInspect
Returns a roster anyone may open, by an id from list_public_rosters or from a roster link someone shared: public and unlisted rosters, never private ones. summary names each unit with its points, models, wargear, enhancements, Warlord and attachments, and gives the total and any problems under today's army data; it is null while army data is unavailable. roster holds the choices by catalogue id, the shape check_roster, grade_roster, compare_rosters and save_roster take, so grade it or set it against another list rather than judging it yourself.
Inputs: id (required), llm_model, conversation_id.
get_referenceRead one Praetorium reference resultARead-onlyIdempotentInspect
Reads the complete bounded document returned by search_reference, with its revisions and attribution. A section that withholds rules text lists textSources: the pinned upstream file and record id to fetch if you need the wording.
Inputs: id (required), llm_model, conversation_id. Returns: id, url, kind, title, +4 more
get_reference_recordRead structured Praetorium reference dataARead-onlyIdempotentInspect
Returns the structured record behind a search result, including mission cards, force dispositions (missions by opposing disposition, detachments that offer them), deployments, terrain geometry, detachments, and datasheets. Records that withhold rules text carry textSources pointing at the pinned upstream file and record id.
Inputs: id (required), llm_model, conversation_id. Returns: data, document
get_roster_loansRead loans of a saved rosterARead-onlyIdempotentInspect
Lists who holds a loan of the signed-in player’s own roster, by roster id from list_my_rosters. Requires mcp:read.
Inputs: id (required), llm_model, conversation_id.
get_skillRead a Praetorium skillARead-onlyIdempotentInspect
Returns step-by-step guidance for a task, including the Warhammer 40,000 knowledge and tool order it needs. Read the matching skill before starting the task. Skills: answer-a-rules-question: Answer a Warhammer 40,000 rules question from Praetorium's reference, citing the source. Use when someone asks how a rule, ability, stratagem, keyword, datasheet value or mission works. build-a-roster: Plan a Warhammer 40,000 army list from Praetorium's current units, points and detachments, weigh what each detachment gives a unit, and save the list to the player's Praetorium account when they ask. Use when someone wants to build, draft, improve, cost or save an army or roster, choose a detachment, or asks how a unit fits a list. choose-secondaries: Help a Warhammer 40,000 player choose between Tactical and Fixed secondary missions for a mission and opponent, from the secondary cards in Praetorium's reference. Use when someone asks which secondaries to take, or whether to go fixed or tactical. compare-units: Compare two Warhammer 40,000 units with Praetorium's combat simulator and explain the expected result. Use when someone asks how one unit does against another, which of two options hits harder, which wargear is best against a target, or what the odds are of destroying a target. explain-a-mission-matchup: Explain which primary missions, deployments and terrain two Warhammer 40,000 force dispositions get in a mission pack, from Praetorium. Use when someone asks what mission they play against an opponent's disposition, or how to set up a game in the current pack. grade-a-roster: Grade a Warhammer 40,000 army list with Praetorium, explain what it does well and lacks, compare it with winning tournament lists, and tune it with tested swaps. Use when someone asks how good their list is, what it is missing, how to improve it, or before handing over a list you built. import-a-list: Bring an army list from the official Warhammer 40,000 app, New Recruit, BattleBase or another builder into Praetorium, report what didn't match, and check, grade, save or export it. Use when someone pastes a list or exchange code, or asks to import, check or convert a list from another app. plan-a-matchup: Plan how a player's Warhammer 40,000 list takes on one opponent with Praetorium's simulator and mission data. Use when someone asks how to play their list against an army, which of their units handle the opponent's threats, or who should play the objectives. play-in-a-tournament: Take a signed-in player through a tournament, hidden-list game or group league: join, seal a list, find their table, start the battle and report the score. Use when someone asks what's due, wants to seal a list, or asks who they play next. review-a-battle: Summarise one of a signed-in player's Praetorium battles from its report, such as how the score built up, which stratagems were used and the turning points. Use when someone asks how a game went or wants a write-up of it. review-my-battles: Look back at a player's Praetorium battles and record, such as results against an army, win rates by detachment or mission pack, and leaderboard places. Use when someone asks how they've been doing, who they lose to, or to find a past game. set-up-a-battle: Start a Praetorium battle for a signed-in player and set the table in the order the game does, from opponent and armies to the first turn. Use when someone wants to start, create or set up a game to track. track-a-battle: Read a Praetorium battle and record what happens during play for a signed-in player, such as phases, command points, stratagems, scoring, casualties and undo. Use when someone asks about the score or state of their battle, or wants to record something that happened in it.
Inputs: name (required), llm_model, conversation_id.
get_unit_optionsRead unit options for a rosterARead-onlyIdempotentInspect
Lists what each named unit lets a roster pick set, with names first and the ids a pick takes beside them: its sizes, its toggles (key of the Warlord toggle: set toggles {key: 1} on exactly one CHARACTER), and every choice group (wargear, enhancement, detachment upgrade, unit composition) with its options' ids, points, how many the default loadout takes (taken), and per-option min and max. A choice whose set is choices takes {key: optionId}; omit an optional one to decline it. One whose set is spreads takes {key: {optionId: count}}, counts within each option's min and max, totalling no more than room and at least least; for 'every model one option' give the whole room to one option. A group whose key extends another's key and option id applies only while that option is taken. Enhancements and detachment upgrades appear only with a detachment, at their cost; a list takes each enhancement once, on a CHARACTER that is not an Epic Hero, and a unit holds at most one, counting the leaders and support units attached to it, which these options can't see; check_roster flags a second. roster gives the catalogueId, detachmentIds and dispositions a save_roster or check_roster roster takes. Leave out a choice to keep the default; check the finished list with check_roster.
Inputs: units (required), faction (required), llm_model, battleSize, +2 more.
get_winning_listRead a tournament-winning listARead-onlyIdempotentInspect
Reads one top-four tournament placing from list_winning_lists as it imports under today's army data: its placing, whether it is legal today, record and event, the army text the player submitted, draft (the list in the shape check_roster, grade_roster, compare_rosters and save_roster take) and summary, which names each unit with its points, models, wargear, enhancements, Warlord and attachments. Grade the draft with grade_roster or set it against another list with compare_rosters rather than judging it yourself.
Inputs: id (required), llm_model, conversation_id.
grade_rosterGrade a rosterARead-onlyIdempotentInspect
Grades which jobs a roster can do on the table, as the roster builder's grades do: score 0 to 100 and grade A to D overall and per category (board control, mobility, damage against reference targets, durability), placed among tournament lists of the same battle size and centred on comparedWith's armies, so a list's distance from its army's typical list reads on every army's spread. A typical tournament list scores about 70. It measures coverage, not strength: in tournament games the players' skill decided far more than any list measure, the overall grade went with winning only slightly, and more units with an even spread of points went with winning most. So never call a list competitive from its grade, and never present it as a win rate. missing names the reference targets nothing in the list can take half of alone. units gives each unit the jobs it is credited with; a leader or support character counts inside the unit it joins, so its buffs never show as its own job, and cutting it for another unit always raises board presence. A unit with one joined to it lists it under attached, with each target whose share of wounds the unit takes changes without it: with and without, where 1 is one whole target. Weigh that before cutting it. tournament, when the army has enough top-four lists, gives stapleShare (the share of its points in datasheets at least 3 in 10 of those lists field, which went with winning slightly), the staples it leaves out and its unproven datasheets that no winning list fields. calibration.lists is 'drawn' when the battle size was compared with lists drawn from 2,000-point tournament lists rather than real lists of its size, a rougher comparison, and there nothing shows that more units or an even spread go with winning. It measures units at full strength with passive rules only, from the exact simulator, so it rarely tells detachments apart; compare detachments with simulate_combat. Each row's notCalculated names units or rules it could not measure. Takes a few seconds; check the list with check_roster first, since a list that cannot be fielded still grades.
Inputs: roster (required), llm_model, conversation_id.
import_battlebase_historyImport finished games from BattleBaseADestructiveInspect
Imports up to 20 public games at a time from a verified BattleBase account, skipping unfinished or already imported games. Use a username when linking a new account after the player adds their verification code to their tagline. Confirm the import first, then repeat with nextCursor as before until nextCursor is null. Retrying the same page is safe. Requires mcp:manage.
Inputs: before, username, llm_model, conversation_id.
import_collectionImport multiple collection entriesADestructiveInspect
Saves collection counts in one operation. Match every row to a datasheet id with list_units. Use replace false to keep existing counts. Use true only after explicit confirmation to overwrite counts on matching entries. Entries omitted from the import stay in the collection, so imports can be split into batches. Requires mcp:manage.
Inputs: rows (required), replace (required), llm_model, conversation_id.
import_rosterImport an army listARead-onlyIdempotentInspect
Reads a pasted army list into a roster draft without saving it or needing an account, as the site's import does. Takes the whole text export from the official Warhammer 40,000 app, New Recruit, BattleBase, ListForge, Warscribe, WTC layouts, Mini Headquarters or Praetorium, or a Praetorium exchange code (PR1./PR2.). draft is the list in the shape check_roster and save_roster take, or null when no faction matched. review is what the importing player sees: matchedEntries of sourceEntries, the points the text reported against currentPoints at the selected rules version, notImported (units, detachments or lines left out, each with why) and builtByDatasheet (units that imported but keep their datasheet defaults for the choices named, each with why). Tell the player about every row in both before relying on the draft. When battleSizeStated is false the draft uses 2000 points; ask the player. Anything the import had to assume, such as a unit's god, is named in builtByDatasheet; nothing is substituted silently.
Inputs: file (required), llm_model, conversation_id.
invite_friend_to_battleSend a battle invite to a friendADestructiveInspect
Sends an in-app notification and returns the join link. Use the draft token from list_my_battle_drafts and the friend id from list_my_opponents. Confirm the recipient first. Requires mcp:manage.
Inputs: token (required), friendId (required), llm_model, conversation_id.
join_battleJoin a battle from an inviteAInspect
Takes an open place on side 0 or 1 from get_battle_invite. Confirm the host and side with the player before joining. Requires mcp:manage.
Inputs: side (required), invite (required), llm_model, conversation_id.
join_eventJoin a tournament or hidden-list gameADestructiveInspect
Enters the signed-in player in a tournament by its token, as its invite link does, or in a hidden-list game of a group they belong to. A tournament whose organizer approves each player answers pending until they let you in. Closed once lists are revealed or the roster deadline passes. Requires mcp:write.
Inputs: token (required), llm_model, eventToken, conversation_id.
join_groupJoin a groupADestructiveInspect
Joins a group by its token, as its invite link does. A group whose organizers approve each member answers pending until they let you in. Requires mcp:write.
Inputs: token (required), llm_model, conversation_id.
join_leagueJoin a group's leagueADestructiveInspect
Joins the draft league of a group you are a member of. Nobody can join once an organizer publishes its fixtures. Requires mcp:write.
Inputs: token (required), llm_model, conversation_id.
leave_groupLeave a groupADestructiveInspect
Removes the signed-in player’s own group membership. Confirm the group before calling. Requires mcp:manage.
Inputs: token (required), llm_model, conversation_id.
leave_leagueWithdraw from a leagueADestructiveInspect
Withdraws the signed-in player from the group’s current league. Confirm before withdrawing. Requires mcp:manage.
Inputs: token (required), llm_model, conversation_id.
lend_rosterLend a roster to a friendAInspect
Lets a friend use an owned roster. Get the roster id from list_my_rosters and the borrower id from list_my_opponents. Confirm the roster and recipient. Requires mcp:manage.
Inputs: id (required), borrowerId (required), llm_model, conversation_id.
list_borrowed_rostersList rosters friends lent youARead-onlyIdempotentInspect
Lists rosters the signed-in player has borrowed from friends. Use a borrowed roster’s id to field or seal it where the site allows. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_data_updatesList game-data updatesARead-onlyIdempotentInspect
Lists the points and datasheet updates the installed army data recorded, newest first, as the /data-updates pages show them. Each update has its UTC time, url, total change count and omitted (changes past its stored bound). Without faction, each update lists only the factions it reached with their change counts. With faction, it lists that faction's changes in groups: kind (datasheet-points, datasheet-added, datasheet-removed, detachment-points, detachment-added, detachment-removed, enhancement-points, enhancement-added, enhancement-removed), name, points from and to (per models row for datasheets; null where none), and the url of the page describing it now, or null when it no longer exists. Pass older as before for the next page; null means no older updates.
Inputs: before, faction, llm_model, conversation_id.
list_factionsList factions in the Praetorium referenceARead-onlyIdempotentInspect
Lists the factions that can be used to narrow reference searches.
Inputs: llm_model, conversation_id. Returns: factions, revisions
list_my_battle_draftsList my battle draftsARead-onlyIdempotentInspect
Finds unfinished setups the signed-in player has created or joined. Use a draft token with get_my_battle and submit_battle_action to resume it. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_my_battlesList my battlesARead-onlyIdempotentInspect
Lists the signed-in player's battles, newest first, up to 25 a page, narrowed and ordered as the battles page is. Each battle has its url, status, your result, ending, size, mission and one entry per seat (you, side, army, faction, detachments, score with its primary and secondary halves, rating change). A filtered page can come back short or empty while nextCursor is set; keep paging until nextCursor is null. Requires mcp:read.
Inputs: order, before, filter, llm_model, +1 more.
list_my_eventsList my groups and tournamentsARead-onlyIdempotentInspect
Lists the signed-in player's groups, tournaments and hidden-list games (a group's game where everyone seals a list in secret before the reveal), each with its token, url, dates and your place in it: membership, entry status, whether you sealed a list, and the size you seal at. Pass includeOpen to also list public groups and tournaments you could join. Read one with get_my_group or get_my_event. Requires mcp:read.
Inputs: llm_model, includeOpen, conversation_id.
list_my_opponentsList who I can playARead-onlyIdempotentInspect
Lists the friends the signed-in player can seat in create_battle, by id. Everyone at the table needs an account: someone without one signs up and becomes a friend first. To play a game alone, create_battle takes bothSides instead. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_my_rostersList my saved rostersARead-onlyIdempotentInspect
Lists the rosters saved to the signed-in Praetorium account. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_public_battlesList public battlesARead-onlyIdempotentInspect
Lists the battles anyone may watch on Praetorium, newest first, up to 25 a page, narrowed and ordered as the battles page's public tab is. Each battle has its url, token, status, ending, size, mission and one entry per seat (side, result once finished, army, faction, detachments, score with its primary and secondary halves, rating change). A filtered page can come back short or empty while nextCursor is set; keep paging until nextCursor is null. Read one with get_public_battle.
Inputs: order, before, filter, llm_model, +1 more.
list_public_rostersList public rostersARead-onlyIdempotentInspect
Lists the rosters players have made public on Praetorium, as the rosters page's public tab shows them, most recently saved first unless sort says otherwise. Each roster has its id, url, name, owner, faction, detachments, battle size, points under today's army data and problem, the first thing stopping it being fielded or null when it is legal. total counts every match when it is known. A page can come back short while nextCursor is set; keep paging until it is null. Read one with get_public_roster. These are players' own lists, not tournament results: for what wins, use list_winning_lists.
Inputs: q, sort, before, faction, +5 more.
list_referenceList the Praetorium reference catalogueARead-onlyIdempotentInspect
Discovers available factions, mission packs, rule documents, reference kinds, and active source revisions.
Inputs: llm_model, conversation_id. Returns: kinds, factions, revisions, missionPacks, +2 more
list_roster_foldersList my roster foldersARead-onlyIdempotentInspect
Returns folder ids, names and parents, and the saved roster groups filed in each folder. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_saved_unit_loadoutsList saved unit loadoutsARead-onlyIdempotentInspect
Lists the signed-in player’s saved unit loadouts with their ids, models and choices, including joined units. Requires mcp:read.
Inputs: llm_model, conversation_id.
list_tournament_table_battlefieldsList battlefields for a tournament tableARead-onlyIdempotentInspect
Lists the allowed deployments and terrain layouts after the table’s rosters are revealed. Use the event token, round and table from get_my_event. Requires mcp:read.
Inputs: round (required), table (required), token (required), missionPackId (required), +3 more.
list_unitsList compact faction units for roster planningARead-onlyIdempotentInspect
Returns every pickable unit in one bounded response with unit-size costs, composition, attachment relationships, roster limits, roles, keywords, and links. Without a detachment it also lists every detachment the faction can take, with its detachment points, Force dispositions, rule names and enhancement costs, so you can compare them before choosing. Include a detachment, including one a chapter takes from its codex, to list only the units it allows and receive its rules, enhancements, upgrades, and stratagems by name, cost, and timing without opening every unit page. Their rules text is at each record’s textSources. A unit’s points is what its smallest size costs in this battle size and detachment, including any wargear or enhancement the detachment makes it take; costs is the Munitorum Field Manual table for every size. Legends and Crucible datasheets are left out unless nonMatchedPlay is true. A large faction such as a Space Marine chapter can exceed what an assistant reads at once, so pass query to list only the units whose name or keywords contain it; a query nothing contains lists the units whose names are close to it, so a misspelt name still finds its unit. To see which units and detachments the faction’s top-four tournament lists take, call list_winning_lists rather than relying on memory.
Inputs: faction (required), query, llm_model, battleSize, +3 more. Returns: query, units, faction, revisions, +4 more
list_winning_listsList tournament-winning listsARead-onlyIdempotentInspect
Lists a faction's top-four tournament placings from 40k Stats and Mini Headquarters whose lists import cleanly and are legal under today's army data, newest first; pass includeNoLongerLegal for lists a points or rules change has made illegal too, such as to read the meta from before a points rise. A faction counts its whole family, so a list imported under an earlier rules version still counts. of is how many lists matched and events the date range of their events; a small of is a small sample. latestUpdate is the date of the faction's newest points or datasheet update and sinceLatestUpdate how many lists come from events since; lists from before it were built for other points, so weigh them less or pass since. detachments counts how many lists took each detachment. battleSizes counts the faction's lists at each size: when it has none at the size being built, say so, and read other sizes' lists as which units the faction favours rather than as a shape to copy. datasheets names every datasheet those lists field with how many of them field it, most first, and the unit sizes taken, most common first. Each list gives its placing, record, event, detachments, Force disposition, points under today's data and as the player reported them, whether it is legal today, and units with every copy's model count; pass its id to get_winning_list for the full list as a draft. A placing reflects the player and the field as much as the list: learn the shapes and staples these lists share rather than copying one. While checking is true the first import is still running and every count is partial; say so.
Inputs: faction (required), count, since, llm_model, +4 more.
moderate_event_entrantApprove or decline a tournament entrantADestructiveInspect
A tournament organizer accepts or rejects one entrant by id from get_my_event. Requires mcp:manage.
Inputs: token (required), status (required), userId (required), llm_model, +2 more.
moderate_group_memberApprove or decline a group requestADestructiveInspect
A group organizer accepts or declines a membership request. Use the pending member’s id from get_my_group. Requires mcp:manage.
Inputs: token (required), accept (required), userId (required), llm_model, +1 more.
optimize_loadoutFind the best loadout against a unitARead-onlyIdempotentInspect
Searches the attacking unit's legal wargear, with any attached leaders, for the loadout most likely to destroy the defender, then the most models destroyed, then the most wounds, then the most optional wargear that costs no points and replaces nothing, then the fewest choices changed from the start, as the simulator's Optimize does. Takes the same sides as simulate_combat; the attacker's choices and spreads are where the search starts, and model counts, enhancements and detachment upgrades stay fixed. mode ranks shooting followed by melee (combined), or one phase. Returns best and current, each with every attacking unit's choices and spreads ready for a roster pick or simulate_combat (a group left out keeps its default), its wargear by name, the weapon modes it used, and its odds; better says whether best beats current, or ties it while adding free wargear. exhaustive is true only when every legal loadout was checked; otherwise notes say why a better one may exist. Loadouts with rules the simulator cannot estimate are left out and named in notes. Takes up to about 20 seconds.
Inputs: attacker (required), defender (required), mode, llm_model, +2 more.
pair_tournament_roundPair the next tournament roundADestructiveInspect
A tournament organizer pairs the next Swiss round once each table from the previous round is finished. Confirm before publishing pairings. Requires mcp:manage.
Inputs: token (required), llm_model, eventToken, conversation_id.
pick_tournament_team_playersSubmit a team pairing pickADestructiveInspect
In team Swiss, submits the player ids for the current step of a team meeting. Use the round, table and current step from get_my_event. Omit squadId to pick for your own team. Requires mcp:manage.
Inputs: step (required), round (required), table (required), token (required), +5 more.
play_both_battle_sidesPlay both sides of a battleADestructiveInspect
Fills the open places in a draft with practice seats the signed-in player can control. Use create_battle with bothSides when starting a fresh draft. Requires mcp:manage.
Inputs: token (required), llm_model, conversation_id.
publish_leaguePublish a league drawADestructiveInspect
A group organizer publishes the reviewed draw. Use the seed and ordered playerIds from get_my_group. Confirm the fixtures before publishing. Requires mcp:manage.
Inputs: seed (required), token (required), playerIds (required), llm_model, +1 more.
remove_battle_playerRemove a player from a battle draftADestructiveInspect
The creator removes a named player from a draft that has not started. This retires the current join link. Confirm the player and battle. Requires mcp:manage.
Inputs: token (required), playerId (required), llm_model, conversation_id.
remove_group_memberRemove a group memberADestructiveInspect
An organizer removes a named member from a group. This also removes their entry from hidden-list games still sealing. Requires mcp:manage.
Inputs: token (required), userId (required), llm_model, conversation_id.
rename_unit_loadoutRename a saved unit loadoutADestructiveInspect
Renames a loadout by id from list_saved_unit_loadouts. Requires mcp:manage.
Inputs: id (required), name (required), llm_model, conversation_id.
reopen_tournament_tableReopen a finished tournament tableADestructiveInspect
An organizer reopens a finished Swiss battle for score corrections, even if a later round has locked it. Use get_my_event with tableRound to find the battle token, then confirm the table. Requires mcp:manage.
Inputs: token (required), battleToken (required), llm_model, eventToken, +1 more.
report_league_resultReport a league resultADestructiveInspect
A group organizer records a score for a game played outside Praetorium. Use the fixture key and scores in the exact seat order shown by get_league_fixtures. Confirm both player names and final scores. Requires mcp:manage.
Inputs: vp (required), token (required), fixture (required), missionPackId (required), +2 more.
report_table_resultReport my table’s scoreADestructiveInspect
Records the final score of the signed-in player's Swiss table, for a game not tracked on Praetorium, and finishes its battle; it counts for the tournament's standings but not the leaderboard. Report only a score both players agree. Defaults to your table this round. A result locks once the next round is paired; then only the organizer can reopen it. Requires mcp:write.
Inputs: token (required), yourScore (required), opponentScore (required), round, +4 more.
report_tournament_tableReport a tournament table scoreADestructiveInspect
An organizer reports a score for a tournament table. Obtain the round, table and seat order from get_my_event. Confirm both players and scores, then pass those same player IDs in expectedPlayers. Players at the table can use report_table_result instead. Requires mcp:manage.
Inputs: vp (required), round (required), table (required), token (required), +5 more.
reveal_event_rostersReveal sealed rostersADestructiveInspect
Irreversibly reveals sealed rosters in a tournament or hidden-list game, where the signed-in player has permission. Ask for explicit confirmation to reveal now. Requires mcp:manage.
Inputs: token (required), llm_model, eventToken, conversation_id.
save_rosterCreate or edit my rosterADestructiveInspect
Saves a complete roster. Pass its id to edit an owned roster; omit id to create one. Send an empty name to have Praetorium title the list from its army and keep that title current as the list changes; send a name only when the player chooses one, since any name stops the automatic title. limit is the battle size (1000, 2000 or 3000 points, or 600 for King of the Colosseum), which sets detachment points, enhancement and unit limits. pointsBudget optionally replaces only its points total (500 to 10000, not King of the Colosseum); omit it to keep a saved budget, or send null for the standard total. Requires mcp:write.
Inputs: name (required), prep (required), limit (required), picks (required), +12 more.
save_unit_loadoutSave a unit loadoutADestructiveInspect
Saves a named unit configuration using datasheet and choice ids from get_unit_options. Use a new UUID for a new configuration. Reusing an id keeps the first saved configuration. Use rename_unit_loadout to change its name. Requires mcp:manage.
Inputs: id (required), name (required), pick (required), catalogueId (required), +3 more.
search_referenceSearch the Praetorium game referenceBRead-onlyIdempotentInspect
Searches Praetorium’s missions, force dispositions, deployments, terrain, rules, detachments, and datasheets by name, number, keyword, and value, then datasheets and detachments whose abilities, stratagems or enhancements say the words searched for, such as objective control remains for an ability that keeps an objective. Returns bounded excerpts with canonical URLs, source revisions, and attribution; a match found by what an ability says names that ability and points at its section. Rules text is not included; records point to it upstream.
Inputs: query (required), pack, kinds, limit, +5 more. Returns: query, results, revisions, nextCursor
set_collection_counts_asSet what a model collection entry counts asADestructiveInspect
Replaces the alternative datasheets a unit’s models can be fielded as. Use datasheet ids from list_units. An empty list clears the alternatives. Requires mcp:manage.
Inputs: entryId (required), countsAs (required), llm_model, conversation_id.
set_collection_modelsSet owned model countADestructiveInspect
Sets the total number of models owned for a datasheet. Use its id from list_units or get_my_collection. Confirm the unit and count with the player. Requires mcp:manage.
Inputs: models (required), entryId (required), llm_model, conversation_id.
set_collection_progressSet built and painted model countsADestructiveInspect
Sets a datasheet’s built and painted totals. Read get_my_collection first and use the datasheet id it returns. Requires mcp:manage.
Inputs: built (required), entryId (required), painted (required), llm_model, +1 more.
set_collection_wantedSet a wishlist model countADestructiveInspect
Sets how many more models the player wants for a datasheet. Use its id from list_units; zero clears it. Requires mcp:manage.
Inputs: wanted (required), entryId (required), llm_model, conversation_id.
set_event_team_dispositionSet a sealed team’s Force DispositionADestructiveInspect
Chooses a Force Disposition the allied sealed lists offer before reveal. Use the Force Disposition id from the rules reference. Requires mcp:manage.
Inputs: token (required), disposition (required), llm_model, eventToken, +1 more.
set_event_team_warlordChoose which allied Warlord leadsBDestructiveInspect
Sets whose Warlord leads a side made from allied sealed lists. Use a teammate’s entrant id from get_my_event. Requires mcp:manage.
Inputs: token (required), userId (required), llm_model, eventToken, +1 more.
set_league_clockSet the league chess clockADestructiveInspect
A group organizer sets the chess-clock minutes for league games that have not started, or null to clear the limit. Requires mcp:manage.
Inputs: token (required), minutes (required), llm_model, conversation_id.
set_league_deadlineSet a league round deadlineADestructiveInspect
A group organizer sets the deadline for one league round. Give milliseconds since the Unix epoch, or null to clear it. Requires mcp:manage.
Inputs: round (required), token (required), deadline (required), llm_model, +1 more.
set_roster_archivedArchive or restore my rosterAIdempotentInspect
Archives one of the signed-in player's saved rosters, which moves it out of their main roster list without deleting it, or restores it with archived false. Requires mcp:write.
Inputs: id (required), archived (required), llm_model, conversation_id.
set_roster_lockedLock or unlock a rosterAInspect
Changes the saved roster’s edit lock. This does not change its army or visibility. Requires mcp:manage.
Inputs: id (required), locked (required), llm_model, conversation_id.
set_roster_visibilityChange my roster visibilityBDestructiveInspect
Changes the visibility of an owned roster. Requires mcp:write.
Inputs: id (required), visibility (required), llm_model, conversation_id.
set_tournament_round_timerSet the tournament round timerADestructiveInspect
An organizer starts or stops the current round timer. Send minutes, or null to stop it. Use fromEnd only to add time to an existing deadline. Requires mcp:manage.
Inputs: token (required), fromEnd (required), minutes (required), llm_model, +2 more.
set_tournament_table_battlefieldAssign a battlefield to a tournament tableBDestructiveInspect
An organizer chooses a layout from list_tournament_table_battlefields. Use roll to draw an allowed layout or null to let the players choose. Requires mcp:manage.
Inputs: round (required), table (required), token (required), battlefield (required), +4 more.
set_tournament_teamCreate, join or leave a tournament teamADestructiveInspect
For team Swiss, send a name to start a team, a squadId to join a team, or null to leave. Read team ids with get_my_event. Requires mcp:manage.
Inputs: squad (required), token (required), llm_model, eventToken, +1 more.
simulate_combatEstimate combat between two unitsARead-onlyIdempotentInspect
Runs Praetorium's exact combat simulator for one attacking unit, with any attached leaders, against one defending unit: shooting, melee, and shooting followed by melee. Returns expected models destroyed, expected wounds lost, the chance to destroy the unit, cumulative odds, weapons used, the wargear each unit fielded, the rule and weapon-mode choices each side can change, datasheet citations, and a simulator link. Each unit takes its default loadout unless given choices and spreads; to field a unit from get_my_roster, pass its pick's entryId as unit with the pick's models, choices and spreads, its attached picks under attached, and the roster's detachment. Units start at full strength unless modelsLost or woundsLost say otherwise. Passive datasheet rules apply by default; stratagems and conditional rules, including below-strength ones, stay off until chosen in rules. A modifier never chooses a rule: charged and heavy change only weapon abilities such as [LANCE] and [HEAVY], so a rule whose option needs the unit to have charged or remained stationary must also be chosen. Rules the simulator cannot calculate are never approximated: a phase it cannot estimate has status refused with its reasons, and recognised rules it leaves out are listed under notCalculated, so explain those gaps rather than retrying. Errors are reserved for unknown factions or units, illegal unit sizes, wargear, attachments, enhancements, or losses, and unavailable reference data. A weapon choice left out of weaponModes takes the option that does most against this defender. A side fields a detachment's rules and offers its stratagems only when its detachment is named, an enhancement applies only when named for its unit or among its choices, and another unit's aura applies only when that unit is listed in nearby and its rule chosen. The simulator link keeps loadouts but opens every unit at full strength.
Inputs: attacker (required), defender (required), llm_model, modifiers, +2 more.
split_roster_variantSeparate a roster variantCDestructiveInspect
Makes a saved variant a standalone roster without changing its army. Requires mcp:manage.
Inputs: id (required), llm_model, conversation_id.
start_event_battleStart my tournament battleADestructiveInspect
Starts the battle for a revealed tournament or hidden-list game with both sealed lists attached, as Start battle on its page does, and returns its token for get_my_battle and submit_battle_action. In Swiss rounds omit opponentId to play your current table; Swiss refuses anyone else. Otherwise name the opponent from get_my_event's entrants, and for a team game the ally and second opponent too. For a league with sealed lists, pass the fixtureKey, token and opponentId from get_my_group. Requires mcp:write.
Inputs: token (required), allyId, llm_model, eventToken, +5 more.
start_sealed_leagueStart a league with sealed listsBInspect
A group organizer starts a league in which players seal rosters before the draw is published. Requires mcp:manage.
Inputs: token (required), llm_model, allowances, rosterLimit, +2 more.
stop_sharing_battle_inviteRetire a battle join linkADestructiveInspect
Disables a battle’s existing join link. People already seated keep their places. Requires mcp:manage.
Inputs: token (required), llm_model, conversation_id.
submit_battle_actionRecord a battle actionADestructiveInspect
Appends one command to a battle's log, only when expectedSeq equals the battle's current seq from get_my_battle. The answer's result.outcome is appended, stale (someone recorded first: read the battle again) or refused with the reason. Any seated player may record for any seat with playerId, as at a shared table. Each command kind says when it is used; follow get_my_battle's next for the order. Requires mcp:write.
Inputs: token (required), command (required), expectedSeq (required), llm_model, +1 more.
submit_event_rosterSeal my roster for a tournamentADestructiveInspect
Seals one of the signed-in player's saved or borrowed rosters for a tournament or hidden-list game, or replaces the list sealed before, with the site's checks: battle size, points, the event's house rules, a Warlord, and the roster deadline. Sealing stores a copy; later edits to the saved roster don't change it. Before the reveal only you and an assigned ally can read it. A player who plays alone fixes their Force Disposition by sealing it: when the list offers several, ask which and pass it. Check a saved roster with get_my_roster or open the borrowed roster link from list_borrowed_rosters. Seal only after the player confirms. Requires mcp:write.
Inputs: token (required), rosterId (required), llm_model, eventToken, +2 more.
swap_tournament_table_seatsSwap players between tournament tablesADestructiveInspect
An organizer swaps two entrants in the current Swiss round. Use the round, table numbers and ordered player ids from get_my_event. Confirm the affected tables before calling. Requires mcp:manage.
Inputs: round (required), token (required), tables (required), players (required), +3 more.
unseal_event_rosterUnseal an entrant’s rosterADestructiveInspect
Clears the named entrant’s sealed roster so they can seal again, where their role and the event state allow it. Confirm before calling. Requires mcp:manage.
Inputs: token (required), userId (required), llm_model, eventToken, +1 more.
update_eventUpdate a tournament or hidden-list gameBDestructiveInspect
An organizer changes settings or schedule. Read get_my_event first. If changing tournament details, send the name, description, visibility, admission and player limit together. Requires mcp:manage.
Inputs: token (required), name, rule, schedule, +7 more.
update_groupUpdate group detailsADestructiveInspect
An organizer replaces the group name, description, visibility and admission policy. Read get_my_group first and keep any fields the player did not ask to change. Requires mcp:manage.
Inputs: name (required), token (required), admission (required), visibility (required), +3 more.
withdraw_from_eventWithdraw from a tournamentADestructiveInspect
Withdraws the signed-in player from a tournament. The entry and recorded results are kept. Confirm the tournament and withdrawal. Requires mcp:manage.
Inputs: token (required), llm_model, eventToken, conversation_id.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceRemote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.MIT
- AlicenseCqualityCmaintenanceCompetitor Monitor AI - MCP server providing AI-powered tools and automation by MEOK AI Labs112 npm37 PyPIMIT
- AlicenseAqualityDmaintenanceEnables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.1611 npm1MIT

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