All eight, the way I'd walk a reviewer through them
This is the actual breakdown I use in interviews. What each module takes in, what it does with an LLM, and what it hands back to the student.
Kia: Contextual Course Chatbot
A persistent chatbot that answers course specific questions, grounded in this course's own lectures rather than generic knowledge. Ask what Gini impurity is and Kia doesn't just define it. It retrieves and cites the exact lecture numbers where the concept is taught, so the answer is something you can act on, not just something that sounds right.
Naive RAG returns plausible but ungrounded answers when retrieval quality is poor. I tuned chunk size and retrieval depth against a set of test queries specifically to keep citations accurate rather than invented, and persisted chat history per session so context survives page navigation.
AI Video Summarizer
Lecture videos run long, and re-watching one to find a single explanation is a bad use of revision time. This module takes a lecture's transcript and condenses it into a short, structured summary a student can read in under a minute, without losing the specific technical detail that would actually show up in an exam.
The failure mode with long transcript summarisation is losing specific detail to generic paraphrase. I chunked longer transcripts before summarising each part, then merged the results, so a forty minute lecture doesn't collapse into three vague sentences.
AI Week Summarizer
One step up from a single lecture: generate a full week's summary across every lecture in that week, unified into one document. Week 7's Naive Bayes derivation, for instance, rendered with proper mathematical notation, straight from the raw lecture content rather than a manually written recap.
A plain "summarise this" prompt gives inconsistent structure every time. I designed the template to force a consistent shape, theorem and derivation blocks rather than a loose paragraph, so the output is reliably exam usable.
AI Topic Notes Generator
Search any course topic, for example Convolutional Neural Networks, and get structured notes back: comparison tables, code snippets, and key formulas, not a wall of prose. This is the module I reach for myself before an exam, so I was strict about the output being something worth reading twice.
AI Topic Questions Generator
On demand practice questions for any topic, including questions that embed runnable code a student has to trace through by hand, not just recall based options. Type "Backpropagation" and get five questions ranging from conceptual, like the purpose of backpropagation, to applied, like tracing a NumPy weight update line by line.
AI Mock Quiz Generator
Full mock tests built for the actual assessment structure of the course, Quiz 1, Quiz 2, and the End Term, not generic multiple choice. Questions embed real, runnable code, so a student is graded on reading and tracing code, which is closer to what the real exam asks of them.
AI Topic Recommendations
This is the module I'm most particular about, because it's where the system stops being a content generator and starts being a tutor. After a student finishes a mock quiz, Kia doesn't just return a score. It generates a topic by topic diagnostic: exactly which concepts to revisit, and why, based on which questions were missed.
A scoring engine that just says "5 out of 50" isn't useful to anyone. The harder problem was prompting the model to turn a raw answer sheet into specific, actionable study guidance, flagging something like "review StandardScaler's transformation formula" rather than "study data preprocessing," which meant carefully mapping question content to named library and concept references.
AI Error Explainer
An in browser code editor lets students submit programming assignment solutions. When a submission fails its test cases, Explain Error sends the student's actual code plus the failure output to the LLM, which diagnoses the root cause in plain language and suggests the specific fix, rather than just echoing the stack trace.
# Student's submitted, broken code def sum_of_array(arr): return sum(arr) arr = list(map(str, input().strip().split())) # bug: str, not int result = sum_of_array(arr)
What Kia returned: the program crashed because it tried to add up strings instead of numbers. sum() needs integers, but the input was read as a list of strings through map(str, ...). The fix is to change it to map(int, ...). A root cause explanation and a one line fix, not a raw traceback.
