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

StudyBuddy: A Private AI Study Assistant Built for a Friend

What I Built

I built StudyBuddy, a simple AI-powered study assistant for a friend who spends a lot of time going through lengthy lecture notes and PDFs before exams.

Instead of repeatedly searching through hundreds of pages, they can upload their study material to StudyBuddy and interact with it like a personal study assistant.

The app can:

• 📚 Upload and process PDF notes
• 💬 Ask questions about the uploaded material
• 🧠 Explain difficult concepts in simpler language
• 📝 Generate multiple-choice quizzes from the notes
• ⚡ Create quick revision notes before an exam
• 🔎 Show the relevant information retrieved from the uploaded documents

The main idea was simple:

Turn the notes my friend already has into something they can actually talk to.

I wanted to build something small enough to finish in a weekend, but useful enough that my friend could actually use it.

Demo

🚀 Live Demo: https://studybuddy-hackoctober-mkt.streamlit.app/

The basic workflow is:

Upload PDF → Process Notes → Ask a Question → Retrieve Relevant Content → Generate Answer

Code

💻 GitHub Repository: https://github.com/mayank-aiml/HackOctober-Study-Buddy

The project is intentionally kept small and easy to understand.

StudyBuddy/
│
├── app.py
├── rag.py
├── pdf_processor.py
├── prompts.py
├── requirements.txt
├── README.md
└── .gitignore

The goal wasn't to create a huge AI framework. I wanted every part of the application to be understandable and replaceable.

How I Built It

The most important part of StudyBuddy is that the AI isn't simply a call to a closed AI API.

I built the application around open-weight AI and open-source tools.

Tech Stack

• 🐍 Python
• 🎈 Streamlit
• 🦙 Ollama/Grok
• 🤖 Open-weight LLM
• 🔗 LangChain
• 🧠 Hugging Face embeddings
• 🗄️ ChromaDB
• 📄 PDF processing
• 🔍 Retrieval-Augmented Generation (RAG)

The application follows a relatively simple RAG pipeline:

                 PDF Notes
                    │
                    ▼
             Extract Text
                    │
                    ▼
              Split into Chunks
                    │
                    ▼
            Generate Embeddings
                    │
                    ▼
               ChromaDB
                    │
          ┌─────────┴─────────┐
          │                   │
     User Question       Retrieved Chunks
          │                   │
          └─────────┬─────────┘
                    ▼
             Open-weight LLM
                    │
                    ▼
               AI Response

When my friend asks a question, StudyBuddy doesn't simply ask the model to answer from its general knowledge.

Instead, it:

1. Converts the question into an embedding.
2. Searches the local vector database.
3. Retrieves the most relevant sections from the uploaded notes.
4. Gives those sections to the open-weight model.
5. Generates an answer based on the retrieved information.

This makes the application much more useful for questions that are specific to the friend's own study material.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

I could have built the entire application around a closed AI API.

It would have been easier.

But using open-weight AI made the project more interesting and more useful for this particular problem.

🔒 Privacy

Study notes can contain personal information, assignments, internal college material, or other documents that someone may not want to upload to a third-party AI service.

With a local setup using Ollama and an open-weight model, the documents can stay on the user's machine.

Traditional API approach:

PDF → Cloud Service → AI Model → Response


StudyBuddy local approach:

PDF → Local RAG → Local Model → Response

🔄 Models Can Be Swapped

I'm not locked into one model.

If a better open-weight model becomes available, I can replace the model without redesigning the entire application.

The same application can experiment with different models based on:

• Speed
• Accuracy
• Hardware
• Model size
• Reasoning capability

Prize Categories

I'm entering the categories that best match the project:

• Open Innovation / Open Source AI
• Build for a Friend

If there are specific partner categories required by the challenge, I'll update this section accordingly.

What I Learned

The biggest takeaway from this project wasn't building another chatbot.

It was seeing how much can be built with relatively small open-source components.

A few building blocks:

PDF parsing + embeddings + vector search + an open-weight model + Streamlit

can become a genuinely useful personal application.

And because those pieces are open and replaceable, the project can continue evolving.

My friend doesn't need another generic AI chatbot.

They needed something that understands their notes.

So that's what I built.

---

Built for a friend.

Built with open AI.

Built to be modified. 🚀

Hacktoberfest #AI #OpenSource #RAG #LLM #Streamlit #Python #GenAI #BuildForAFriend