CurriculumMind AI

Turn any syllabus into a personalized learning journey with AI-powered curriculum mapping, smart topic sequencing, curated resources, and personalized quizzes to track measurable progress.

Comment

💡 Inspiration

Every semester, I'd open my syllabus and then lose hours on YouTube.

Twenty tutorials for one topic. No idea which one matched my syllabus, what I needed to learn first, or whether I'd covered everything before the exam. I wasn't short of content. I was short of a path.

Millions of students face this every day. Learning platforms recommend content, but none of them understand the structure of what you're trying to learn.

So I built one that does.

🚀 What it does

CurriculumMind AI turns any syllabus, or a single sentence like "I want to learn machine learning", into a personalized, week-by-week learning path that adapts when you struggle.

Upload a syllabus (PDF, DOCX, PPTX or even a scanned photo) and in one flow you get:

  • 🧠 A concept map of your subject. Topics are broken into learnable concepts ("OOP" → Class, Object, Inheritance, Polymorphism), connected by what-you-need-first relationships in a knowledge graph.
  • 📅 A smart semester plan. Concepts are scheduled so you never meet a topic before its foundations, and no week exceeds the study hours you choose.
  • 🔗 The right resources, checked. Videos and articles are matched to every concept, duplicates and outdated material are filtered out, and each concept is labelled covered, weakly covered or uncovered.
  • 🔍 Gaps it hunts down. Missing concepts trigger targeted searches for up to 3 rounds. If nothing good exists, the concept is flagged for a teacher instead of being silently skipped.
  • 📝 Quizzes that rewire your path. Struggle with Binary Search? The system traces back through the graph, finds the weak foundation (say, Sorted Arrays), adds review material, re-tests you, and skips what you've already mastered.
  • ✅ A human in control. At three checkpoints (curriculum, concept map and semester plan), a teacher or learner reviews and approves the AI's work before anything moves forward.

Before vs. after

Without CurriculumMind AI With CurriculumMind AI
A syllabus with topic names A concept-level knowledge graph
Topics in document order Prerequisite-aware, week-by-week plan
20 random videos per topic Resources matched and checked per concept
"Did I miss anything?" Coverage status for every concept
Same path for everyone Path that adapts to your quiz results

🏆 What makes it different

Most AI learning tools are chatbots that answer questions. CurriculumMind AI is a system that understands a subject's structure, and it doesn't blindly trust its own AI:

AI proposes → validation checks → a human approves → only then does the next stage use it.

  • Graph validation catches AI mistakes. If the AI invents circular prerequisites (A needs B, B needs C, C needs A), the system detects it before building a schedule.
  • Coverage, not just recommendations. It answers "does this resource actually teach what I need?", not just "is this video related?":

$$ \text{Coverage} = \frac{\text{concepts covered by good resources}}{\text{concepts required}} \times 100\% $$

  • Remediation that targets the cause. Weak results trigger a backwards walk through the prerequisite graph, so learners fix the foundation, not just the symptom.

🛠️ How I built it

Layer Technology
LLM reasoning Groq API, with schema-validated JSON for every response
Knowledge graph Neo4j AuraDB, with vector indexes
Semantic matching sentence-transformers all-MiniLM-L6-v2 (384-d embeddings)
Graph algorithms NetworkX: cycle detection, DAG validation, topological sort
Application data MongoDB Atlas
Backend Python, FastAPI, Pydantic
Document intelligence pypdfium2, Docling + OCR for scans
Resource discovery YouTube Data API, DuckDuckGo
Frontend React, Vite, Tailwind, Cytoscape.js (interactive concept map), Recharts (dashboards)
Quality pytest (90 unit tests + integration + end-to-end), Puppeteer browser checks

The scheduling logic in one line. After validation guarantees the graph has no cycles, Kahn's topological sort orders the concepts, and each week $k$ is filled so that prerequisites come first and the workload stays within the learner's hours $H$:

$$ w(\text{prereq}) \le w(\text{concept}), \qquad \sum_{c \in \text{week } k} h(c) \le H $$

Two databases, each doing what it's best at: MongoDB for users, drafts and quiz history, and Neo4j for knowledge and relationships, because "what must I learn before this?" is a graph question.

🧗 Challenges I ran into

AI was confidently wrong. In an early test with a small local model, a six-unit Java syllabus produced 37 concepts but only 25 prerequisite links, a graph too sparse to trust. That moment changed the whole design: I stopped treating AI output as an answer and started treating it as a proposal. Graph validation and the three human checkpoints came directly from that failure.

"Related" isn't "useful." A video can match every keyword and still miss the learning objective. Switching from ranking resources to measuring concept coverage, with evidence for each match, was the hardest and most important shift.

An agent that never stops isn't smart. Unlimited searching for missing material just loops. Capping it at 3 rounds and escalating to a human made the system predictable and honest.

Real syllabi are messy. Tables, scanned pages, broken formatting. I built a two-path pipeline: fast extraction for text PDFs, OCR for scans, and a clear error message instead of a silently empty result.

Making it all one product. An LLM, two databases, graph algorithms, external APIs and a React UI all had to agree on the same data. Strict schemas, plus an automatic retry that feeds validation errors back to the model, kept bad output from ever reaching the knowledge graph.

🎉 Accomplishments I'm proud of

  • A fully working end-to-end product: upload → concept graph → semester plan → resources → quiz → adaptive path.
  • Trustworthy AI by design: validation plus three human checkpoints, not a black box.
  • Root-cause remediation that uses the knowledge graph to find why a learner is struggling.
  • Engineering discipline: 90 unit tests, integration tests against live services, full-pipeline end-to-end tests, and secure auth (bcrypt, session-bound JWTs, login throttling, per-user data isolation).

📚 What I learned

  • Great AI products are 10% model, 90% system: structure, validation and feedback loops.
  • Knowledge graphs are the right tool whenever the question is "what depends on what?"
  • Finding a resource ≠ verifying it teaches the concept.
  • Responsible AI is knowing when to automate, when to check, and when to ask a human.

🔭 What's next

  • Prove it with data: compare generated concept graphs against expert-built ones across many syllabi.
  • Learner pilots to measure whether adaptive remediation improves mastery.
  • Smarter learner modeling (knowledge tracing) and better resource-quality scoring.
  • Institution mode: full-semester, multi-course planning for colleges.

CurriculumMind AI exists so that no student has to spend more time searching for how to learn than actually learning.

Built With

Share this project:

Updates

Submission history