DEV Community: Sameer

प्रश्न पत्र

Sameer — Sat, 17 Oct 2026 15:19:02 +0000

It's 11:47 PM in Patna. Classes ended hours ago, and a coaching teacher is typing tomorrow's practice test:

Q1. Which Article abolishes untouchability?

Then they type it again, because half the batch studies in Hindi:

प्र.1 कौन-सा अनुच्छेद अस्पृश्यता का अंत करता है?

Twenty-five questions, twice, every week. Paid question banks don't match their own notes, and cloud AI tools charge per use, need good internet, and send the institute's notes to someone else's server.

So for "Side Hustle", I built the tool a small coaching centre would actually pay for.

What I Built

Prashn Patra (प्रश्न पत्र, "question paper") turns a chapter into a ready-to-print practice test:

In: a chapter PDF, photos of book pages, or the teacher's own notes
Out: a student paper and an answer key, in Hindi, English or bilingual (both on one sheet, same answer letters)
Question types: MCQ, true/false, fill in the blank, short answer, at easy, medium or hard difficulty, 5 to 50 questions

The part I care about most: every answer has to cite the chapter. Each question carries the exact sentence it came from, the code checks that sentence really is in the chapter, and the answer key prints it beside the answer. A wrong answer key costs a teacher their credibility in front of students, so accuracy beats quantity.

It runs Gemma 3 (4B) locally through Ollama, on the institute's own laptop. No API bill, no internet after setup, and the notes never leave the room.

Who it's for: coaching institute owners with 1–5 teachers and 50–500 students, and home tutors teaching several classes. In Patna that mostly means school boards (Bihar Board), BPSC, SSC and Railway exam prep.

Demo

The flow is four steps:

Add the chapter (PDF, photos or pasted notes).
Pick the number of questions, types, difficulty and language, then press Generate test · टेस्ट बनाएं.
Review every question, with its ✅ answer and 📖 source line. Edit, delete or regenerate any of them.
Tick "I have reviewed all questions" and download two PDFs: the student paper and the answer key.

Export stays locked until step 4. The app never prints a question the teacher hasn't seen.

Code

ThePlator / Coaching_Test_Generator-

Turn a chapter into a printable practice test in Hindi, English or both — with an answer key that cites the source line. Runs offline with Gemma via Ollama.

Coaching Test Generator · प्रश्न पत्र

Turn a chapter into a ready-to-print practice test in Hindi, English or both, with an answer key that shows where each answer comes from. It runs fully offline on your own laptop.

Built for small coaching institutes and home tutors preparing students for school boards, BPSC, SSC and Railway exams. Upload a chapter PDF, photos of book pages, or your own notes. Pick how many questions you want. A few minutes later you have a student paper and an answer key to print.

🏁 Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 2 — "Side Hustle". Uses Gemma running locally through Ollama.

Why

Writing 25 good questions for one chapter takes hours. Translating them for Hindi-medium students doubles the work.
Paid question banks are generic and don't match your notes.
Cloud AI tools charge per use, need good internet, and send your notes…

View on GitHub

Setup is one script (scripts/setup.sh on Linux/macOS, scripts/setup.ps1 on Windows), or by hand:

ollama pull gemma3:4b
pip install -r requirements.txt
streamlit run app.py

How I Built It

Part	Choice	Why
Model	Gemma 3 4B via Ollama	Open weights, runs on a laptop CPU, reads photos too
App	Python + Streamlit	Upload, review and edit on one page
Reading	`pypdf` for text PDFs, Gemma vision for photos and scanned pages	Many coaching notes are phone photos
Output checks	Pydantic + rapidfuzz	Catch broken JSON and made-up answers in code
PDF	Jinja2 + WeasyPrint, embedded Noto Sans Devanagari	Hindi has to print correctly

There are already tools that turn notes into quizzes, like PageLM, and cloud question-paper generators built on Gemini and Document AI. What I wanted was narrower: one printed paper, in exam Hindi and English, where a teacher can verify every answer in seconds, on hardware they already own.

1. One small chunk at a time

The chapter is split into topic-sized chunks of about 1,500 characters, at headings and paragraph breaks. Gemma only ever sees one chunk and is told to use only facts from it. A small model hallucinates far less with a narrow context, and it gives every question exactly one piece of text to be checked against.

Gemma answers in JSON. Ollama's structured outputs take a JSON schema, so the model can't skip the Hindi block in bilingual mode or forget the source_quote. Hindi and English come from one call, so they share one answer_index by construction. Both versions always have the same correct letter, and the Hindi is written as exam Hindi, not translated word by word afterwards.

2. The check that matters: is the quote really in the chapter?

# ctg/textutil.py
def quote_score(quote: str, chunk: str) -> int:
    """0-100 score for how well `quote` appears in `chunk` (100 = exact substring)."""
    q, c = norm(quote), norm(chunk)
    if not q:
        return 0
    if q in c:
        return 100
    return round(fuzz.partial_ratio(q, c))

norm() does the Hindi-specific work. It applies Unicode NFC, strips zero-width joiners, maps । to ., and drops punctuation while keeping matras and the virama, so a quote with slightly different punctuation still matches. Below 90, the question fails as quote_not_found.

The same validator also checks for:

exactly 4 distinct options, with the answer among them
no "all of the above" (or उपरोक्त सभी / इनमें से कोई नहीं)
Hindi that's actually in Devanagari
matching option counts in Hindi and English
a real ____ in fill-in-the-blank questions

3. Retry once, then drop, and tell the teacher

# ctg/pipeline.py (trimmed)
k = math.ceil(c.quota * settings.overgen_factor)          # ask for ~30% extra
cands, lost = generate_for_chunk(llm, c, expand_plan(plan, k, cfg.qtypes), cfg, ...)
good, failures = _screen(cands, c, cfg, settings, existing, report)

missing = c.quota - len(good)
if missing > 0:                                           # retry ONCE for this chunk
    cands2, lost2 = generate_for_chunk(..., feedback=failures[:FEEDBACK_LIMIT], ...)
    good2, _ = _screen(cands2, c, cfg, settings, existing + good, report)
    good += good2
return good[:c.quota]

The retry prompt tells Gemma exactly what failed ("source not found in chapter", "repeated options"). Anything still failing is dropped, and the review screen says so honestly, for example: "Kept 9 of 10 — dropped: 1 source not found in chapter".

4. A dedupe bug I'm glad I caught early

My first duplicate filter used rapidfuzz's token_set_ratio. It scored these two stems at 88, over my threshold:

"Which Articles deal with the Right to **Equality?"
"Which Articles deal with the Right to **Freedom?"

Set-based matching mostly ignores the one word that makes them different questions, and on an exam paper that word is the whole point. token_sort_ratio at 90 still catches real repeats and reordered wording, but keeps these apart.

5. Hindi that actually prints

Devanagari isn't just characters. Conjuncts like क्ष, त्र, श्र and matras need OpenType shaping, and drawing text without it can print broken Hindi. That's a disaster on a paper students will read. Rendering HTML through WeasyPrint gets shaping from HarfBuzz (via Pango), with Noto Sans Devanagari embedded in the PDF. On Windows, where WeasyPrint's GTK libraries are hard to install, the same HTML prints through Chromium instead.

Who Would Pay

These are the prices I'm testing:

Plan	Who	Price
Free	Try it	3 tests / month
Tutor	Home tutors	₹199 / month
Institute	Coaching centres	₹999 / month, unlimited, set up on their laptop
One-time setup	Institutes without tech help	₹1,500 install + training

The software itself is MIT-licensed. People pay for setup, support and not having to do it themselves, which is how a lot of small-town software actually gets bought. These prices only work because running cost is close to zero: the model runs on a laptop the institute already owns.

My First User

[FILL — after the session, from docs/first-user.md. Suggested shape:

Who: a coaching teacher or tutor in Patna (name only with permission), the subject and exam they teach.
They uploaded their own chapter and made a 10-question bilingual test in [time]. Normally that takes them [their answer].
Of 10 questions: kept [k], edited [e], marked [w] wrong, and why.
Their verdict on the Hindi.
"Would you pay ₹199 a month? ₹999 for the institute?" Their exact words.
What they asked for next.
Photo of the printed paper (no student names).]

Why Does Open Innovation Matter?

For this business, open weights aren't a nice extra. They're what makes the price possible.

Near-zero running cost. A cloud API bills every question, every week, for every teacher. On the institute's own laptop, the hundredth test costs the same as the first: nothing. That's the difference between ₹199 a month being a business and being a loss.
The notes stay theirs. A teacher's notes are their competitive edge in a crowded coaching market. Here they never leave the laptop, and you can check that: turn off the Wi-Fi and it still works.
Built for bad internet. Power cuts and patchy mobile data are normal. Once set up, this needs neither.
Tunable for exam styles. Open weights mean the model can later be fine-tuned on BPSC/SSC-style questions written by teachers themselves, a niche a general-purpose API handles poorly.
No lock-in. The model is one setting (CTG_MODEL). If a better open model comes out, or a smaller one runs faster on an old laptop, the institute switches without asking anyone.

Honest Limits

Speed depends on the laptop. On a CPU-only machine, writing 10 bilingual questions takes [FILL — measured time]. Start with 10–15 questions.
A 4B model still makes mistakes. That's why review is required and the key shows the source line. The checks catch made-up quotes, but not every awkward distractor.
Text subjects only, for now. GK, history, polity, science theory, English and Hindi work. Maths with diagrams or long derivations doesn't.
Photos are slower and less reliable than text PDFs or pasted notes.
Tested with a stand-in model. The automated tests use a fake model so they run without Ollama. The real-model numbers above come from the first-user session.

Prize Categories

Best Use of Gemma. Gemma 3 4B writes every question in Hindi and English and reads photos of book pages and scanned PDFs, fully offline, on one laptop.

हर अध्याय के साथ, देर रात की मेहनत थोड़ी कम हो। (With every chapter, a little less late-night work.) 📝

— Sameer

Chhath Ghat Guide: an offline AI helper for the day the network dies at the ghat

Sameer — Sat, 10 Oct 2026 11:35:25 +0000

The ghat, the crowd and the dead network

Every year during Chhath Puja, lakhs of families walk down to the ghats of Bihar to offer arghya to the setting and the rising sun. Vratis stand waist-deep in the river, children hold their parents' hands, elders watch the water, and the songs carry across the steps.

And every year the same three things happen:

Families get separated in the crowd.
Notices about deep water, barricades and timings are hard to read in the press of people — and many elders are more at home in Bhojpuri or Maithili than in printed Hindi.
The mobile network jams. Calls don't connect, messages don't send, and every app that needs the internet stops working — exactly when it's needed.

So I built a small helper for that moment. Chhath Ghat Guide runs on one laptop at the ghat. The laptop's Wi-Fi hotspot has no internet at all; family phones join it and open the app in a browser. The AI model, the notes and every photo stay at the ghat.

The screen is meant to be a few seconds of help, not the experience. The experience is the river, the sun and the family.

What it does

Three tabs, one job each. (Screens are from the real app on a phone-sized browser; see the note under each image about what's test data.)

📜 सूचना पढ़ें — Notice Reader

Take a photo of a notice or banner. A local Gemma 3 (4B) vision model:

copies the text exactly as written, and
explains it in simple Hindi, Bhojpuri or Maithili — using only the text it just read.

The original words are always on screen. Safety notices (deep water, barricades, emergency) show the original text first, inside a red box — never only a summary. A blurry photo gets "साफ़ नहीं पढ़ पाए" ("couldn't read it clearly") and tips for a better photo, instead of a guess. And if the explanation contains a number that isn't in the notice — an invented ghat number or time — the app warns you.

Real app screens; the notices are printed samples, and the read text and explanations shown are test data copied from the notices (screens with Gemma's own output will replace these after the field test).

🪔 पूजा सहायक — Ritual Helper

Ask "सूप में क्या रखते हैं?" (what goes in the soop?) or "खरना में क्या बनता है?". Answers come only from ten short notes written by the family and checked by an elder — not from the model's memory. Each answer:

shows which note it came from and who checked it,
ends with a reminder that customs differ between families and regions, and
falls back to "यह मेरे नोट्स में नहीं है — किसी बड़े से पूछें" ("not in my notes — ask an elder") when the notes don't cover it.

Questions about clock times, this year's dates or parking never reach the model at all — they're sent to official notices and the panchang. An AI should not be the one telling a vrati what time to stand in the river.

Real app screens; the answer text is test data copied from the note it cites. The notes are marked "डेमो — समीक्षा बाकी" (demo — review pending) because the elder review comes before the real demo.

📍 मिलने की जगह — Meeting Spot

"Save our spot" stores the GPS position, a photo of a landmark and a note ("नीला टेंट, घाट 5 की सीढ़ियों के पास" — blue tent by the ghat 5 steps) on the phone only. "Take me back" shows the distance and an arrow that turns with the phone's compass.

GPS comes from satellites, not the mobile network, so this keeps working when calls don't — and because it runs entirely in the phone's browser, it keeps working even if the phone wanders out of the laptop's Wi-Fi. When you're within GPS error of the spot, the arrow would just be noise, so it switches to "आप बहुत पास हैं — फोटो वाली निशानी देखें" (you're very close — look for the landmark in the photo). The spot deletes itself at midnight.

Real app screens with emulated GPS and compass (the landmark is a drawing).

An emergency card sits on every screen and sends people to the nearest police or volunteer booth. The app ships with no phone numbers — organisers add verified ones on the day; a made-up number at a crowded river is worse than none.

How it works offline

Part	Choice	Why
Model	Gemma 3 4B via Ollama, for both reading photos and writing answers	Open weights, runs on a laptop CPU, no internet
App	Python + Streamlit, three tabs	Fast to build; camera and file inputs built in
Ritual answers	10 Markdown notes, keyword + `nomic-embed-text` search	Answers traceable to checked text
Meeting Spot	Plain HTML + JS, Geolocation + DeviceOrientation APIs	Runs on the phone; location never leaves it
Phones	Self-signed HTTPS on the hotspot	Phone browsers only allow GPS, camera and compass on secure pages

The code that keeps the AI honest

The interesting part of this project wasn't getting Gemma to talk — it was making sure it doesn't say more than it knows, in a place where a wrong answer can matter.

1. Read first, then explain only what was read

The Notice Reader makes two calls on purpose. The first copies the text (temperature 0, unreadable words marked [?]); the second explains only that text, so every claim on screen can be checked against the original right below it.

# ghat_guide/notice_reader.py (trimmed)
def transcribe(self, image: bytes) -> Transcription:
    out = self.llm.chat_json(
        model=self.models.vision_model,
        system=prompts.SYS_TRANSCRIBE,      # "copy exactly; write [?] for unreadable words"
        user=prompts.USER_TRANSCRIBE,
        schema=prompts.TRANSCRIBE_SCHEMA,   # {text_read, script, clarity}
        temperature=0.0,
        images=[image],
    )
    clarity = clarity_verdict(out["text_read"], out["clarity"], ...)  # model's opinion + our own rules
    return Transcription(out["text_read"], ..., clarity, is_safety_notice(out["text_read"]), ...)

def explain(self, tr: Transcription, lang: str) -> Explanation | None:
    if tr.clarity == "unclear":
        return None                          # nothing reliable to explain: show "साफ़ नहीं पढ़ पाए"
    out = self.llm.chat_json(model=self.models.text_model, system=prompts.sys_explain(lang),
                             user=prompts.user_explain(tr.text_read), ...)
    return Explanation(..., number_warning=unsupported_numbers(out["explanation"], tr.text_read))

Splitting the steps had a nice side effect: switching language re-runs only the cheap text step, not the slow image step.

The safety check is plain keyword matching, chosen carefully — "डूब" (drown) alone would also match "डूबते सूर्य", the setting sun that Sandhya Arghya is offered to, so the list uses "डूबने" instead:

# ghat_guide/safety.py (excerpt)
#   "डूब" alone would match "डूबते सूर्य" (the setting sun of Sandhya Arghya),
#   "मना" alone would match "मनाया" (celebrated).
SAFETY_TERMS_DEVANAGARI = ("गहरा", "गहराई", "डूबने", "खतरा", "बैरिकेड", "निषेध", "मना है", ...)

2. Ritual answers have to earn their way out

# ghat_guide/ritual/answerer.py (trimmed)
def ask(self, question: str, lang: str) -> RitualAnswer:
    if asks_for_official_info(question):       # "बजे", "तारीख", "इस साल", "पार्किंग", ...
        return RitualAnswer("official_info", None)   # never asks the model

    relevant = [h for h in self.retriever.search(question) if self.retriever.is_relevant(h)]
    if not relevant:
        return RitualAnswer("not_in_notes", None)

    out = self.llm.chat_json(..., user=prompts.user_ritual(context, question),
                             schema=prompts.RITUAL_SCHEMA)  # {found, answer, used_chunk_ids}
    given = {h.chunk.chunk_id for h in relevant}
    cited = out.get("used_chunk_ids") or []
    if not out.get("found") or not cited or any(c not in given for c in cited):
        return RitualAnswer("not_in_notes", None)   # no sources, or sources it wasn't given
    return RitualAnswer("answered", out["answer"], sources=[...])

Search is a mix of keywords and embeddings, because nomic-embed-text is mostly trained on English and Devanagari questions alone can rank poorly. Hand-written keywords plus a small synonym map (अरघ → अर्घ्य, सूपा → सूप) and a light stemmer (खरने ↔ खरना) catch the words families actually use. And a note without an elder's checked_by is never loaded at all.

3. The arrow is just two lines of trigonometry

The Meeting Spot runs in the phone's browser, so it's plain JavaScript:

// static/meeting_spot.html (excerpt, simplified)
function bearing(lat1, lon1, lat2, lon2) {          // degrees clockwise from north
  var p1 = lat1 * rad, p2 = lat2 * rad, dl = (lon2 - lon1) * rad;
  var x = Math.sin(dl) * Math.cos(p2);
  var y = Math.cos(p1) * Math.sin(p2) - Math.sin(p1) * Math.cos(p2) * Math.cos(dl);
  return (Math.atan2(x, y) / rad + 360) % 360;
}
// heading comes from the compass (iOS: webkitCompassHeading, Android: 360 - alpha),
// smoothed with a circular mean so 350° and 10° average to 0°, not 180°.
arrow.style.transform = "rotate(" + mod360(bearing(here, spot) - heading) + "deg)";

The same maths lives in Python (ghat_guide/geo.py), and a test runs both side by side in a real browser so they can't drift apart.

4. A pre-trip check, because you can't download anything at the ghat

A real run of scripts/check_offline.py — the warnings are true: the notes are still waiting for the elder review.

It checks that the models are downloaded, the ritual index is built, the phone pages load nothing from the internet, the HTTPS certificate matches the hotspot's IP (a classic "it worked at home" failure), and that the model server isn't reachable from the phones.

Touching grass

[FILL — after the field test. Suggested shape:

Where: the ghat or riverbank, the date, who came along.
The moment you switched mobile data off and the app kept working.
Numbers from docs/FIELD_TEST.md: seconds per notice, whether the arrow pointed the right way, GPS accuracy near the water.
What the elder said about the Ritual Helper (with permission), and what they corrected in the notes.
What didn't work — honestly.]

The real test is still ahead: Chhath Puja is in late October / early November, and I'll take it to the ghat then and report back here.

Demo

Why open innovation matters here

It works with no network. A cloud AI is useless when the network is jammed; an open-weight model on a laptop isn't.
Data stays at the ghat. Photos, questions and family locations never leave the laptop and phones.
It's free. No API keys, no subscription — a laptop the family already has.
Local languages. Bhojpuri and Maithili rarely get first-class support; open models and open notes let the community improve that.
Anyone can swap or tune the model — one line in config/settings.toml — or rewrite the notes for their own family's customs.

Limits (honest list)

Bhojpuri and Maithili are beta. The model may slip into Hindi; Hindi is the default.
Speed: on a laptop CPU, reading a photo can take tens of seconds, and phones take turns.
GPS near water and crowds is often off by 5–20 m — so the landmark photo and note are always on screen.
Not a lost-person tracker, and not an authority. Official announcements, police, volunteers and elders come first.
Not field-tested yet with real Gemma output — the automated tests use a stand-in model and emulated GPS/compass; the outdoor test is next.

Prize category

Best Use of Gemma — Gemma 3 4B reads the notices and writes the explanations and answers, fully offline, on one laptop.

Try it / contribute

Code (MIT): https://github.com/ThePlator/Chhath_Ghat_Guide- — setup, the design docs (HLD/LLD), and the field-test sheet are in the repo. Checked ritual notes, Bhojpuri/Maithili corrections and sample notice photos (without identifiable people) are especially welcome.

छठी मइया सबके मनोकामना पूरा करस। 🌅

— Sameer

Dawa Samjho — I built my parents an offline app that explains their medicines in Hindi

Sameer — Sun, 04 Oct 2026 17:26:49 +0000

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

My parents take several medicines every day. Every strip is printed in tiny English text, and every prescription is in a doctor's handwriting. So I often get the same question, usually with a strip held up close to the light:

"यह गोली किसलिए है?" — "What is this tablet for?"

It's a simple question, and they shouldn't have to wait for me to come home to get an answer. Asking the chemist the same thing again feels awkward, and uploading prescriptions to some random app on the internet doesn't feel right either.

So for "Build for a Friend", I built for the two people I'd most like to help.

What I Built

Dawa Samjho (दवा समझो, "understand your medicine") reads a photo of a medicine strip or prescription and explains every medicine in simple Hindi (or English):

💊 what it's for, in everyday words
🕗 when to take it, only as the doctor wrote it
⚠️ general precautions, like "tell the doctor if you feel dizzy"

Three things mattered more to me than features:

It runs entirely on our laptop. The AI is Gemma, an open-weight model running locally through Ollama. Prescriptions never leave the house, and it works with the Wi-Fi turned off.
It never guesses a dose. If it can't read something, it says "साफ़ नहीं पढ़ पाए — डॉक्टर या केमिस्ट से पूछें" ("Couldn't read this clearly — ask your doctor or pharmacist") instead of making something up.
It's built for them, not for me. Large text, big buttons, every label in Hindi with English beside it, and a one-click copy button to share the result in the family WhatsApp group.

It only explains what's already written. It never gives medical advice, and every result ends with the same line:

यह सिर्फ समझने के लिए है। हमेशा अपने डॉक्टर की सलाह मानें।
This is for understanding only. Always follow your doctor's advice.

Demo

The flow is four steps: choose हिंदी, upload or take a photo, press समझाओ · Explain, and read one card per medicine.

I tested it on the strips from our own medicine box, then handed the laptop to my parents. They liked it, and what I liked most was watching them do it themselves, without calling me over.

Code

ThePlator / Dawa_Samjho

दवा समझो · Dawa Samjho

Understand your medicine. Take a photo of a prescription or medicine strip and get each medicine explained in simple Hindi or English. Everything runs on your own laptop, so your health data stays on your machine.

Built for the DEV Hacktoberfest Weekend Challenge: Build for a Friend. The "friend" is a parent who takes several medicines a day and can't always read the doctor's handwriting or the English brand names.

⚠️ Status: the core app works (P0). Accuracy on handwritten prescriptions is still being tested, so always check names against the paper.

What it does

Open the app in your browser (it runs locally).
Pick a language: हिंदी (default) or English.
Upload a photo of a prescription or medicine strip, or take one with your camera.
Press समझाओ · Explain.
Read one card per medicine
- Name, exactly as printed
- Purpose…

View on GitHub

Once Ollama is installed, setup is three commands:

ollama pull gemma3:4b
pip install -r requirements.txt
streamlit run app.py

How I Built It

The stack is deliberately small:

Gemma 3 (4B), the smallest Gemma that can read images, served by Ollama
Streamlit for the UI, in pure Python
Pillow for image handling
Pydantic to validate the model's output

It all runs on an ordinary laptop with about 7 GB of RAM, integrated graphics and no GPU.

One photo, one pipeline. When you press Explain, the app:

checks the photo, fixes its rotation and shrinks it to 1024 px,
makes sure Ollama is running and the model is installed,
sends the image to Gemma with a strict prompt that asks for JSON only,
validates that JSON against a schema, retrying once if it's malformed,
runs the answer through safety rules written in code,
shows one card per medicine.

The biggest lesson: don't trust a model to be honest about itself

My first real test was a sample of doctor's handwriting that said "Cap Risek 20mg". Gemma read it as "Cap Risele", marked it as perfectly readable, and then added that it should be taken "once" (एक बार). Nothing on the paper said that.

That changed the project. A prompt that says "never guess" isn't enough for health information, so I moved the safety rules into code, where I can test them:

No invented numbers. If a strength or dose in the answer doesn't appear in the text the model says it read from the image, the medicine is marked "couldn't read clearly". Hindi digits like १ are normalised first, so they're compared fairly.
No invented timings. If the text on the paper contains no timing at all (no 1-0-1, no OD/BD, no "after food"), any timing the model adds is removed, and the card says "Not written — ask your doctor".
No made-up advice. If the model doesn't recognise a medicine, the app shows no purpose and no precautions, rather than generic filler.
Always checkable. "What the app read" is one click away, so you can compare it with the paper, and every result reminds you to match the name against the strip.

All of this is covered by 32 unit tests, including the exact "Risele / once" case that started it.

Honest limits

Handwriting is hard. On cropped samples of doctors' handwriting, Gemma 4B often gets close but wrong, which is exactly why the code-level checks exist. Printed strips are much easier.
It's not instant. It takes about 65–90 seconds per photo on my laptop's CPU, and the first photo is slowest while the model loads. That's slow for a demo, but still faster than waiting for me to get home.

Why Does Open Innovation Matter?

For this app, open isn't a nice extra. It's the only way it could exist.

Privacy you can check. Prescriptions are some of the most personal documents a family has. With an open-weight model running locally, "your data stays at home" isn't a promise you have to trust: turn off the Wi-Fi and watch it still work.
Free to run, forever. There's no API key, no subscription and no cost per photo. That matters for retired parents, and for every family that could use something like this.
It speaks our language. Big apps are built for English first. Because the model and the code are open, I could tune the prompt for simple, spoken Hindi, and anyone can adapt it for Bhojpuri, Bengali, Tamil or Marathi without asking anyone's permission.
Safety anyone can inspect. Every rule that stops the app from inventing a dose is in a file anyone can read, test and improve. For health information, being able to check a system matters as much as how clever it is.

My parents don't know what an open-weight model is. They just know that when they hold up a strip and ask "यह गोली किसलिए है?", something in the house now answers them in their own language, and honestly.