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.

SF State degree-planning tools for the 2024-25, 2025-26, 2026-27 Bulletins: requirements follow the student's catalog year, courses and prereqs are the newest (2026-27). Answers come only from the Bulletin and reviewed rules: don't add courses, prereqs or requirements the tools didn't return. Cite the source/source_page each answer comes with (Bulletin pages; a few office policies cite that office's page), show every warning, and remind the student that the DPR and an academic advisor are the official sources for degree requirements. A course meets a GE, SF State Studies or American Institutions area only where a tool shows it (ge_areas, counted, major_courses): never infer one from a course's subject or title. Never guess what transfer credit covers (the DPR shows it), what's left or whether a student is done (audit_progress says, from the courses they typed), or when they will graduate (build_plan says). To plan a degree without the plan_my_degree prompt, call get_planning_steps first and follow it: a typed course list is enough to plan from, so don't hold the plan back for a DPR. After a plan passes check_plan, show its first term's sections (class number, days, times, room, instructor, seats) with get_sections when that term's schedule is out. Build the profile from the student's words, in full from the first call: every course with its grade exactly as given (W, I, D and F rows too), the math placement, everything in progress, advisor approvals. Don't fill in what they didn't say. first_time means they began college at SF State, not that this is their first term: set it only when they say so (false for a transfer student). Student profiles are passed in per call and never stored, except by save_profile: one file on the student's machine, only when they ask.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
search_coursesB

Keyword search over Bulletin course codes, titles and descriptions.

subject: e.g. 'CSC'. level: 'lower' (100-299), 'upper' (300-699), 'graduate' (700+), or a hundred like '600'.
get_courseA

Full Bulletin record for one course: description, units, grading, GE areas, prereq (raw text + parsed tree + status), paired/cross-listed links, source_page, and unlocks: courses whose prereqs name it (as a requirement or one of the alternatives), so a student sees what skipping or delaying it holds up. A '*' after a prereq item means registration enforces it; items without one may be enforced by the instructor up to the end of add/drop (p.2436).

get_sectionsA

Class Search sections of courses in one term (e.g. '2027-spring'), to show after a plan for its first term once that term's schedule is out: class number (class_nbr, what Student Center asks for), meetings (days, time, where), mode, instructor, seats_open, waitlist_open, enrolled, and attributes (permission numbers, GE tags; Class Search shows no capacity). rate_my_professors: {instructor: a Rate My Professors search} per named instructor, links for the student to open (anonymous student opinion, not SF State's). not_offered: no section that term (move it in the plan, then check_plan). unknown: GatorPath has no schedule for that subject and term (not out yet, or a subject it didn't scrape): check Class Search. A snapshot from scraped_at: seats, rooms and instructors change, so the student confirms in Class Search before registering.

Time clashes are checked here, not by you: `schedule` {code: [class_nbr, …]} is one set of sections with no time
clashes, the fewest full sections first (a lecture with its lab or activity is one pick), and each section says
in_schedule, or clashes_with: the scheduled sections of other courses it overlaps ([]: it fits instead). `sets`:
how many clash-free sets there are. When none fits, schedule is null and always_clash names the course pairs that
never fit together: one moves to another term (then check_plan). online: the courses the student wants online: the
schedule uses their fully online sections when they have one. keep: class numbers the student chose; those sections
stay (a lecture with its lab) and the rest fit around them. pinned_blocking says whether releasing chosen
sections finds a clash-free set; all_counted is false when the bounded search could not establish impossibility.
get_prereq_chainA

Everything that must come before a course, all the way down.

`requires` is the course's own prereq tree ({"all": […]} / {"any": […]} of course, standing, gpa, permission, …
leaves). `chain` lists every course mentioned anywhere below it, alternatives included, prerequisites first and the
course itself last; read each entry's `requires` for which are and/or. `conditions` are the non-course leaves;
`verifiable: false` ones (permission, "or equivalent", …) can't be checked by GatorPath.
list_programsC

Programs GatorPath has requirement rules for. verified: a person checked them against the Bulletin; drafted: AI-drafted from the Bulletin's text and checked by program (codes, pages, word-for-word quotes, units, a test plan), not yet by a person: say so when planning with one.

get_program_requirementsA

A program's requirement groups (as written in its rules YAML, each with its Bulletin page) plus the university graduation requirements every bachelor's degree shares: GE areas, SF State Studies, American Institutions, GWAR, unit/residence/GPA totals. catalog_year: the student's (e.g. 'Fall 2025' or '2025-26'); default the newest.

get_roadmapA

The Bulletin's suggested semester-by-semester roadmap. Items are course codes or slots like {slot: GE, area: "1A", units: 3}. Without a valid variant, returns the variants to choose from (for BS CS the variant follows the student's QR pathway / math placement, or the ADT for transfer students). catalog_year: the student's (e.g. 'Fall 2025'); default the newest.

audit_progressA

Degree audit: per requirement group satisfied / in_progress / remaining / waived (or unparsed: a rule GatorPath can't check, with the Bulletin's quote) and which courses counted, plus university totals (120 units, upper-division, residence, CR cap, GPAs). A total's value is what's done: add units_in_progress (and upper_division_units_in_progress) for where the student stands once this term ends, as the DPR counts it. Nothing is stored.

profile: program (e.g. 'bs-cs'); catalog_year (the DPR's "Requirement (Catalog) Term", e.g. 'Fall 2025': that
year's rules when GatorPath has them, else the newest with a warning); completed: [{code, grade, term?, units? (variable-unit
courses), transfer? (articulated transfer course), credit? ('extension' | 'exam' | 'evaluation': counts for
units, never residence)}], grades as SF State symbols (A..F, CR, NC, W, I);
in_progress: [codes]; ge_done: GE areas met by transfer/AP/IB credit, as the DPR writes them (e.g. "1A", or an
older catalog's "A2", "D", "UD-D": translated automatically), also USH/USG/CSLG; dpr_met: required courses the
DPR shows met by a substitution or exception (e.g. MATH 225 met by MATH 325); not_on_dpr: requirements the
tools list but the student's DPR doesn't have at all (an older catalog, e.g. GE "6" Ethnic Studies): left out and
flagged for an advisor to confirm; first_time (began at SF State as a first-time college student; leave it out
unless the student says: without it, transfer work decides, and false needs transfer work); ge_certified (Cal-GETC certification of lower-division GE, p.2304); prior_bachelors (already holds
a bachelor's or higher degree from a regionally accredited institution: GE and graduation requirements waived,
p.2313); transfer_units: total transfer units, AP and IB units too; adt: true only for a verified AA-T/AS-T from a California Community
College in a similar approved major (waives SF State Studies, p.2313); approved: {group id: [codes]}, the courses
the student's advisor approved for a group with `approval` (BS Applied Mathematics application electives: no
Bulletin list), from the DPR or the student; gpa optional. A group with `options` is a "Select One": `remaining`
is one option, and the student may take another.
check_planA

Validate a term-by-term plan. Call this before presenting any plan, fix every error, and re-check until valid. courses gives each planned course's title, units and source_page for the plan's table: no get_course per course. Errors (with Bulletin text/pages): prereq not met by that term, course already passed or planned twice, unknown course, units over the term's cap (term max_units, else 15; with the student's max_units_per_term, which guides the first plan, a later edit above it is a warning in over_preference, not an error: the 15-unit advisor flag and the university's 19-unit maximum still apply). requirement or 120/upper-division units not covered. Warnings: unverifiable prereqs (GPA not given, permission), loads above the normal 15 (p.2393; "as on the Bulletin roadmap" with no advisor when the term's roadmap semester prints that load), unfilled slots. profile.f1: true for an F-1 visa student: a spring/fall term under 12 units is an error (the plan's last term: a warning and the international office), and so is a skipped spring/fall term (pp.2390, 2393). profile.permissions: courses the student says an instructor or department already gave them permission for: those prereq branches count, with a warning to bring it to registration. profile.overload_approved: terms whose overload the student says their advisor approved: no advisor handoff for that load (the term's cap still applies).

plan: {semesters: [{term: '2027-fall', courses: ['CSC 413', {slot: 'senior_electives', units: 3}]}]}. Pass
build_plan's semesters back as returned: their max_units and roadmap {units, source} keep the roadmap's loads. A slot is an
unfilled pick for a requirement group (group ids from get_program_requirements), or {slot: 'elective', units: 3,
upper_division?: true} for free units. Terms are YYYY-spring/summer/fall, or YYYY-winter for Winter Session (January,
between fall and spring, at most 4 units), after the profile's completed terms.
build_planA

Deterministic baseline plan to graduation, laid out on the Bulletin roadmap: each term starts from its roadmap semester (what's done is skipped, what isn't ready carries over), then the remaining required courses by prereq chain (critical path first, corequisites together), then slots for what's open (GE areas, senior electives, free electives) to reach the 120 and upper-division totals. Already run through check_plan: see check.

Fill each slot with list_eligible_electives + the student's goal, then call check_plan again before presenting.
Unit loads follow the roadmap (D24): each spring/fall term's cap is the printed units of the roadmap semester the
student's units have reached (16, 15, 16, … for a BS CS QR 1/2 freshman; the last semester's past its end; never
under 12 for f1), shown as each semester's max_units and roadmap. max_units_per_term is the student's own pace and
overrides it for this plan (check_plan only warns when a later edit goes above it). Also include_summer, include_winter (Winter Session terms
between fall and spring: up to 4 units of GE, American Institutions or free electives) and f1 (F-1 visa: spring/fall
terms filled toward 12 units, pp.2390, 2393). Returns needs_input
(qr_pathway, start_term) instead of guessing. Each semester has `why`: per course, what it's needed before, the
chain it starts, and whether delaying it pushes back graduation. `pace` says what sets the length: the longest
prereq chain vs the units per term (load: roadmap / max_units_per_term); normal_load is the lighter option at the
normal 15 (terms, graduation term) when the roadmap goes above it; fold_last_term when a light last term fits into
one earlier term (a term sooner at one heavier load). profile.graduate_by (D25) fits the loads to that goal: when the
roadmap's loads end later, every term goes to the roadmap's heaviest semester, then one unit more at a time up to
19, until the plan ends by then (load: graduate_by, pace.fit with the units and a note; above the roadmap's
heaviest is an overload: advisor). pace says whether the term is reachable and, if not, why_not.
For "3, 4 or 5 years", call it at different max_units_per_term / include_summer / include_winter.
list_eligible_electivesA

Courses that can fill one requirement group's slot (e.g. 'senior_electives', 'ge_4ud', 'sfss_esca'), with the Bulletin description, so you can pick by the student's goal.

Each option has readiness at by_term (default: the plan's first term, or the next term): 'ready' (prereqs met),
'check' (met except what GatorPath can't verify: GPA, permission, unparsed text: see cannot_check), or 'blocked'
(blocked_by, plus ready_by: the first plan term it opens up, when a plan is given). Pass the build_plan output as
`plan` and the slot's term as by_term, so planned courses count (a later by_term with no plan uses build_plan's
baseline and says so). Options are ranked ready-first, then by
also_covers: other open requirements the same course would satisfy (GE, SF State Studies and American Institutions
may overlap with each other and the major, p.2352; one course can do triple duty, e.g. 4UD + Environmental
Sustainability + Global Perspectives). Re-run check_plan after filling slots. A group with
`approval` (courses an advisor consents to, no Bulletin list) returns that text, no options, and see_advisor.

full: true for the rest of the list, when the student asks for it: every option they can take (ready or check), no
limit, without descriptions. When by_term's Class Search schedule is out (schedule_out), each has on_schedule: true
(a section that term; these come first), false, or "unknown" (its subject wasn't scraped). crosslisted: the same
class under other codes (one option, not two). Without full, `more` names (code: title) the ones past `limit`
that are ready or open up later in the plan, so a course that fits the goal isn't missed for ranking low.

online: true keeps only the options that can be taken online at by_term, and `online` on each says how that's known:
a fully online section when by_term's schedule is out (hybrid doesn't count), before that only how it last ran that
season, so an empty list for a later term means not known yet, not none.
ge_combinationsB

Up to 8 ways (3 when more than 5 are open) to finish the open GE, SF State Studies and American Institutions requirements that one course can fill, fewest courses first, from courses that ran in the last year where that covers them (overlaps lists every course that counts for two or more); the first is the fewest a bounded search found, not a proven minimum: one course covering several (4UD + Environmental Sustainability + Global Perspectives), two that split them, or one each. Each part says what one course covers, how many courses cover exactly that (options), and examples (ready first, then recently offered); the parts can go in different terms. courses_that_fit: per open requirement, every course the student can take for it. Pass the build_plan output as plan so planned courses count; readiness is at each requirement's slot term in it (by_term: one term for all).

compare_programsA

What if the student changes major to target (a program id from list_programs)? Returns current and target: major units done / in progress / needed, and build_plan's terms and est_graduation_term at the profile's load; the target's major groups (what counts, what's left); courses: count_in_both, only_current (still count toward the 120 and GE), only_target; and extra_terms (target minus current). The new major is the Bulletin in effect when they change (quoted in warnings); GE and graduation requirements stay their catalog year's. Show the see_advisor items: the official check is the Student Center What-If report and the target department.

save_profileA

Save the student's profile so the next session starts from it. Only when the student asks to save.

Writes one YAML file on the student's machine at `path` (default ~/.gatorpath/profile.yaml): plain text they can
read, edit or delete, readable only by them. Replaces an earlier GatorPath profile at that path, never any other
file; refuses paths inside the GatorPath folder. Keeps everything in the profile, plus goal, chosen_electives and
the plan that last passed check_plan. Nothing else is stored anywhere.
load_profileA

Read the profile the student saved with save_profile (default ~/.gatorpath/profile.yaml), to start a session from it. Returns profile, or error not_found. Warns when dpr_imported is before the current term: ask for a fresh DPR before planning.

import_transcriptA

Read the student's SF State unofficial transcript PDF on their own machine (Student Center → Unofficial Transcript, saved as a PDF) and return only course codes, grades, units and terms: completed, in_progress, transfer_units. Name, ID, birthdate and the PDF text never leave this tool, so the student doesn't need to attach the PDF to the chat; ask for the file's path instead. Merge the result into the profile. Transfer courses show as totals only: their requirements come from the DPR.

import_dprA

Read the student's Degree Progress Report on their own machine (Student Center → Degree Progress Report, printed to PDF; click Expand All and View All on long lists first) and return a ready profile (completed SF State and transfer courses, in_progress, ge_done, dpr_met substitutions, gpa, catalog_year from the DPR's "Requirement (Catalog) Term") plus remaining: what the DPR itself says is still needed, and cross_check: where GatorPath's audit disagrees with the DPR (the DPR wins). Name, ID and the PDF text never leave this tool, so the student doesn't need to attach the PDF to the chat; ask for the file's path. Add qr_pathway, goal and start_term, then use the profile with the other tools. If it returns unknown_program, ask which of choices is their major (a concentration doesn't show on the DPR's Plan line) and call again with that id as program.

get_planning_stepsA

The Plan my degree workflow, for a client that didn't start from the plan_my_degree prompt: call it first when a student asks to plan their degree (or what's left, or when they'll graduate), then follow its steps.

Prompts

Interactive templates invoked by user choice

NameDescription
plan_my_degreeStep-by-step workflow: profile → audit → plan → electives by goal → check_plan → pace/what-ifs → advisor.

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.6/5.0

Scored across 18 tools

Disambiguation4/5

Most tools have distinct roles: imports, auditing, planning, validation, course lookup, and profile persistence are separated by resource and action. A few boundaries are nuanced, especially audit_progress versus check_plan and build_plan versus get_roadmap, but the descriptions make the intended use clear enough.

Naming Consistency4/5

Nearly all tools use consistent snake_case verb_noun naming such as get_course, build_plan, import_dpr, and search_courses. The main outlier is ge_combinations, which is a noun phrase rather than a verb-led name, but the overall convention is still highly readable.

Tool Count4/5

Eighteen tools is slightly above the ideal compact range, but the domain is genuinely broad: importing records, auditing requirements, building and checking plans, retrieving course/program data, and managing profiles. Each tool appears to earn its place, though some consolidation might be possible.

Completeness4/5

The tool set covers the main lifecycle: importing DPRs and transcripts, auditing progress, building and validating plans, exploring programs, courses, prerequisites, sections, electives, and saving/loading profiles. Minor gaps remain around explicit manual profile editing/deletion and term/calendar discovery, but core planning workflows are covered.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues