Skip to main content
Glama

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 gatorpath

The 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:8000

Claude 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_dpr recognizes 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_programs marks them drafted: 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 stay verified: false. Rules the format can't express (a CR/NC unit cap, a course taken four times, a GPA floor) show as unparsed with 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 are verified: 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 tools
audit_progressA
Read-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_planA
Read-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_planA
Read-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_programsA
Read-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_combinationsB
Read-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_courseA
Read-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_stepsA
Read-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_chainA
Read-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_requirementsA
Read-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_roadmapA
Read-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_sectionsA
Read-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_dprA
Read-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_transcriptA
Read-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_electivesA
Read-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_programsC
Read-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_profileA
Read-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_profileA
DestructiveIdempotent

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_coursesB
Read-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

    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

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      A
      quality
      D
      maintenance
      Local-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
      -
    • F
      license
      Not graded
      quality
      C
      maintenance
      Exposes 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.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables 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.
      9
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables 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.
      -