DEV Community: BANNE AKHIL

StudyMate AI: A Local-First AI Study Assistant Built with Open-Weight Models

BANNE AKHIL — Mon, 19 Oct 2026 11:42:19 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Studying often means switching between lengthy PDFs, lecture notes, textbooks, and multiple online tools. I wanted to explore a simpler approach: what if students could ask questions directly about their own study materials?

That's the idea behind StudyMate AI, an AI-powered study assistant designed for college students. The goal is to help students understand difficult concepts, summarize notes, generate practice quizzes, and revise more efficiently.

The project is designed around local AI inference, allowing students to work with their materials without depending on a paid, proprietary AI API for every interaction.

The potential users are students preparing for examinations and learners working through technical subjects. In the future, I want to explore whether students would pay for customized study workflows, convenient setup, or features that save them meaningful time.

Demo

Live demo: [Add your deployed demo URL, or remove this line if unavailable]

Screenshots/video: [Add a link to a genuine demo video or screenshots]

Code

GitHub repository: [Add your public GitHub repository URL]

How I Built It

The planned architecture combines a React and TypeScript frontend with a Python FastAPI backend and SQLite for application data.

For the AI layer, StudyMate AI uses Ollama to run a compatible open-weight language model locally. Document processing extracts text from study materials, splits it into manageable chunks, and uses local embeddings and vector retrieval to find relevant passages before generating an answer.

The intended workflow is:

Upload a study document.

Extract and divide its text into chunks.

Retrieve relevant passages for a student's question.

Pass those passages to the local language model.

Return an answer with source references where available.

This retrieval-based approach aims to keep responses grounded in the student's material instead of relying entirely on the model's general knowledge.

The exact features, model, dependencies, and architecture should match the implementation available in the linked repository.

Why Does Open Innovation Matter?

For a student-focused product, cost and privacy are important design considerations.

Building around open-weight models gives developers more control over model selection, local inference, and how the application is deployed. Running inference locally can reduce dependence on external API pricing and help keep documents on the student's own machine when the complete workflow is configured to remain local.

It also creates room to experiment. Different models can be evaluated for response quality, speed, memory requirements, and suitability for educational tasks.

There are trade-offs, too. Local inference requires compatible hardware, models vary in quality, and open-weight licenses differ. Open innovation does not automatically make every model or dependency fully open source.

For me, the value is the ability to experiment, understand the complete AI pipeline, and build around users' needs instead of relying entirely on a closed service.

SketchBiz AI: Turn Every Sketch Into a Sale

BANNE AKHIL — Sat, 17 Oct 2026 15:14:37 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built SketchBiz AI, a simple AI-powered business assistant for artists, sketch creators, and independent sellers who want to turn their artwork into products they can sell online.

Many talented artists struggle with writing product descriptions, choosing relevant keywords, and calculating prices that cover their costs while making a profit. SketchBiz AI aims to make these tasks easier with two core features:

AI Artwork Listing Generator: Generates product titles, descriptions, relevant tags, and promotional captions from basic artwork details.

Smart Artwork Pricing Calculator: Calculates production costs, a suggested selling price, and estimated profit based on materials, working hours, and the desired profit margin.

The goal is to help artists spend less time on repetitive business tasks and more time creating art.

Demo

Live Demo: https://share.gemini.google/pO2zGDQLieKF

Code

💻 GitHub Repository: [Add your GitHub repository URL]

SketchBiz AI was built with the help of Google Gemini AI. It focuses on two practical tools for independent artists and small creative businesses:

AI Artwork Listing Generator — helps create product titles, descriptions, tags, and promotional captions for artwork.

Smart Artwork Pricing Calculator — helps artists estimate production costs, suggested selling prices, and potential profit.

How I Built It

I built SketchBiz AI with a focus on simplicity, usability, and open-source AI.

Planned technology stack:

Frontend: React, Vite, and Tailwind CSS

Backend: Python and FastAPI

AI: An open-weight language model served locally through Ollama

Storage: Browser localStorage for saved listings

The listing generator uses an open-weight model to transform basic artwork information into product content. The pricing calculator uses deterministic formulas to calculate costs and suggested prices rather than relying on AI for arithmetic.

This separation keeps pricing calculations predictable while allowing the language model to handle creative writing.

Why Does Open Innovation Matter?

I wanted to explore how open-source AI could help someone build a small business tool without depending entirely on a paid proprietary AI API.

Using an open-weight model can provide several advantages:

Greater control: The model can potentially be changed or replaced as requirements evolve.

Privacy: Local inference can help keep artwork descriptions and business information on the user's device.

Cost control: Local inference can avoid per-request API fees, although it still requires suitable hardware and electricity.

Flexibility: Developers can experiment with different models and adapt the application to specific creative workflows.

For a small side hustle, keeping recurring costs manageable matters. Open-source AI offers a way to experiment with practical tools while maintaining greater control over the technology.
``

TouchGrass AI : Less Scrolling, More Exploring — Open-Source AI for Outdoor Adventures

BANNE AKHIL — Sun, 11 Oct 2026 15:43:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TouchGrass AI — Less scrolling. More exploring.

TouchGrass AI is a nature-inspired web application designed to help people take a break from their screens and explore the world around them.

Users can choose an activity, such as nature walking, birdwatching, gardening, or nature discovery, and receive personalized outdoor missions generated using open-source AI.

The goal is simple: spend less time looking at a screen and more time experiencing the real world.

Key features:

Personalized outdoor mission generation.

Simple, achievable activities for different time limits.

A nature journal to record observations and completed missions.

A clean, responsive interface designed around nature and well-being.

Demo

Screenshots: Add screenshots of the homepage, mission generator, and nature journal

Code

How I Built It

I built TouchGrass AI with React and Vite for the frontend and Python with FastAPI for the backend. The application is designed to use an open-weight language model through Ollama for local AI inference.

The model generates outdoor missions based on the user's selected activity, available time, and interests. The nature journal stores entries locally in the browser.

My focus was to keep the application lightweight, easy to use, and centered on a real-world activity rather than prolonged screen engagement.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI models that users can run and control on their own devices.

With a suitable local model, TouchGrass AI can generate activities without depending on a paid proprietary AI API. The model can also be replaced or customized as the project evolves.

This approach offers opportunities for greater user control, experimentation, and privacy. Local inference can also work without an internet connection once the model and required dependencies are installed.

My Agent Session

Prize Categories

StudyMate-AI: I Built an AI Study Partner for My Friend

BANNE AKHIL — Sun, 04 Oct 2026 10:29:53 +0000

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

What I Built

StudyMate-AI 📚🤖

Turn a folder full of notes into a personal study partner.

I built StudyMate-AI for a friend who often had plenty of study material but struggled with one simple problem: knowing what to study, where to find it, and how to revise it effectively.

Notes were spread across PDFs, documents, and lecture material. Searching through everything before an exam was slow and frustrating.

So I wanted to build something more useful than a generic chatbot.

StudyMate-AI turns study material into an interactive study partner.

The idea is simple: instead of asking an AI generic questions, give it your study material and use it as a companion for understanding and revision.

The project is designed around workflows such as:

📄 Working with study notes and documents
🔎 Asking questions about the material
🧠 Getting explanations in simpler language
📝 Generating practice questions
🎯 Creating quizzes for revision
📚 Summarizing study material
🔄 Revising interactively instead of repeatedly searching through PDFs

The goal wasn't to build another chatbot.

The goal was to make studying from existing notes feel less like searching through files and more like talking to a study partner.

Demo

The current StudyMate-AI prototype was developed and tested in the Claude environment.

Because the prototype link is a temporary blob: URL tied to the browser session, it isn't suitable as a public demo link for judges.

Prototype: [](blob:https://claude.ai/fe18c684-73e0-49d1-ba8a-fc4c88591ac1)

The basic workflow is:

Upload Notes
     ↓
Process Study Material
     ↓
Find Relevant Information
     ↓
Ask a Question
     ↓
AI Generates a Response
     ↓
Personalized Study Experience

A typical session looks like:

Friend:

"I don't understand this topic. Explain it simply."

StudyMate-AI:

Uses the available study material to help explain the topic in a more understandable way.

Then the friend can continue:

"Give me 5 questions from this topic."

"Make them exam-level."

"Quiz me one question at a time."

"Explain the answer I got wrong."

That is the experience I wanted to create.

Code

The project is being developed as an AI-powered study application, with the goal of keeping the architecture modular and easy to extend.

The source repository will contain the implementation, setup instructions, and project documentation.

How I Built It

The central idea behind StudyMate-AI is to make the AI useful because of the user's own study material, rather than simply acting as a general-purpose chatbot.

The planned architecture is:

                ┌──────────────────┐
                │   Study Material │
                │  PDFs / Documents│
                └────────┬─────────┘
                         ↓
                ┌──────────────────┐
                │ Document Parsing │
                └────────┬─────────┘
                         ↓
                ┌──────────────────┐
                │ Content Processing│
                └────────┬─────────┘
                         ↓
                ┌──────────────────┐
                │ Relevant Context │
                │    Retrieval     │
                └────────┬─────────┘
                         ↓
                ┌──────────────────┐
                │     AI Model     │
                └────────┬─────────┘
                         ↓
                ┌──────────────────┐
                │   StudyMate-AI   │
                │    Response      │
                └──────────────────┘

The application is designed with a modular AI layer so that different models and inference approaches can be experimented with as the project develops.

This is important because the project isn't intended to be permanently tied to one particular AI provider.

Why Does Open Innovation Matter?

This is one of the main reasons I chose an open approach.

A student's notes can contain personal information, assignments, unfinished work, or material they simply don't want to upload to an external service.

An open AI approach gives developers more control over how the system is built and where the data is processed.

🔐 More control

The architecture can be adapted for local processing and inference instead of requiring every piece of study material to be sent to a closed third-party service.

🔄 Models can be replaced

The AI layer can be experimented with and changed as better open models become available.

Different models can be evaluated based on:

Hardware requirements
Speed
Accuracy
Context length
Language support
Reasoning capabilities

🛠️ More control over the system

Instead of treating AI as a black box, developers can experiment with the retrieval process, prompts, model configuration, and application logic.

💰 Lower barriers to experimentation

Open models make it easier for students and developers to experiment with AI without building the entire project around a paid closed API.

🌱 Open innovation makes the project adaptable

For me, the biggest advantage isn't simply that the model is free.

It's that the AI becomes something I can experiment with and change.

That's important for StudyMate-AI because the ideal study partner for one person may be completely different from the ideal study partner for another.

Open innovation gives me control over the AI instead of making the AI the thing controlling the project.

Building for a Friend ❤️

The challenge wasn't just:

"What AI application can I build?"

It was:

"What can I build that would actually help someone I know?"

That changed the project.

I didn't start by designing a complicated AI system.

I started with a simple problem:

Too many notes. Too little time. Too much searching.

From there, StudyMate-AI became a small attempt to remove some of that friction.

The best part is seeing the project from the perspective of the person it was built for rather than just looking at it as another technical demo.

Because that's the kind of feedback that matters more to me than simply having another AI project.

What I Learned

Building StudyMate-AI taught me that an AI project doesn't need to be huge to be meaningful.

A useful workflow can be surprisingly simple:

Real Problem
     ↓
Real Person
     ↓
Useful Workflow
     ↓
Open AI
     ↓
Working Product

I also learned that the quality of the context is extremely important when building applications around personal documents.

A powerful AI model isn't enough if the application cannot provide it with the right information.

The real challenge is making the complete pipeline work together:

documents → relevant context → AI → useful answer

What's Next?

StudyMate-AI is still evolving.

Some features I'd like to explore next:

🎙️ Voice-based study sessions
📊 Personal progress tracking
🧩 Adaptive quizzes based on mistakes
🗂️ Better organization of large note collections
🌐 Support for more languages
💻 Better low-resource/local inference
📱 A more mobile-friendly experience
👥 Shared study spaces
🧠 Personalized revision plans

Eventually, I'd like StudyMate-AI to move from simply answering questions about notes to becoming a complete personal revision companion.

My Agent Session

I also used an agent-assisted development workflow while building StudyMate-AI.

The session documents the development process, including experimentation, implementation, debugging, and iteration.

DevRelay Agent Session: To be added after the session is saved and publicly shareable.

Final Thoughts

I started with a very ordinary problem:

Someone I know had a folder full of notes and didn't want to spend hours searching through them.

That became StudyMate-AI.

It's not trying to replace teachers, textbooks, or studying.

It's trying to make the material a little easier to understand and a little easier to use.

And that's why I liked the Build for a Friend theme.

Because sometimes the best project idea isn't something that sounds revolutionary.

Sometimes it's just something that makes one person's day a little easier.

StudyMate-AI
Turn a folder full of notes into a personal study partner. 📚🤖

Project Links

StudyMate-AI Prototype: blob:https://claude.ai/fe18c684-73e0-49d1-ba8a-fc4c88591ac1
GitHub: Source repository to be added
Demo Video: To be added
DevRelay Session: To be added

devchallenge #weekendchallenge #hf26challenge