ScarletPlan
ScarletPlan is a Rutgers course planning assistant that combines live course catalog data, prerequisite checking, degree requirements tracking, schedule optimization, professor ratings, and section fill statistics to help students plan their academic career.
Course Search & Details (
search_courses,get_course): Search the catalog by free text, subject, level, and term; get full course info including prerequisites, sections, core codes, and credits.Prerequisite Analysis (
get_prereq_tree,check_eligibility): View annotated prerequisite trees for any course and check which courses a student is eligible to take based on their completed transcript.Section Information (
get_sections): List all sections for a course in a given term, including meeting times, instructors, and open/closed status.Professor Ratings (
get_professor): Look up RateMyProfessors data (avg rating, difficulty, would-take-again %) with match confidence scores and courses taught.Fill Rate Statistics (
get_fill_stats): Historical fill-rate stats showing how quickly sections fill, how long they stay closed, and how often they reopen.Degree Requirements Progress (
get_requirements_progress): Track per-bucket progress toward the CS BS degree, including satisfied and remaining courses and credits.Conflict-Free Schedule Optimization (
solve_semester_schedule): Generate up to k conflict-free schedules using CP-SAT, with preferences for start/end times, days off, and campus.Schedule Validation (
validate_plan): Check a manually edited schedule for time conflicts.Degree Plan Generation (
solve_degree_plan): Create a multi-semester plan respecting prereq ordering, credit limits, and pinned course placements toward a target graduation term.Student Profile Management (
get_user_profile,set_user_profile): Persistently store and retrieve student data (completed courses, graduation target, preferences) across sessions.
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., "@ScarletPlan Plan my remaining semesters for CS BS 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.
ScarletPlan
Local-first Rutgers course planning assistant. Answers "what should I take and when?" using a CP-SAT solver, your real transcript, and live SOC data — running entirely on your machine, connected to Claude Desktop or Claude Code via MCP.
Disclaimer: ScarletPlan is not an official Rutgers tool. Always verify plans with Degree Navigator and your academic advisor.
What it does
Question | How |
What courses am I eligible for? | Prereq tree evaluation against your transcript |
Build me a conflict-free schedule | CP-SAT section optimizer with time/campus preferences |
Plan my remaining semesters | CP-SAT degree planner against CS BS requirements |
Will this section fill? | openSections fill-rate stats (grows over time) |
Who's a good professor for 344? | Cached RateMyProfessors ratings with name matching |
Related MCP server: polyu-estudent-mcp
Setup (5 commands)
Requirements: Python 3.11+, uv, Claude Desktop or Claude Code.
# 1. Clone and install
git clone https://github.com/heetshah15/scarletplan && cd scarletplan
uv sync
# 2. Build the database (ingest current + next term for NB)
uv run python scripts/setup.py
# 3. Start the MCP server (test it works)
uv run scarletplan-server
# 4. Add to Claude Desktop config (see below)
# 5. Start the openSections poller cron (see below)Claude Desktop config
Add this to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"scarletplan": {
"command": "uv",
"args": ["run", "--directory", "/absolute/path/to/scarletplan", "scarletplan-server"],
"env": {
"SCARLETPLAN_DB": "/absolute/path/to/scarletplan/scarletplan.db"
}
}
}
}Or see docs/claude_desktop_config.snippet.json for a ready-to-copy snippet.
HTTP transport (website / remote clients)
The server also speaks MCP over streamable HTTP for the planned web frontend — stateless with JSON responses, so multiple workers can run behind a load balancer:
uv run scarletplan-server --transport streamable-http --host 127.0.0.1 --port 8765
# endpoint: POST http://127.0.0.1:8765/mcpConfiguration (flags override env vars):
Env var | Flag | Default |
|
|
|
|
|
|
|
|
|
|
|
|
| — |
|
There is no auth on the HTTP transport: keep it bound to localhost and put the
website's authenticated backend in front of it. Every tool returns structured
JSON with error/caveats[] contracts (see docs/PRODUCTION_AUDIT.md), and a
health tool reports version, schema, and catalog freshness.
Claude Code / Project Instructions
Paste this into your Claude project instructions (or .claude/instructions.md):
You are a Rutgers course planning assistant powered by ScarletPlan tools.
Rules:
- Always resolve course facts via tools, never from memory (SOC data changes).
- On first use: gather completed courses, target graduation, preferences via
set_user_profile so the student doesn't repeat themselves.
- Planning flow: get_requirements_progress → solve_degree_plan → present → iterate.
- Scheduling flow: solve_semester_schedule (k=3) → present tradeoffs →
validate_plan after any manual edits.
- Always surface caveats[] to the user, especially low-confidence ratings.
- End every degree plan with: "Verify this plan with Degree Navigator and your
academic advisor. ScarletPlan is not an official Rutgers tool."
- For professor ratings: always show match_confidence; flag anything below 85%.openSections poller (start now)
The fill-rate stats dataset only grows if the poller runs during registration windows. Add this cron job so data starts accumulating:
# Edit crontab: crontab -e
*/5 * * * * cd /path/to/scarletplan && \
uv run python -m scarletplan.poller.poll_open \
--year 2026 --term 9 >> poller.log 2>&1Key registration windows (when fill-rate data is most valuable):
November 2026 — spring 2027 registration
April 2027 — fall 2027 registration
January / September — add/drop chaos
RateMyProfessors ratings (optional)
RMP uses an unofficial GraphQL endpoint. Isolated and optional — if it breaks, all other tools continue working.
# Scrape once per semester, cache in DB
uv run python -m scarletplan.ingest.rmp.rmp_scraper --year 2026 --term 9
# Dry run to check match quality first
uv run python -m scarletplan.ingest.rmp.rmp_scraper --year 2026 --term 9 --dry-runMatch confidence ≥0.85 is reliable. 0.70–0.85 is surfaced as low-confidence. Below 0.70 is not stored.
MCP tools
Tool | What it does |
| Full-text search the catalog |
| Full detail: prereqs, sections, core codes |
| Prereq AST annotated with course titles |
| Which courses you can take given your transcript |
| Sections with meeting times, instructors, open status |
| RMP rating + match confidence + courses they teach |
| Historical fill rate for a section index |
| CS BS degree progress by bucket |
| Top-k conflict-free schedules with CP-SAT |
| Check a manually-edited schedule for conflicts |
| Multi-semester degree plan with prereq ordering |
| Persistent student profile |
Dev
uv run pytest # all tests
uv run pytest -m "not network" # skip live SOC tests
uv run python scripts/report_parse_failures.py # see unparsed prereq stringsTests use synthetic in-memory SQLite — no network, no real DB required.
Available Tools
13 toolscheck_eligibilityA
Given candidate course_strings and the student's completed courses, return per course: eligible (bool), the unsatisfied prereq subtree, and any 'unknowns' (notes we could not verify automatically).
Inputs: completed (required), course_strings (required).
get_courseA
Full detail for one course: prereq AST + raw text, sections summary, core codes, credits. Accepts 'CS 344', '198:344', or '01:198:344'. Always pass caveats through to the user.
Inputs: course_string (required), term.
get_fill_statsA
Historical fill statistics for a section index, derived from the openSections poller. Returns hours_to_first_fill (how quickly the section filled after registration opened), pct_time_closed (fraction of the registration window the section was unavailable), and reopen_count (how many times a closed section reopened due to drops — high reopen_count means a closed section is still worth watching). Returns status='no_data' when the poller has not yet collected data for this term. Always surface caveats[] to the user.
Inputs: index_number (required), term, year.
get_prereq_treeB
Annotated prerequisite tree for a course (AST with course titles). Use to explain WHY a course is or isn't available.
Inputs: course_string (required).
get_professorA
Look up a professor by name. Returns their cached RateMyProfessors rating (avg_rating 1–5, avg_difficulty 1–5, would_take_again_pct) plus which courses they teach this term. Accepts any name format: 'Professor Smith', 'J. Smith', or SOC format 'SMITH, J'. Always surface match_confidence and caveats[] — low-confidence matches (<85%) should be flagged to the user. ratings_available=false means the scraper has not run yet for this term.
Inputs: name (required), term.
get_requirements_progressA
Per-requirement-bucket progress for the CS BS major. completed: list of course strings the student has finished. Returns buckets with satisfied/remaining course lists and credit counts. Call this before solve_degree_plan to show what's left to complete.
Inputs: completed (required).
get_sectionsA
List sections for a course in a term with meeting times, instructors, and open status. Times are minutes-from-midnight; Thursday is 'H'.
Inputs: course_string (required), term.
get_user_profileA
Read a stored user-profile value (e.g. 'completed_courses', 'target_grad', 'preferences'). Returns null if unset.
Inputs: key (required).
search_coursesA
Search the Rutgers course catalog by free text, subject code (e.g. '198' for CS), level (300 = 300-level), and term. Returns compact course rows. Use before get_course when the user names a topic not a code.
Inputs: term, level, limit, query, +1 more.
set_user_profileB
Store a user-profile value so the student does not repeat themselves across turns. Value is any JSON.
Inputs: key (required), value (required).
solve_degree_planA
Plan remaining semesters from now to target_term. completed: list of course strings the student has finished. target_term: {'year': 2028, 'term': 1} where term 1=spring, 9=fall. preferences: optional dict with max_credits_per_term (int, default 18), min_credits_per_term (int, default 12), current_year, current_term. pins: optional dict mapping course_string to {'year': Y, 'term': T} to force placement. Returns a semester-by-semester plan or a structured infeasibility explanation. Always call get_requirements_progress first to show the student their remaining requirements.
Inputs: completed (required), target_term (required), pins, preferences.
solve_semester_scheduleA
Given a list of course_strings and a term, return up to k (default 3) conflict-free section schedules using CP-SAT optimization. preferences may include earliest_start (minutes from midnight, e.g. 600=10am), latest_end, days_off (list of day strings like ['F']), campus_preference (e.g. 'BUSCH'). Returns schedules with section assignments, a human-readable summary, and penalty_score (lower=better). Always surface caveats[] to the user. Use get_sections first to confirm sections exist for the term.
Inputs: term (required), course_strings (required), k, preferences.
validate_planA
Check whether a proposed schedule (list of section index numbers) has any time conflicts. Use after the student manually edits a solve_semester_schedule result. Input: {sections: [index_number, ...], term: int}. Returns valid (bool), conflicts (list of overlapping pairs), and caveats (unknown indexes).
Inputs: plan (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Each tool targets a distinct aspect of course planning—eligibility, details, fill stats, professors, requirements, schedules—with clear descriptions that prevent confusion. The only potential overlap between solve_degree_plan and solve_semester_schedule is well-differentiated by their long-term vs. short-term focus.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., get_course, solve_degree_plan). The verbs are appropriately chosen and uniform across the set, making it easy to predict functionality from the name.
With 13 tools, the number is well-scoped for a university course planning assistant. Each tool serves a clear purpose without redundancy, covering search, details, prerequisites, scheduling, and user profile management.
The tool set covers the full student planning workflow: searching courses, checking prerequisites and eligibility, managing schedules, validating plans, and storing preferences. No obvious gaps exist for typical planning tasks, though external actions like enrollment are excluded.
Related MCP Connectors
An agent-first office suite Claude & ChatGPT read and write over one MCP URL.
MCP-native notes and memory for ChatGPT, Claude, and other AI tools.
Your planner in every AI chat: tasks, calendar, docs, habits, goals and memory, over MCP.
Persistent memory for AI assistants. Save once; recall from Claude, ChatGPT, or any MCP client.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server for a self-hostable personal planner — exposes memo, todo, calendar event, and cross-resource full-text search tools so Claude, Cursor, or any MCP client can manage your schedule and notes in natural language.181MIT
- FlicenseAqualityBmaintenanceA local MCP server that lets Claude Code operate the PolyU eStudent portal to check grades, timetable, exams, search subjects, and manage course registration through natural language.9-
- AlicenseAqualityDmaintenanceAn MCP server for accessing Dutch school schedules from Magister. Enables Claude and other MCP-compatible AI assistants to query school schedules, drop-off times, and pick-up times.48 npm7MIT
- AlicenseBqualityCmaintenanceA local-first open-source MCP server that acts as a personal secretary, memory manager, and automation hub—it syncs Calendar, Gmail, Canvas, GitHub, and Health into a typed temporal memory graph, and enables approval-gated write actions like creating events, drafting/sending mail, and filing issues, all with telegram/slack/CLI interfaces and a SQLite-backed audit trail.33Apache 2.0