GatorPath
GatorPath is an MCP server that lets an AI assistant plan an SF State student's degree and verifies every plan against the official Bulletin — the AI suggests, the code checks.
Course lookup —
search_courses(keyword search filtered by subject and level),get_course(full Bulletin record: units, prereqs, GE areas, cross-listings, source page, and what the course unlocks),get_prereq_chain(the whole prerequisite tree, all alternatives, down to non-course conditions).Schedules —
get_sectionsfor a term: class numbers, meeting times, seats, instructors, Rate My Professors links, and clash-free section sets, honoring "online" and pinned sections; flags courses not offered or unknown.Programs and requirements —
list_programs,get_program_requirements(requirement groups by catalog year plus shared GE/graduation rules),get_roadmap(the Bulletin's suggested semester-by-semester plan, including QR/ADT variants).Degree audit —
audit_progress: per group satisfied / in progress / remaining / waived / unparsed, with course-by-course credit and university totals (120 units, upper-division, residence, GPA), handling transfers, GE credit, DPR substitutions, ADT, prior bachelor's and F-1 status.Plan building —
build_planproduces a deterministic baseline laid out on the roadmap (with pace, load, summer/winter and graduate-by options, and a "why" for each course);check_planvalidates any plan and must pass before it's presented.Filling gaps —
list_eligible_electivesranks courses for a requirement slot by readiness, schedule and what else they cover;ge_combinationsfinds the fewest courses that finish the open GE / SF State Studies / American Institutions requirements.Major changes —
compare_programs: units done and left, shared vs. unique courses, and extra terms for a different major.Local record import —
import_dprandimport_transcriptread PDFs on the student's own machine and strip name and ID.Saved profiles —
save_profile/load_profilewrite and read one plain YAML file locally, only on request.Workflow help —
get_planning_stepsreturns the "Plan my degree" steps for clients without MCP prompts.
All tools are read-only except save_profile; nothing is stored on the server.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@GatorPath I'm an SF State CS major, plan the rest of my degree"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
GatorPath
An MCP server that helps SF State students plan their degree with any AI assistant. It answers "what's left?", "what's my 4-year path?", and "which classes for cybersecurity, and in what order?" Every answer is checked against the official Bulletin.
The AI suggests, the code verifies.
Status: v0.2.0 (2026-11-10), phase 7 (evals, first users); the website is live at https://gatorpath.fly.dev. Design:
docs/ARCHITECTURE.md. Work:TASKS.md. Changes: releases.
Why
SFSU's Degree Planner and DPR show what's required, but not which direction to take or why. Ask a chatbot
instead and it answers from memory: renumbered courses (CSC 210 is now CSC 215), prerequisites that don't exist,
a graduation term nobody checked. GatorPath gives the assistant tools that read the 2026-27 Bulletin, the major's
roadmaps and SFSU class-search history, and a check_plan that every plan has to pass. Each rule cites
its source: a Bulletin page, or the SF State office page it came from.
Related MCP server: Academic Advisor MCP Server
Setup (macOS)
You need gatorpath.zip, which includes the course catalog: download it from the
latest release. Then:
brew install uv poppler
unzip gatorpath.zip -d ~ && uv --directory ~/gatorpath sync
claude mcp add --scope user gatorpath -- uv --directory ~/gatorpath run gatorpathThe last line is for Claude Code. It asks before each GatorPath tool runs; to approve them all once, type
/permissions in Claude Code and add the allow rule mcp__gatorpath__*. For Codex CLI it's
codex mcp add gatorpath -- uv --directory ~/gatorpath run gatorpath.
For Claude Desktop, open Settings → Developer → Edit Config, add this, and restart the app:
{
"mcpServers": {
"gatorpath": {
"command": "uv",
"args": ["--directory", "/Users/YOU/gatorpath", "run", "gatorpath"]
}
}
}If Desktop says it can't find uv, put the full path from which uv in "command".
From source (no zip): clone the repo, put the Bulletin PDF at data/raw/bulletin-2026-27.pdf, and build the
catalog with the ingest commands in AGENTS.md.
Use
Start with the Plan my degree prompt (Claude Code: /mcp__gatorpath__plan_my_degree). It asks once for what it
needs. The fastest way in is your DPR: in Student Center, print the Degree Progress Report to a PDF and give the
assistant the file's path (don't attach it). GatorPath reads it on your machine and drops your name and ID.
In a client without MCP prompts (Codex CLI), just ask, and mention SF State, e.g. "I'm an SF State CS major, plan the rest of my degree": the tools hand it the same steps. Without "SF State" a client may answer from web search, and nothing checks that plan.
Website
Live at https://gatorpath.fly.dev, or run it yourself below. Claude Code with this server, for students with no AI app: upload your DPR (or type your courses), and a chat beside your plan does the rest. Ask anything about your degree, or tell it what to change, and the plan updates. Needs Node as well as the Setup above:
(cd web && npm install && npm run build)
# Save ANTHROPIC_API_KEY=your_key in the git-ignored .env file first.
set -a; . ./.env; set +a
uv run gatorpath-web # http://127.0.0.1:8000Claude Haiku has the same tools as an AI app with this server. It fills your electives and GE for your goal, answers questions, changes classes and the pace, and corrects your record when you tell it to. GatorPath's checks run on every change. A change that makes the plan worse is refused unless you insist, and then the plan stays marked as failing. Without a key the site still plans, and you choose the courses yourself.
The PDF is read in memory, and your name and ID are dropped as it's read. There is no sign-in. The website counts visits, plans built and questions asked as anonymous daily totals (never who), and keeps feedback you choose to send with its "Send feedback" link. The web app saves your record and plan in this tab's session storage so a reload keeps your work; closing the tab clears it, or choose "Clear my saved data" in the footer. The server keeps no student record (ARCHITECTURE D37 covers the totals and feedback). Anthropic's API receives your major, catalog year, goal, load choices and course list, never your name, ID or GPA, and a grade only if you type one in the chat. Questions an advisor should answer go to Navigator.
Deploying and reading the numbers
The site runs on Fly.io: one machine, the course catalog baked into the image, and a small volume for the usage file.
fly deploy --remote-only ships a new version (see the fly lines in AGENTS.md). The usage numbers
are uv run python -m gatorpath.stats locally, or on the live site
fly ssh console -C "uv run --no-sync python -m gatorpath.stats --days 30 --feedback".
Evals
47 questions (evals/questions.yaml) on synthetic students across the three catalog years, Winter Session included,
run through Claude Code and Codex CLI with only the gatorpath server attached (run 2026-10-29, full report in
evals/REPORT.md). Each client starts the way its students do: Claude Code from the Plan my degree
prompt, Codex CLI (no MCP prompts) from the student's words alone.
Metric | Claude Code | Codex CLI |
Questions fully passed | 45/47 | 45/47 |
Plans passing check_plan | 15/15 | 14/15 |
Electives fit the goal | 13/14 | 12/14 |
Hallucinated course codes | 0 | 0 |
Used only the gatorpath tools | 47/47 | 47/47 |
Plan in the first reply (nothing asked back) | 15/15 | 14/15 |
Median time to a plan | 147 s | 403 s |
Median tool calls per plan | 10 | 22 |
Misses in that run: goal fit for the same game-development student on both clients (SF State's two game courses rarely run and ranked past the first 25 electives, so neither plan had them); Codex presented a plan with open slots for a student retaking CSC 215 without running check_plan; Claude left one student's math placement out of the profile. Codex's plans took a median 22 tool calls, down from 68 on 2026-10-21 (TASKS.md, "Done 2026-10-29": efficiency and token usage).
Fixed on 2026-10-30: the electives list names the options past its first 25, and GE suggestions are checked at each requirement's own term in the plan, not the plan's first. A rerun of the 15 plan questions: both clients 15/15 passed, plans 15/15, goal fit 14/14, a plan in the first reply 15/15. After that, GE suggestions come from courses that ran in the last year, each with when it ran; on the four plan questions this touches, every plan passed check_plan with goal fit, and none picked a course that hadn't run lately.
Haiku (claude-haiku-5-5, inside Claude Code) on the same 47 questions, two runs on 2026-11-06: 45/47 both times, plans
14/15 and 15/15, goal fit 13/14, 0 hallucinated course codes, a median of about two minutes and 10 tool calls per plan,
about $1.30 a run at API prices. The misses: most electives looked blocked for a data science student (both runs),
Haiku skipped check_plan on a last-term plan, and it once rewrote a long record's grades. After a fix, that data science
question passed three reruns of three, which makes the report 46/47. A bare API client is built (--clients haiku) but
hasn't run against the real API yet.
Limitations
Hand-written rules: BS Computer Science and BS Applied Mathematics for three catalog years, 2024-25 (the old GE Areas A-F), 2025-26 and 2026-27. Requirements follow the student's catalog year; courses and prereqs are the newest Bulletin's. A DPR on a catalog year without rules is planned with 2026-27 rules plus a warning, and the DPR wins where they disagree.
import_dprrecognizes a Computer Science or Psychology DPR; for other majors (no sample to read the program line from yet), type the courses or use the transcript instead.106 other bachelor's programs for 2026-27, plus BA Psychology for 2025-26 (
list_programsmarks themdrafted: true), are AI-drafted from the Bulletin's text, then checked by program: every course code, page and word-for-word quote, the unit totals, and a test plan that passes check_plan. Each had a first-pass review against its Bulletin text (Claude, 2026-10-23; docs/review-2026-27-drafts.md); a person hasn't signed them off yet, so they stayverified: false. Rules the format can't express (a CR/NC unit cap, a course taken four times, a GPA floor) show asunparsedwith the Bulletin's words: GatorPath doesn't check them, and a degree with one is never marked complete. 2 of the Bulletin's 110 aren't served: BA Philosophy and Religion (suspended, nothing printed) and BA Family and Community Sciences (no roadmap).BS Applied Mathematics: the three application electives are "chosen with the consent of the applied mathematics advisor" (p.2129), so GatorPath can't list them; it counts only the ones you say were approved.
Only the 2025-26 BS CS rules are signed off by a person (
verified: true). The others areverified: false: for BS CS 2026-27, eight rounds of independent AI review against the PDF brought the error rate from 19.6% to 10.6%, each finding fixed. BS Applied Mathematics hasn't had a review yet.Offering history (2023-spring to 2027-spring) covers CSC, MATH, PHYS, PSY and SXS; 89 other subjects have only the Spring 2027 schedule, so "not offered" there means one term, and GE suggestions favor courses on it (a fall-only course there reads as not run lately); the rest show
offered: unknown.The transcript importer hasn't seen a real CR / W / I / repeat row yet, and the DPR's transfer-row Notes codes have no legend. Both get flagged rather than guessed.
Tested on macOS only.
Course codes, grades and units go to your AI provider as tool results; your name and ID don't. GatorPath stores nothing unless you ask the assistant to
save_profile.
Prior art
Earlier projects for SF State students: GatorWay (MIT; transcript to interest-based electives over MCP) and Plan-Ed (SF Hacks × GDG 2026, 2nd place; a four-year plan from Gemini and a rules engine, as a web app). How GatorPath differs: ARCHITECTURE §3.
Scope
v1: SF State, BS Computer Science (2026-27 Bulletin), then BS Applied Mathematics (2026-27, rules unverified), then the other bachelor's programs (2026-27, AI-drafted, unverified)
Later: transfer credit, accounts so a plan follows a student across devices (designed in
docs/superpowers/specs/2026-11-09-accounts-design.md, not built)
Not affiliated with San Francisco State University. Always confirm with your advisor and your official Degree Progress Report.
MIT License: see LICENSE.
Available Tools
18 toolsaudit_progressARead-onlyIdempotent
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.
Inputs: profile (required).
build_planARead-onlyIdempotent
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.
Inputs: profile (required).
check_planARead-onlyIdempotent
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.
Inputs: plan (required), profile (required).
compare_programsARead-onlyIdempotent
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.
Inputs: target (required), profile (required).
ge_combinationsBRead-onlyIdempotent
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).
Inputs: profile (required), plan, by_term.
get_courseARead-onlyIdempotent
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).
Inputs: code (required).
get_planning_stepsARead-onlyIdempotent
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.
Inputs: no named parameters.
get_prereq_chainARead-onlyIdempotent
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.
Inputs: code (required).
get_program_requirementsARead-onlyIdempotent
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.
Inputs: program (required), catalog_year.
get_roadmapARead-onlyIdempotent
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.
Inputs: program (required), variant, catalog_year.
get_sectionsARead-onlyIdempotent
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.Inputs: term (required), codes (required), keep, online.
import_dprARead-onlyIdempotent
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.
Inputs: pdf_path (required), program.
import_transcriptARead-onlyIdempotent
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.
Inputs: pdf_path (required).
list_eligible_electivesARead-onlyIdempotent
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.
Inputs: profile (required), group_id (required), full, plan, +4 more.
list_programsCRead-onlyIdempotent
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.
Inputs: no named parameters.
load_profileARead-onlyIdempotent
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.
Inputs: path.
save_profileADestructiveIdempotent
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.
Inputs: profile (required), path.
search_coursesBRead-onlyIdempotent
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'.
Inputs: query (required), level, limit, subject.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
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.
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.
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.
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
Related MCP Connectors
Your planner in every AI chat: tasks, calendar, docs, habits, goals and memory, over MCP.
Build Gantt charts from your AI chat: tasks, dependencies, timeline spreadsheets. All data is local.
Turn grounded AI answers into trusted comparisons, plans, timelines, and decision views.
AI tutor, homework helper, test prep and essay grader. Free to start; Student plan $4.99/mo.
Related MCP Servers
- FlicenseAqualityDmaintenanceLocal-first Rutgers course planning assistant that answers 'what should I take and when?' using a CP-SAT solver, real transcript data, and live SOC data, connected to Claude via MCP.13-
- FlicenseNot gradedqualityCmaintenanceExposes academic advising tools over stdio so an AI assistant can retrieve student profiles, transcripts, and curricula, check graduation requirements and requirement groups, calculate current and planned GPAs, and recommend retakes, courses, study plans, and career-to-specialization matches. All computations run deterministically in Python and return UNKNOWN rather than guessing when verified academic thresholds are missing.-
- AlicenseNot gradedqualityBmaintenanceEnables natural-language queries across multiple schools' Canvas and Blackboard accounts for courses, notifications, assignments, grades, feedback, and schedules, with read-only access and local todo/calendar export.9MIT
- FlicenseNot gradedqualityBmaintenanceEnables AI assistants to explore, compare, and engage with postsecondary education and training offerings—programs, courses, certifications, credit transfer, prior learning, and career transitions—with sourced, snapshot-dated answers and explicit statements of missing data.-