Skip to main content
Glama

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/mcp

Configuration (flags override env vars):

Env var

Flag

Default

SCARLETPLAN_DB

--db

./scarletplan.db

SCARLETPLAN_TRANSPORT

--transport

stdio

SCARLETPLAN_HOST / SCARLETPLAN_PORT

--host / --port

127.0.0.1:8765

SCARLETPLAN_LOG_LEVEL

--log-level

INFO

SCARLETPLAN_REQUIREMENTS

—

requirements/cs_bs_sas.yaml

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>&1

Key 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-run

Match 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

search_courses

Full-text search the catalog

get_course

Full detail: prereqs, sections, core codes

get_prereq_tree

Prereq AST annotated with course titles

check_eligibility

Which courses you can take given your transcript

get_sections

Sections with meeting times, instructors, open status

get_professor

RMP rating + match confidence + courses they teach

get_fill_stats

Historical fill rate for a section index

get_requirements_progress

CS BS degree progress by bucket

solve_semester_schedule

Top-k conflict-free schedules with CP-SAT

validate_plan

Check a manually-edited schedule for conflicts

solve_degree_plan

Multi-semester degree plan with prereq ordering

get_user_profile / set_user_profile

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 strings

Tests use synthetic in-memory SQLite — no network, no real DB required.

Available Tools

13 tools
check_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

    A4.1/5.0

    Scored across 13 tools

    Disambiguation5/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    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.

    Completeness5/5

    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

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      MCP 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.
      18
      1
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      A 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.
      33
      Apache 2.0