DEV Community: Ayush Kawadkar

Drop in a PDF, Get Flashcards

Ayush Kawadkar — Fri, 23 Oct 2026 10:32:07 +0000

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

What I Built

Before exams, I used to spend hours turning lecture PDFs into notes I could actually revise from. [Project name] does that for me. I drop a PDF or notes file into a folder, and a local model produces a short summary, topic-wise key points, flashcards, and likely exam questions. It runs entirely on my laptop.

It’s for any student who has a pile of syllabus PDFs and would rather not read all of them twice.

Demo

Code

!/usr/bin/env python3

"""
study_sloth.py - a lazy, fully local study-notes assistant.

Drop a PDF / .txt / .md of lecture notes into the notes/ folder.
A local open-weight model (served by Ollama) writes, into output/:
_summary.md topic-wise revision summary
_flashcards.md Q/A flashcards
_questions.md likely exam questions with model answers

Nothing leaves your machine. No API key. Works offline once the model is pulled.

Setup:
1. Install Ollama: https://ollama.com
2. ollama pull gemma3:4b (or any other model, see --model)
3. pip install ollama pypdf
4. python study_sloth.py (watches notes/ forever)
python study_sloth.py --once (process what is there, then exit)
"""

import argparse
import time
from pathlib import Path

import ollama
from pypdf import PdfReader

DEFAULT_MODEL = "gemma3:4b"
CHUNK_CHARS = 3500 # size of each piece sent to the model
MAX_SUMMARY_CHARS = 12000 # cap on the combined summary fed to later steps
SUPPORTED = {".pdf", ".txt", ".md"}

SUMMARY_PROMPT = """You are helping a university student revise for an exam.
Summarize the lecture notes below as concise bullet points.
Keep important definitions, formulas, algorithms and complexities.
Use ONLY the text given. Do not add outside facts.

NOTES:
{text}
"""

FLASHCARD_PROMPT = """From the revision summary below, create {n} flashcards.
Use exactly this format, one after another:

Q:
A:

Cover the most important concepts. Use ONLY the summary.

SUMMARY:
{summary}
"""

QUESTION_PROMPT = """From the revision summary below, write {n} questions that are
likely to appear in a university theory exam. For each question give a model
answer suitable for a {marks}-mark question (about {points} clear points).
Format:

Q1.

Use ONLY the summary.

SUMMARY:
{summary}
"""

def ask(prompt: str, model: str) -> str:
"""Send one prompt to the local model and return the text reply."""
response = ollama.chat(
model=model,
messages=[{"role": "user", "content": prompt}],
options={"temperature": 0.3},
)
return response["message"]["content"].strip()

def read_file(path: Path) -> str:
if path.suffix.lower() == ".pdf":
reader = PdfReader(str(path))
return "\n".join((page.extract_text() or "") for page in reader.pages)
return path.read_text(encoding="utf-8", errors="ignore")

def chunk_text(text: str, size: int = CHUNK_CHARS) -> list[str]:
"""Split text into chunks of roughly size characters, on line boundaries."""
chunks, current, length = [], [], 0
for line in text.splitlines():
line = line.strip()
if not line:
continue
if length + len(line) > size and current:
chunks.append("\n".join(current))
current, length = [], 0
current.append(line)
length += len(line) + 1
if current:
chunks.append("\n".join(current))
return chunks

def process_file(path: Path, out_dir: Path, model: str, marks: int) -> None:
start = time.time()
print(f"\n[+] Processing {path.name}")

text = read_file(path)
if len(text.strip()) < 50:
    print("    Could not extract text (scanned PDF?). Skipping.")
    return

chunks = chunk_text(text)
summaries = []
for i, chunk in enumerate(chunks, 1):
    print(f"    Summarizing part {i}/{len(chunks)}...")
    summaries.append(ask(SUMMARY_PROMPT.format(text=chunk), model))

combined = "\n\n".join(summaries)
if len(combined) > MAX_SUMMARY_CHARS:
    combined = combined[:MAX_SUMMARY_CHARS]

print("    Making flashcards...")
flashcards = ask(FLASHCARD_PROMPT.format(n=10, summary=combined), model)

print("    Making exam questions...")
questions = ask(
    QUESTION_PROMPT.format(n=5, marks=marks, points=marks, summary=combined),
    model,
)

out_dir.mkdir(parents=True, exist_ok=True)
stem = path.stem
(out_dir / f"{stem}_summary.md").write_text(
    f"# Summary: {stem}\n\n{combined}\n", encoding="utf-8"
)
(out_dir / f"{stem}_flashcards.md").write_text(
    f"# Flashcards: {stem}\n\n{flashcards}\n", encoding="utf-8"
)
(out_dir / f"{stem}_questions.md").write_text(
    f"# Likely exam questions: {stem}\n\n{questions}\n", encoding="utf-8"
)

print(f"    Done in {time.time() - start:.0f}s -> {out_dir}/")

def already_done(path: Path, out_dir: Path) -> bool:
return (out_dir / f"{path.stem}_summary.md").exists()

def scan(in_dir: Path, out_dir: Path, model: str, marks: int) -> None:
for path in sorted(in_dir.iterdir()):
if path.suffix.lower() in SUPPORTED and not already_done(path, out_dir):
try:
process_file(path, out_dir, model, marks)
except Exception as exc: # keep the watcher alive
print(f" Failed on {path.name}: {exc}")

def main() -> None:
parser = argparse.ArgumentParser(description="Local study-notes assistant")
parser.add_argument("--input", default="notes", help="folder to watch")
parser.add_argument("--output", default="output", help="folder for results")
parser.add_argument("--model", default=DEFAULT_MODEL, help="Ollama model name")
parser.add_argument("--marks", type=int, default=5, help="marks per exam answer")
parser.add_argument("--once", action="store_true", help="process once and exit")
args = parser.parse_args()

in_dir, out_dir = Path(args.input), Path(args.output)
in_dir.mkdir(parents=True, exist_ok=True)

print(f"Model: {args.model} | watching '{in_dir}/' | Ctrl+C to stop")
if args.once:
    scan(in_dir, out_dir, args.model, args.marks)
    return

while True:
    scan(in_dir, out_dir, args.model, args.marks)
    time.sleep(10)

if name == "main":
main()

How I Built It

Model: [e.g. Qwen / Llama, size and quantization] running through Ollama, so inference is local.
Pipeline: Python script that watches a folder, extracts text from PDFs with [library], splits it into chunks by heading, and sends each chunk to the model with prompts for summary, flashcards, and exam questions.
Output: Markdown files saved next to the original, e.g. Unit1_summary.md, Unit1_flashcards.md.
Hardware: [your laptop specs, and how long a typical PDF takes].

Why Does Open Innovation Matter?

Offline: It works in a hostel or on a train with no internet.
Private and free: My course material and notes never leave my machine, and there’s no API bill or rate limit during exam week.
Swappable: I can change models or edit the prompts to fit my needs. For example, I tuned the exam-question prompt to match [your university’s] 5-mark answer format, which a closed tool wouldn’t let me do.
[Add one honest comparison: where the local model was worse than a closed one, and how you worked around it.]

My Agent Session

The Lazy Payoff

Summarizing a unit by hand took me about [X hours]. Now it takes [Y minutes] of unattended processing while I do something else. I used it this week on [specific subject/unit], and [one concrete result, e.g. “it generated N flashcards I used to revise”].

Prize Categories

Best Use of Gemma: The whole project runs on [Gemma 3 4B] served locally through Ollama. Gemma reads each chunk of the lecture notes and generates the summaries, flashcards and exam-style questions. Because it runs on my own laptop, it works offline, my course material never leaves my machine, and I could tune the prompts to match my university's exam format.

Receipt Sorter: a freelancer's tax-season tool that never leaves the laptop

Ayush Kawadkar — Sun, 18 Oct 2026 11:20:26 +0000

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

What I Built

Receipt Sorter turns a messy folder of receipts and invoices into a clean CSV and a tidy, renamed folder structure. For each document it extracts the vendor, date, total, currency and a category (software, travel, meals, office, equipment, utilities, other). Files are copied into category folders and renamed like 2026-09-14_Notion_10.00.pdf. Anything it can't read confidently goes into a needs_review.txt list instead of being silently guessed.

Who would pay: freelancers, solo consultants and small studios who lose hours every tax season sorting receipts, and who often handle client documents they shouldn't upload to a random cloud service. A one-time license makes sense here because the tool has no running cost per document.

Demo

[PASTE YOUR VIDEO OR DEMO LINK HERE]

The demo runs with Wi-Fi turned off.

Code

import csv, shutil, sys
from pathlib import Path

import ollama
from pydantic import BaseModel
from pypdf import PdfReader

MODEL = "qwen2.5:3b"
CATEGORIES = "software, travel, meals, office, equipment, utilities, other"

class Receipt(BaseModel):
vendor: str
date: str # YYYY-MM-DD
amount: float
currency: str
category: str

def read_text(path: Path) -> str:
if path.suffix.lower() == ".pdf":
return "\n".join(p.extract_text() or "" for p in PdfReader(path).pages)
return path.read_text(errors="ignore")

def extract(text: str) -> Receipt:
prompt = (
"Extract the vendor, date (YYYY-MM-DD), total amount, currency code and "
f"category from this receipt. Category must be one of: {CATEGORIES}.\n\n"
+ text[:6000]
)
r = ollama.chat(
model=MODEL,
messages=[{"role": "user", "content": prompt}],
format=Receipt.model_json_schema(),
options={"temperature": 0},
)
return Receipt.model_validate_json(r.message.content)

def main(src: str, dst: str):
src, dst = Path(src), Path(dst)
dst.mkdir(exist_ok=True)
rows, failed = [], []
for f in sorted(src.iterdir()):
if f.suffix.lower() not in {".pdf", ".txt"}:
continue
rec = None
for _ in range(2): # one retry if the JSON is bad
try:
rec = extract(read_text(f))
break
except Exception:
pass
if rec is None:
failed.append(f.name)
continue
folder = dst / rec.category
folder.mkdir(exist_ok=True)
vendor = "".join(c for c in rec.vendor if c.isalnum())[:20]
new_name = f"{rec.date}{vendor}{rec.amount:.2f}{f.suffix}"
shutil.copy(f, folder / new_name)
rows.append({**rec.model_dump(), "file": new_name})

with open(dst / "receipts.csv", "w", newline="") as out:
    w = csv.DictWriter(
        out, fieldnames=["file", "vendor", "date", "amount", "currency", "category"]
    )
    w.writeheader()
    w.writerows(rows)
if failed:
    (dst / "needs_review.txt").write_text("\n".join(failed))
print(f"Sorted {len(rows)} files, {len(failed)} need review.")

if name == "main":
main(sys.argv[1], sys.argv[2])

How I Built It

Model: Qwen2.5 3B, an open-weight model, running locally through Ollama.
Extraction: text is pulled from each PDF with pypdf, then sent to the model with a strict JSON schema (Ollama's structured output) so the reply always has the fields I need.
Validation: the reply is parsed with Pydantic. If it fails, the tool retries once. If it fails again, the file is listed for manual review rather than guessed at.
Output: a CSV for the accountant plus category folders with consistent file names, all in about 70 lines of Python.
Not done yet: photographed receipts. That needs a vision model, which is the next thing I'd add.

Why Does Open Innovation Matter?

Privacy: receipts and invoices often contain client names, project details and bank information. With a local open-weight model, none of it leaves the machine, so there is nothing to disclose and no vendor to trust.
Works offline: the whole pipeline runs with no internet connection.
Cost: there is no per-document API fee. That is what makes a one-time-price product viable, because a closed API would turn every receipt into a recurring cost I'd have to pass on to the customer.
Control: the model is a one-line setting. I can swap in a bigger one for accuracy, or a smaller one for speed on older laptops, and categories are just a list in the prompt that a user can edit for their own bookkeeping.
No lock-in: if a provider changes pricing or retires a model, the tool keeps working exactly as it did.

Thanks for reading!