# Study Saathi — A Local AI Study Companion Built for a Friend > Source: > Published: 2026-10-04 17:04:51+00:00 *This is a submission for the [Hacktoberfest Weekend Challenge: Build for a Friend](https://dev.to/challenges/hacktoberfest-weekend-2026-10-01)* A friend of mine is preparing for university exams. Like many students, they have to go through long PDFs and notes and often struggle with a simple question: **"Where do I even start?"** So I built **Study Saathi**, a simple local AI-powered study assistant that turns study notes into useful revision material. The workflow is simple: **Upload Notes → AI Summary → Practice MCQs → Flashcards** Study Saathi currently supports PDF and TXT study material and provides three main features: The AI is instructed to use the uploaded study material as the primary source and avoid introducing unrelated information. The main goal was not to build a huge AI platform, but to solve a real problem for a real student with a small, useful application. 🎥 **Watch the Study Saathi Demo:** [https://drive.google.com/file/d/1zy5ISFlc8K4PAys0SUK0gh9VlSftoCIa/view?usp=sharing](https://drive.google.com/file/d/1zy5ISFlc8K4PAys0SUK0gh9VlSftoCIa/view?usp=sharing) The demo shows the complete workflow: The AI inference runs locally on my machine instead of using a cloud AI API. GitHub Repository: [https://github.com/NipunGoel02/StudySaathi](https://github.com/NipunGoel02/StudySaathi) ``` StudySaathi/ │ ├── backend/ │ ├── main.py │ ├── ollama_service.py │ ├── pdf_parser.py │ └── requirements.txt │ ├── frontend/ │ └── React + Vite application │ ├── sample_notes/ │ ├── Computer_Networks_Notes.pdf │ └── Operating_Systems_Notes.txt │ ├── README.md └── start.bat ``` `main.py` Contains the FastAPI backend and API endpoints. `ollama_service.py` Handles communication with the local Ollama server and generates summaries, MCQs, and flashcards using the local AI model. `pdf_parser.py` Extracts text from uploaded PDF and TXT study material. | Component | Technology | |---|---| | Frontend | React + Vite + Tailwind CSS | | Backend | Python + FastAPI | | PDF Processing | PyMuPDF | | Local AI Runtime | Ollama | | AI Model | qwen3:1.7b | | Database | None | The application intentionally has a simple architecture. There is no RAG pipeline, vector database, authentication system, or cloud AI API in the current version. ``` ┌─────────────────────┐ │ Student │ └──────────┬──────────┘ │ ▼ ┌─────────────────────┐ │ React Frontend │ │ Vite + Tailwind │ └──────────┬──────────┘ │ ▼ ┌─────────────────────┐ │ FastAPI Backend │ │ Python │ └──────────┬──────────┘ │ ┌─────────┴─────────┐ │ │ ▼ ▼ ┌──────────────┐ ┌──────────────┐ │ PyMuPDF │ │ TXT Parser │ │ PDF Extract │ │ │ └──────┬───────┘ └──────┬───────┘ │ │ └─────────┬─────────┘ │ ▼ ┌─────────────────────┐ │ Ollama │ │ Local AI Runtime │ └──────────┬──────────┘ │ ▼ ┌─────────────────────┐ │ qwen3:1.7b │ │ Local AI Model │ └──────────┬──────────┘ │ ┌─────────────┼─────────────┐ ▼ ▼ ▼ Summary MCQs Flashcards ``` The most important part of Study Saathi is that the AI runs locally. I used **Ollama** as the local AI runtime and `qwen3:1.7b` as the model. The model is small enough to run efficiently on my NVIDIA RTX 3050 with 4 GB VRAM. During testing, Ollama reported the model running at 100% GPU on my system. The application communicates with Ollama locally through: ``` http://localhost:11434 ``` The default model is: ``` DEFAULT_MODEL = "qwen3:1.7b" ``` Study Saathi has separate generation logic for: For structured content such as MCQs and flashcards, the backend asks the model to return structured JSON so that the frontend can reliably display the generated content. For example, an MCQ is represented as: ``` { "q": "What is the role of the OS scheduler?", "a": "Manages process execution order", "b": "Handles file storage", "c": "Controls network packets", "d": "Manages GPU memory", "answer": "A" } ``` The backend also includes parsing and retry handling for generated content. The backend exposes the following endpoints: ``` GET /health POST /upload POST /summary POST /mcqs POST /flashcards ``` The basic flow is: ``` Upload Notes ↓ Extract Text ↓ Send Text + Prompt to Ollama ↓ qwen3:1.7b Generates Content ↓ Backend Parses Response ↓ React Displays Result ``` For this project, open innovation is important because it makes local AI practical for everyday users. Study material can be processed locally through Ollama instead of being sent to a third-party AI API. This is especially useful for students who may have personal notes, assignments, or other private documents. Study Saathi does not require an OpenAI, Gemini, or other cloud AI API key for its core AI functionality. The model runs directly on the user's machine. After downloading the model, local inference does not involve paying for every AI request. A relatively small open-weight model such as `qwen3:1.7b` can run locally on consumer hardware. In my setup, it runs fully on the NVIDIA RTX 3050 GPU. Using Ollama as the runtime makes it easier to experiment with different compatible local models without redesigning the entire application. This means the application is not tightly dependent on a single cloud AI provider. The goal of Study Saathi was to make a useful tool for a student, not to build another application that requires: ``` Account ↓ API Key ↓ Cloud Request ↓ Usage Limits ↓ API Cost ``` Instead, the workflow can be: ``` Install Ollama ↓ Download Local Model ↓ Run Study Saathi ↓ Upload Notes ↓ Study ``` That simplicity is what I wanted to demonstrate with this project. Building Study Saathi helped me understand that local AI does not always require a complicated architecture. For a focused use case, a small local model combined with a simple backend can already provide a useful AI experience. I also learned how to: There are several things I would like to add in future versions: These features are planned improvements and are not part of the current implementation. Study Saathi uses Ollama as the local AI runtime for running the model directly on the user's machine. The project uses an open-weight AI model together with open-source technologies to build a practical local AI application. Study Saathi started with a simple problem: **My friend had notes, but didn't know how to efficiently revise them.** Instead of building a complicated platform, I built a small local AI tool that turns those notes into: **Summary + MCQs + Flashcards** The project demonstrates how open-weight AI and local inference can be used to build useful applications for real people without requiring a cloud AI API. **Built for a friend. Built locally. Built with open AI technology.** 🎥 **Demo:** 💻 **GitHub:**