NSYA.AI — Turning a Friend's Syllabus Into an Interactive Learning Journey

I Built an AI Learning Companion for a Friend Who Was Tired of Studying From a Messy Syllabus

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

The Problem Started With a Friend

My friend didn't have a lack of study material.

They had too much of it.

A syllabus could contain subjects, units, chapters, topics, notes, PDFs, videos, assignments, and practice material — but none of that automatically answers the questions a learner actually has:

• What should I learn first?
• How are these topics connected?
• What do I need to understand before moving forward?
• Which parts of the syllabus have I actually completed?
• What should I revise next?
• Can I understand this topic without jumping between five different resources?

I realized that the problem wasn't really access to information.

It was turning information into a learning path.

So I decided to build something for my friend.

What I Built

I built NSYA.AI, an AI-powered learning companion that turns a curriculum into a structured and interactive learning experience.

The core idea is:

Messy Curriculum
       ↓
   AI Processing
       ↓
Subjects & Units
       ↓
Topics & Relationships
       ↓
Learning Content
       ↓
Practice & Progress

Instead of treating a syllabus as a static document, NSYA.AI treats it as a learning system.

A learner can move from a subject into its units, explore individual topics, access structured explanations and notes, and follow the learning flow without constantly trying to figure out what comes next.

The current prototype demonstrates this workflow through a visual learning interface where curriculum information is transformed into structured subjects and learning content.

Why I Didn't Just Build Another Chatbot

This was probably the biggest design decision I made.

A chatbot can answer:

"Explain recursion."

But a learning companion should also understand:

"Where does recursion belong in my learning journey?"

Those are very different problems.

So instead of building:

User → Prompt → AI → Answer

I designed the system around:

User
 ↓
Curriculum
 ↓
Structured Knowledge
 ↓
Relationships
 ↓
Context
 ↓
AI
 ↓
Learning Activity
 ↓
Progress
 ↓
Next Step

The AI is therefore one component of the learning system — not the entire product.

The Experience

The learner starts with their curriculum.

NSYA.AI processes it and organizes the information into a structured hierarchy.

For example:

Course
│
├── Subject 1
│   ├── Unit 1
│   │   ├── Topic A
│   │   └── Topic B
│   │
│   └── Unit 2
│       ├── Topic C
│       └── Topic D
│
├── Subject 2
│   └── ...
│
└── Subject 3
    └── ...

From there, the learner can navigate through the curriculum instead of treating the syllabus like a giant checklist.

The prototype focuses on making that structure visible and usable.

Demo

🎥 Video Demo

The demo shows the current prototype and its learning workflow, including:

• Curriculum processing
• Subject extraction
• Structured learning navigation
• Topic exploration
• Learning content
• Notes and study material
• The overall learner workflow

Demo link: https://youtu.be/4SliXBGrUcY

Code

The complete project is available here:

GitHub: Durgesh-Kumar-Dewangan/Minor_project_2026

I wanted the project to remain visible and inspectable rather than hiding the implementation behind a polished demo.

How I Built It

The architecture is built around several layers rather than putting everything inside one AI prompt.

1. Curriculum Processing

The first step is understanding the learning material and extracting meaningful academic structure from it.

2. Knowledge Structure

The extracted information is organized into relationships between subjects, units, and topics.

This is important because learning is not purely linear.

Some topics depend on other concepts, some belong to the same subject area, and some concepts become easier once the learner has understood their prerequisites.

3. AI Layer

The AI layer is used to transform structured information into learner-facing content and assist with the learning workflow.

Open-source/open-weight model used: 'Mistral 7B Instruct`

I deliberately want this layer to remain replaceable.

The application should not be architecturally locked to one model provider.

4. Learning Interface

The frontend turns the underlying structure into an experience that feels closer to a personal learning workspace than a document viewer.

The objective is to reduce the cognitive overhead of:

"Where do I go next?"

and replace it with:

"This is where I am, this is what I'm learning, and this is what comes next."

Why Open Innovation Matters

This is where open AI became particularly interesting to me.

Education involves personal information.

A learner's curriculum, questions, mistakes, learning history, and progress can become valuable personal data.

An open model gives developers significantly more control over where and how that intelligence runs.

Depending on the model and deployment architecture, the same learning system can potentially support:

• Local inference
• Private deployments
• Model swapping
• Domain-specific fine-tuning
• Different hardware targets