This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
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.
"""
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](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:
Use ONLY the 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()
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].
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.]
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”].
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.