Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
prompts
{
  "listChanged": true
}
resources
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
optimize_teamA

Pokémon Champions team building: fill open slots against constraints: "cover these types" and "answer these threats." The engine scores every legal species in the regulation against the constraint set — the types the current team never hits super-effectively (computed automatically, or supplied), and the threats named or defaulted to the meta’s top five by usage — by what its typing covers, resists and hits, with a small preference for species the meta actually plays. With two open slots it scores pairs on their combined coverage, not just the sum. Every recommendation carries the reasons, so the tradeoff is visible; unranked species are scored on typing alone because their movesets are unknown. The fills respect Species Clause and stay inside the roster, so the result passes check_legality — verify with it once the team is assembled. Read-only and offline.

prepare_matchupA

Prepare a Pokémon Champions match against a known opponent: "here is their team — what do I bring, and what should I watch for?" A deterministic pre-game dossier composed from the rest of the surface. likelySets orders the opponent most-used first, carrying each species’ actual usage-derived set (item, ability, nature, EVs, four moves, usage share) where one exists. speedTiers compares real level-50 Speed with the margins spelled out. relevantDamageCalcs runs real damage rolls for the key matchups — the team’s hardest hit into their top threats and the threat’s hardest hit back at the member that answers it. recommendedBringFour is the same type-scored pick analyze_team makes. Leads, win conditions, loss conditions, and the members to preserve are heuristics from movesets, Speed and typing, each labelled with what it can see. Speeds and moves for uncurated opponent species are base-stat or STAB estimates and say so. The caller narrates; every number here is a real calculation or a real usage figure.

record_setA

File a Pokémon Champions set the reasoning produced into the local, per-user record, so a set generated once can be read back later — get_set returns it under recorded when asked with includeRecorded. The usage-derived meta (list_threats, get_set) stays the only home of measured usage: a record carries no rank, no usage share and no sample, and is labelled with how it was arrived at — "inferred" (solved from battle observations) or "proposed" (generated for a team). The store is one JSON-Lines file per user, $GETCOMPETITIVE_STORE or ~/.getcompetitive/sets.jsonl, created on first write; re-recording an identical set is a no-op (created: false) and a changed spread, item or move set is filed as a new record, so the file is the timeline of what was generated. The set is resolved against the dataset with the same rules the rest of the server uses, so an unknown species, item, nature or an illegal spread is rejected rather than filed, while unknown moves come back as warnings and the set is filed as given. This is the only tool on the server that writes anything; where there is no writable filesystem (the hosted endpoint) it returns an isError naming the path it could not write.

lookupA

Pokémon Champions data lookup, dispatching on mode: "species" for one Pokémon’s profile, "forms" for its forms, "search" for a fuzzy name search across the dataset, "move"/"item"/"ability"/"nature"/"learnset" for those records, "type" for a type’s defensive profile, "matchup" for one type multiplier, and "sprites" for a whole team’s sprite URLs in one call. Each mode carries the same documented fields the dedicated lookup tools had; pick the mode that names the thing being looked up and pass its arguments. Read-only and offline over the bundled dataset.

calculateA

Pokémon Champions battle calculation, dispatching on mode: "stats" for a final stat table, "damage" for a full single-attack simulation, "matchups" to test one attacker against many defenders, "speed" to place a Speed stat against a regulation roster, and "optimize_evs" to derive a minimal spread from goals (survive, outspeed, KO). Each mode carries the same documented fields the dedicated calc tools had. Read-only and offline; deterministic. Give one spread scale per member: evs (0-252 each, 510 total) or championsPoints (the Champions CP economy: 8 EVs = 1 CP, each stat 0-32, 66 CP total, e.g. 252 HP / 252 Atk / 4 SpD = 32 / 32 / 1 CP); giving both is rejected.

analyze_teamA

Pokémon Champions team analysis, dispatching on mode: "synergy" for the type-synergy read (stacked weaknesses, coverage gaps, speed placement, heuristic score, and battle-math answerClass verdicts against the meta when a regulation and moves are supplied), "diagnose" for the coaching read ("fix my team": problems with evidence, then concrete spread/move/item/member changes). Each mode carries the same documented fields the dedicated tools had. Read-only and offline.

analyze_battleA

Pokémon Champions battle analysis, dispatching on mode: "replay" turns a Showdown-format battle log into a deterministic post-match read (teams, KOs, observed Speed order, damage percentages, type read), "infer" runs reverse constraint solving on battle observations to narrow an opponent’s set. Each mode carries the same documented fields the dedicated tools had. Read-only and offline.

analyze_metaA

Pokémon Champions meta intelligence, dispatching on mode: "threats" for the usage-ranked threat list, "compare" for the two-window usage deltas and emerging cores, "set" for one species’ most-played standard set (batched). Each mode carries the same documented fields the dedicated tools had. Read-only and offline; usage-derived from measured tournament data.

team_ioA

Pokémon Champions team import/export and validation, dispatching on mode: "parse" turns pasted text into the canonical team shape, "format" renders a canonical team back into paste text, "legality" checks a team against a regulation’s rules, "regulation" reads one regulation’s rules (rosters optional), "regulations" lists them all. Each mode carries the same documented fields the dedicated tools had. Read-only and offline.

Prompts

Interactive templates invoked by user choice

NameDescription
team-doctorDiagnose a team against the meta and prescribe evidence-backed changes. "Here is my team — fix it."
matchup-prepPrepare a match against a known opponent: their likely sets, speed races, key rolls, bring-four, leads. "Here is my opponent — prepare me."
build-aroundBuild a legal team around one or two core species: coverage gaps, candidate partners, legality, paste. "Build around Mega Salamence + Rillaboom."
tournament-prepA pre-tournament walkthrough: the rules, the meta, the threats, and a preparation checklist.
learn-my-teamA plain-language guide to the user’s own team: roles, synergies, holes, and how it is meant to play.
scout-opponentScout an opponent from a battle replay: replay, observations, set inference, rematch preparation — one pipeline.
meta-reportThe current meta in one report: usage tiers, the top sets, and a data-dated read of what is good.

Resources

Contextual data attached and managed by the client

NameDescription
getcompetitive workspaceThe bundled getcompetitive App: Team Doctor (team analysis), Team Builder (slot optimization) and Matchup Board (pre-game dossier) over the deterministic competitive Pokémon engine.

TDQS

A4.1/5.0

Scored across 9 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: lookup for data, calculate for damage/stat calcs, analyze_* for different analysis domains (team, battle, meta), team_io for import/export, optimize_team for building, prepare_matchup for pre-game prep, and record_set for persistence. The mode-based dispatch within each tool keeps sub-functions organized without overlapping across tools.

Naming Consistency4/5

Tool names are consistently lowercase with underscores, mostly verb_noun (analyze_team, optimize_team, prepare_matchup, record_set) but a few are single verbs (lookup, calculate) and one is a noun phrase (team_io). The pattern is predictable and readable, though not perfectly uniform.

Tool Count5/5

9 tools is well within the ideal 3-15 range and each covers a distinct functional area. The scope is well-proportioned for a competitive Pokémon analysis server, with no redundant or trivial tools.

Completeness3/5

The surface covers data lookup, calculations, team/battle/meta analysis, import/export, optimization, matchup prep, and recording sets. However, the description mentions a `get_set` function to read recorded sets, but that tool is not present, leaving a gap in the read path for persisted data. Other minor gaps include no explicit delete or update for recorded sets, but these are less critical.

Maintenance

ActivityMaintained
ResponsivenessNo issues