• 

• 

• 

Inspiration

Academic advising is hard at scale. Students get stuck behind hidden prerequisite chains and limited seats; advisors guess which policy change will help most. We wanted a sandbox where universities can simulate changes before students feel the pain.

What it does

AdvisorGPT is an AI dashboard that:

Detects bottlenecks: finds courses blocking the most students.

Explains why: shows prerequisite chains and historical D/F/W patterns.

Runs “what-if” simulations: add seats, relax a specific prerequisite, or prioritize near-grads—then see throughput gains, risk deltas, and who benefits (by major/term).

Personalizes plans: generates 3 schedule options per student (fastest, balanced, light load) with plain-English rationales.

How we built it

Graph model: Students, Courses, and PREREQ edges in Neo4j (Cypher for eligibility & deficits).

API: FastAPI endpoints (/bottlenecks, /whatif/capacity, /whatif/relax, /student/:id/plan).

NL → Cypher: a small LLM router (Gemini/GPT) that turns natural language into read-only Cypher with a schema whitelist.

Frontend: React + Vite + Tailwind with Recharts/D3 visuals and framer-motion micro-animations.

Design: “Scenario Compare” drawer to pin simulations; every chart shows hover explanations and the exact Cypher we ran.

The modeling bits

We compute a transparent risk score to keep decisions responsible:

$$ \text{risk} \;=\; w_1\,\mathbf{1}[\text{missing core}] \;+\; w_2\,\mathbf{1}[\text{GPA}<2.5] \;+\; w_3\,\mathrm{DFW\_rate}(\text{course}) \;+\; w_4\,\mathbf{1}[\text{credit load}>15]. $$

Where ( \mathbf{1}[\cdot] ) is an indicator (1 if the condition is true, else 0).

For each what-if, we report (\Delta) throughput, (\Delta) average risk, and benefit distribution across majors/years.

Challenges we ran into

Visualizations: Time constraints meant we couldn’t fully integrate Sankey, waterfall, and scatter plots. These remain clear next steps.

Gemini limits: We hit token request limits during the hackathon, so real-time comparisons were constrained. With more time/credits, we’d enable smoother live demos.

Data realism: Tuning synthetic datasets to feel authentic (prereq chains, GPA, D/F/W rates) took longer than expected.

Accomplishments we’re proud of

A production-feel demo with reproducible simulations and clear explanations.

Transparent risk metrics that frame policy in terms of both throughput and fairness.

A system design that could plug directly into advising workflows.

What we learned

Graphs beat tables for curriculum logic.

“Transparent by default” (show queries + rationale) builds trust fast.

Small fairness checks shift the convo from “Can we?” to “Should we, and for whom?”

What’s next

Visualizations: integrate bottleneck leaderboards, Sankey flows, and fairness heatmaps.

Report generation: auto-generate advisor-ready reports per course or student cohort.

Waitlist allocator: use optimization (knapsack/ILP) to maximize cleared students under a seat budget.

Auto-scheduler: OR-Tools to suggest valid schedules respecting conflicts and instructor load.

Real SIS integration: role-based access + audit logs to connect with live student systems.

How to run (quick start)

backend

cd api && uvicorn app:app --reload

neo4j

docker run -p7474:7474 -p7687:7687 -e NEO4J_AUTH=neo4j/test neo4j

frontend

cd web && npm i && npm run dev

Environment vars: NEO4J_URI, NEO4J_USER, NEO4J_PASS, LLM_PROVIDER (gemini or openai), API_BASE_URL.

Built With

• ai:
• d3-(sankey)
• docker
• fastapi
• framer-motion-backend:-python
• frontend:-react
• gemini/gpt
• pydantic-data/db:-neo4j-(cypher)
• python
• recharts
• tailwind-css
• typescript
• vite