Nexus

An AI that builds your personalised learning roadmap — and rebuilds it when it gets something wrong.

Comment

Inspiration

Students and self-learners waste months following generic courses and playlists that weren't built for their level, their learning style, or their actual goals. They get stuck, lose motivation, or spend time relearning things they already know. Most AI learning tools either oversimplify — a flat list of topics — or overwhelm with too much content. We wanted to build something that reasons about how a specific person should learn a skill, not just what they should learn.

What it does

Nexus turns a vague skill goal into a structured, personalised execution plan — and rebuilds it the moment it gets something wrong.

  • Knows your level — an adaptive assessment adjusts question difficulty in real time. It doesn't ask what level you are; it figures it out from how you answer.
  • Knows how you learn — a short personality quiz captures learning style (visual vs text, structured vs exploratory) before the roadmap is built.
  • Admits when it's wrong — if the generated roadmap doesn't feel right, you correct it in plain English and watch it regenerate live, streamed token by token.
  • Teaches what you're missing — when you fail a level test, Nexus reads your wrong answers, identifies the exact concept gap, and generates a targeted mini-lesson for it instead of just saying "try again."
  • Makes progress feel real — points and badges tied to real learning milestones, with a clear path from Beginner → Intermediate → Advanced.

How we built it

The backend is a FastAPI service hosting a 9-node LangGraph StateGraph — one graph instance per user session, with a shared NexusState contract frozen between the two of us on Day 1 so backend and frontend could be built in parallel. A model_router.py config injects the right LLM into each node at runtime rather than hardcoding models: Gemini 3.5 Flash handles roadmap generation (structured output validated with Pydantic), while Llama 3.3 70B via NVIDIA NIM handles gap analysis, quiz generation, and automatic fallback. Roadmaps and assessment questions stream to the frontend over Server-Sent Events so the AI's output appears live rather than after a long wait.

The frontend is Next.js 14 (App Router), built component-first: we defined design tokens in Figma, built a small reusable component kit from them, then assembled full pages from those components so the app stays visually consistent. Supabase handles Postgres storage and Google OAuth. The backend deploys to Railway, the frontend to Vercel, with LangSmith tracing every LLM call for observability.

Challenges we ran into

  • Gemini's free-tier quota was far tighter than documented — live testing showed roughly 5 requests/minute and 20/day on a personal key, which two people testing simultaneously could exhaust in under 20 minutes. We fixed this architecturally: separate API keys per teammate, a dev-mode response cache so repeated test runs don't re-hit the API, and automatic fallback to NVIDIA NIM on a 429.
  • The assessment-to-roadmap transition was our highest-latency moment — generation could take 8–15 seconds, which is enough for a judge to mentally check out. We split the SSE stream into an immediate "thinking" event followed by token streaming, so something visibly changes within 2 seconds even before the first real token arrives.
  • Structured output occasionally broke mid-stream — Gemini would produce roadmap JSON that failed Pydantic validation partway through a stream. We separated the concerns: stream a narrative description for the live visual effect, and run the actual structured Pydantic generation as a separate, non-streamed call that saves to Supabase.
  • Keeping two independently-built halves in sync — with backend and frontend built in parallel, we froze the NexusState schema and API contracts on Day 1 and ran structured integration syncs on Day 3 and Day 5, walking the demo script one step at a time instead of testing the whole flow blind.

Accomplishments that we're proud of

  • A roadmap regeneration loop that lets users correct the AI in plain English and watch it rebuild live — our concrete answer to "how do you keep AI outputs honest and correctable" rather than just claiming responsible AI.
  • An adaptive sublevel system that diagnoses which specific concept a user got wrong from their test history and generates a targeted mini-lesson for it, instead of a generic retry.
  • A multi-model architecture where routing is a one-line config change, with automatic graceful degradation to a fallback model rather than a hard crash under rate limits.
  • Getting the full token-by-token roadmap streaming experience working end-to-end, which is the centrepiece of the demo.

What we learned

  • Model selection should live in a single routing config, never hardcoded inside a node — it made swapping models under rate-limit pressure trivial.
  • Free-tier LLM quotas need an architectural mitigation plan (caching, per-teammate keys, fallback routing) decided on up front, not discovered mid-build.
  • Human-in-the-loop has to be designed deliberately into the state machine (regeneration counters, explicit accept/reject decisions) — it doesn't happen by accident.
  • Component-first frontend work (tokens → component kit → pages) keeps a fast-moving build visually consistent in a way that designing full pages first never does.

What's next for Nexus

  • Assessment types beyond quizzes — portfolio review and small code challenges for technical skills.
  • A production-grade inactivity re-engagement pipeline (the hackathon version is a UI mockup of the email).
  • LangSmith-based evaluators to continuously score roadmap and gap-analysis quality, not just trace token counts.
  • A full GDPR-compliant email preference centre.
  • Expanding the leaderboard and social features, and adding more skill domains beyond the initial set.

Built With

Share this project:

Updates