Astra

Project Title
Astra: Learn, Explore, Visualize.

Tagline
The only 3D galaxy that uses real data to model your mastery, propagate updates through prerequisites, and adapt your learning path live as you learn.

Inspiration
Every UTD student knows the pain: CourseBook is static, grades feel unpredictable, scheduling conflicts hide, and no tool shows how mastering one concept actually affects the next. NotebookLM style PDF chatbots and generic recommenders don't help with real campus decisions. I wanted to build something alive that learns with you, uses UTD's own data, and visualizes your progress in an immersive 3D universe. Astra turns your degree plan into a living galaxy where mastery ripples like gravity.

What it does
Astra is a 3D interactive learning companion built specifically for UTD students and professionals.

Pulls real courses, grade distributions, DFW rates, and scheduling from the Nebula API
Extracts key concepts from course descriptions (or uploaded syllabus PDFs) using Gemini
Builds a nested 3D knowledge graph: Level 1 galactic degree plan (courses) → Level 2 planetary concept maps (concepts orbiting parent course)
Predicts personalized mastery probability using Bayesian Beta Binomial (cold start from Nebula averages, updates with quiz performance + slip/guess weighting)
Propagates mastery recursively across real prerequisites (hard edges only) causing visible ripple updates glows and recommendations live
Generates adaptive quizzes, diagrams, and mini-games with tone anchored to your current mastery (supportive when struggling, challenging when advanced)
Lets you select professors → plans shift in their inferred style + voice readout
Projects GPA impact and highlights risky courses (DFW + low mastery)

Answer a quiz → mastery updates → graph ripples → recommendations and projected GPA change instantly. It's not static Q&A — it's a living model of your learning in UTD's real ecosystem.

Professional view

Easy to understand flowchart with time constraints
Nvidia Nemotron powered AI-analysis and chatbot help

How we built it

Frontend: React + Tailwind + React Three Fiber + r3f-forcegraph (nested zoom, containment orbiting, memoized positions for stable nav)
Backend: FastAPI + MongoDB Atlas (curriculum graph, vector index for semantic edges)
AI/ML:
- Gemini Flash: concept extraction, quiz/diagram/game generation, tone-anchored explanations
- NVIDIA llama-nemotron-embed-1b-v2 (NIM API): semantic similarity for soft edges
- Scikit-learn: Bayesian Beta-Binomial mastery updates + propagation
Data: Nebula API (courses, grades, sections) + cached RMP JSON for professor styles
Polish: Ripple animations (GSAP/Three.js)

Challenges we ran into

ForceGraph3D stability: Level 2 zoom caused exploding layouts (solved with Group nesting + centripetal force + memoized positions)
Making Bayesian updates feel magical instead of abstract (added visible ripple + toast text)
Balancing real-time ripple without stutter (batched updates, frameloop="demand")
Nebula API limitations (no full syllabi → upload syllabus PDF)

Accomplishments that we're proud of

Built a closed-loop adaptive system: quiz → Bayesian update → graph ripple → recommendation change — in ~24 hours
Deep Nebula integration: real grades/DFW/scheduling drive mastery priors and risk warnings
Nested 3D containment + stable navigation (no exploding graphs)
Dual-glow visualization (UTD prior vs. personalized posterior) + live ripple animation

What we learned

Real data integration (Nebula grades/sections) makes everything feel credible vs. mock data
Bayesian propagation + visual ripple is far more compelling than static predictions
Safe dynamic Three.js (templates + validation + cleanup) is essential for hackathon demos

What's next for Astra