DueWise：以開放權重 AI 將課程大綱轉化為學習計劃

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Meet DueWise — an AI-powered academic planning assistant that helps students spend less time organizing their work and more time actually getting it done.

Students receive syllabuses, assignment briefs, examination notices, and course materials throughout the semester. Manually reading these documents, extracting deadlines, creating tasks, planning revision sessions, and deciding what to study next can become a project of its own.

DueWise is designed to eliminate that repetitive work.

Upload an academic document once, and DueWise helps turn it into an actionable academic workflow.

Here is what it does:

• Document to tasks: Upload PDF, DOCX, or TXT files and extract their contents automatically.
• AI-powered analysis: Generate summaries, identify academic requirements, and suggest assignments, deadlines, and actionable tasks.
• Review before saving: Edit and confirm AI-generated suggestions instead of blindly trusting them.
• Weekly study planning: Organize tasks around deadlines, available study time, and estimated effort.
• Revision checklists and flashcards: Turn course material into concise revision prompts for active recall.
• The “What Should I Do Now?” feature: Recommend one practical next action instead of leaving students overwhelmed by a long to-do list.

The goal is simple: reduce the friction between receiving academic work and knowing what to do next.

Demo

Live demo / video: [Add your deployed application or demo video link here.]

The project can also be run locally using the setup instructions in the repository README.

Code

GitHub repository: https://github.com/aniket937/DueWise

The repository contains the frontend, backend, setup scripts, documentation, and tests.

How I Built It

DueWise uses a full-stack architecture combining a modern web interface, a local database, document-processing tools, and an open-weight AI model accessed through OpenRouter.

Technology stack:

• Frontend: Next.js 16, React, TypeScript, and Tailwind CSS v4.
• Backend: Python and FastAPI.
• Database: SQLite with SQLAlchemy and aiosqlite.
• Document processing: PyMuPDF for PDFs and python-docx for Word documents.
• AI integration: OpenRouter with a configurable open-weight language model.
• Testing: pytest, Ruff, TypeScript checks, and the Next.js production build.

The AI analysis pipeline extracts text from uploaded documents and sends the relevant text to the configured OpenRouter model. The model proposes structured academic information, which the backend validates before presenting it to the user.

I also wanted the core application to remain useful without an AI API key. Document extraction, task management, database persistence, and deterministic task prioritization can work in Demo Mode without live model inference.

The system keeps extracted task suggestions separate from confirmed tasks, so users retain control over their academic schedules.

Why Does Open Innovation Matter?

For this project, open innovation is about flexibility, transparency, and avoiding unnecessary dependence on a single proprietary model.

DueWise uses an open-weight model through OpenRouter rather than hardwiring the application to a single closed-model provider. The model identifier is configurable, which makes experimenting with alternative open-weight models easier without redesigning the entire application.

This matters because different models can offer different trade-offs in reasoning quality, structured output, latency, and cost. Keeping the model integration separate from the application logic makes those trade-offs easier to evaluate.

Open innovation also influenced how the application handles everyday work:

• Local document processing: PDF and DOCX text extraction happens in the backend before the AI request.
• Local data storage: Academic tasks and application data are stored in SQLite rather than requiring a hosted database.
• User control: AI-generated tasks require review and confirmation.
• A useful fallback: Core task management and deterministic prioritization do not depend on a live AI request.
• Model flexibility: The runtime model can be changed through configuration when another suitable open-weight model is available.

There is an important trade-off: DueWise uses hosted inference through OpenRouter. When users request AI analysis, relevant extracted document text is sent to the configured provider. Live AI analysis therefore requires an internet connection, and this implementation does not claim fully offline AI processing.

For me, openness is not just about choosing a model. It is also about building an application whose components can be inspected, adapted, and replaced without having to rewrite the whole product.

The Lazy Payoff

The best part of DueWise is the reduction in repeated decisions.

Instead of manually copying deadlines from a syllabus, creating separate tasks, and figuring out how to distribute everything across the week, the student starts with one upload and reviews the proposed plan.

The “What Should I Do Now?” feature tackles another common problem: having so many tasks that choosing the first one becomes difficult.

DueWise recommends a manageable next step based on deadlines, priority, remaining effort, and progress. The underlying prioritization also works without an AI request.

I have not established a measured before-and-after time-saving benchmark yet, so I will not claim a specific number of minutes saved. The intended payoff is fewer manual steps, less administrative effort, and a clearer path from a pile of academic documents to the next task.

Prize Categories

This submission focuses on the overall Hacktoberfest Open-Source AI Challenge.

I have not selected a partner prize category because the current implementation does not establish that it qualifies for a specific partner category.