DEV Community: Preksha barjatya

SlothWeaver: a local summarizer that naps when your laptop does (and picks up where it left off) 🦥

Preksha barjatya — Thu, 22 Oct 2026 09:33:05 +0000

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

What I Built

SlothWeaver is a desktop app for the most sloth-like workflow I know: pick a file, walk away, come back to a summary.

You choose a .txt or .md file. A local Gemma 2 (9B) model running in Ollama reads it and writes a short summary plus three tags to <file>.summary.md. Nothing leaves your machine.

It is deliberately slow and steady:

It doesn't care if your laptop falls asleep. In durable mode, each summary runs as a Temporal workflow. If Ollama is down, the model crashes, or the lid closes mid-run, Temporal retries with backoff (5s, 10s, 20s… capped at 5 minutes) and resumes. You never re-click anything.
It never destroys your work. If a summary file already exists, the old one is backed up to .backup, then .backup.1, .backup.2… and the new one is written atomically. A crash mid-write can't leave a half-written file.
It's lazy about failure too. If the model rambles instead of returning JSON, that's caught and reported (to Sentry, if you set SENTRY_DSN) instead of saving garbage.

Demo

Here's a real run against the project's own README, using gemma2:9b locally:

{
  "status": "completed",
  "summary": "SlothWeaver is a tool for generating durable document summaries using local AI models. It leverages Ollama for processing, Temporal for persistence, and Tauri for a desktop application...",
  "tags": ["AI", "Summarization", "Local Development"]
}

Code

👉 https://github.com/Prekshabarjatya/slothweaver

How I Built It

Four small layers, each built test-first:

Layer	What it does	Key test
`summarizer.py`	Calls Ollama with `format: json`, strips markdown fences, validates there's a `summary`	Garbage, fenced, and keyless model output all raise `LLMError`
`file_ops.py`	Backup-then-atomic-write	A second save never clobbers the first backup
`workflows.py`	Temporal workflow + heartbeating activity	A flaky activity fails twice, then succeeds, on Temporal's time-skipping test server
Tauri (`src-tauri/`)	Rust command that shells out to the Python CLI	—

The retry test was my favourite. Temporal's WorkflowEnvironment.start_time_skipping() fast-forwards the backoff timers, so a test that would "wait" 15 seconds for retries runs in about one:

@activity.defn(name="process_file_activity")
async def flaky(file_path: str) -> dict:
    attempts.append(1)
    if len(attempts) < 3:
        raise RuntimeError("laptop went to sleep")
    return {"status": "completed", "file": file_path}

One gotcha worth sharing: my first version was an async activity that called a blocking requests.post to Ollama. That stalls the worker's event loop for the whole generation. The fix was to make the activity a plain def and give the worker a small ThreadPoolExecutor. It's two threads, because the GPU is the bottleneck, not the CPU.

The LLM is mocked in unit tests so they run in about a second. A separate pytest -m integration hits real Ollama, and it passes in about 38s on my machine. CI runs the unit tests on every push.

I built this pairing with Claude Code (Claude Opus 5.5).

Why open innovation matters here

Private by default. Notes, journals and work docs are exactly the files you don't want to upload. An open-weight model on localhost means they never leave the laptop.
Free to be slow. There's no per-token bill, so retrying five times after a sleep costs nothing. That makes durable retries a sensible default rather than a luxury.
Swappable. The model is one env var (SLOTH_MODEL). When a better open model ships, I change one line.
Open plumbing. Temporal, Tauri, and Ollama are all open source, so every layer is inspectable and replaceable.

Prize Categories

Best Use of Gemma: Gemma 2 9B is the only model in the loop, running locally through Ollama.
Best Use of Temporal: durable workflow with heartbeats, an exponential-backoff retry policy, and time-skipping tests that prove the retries work.

What I'd do next

Watch a folder and summarize new files overnight. That's the ultimate sloth mode.
Bundle Python as a Tauri sidecar so it ships as a single .app.

Sentinel: Test Your AI Visibility Fixes Before You Ship Them

Preksha barjatya — Sun, 18 Oct 2026 12:44:14 +0000

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

What I Built

Sentinel is a weekly "AI visibility" audit for small brands. Shoppers in India now ask an AI assistant "best baby wipes for sensitive skin" instead of scrolling Google. If the assistant never names your brand, you lose that sale and never find out.

Sentinel asks open-weight models the questions a brand's buyers ask, measures how often the brand is named versus its competitors (share of voice), checks whether AI crawlers can read the site, audits the page for SEO and answer-engine readiness, and writes a prioritized fix list.

New this week: a digital twin. It takes the client's real homepage, builds a copy with the recommended fixes applied, and puts each version into the real Google results for the same question (via SerpApi). Then it asks the model the same questions against both and compares. The client sees what the fixes are likely to change before touching their website.

Who pays: small D2C brands and the freelance SEO consultants who serve them. A one-time audit plus fix list, then a monthly re-check. The paid AI-visibility tools in this space cost hundreds of dollars a month, priced for enterprises, not a small Indian hygiene brand.

Demo

First real brand: an Indian D2C hygiene brand (I'll call it Brand X) selling baby wipes, face wipes, tissues, hand wash and home cleaning products.

Baseline (8 buyer questions, 16 AI answers, open model with no page given):

Share of voice: 0%. Brand X was never named.
AI crawlers (OAI-SearchBot, ClaudeBot, PerplexityBot, ...): all allowed, so the gap is content, not access.
31 fixes found, for example: no FAQ section or FAQPage schema, no question-style headings, a 114-character title, 34 of 103 images without alt text.

Digital twin (homepage inserted at rank 3 in real Google results):

Buyer question	Original page	Fixed page
best natural baby wipes in India	100%	100%
best baby wipes for sensitive skin in India	100%	100%
best refreshing face wipes in India	50%	100%
best toilet paper and tissue brands in India	50%	100%
best kitchen tissue roll brand India	100%	100%
best liquid hand wash brand in India	50%	100%
eco-friendly bamboo hygiene products India	100%	100%
best floor cleaner brand in India	0%	50%
All 8 questions	68.8%	93.8%

Answers that named a competitor but not Brand X fell from 25.0% to 6.2%. The fixed page wins on exactly the questions where the original had no direct answer: face wipes, toilet paper, hand wash and floor cleaner.

Read this as a direction, not a forecast. The page is placed inside the results, so even the original scores far above the 0% baseline; the gap between the two columns is what matters. It's 2 samples per question on one open model (16 answers per side, 0 failed).

Code

Prekshabarjatya / sentinel-ai-visibility

Open-model AI visibility audit for small brands, with a digital twin that tests fixes before you ship them

Sentinel AI: Phase 1 engine

Weekly AI-citation tracker per BRD v1.1. Python 3.10+, only dependency: requests.

Run

pip install requests
python tests/test_engine.py                                   # 8 tests, no keys needed
python -m sentinel.run clients/acme.json --mock               # full cycle with fake engines
export OPENAI_API_KEY=... ANTHROPIC_API_KEY=... GEMINI_API_KEY=... PERPLEXITY_API_KEY=...
python -m sentinel.run clients/acme.json --samples 3          # real engines

Output per client in data/<domain>/: latest_report.md, history.json, audit.jsonl, review_queue.json.

Optimization (needs internet; add `--optimize`)

python -m sentinel.run clients/acme.json --samples 3 --optimize

Adds to the report and writes data/<domain>/fixes.json:

Crawler access (crawlers.py): reads robots.txt; flags blocked OAI-SearchBot, ClaudeBot, PerplexityBot, etc. as P0.
Page gap analysis (pagegap.py): for each losing prompt (SoV under 50%), fetches your page and the competitor pages engines cited, and lists what they have that you lack (direct answer, FAQ schema, Organization schema, table, question headings, depth). P1.
Fix list (…

View on GitHub

Two commands: sentinel.run for the weekly audit (with --optimize --seo) and sentinel.twin for the digital twin.

A new client is one JSON file (brand, domain, competitors, prompts) plus a _twin_fixes.json file. No code changes.

How I Built It

Python + requests only. 28 tests run without any API keys, using a mock engine.
Open-weight models: OpenAI's open-weight gpt-oss-120b on Groq, plus OpenRouter's free router, which picks an open model that's available. Every engine is an OpenAI-compatible endpoint, so swapping models is one environment variable.
SerpApi fetches the real Google India results for each buyer question. They're cached, so every AI run reuses the same results and doesn't spend extra searches.
The twin's fairness rules: both versions sit at the same rank among the same real results, and the model is told to use a result only if it actually helps. Fixes may only use facts already on the client's site. No invented "dermatologist-tested" claims.
Everything is a recommendation. Sentinel never edits the client's site. Fixes have ids, and when one is applied, later weekly runs report the before and after.

What went wrong along the way (and is now handled): free model slugs get retired without warning (switched to OpenRouter's openrouter/free router), free tiers rate-limit hard (paced requests, a configurable delay, failed runs counted rather than hidden), and SerpApi's num parameter returned unrelated results (dropped it and pinned google.co.in).

Why Does Open Innovation Matter?

The unit economics only work this way. An audit is roughly 100 model calls. On free open-weight endpoints that costs nothing, so I can sell an audit to a small brand at a price it can pay.
No lock-in. In one afternoon two "free" models disappeared. Because every engine is an OpenAI-compatible endpoint serving open weights, the fix was changing a string, not rewriting the product.
Can run on the client's own machine. The same code can point at a locally hosted open model, so an agency can audit a client's unreleased pages without sending them to a third party.
Honest limit: open models aren't ChatGPT or Gemini. Sentinel treats them as a stand-in for consumer AI search, and the report says so on page one.

My First User

I ran it on a real Indian hygiene brand I know well (anonymized here). The first useful feedback came immediately: my first config tracked diapers and sanitary pads, but the brand doesn't sell those yet. I rebuilt the questions around what it actually sells, which is the kind of correction a real user gives that no test catches.

Prior art on DEV

Measure AI Share of Voice in Python by odeeb, on counting mentions while ignoring "I'm not familiar with X" answers.
Measuring AI Visibility: A Practical Framework for Reliable Results by benardkemp, on why repeated samples matter.

Sentinel adds the step those stop short of: testing the fix before shipping it.

Prize Categories

Best Use of SerpApi

Dharohar: an open-source AI audio guide that makes you put your phone in your pocket 🌿

Preksha barjatya — Tue, 06 Oct 2026 10:11:58 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I live in Indore. Ten minutes from my house is Rajwada, a seven-storey palace the Holkars started building in 1747. I have walked past it hundreds of times, usually looking at my phone.

Dharohar (धरोहर, heritage) is an audio guide for India's old city lanes that tries to get you to stop doing that. You tap Walk where I am, or pick a heritage city. It finds the heritage sites around you, shows you the route, writes a short spoken guide for each stop, voices it, and then asks you to put your phone in your pocket. The screen goes black. You walk. When GPS says you have reached the next stop, the guide starts talking, and when it finishes it tells you where to go next.

The measure of success is how little you look at it.

It's for anyone in a heritage town who wants the story without the screen: residents who never learned the history of the street they live on, and visitors who don't want to follow a blue dot for an hour.

What keeps you off the screen:

Black, not locked. Phones pause GPS and web audio when the screen locks. So Dharohar keeps the screen awake with the Wake Lock API and paints it pure black. On an OLED phone, black pixels are switched off: almost no battery, and nothing to look at.
GPS does the tapping. Each stop has a geofence. Walk into it, feel a short vibration, hear the story. A stop never repeats. Then you hear "Next: Gopal Mandir, about 140 metres north-east", and at the end, that the walk is complete.
Dead zones are fine. Every stop is written and voiced before you reach it, while you still have signal. A service worker caches the app and every MP3, so a temple courtyard with no network doesn't stop the walk. If GPS is weak, an "I'm here" button plays the stop by hand.
The guide is forbidden from mentioning screens. No "on your map", no "tap here". Only things you can see with your own eyes.
Your language. English plus nine Indian languages, from Hindi and Marathi to Tamil and Malayalam.

Demo

Live: https://dharohar-agent.onrender.com. Open it on your phone, allow location, tap Walk where I am, or pick a city under Heritage cities. Indore and Ujjain are instant: their walks ship with the audio already made. Anywhere else, the first stop is ready in about 15 seconds and the rest are written while you walk. (It runs on Render's free tier, so the very first visit after a quiet spell takes a minute to wake up.)
Video: https://youtu.be/wnoLYbbGi38?si=egkM_3cZ_uh14CGK

The whole interface is black and white on purpose: one button to start, a list of cities, and the route. Everything else stays out of the way, because the point is to look up.

In the video I'm standing at Holkar Stadium in Indore, a cricket ground with no heritage of its own. Dharohar looks wider, finds Gajanan Maharaj Temple, Indore Museum, Rajwada, Lalbagh Palace and Kanch Mandir, and orders them into a walk. Then: countdown, black screen, the guide begins. When I reach Rajwada, the phone vibrates and Rajwada's story plays.

You can also type any place, or pick one of 18 heritage cities, from Delhi and Agra to Hampi and Madurai. Gwalior Fort gives Chaturbhuj Temple, Gujari Mahal, Sasbahu Temple and the Siddhachal caves, all within 800 metres. Mandu gives Jama Masjid, Lohani Caves, Hindola Mahal and Nilkanth temple.

Code

Prekshabarjatya / dharohar-agent

Dharohar agent

Audio-first heritage walking tours for Indian cities. A Mastra agent fetches live facts with SerpApi and Gemma writes a short spoken script with physical, real-world cues only. No screen talk: put the phone in your pocket and walk.

POST /script {"monument": "Rajwada, Indore"} → {"script": "...", "audioUrl": "/audio/rajwada-indore_<ts>.mp3", "duration": 32}
GET /audio/<file>.mp3 serves the spoken guide (ElevenLabs eleven_multilingual_v2, so Hindi works too).
Audio is cached per monument, so a second visitor costs no ElevenLabs credits. If ElevenLabs fails, the response has audioUrl: null and a warning, and the script is still returned.
Model: Gemma via Google AI Studio (gemma-4-26b-a4b-it) when GOOGLE_GENERATIVE_AI_API_KEY is set, else Groq when GROQ_API_KEY is set, else local Ollama (gemma3:4b).
Evals (npm test, ElevenLabs mocked, no credits used) check audio, fallback and caching, and fail if a script runs over 100 words, mentions screens/apps/maps, or skips the…

View on GitHub

How I Built It

Each stop goes through a small pipeline, held together by a Mastra agent with two tools:

SerpApi searches the web for the monument, so the guide starts from real facts.
Gemma writes a script of under 100 words: physical directions only, and only facts from the search.
ElevenLabs voices it, with four voices to choose from. eleven_multilingual_v2 covers English, Hindi and Tamil; Marathi, Gujarati, Bengali, Punjabi, Telugu, Kannada and Malayalam need eleven_v3, which I found by testing every language against the API.

Then the walk page takes over: a route screen that shows every stop and its live status, geofences, wake lock, next-stop directions and the offline cache.

Gemma, two ways. On my laptop Gemma 3 4B runs locally through Ollama, with no API at all. In production the same code calls gemma-4-26b-a4b-it on Google AI Studio. One environment variable switches between them, and Groq works too. A Gemma 4 script reads noticeably better than the 4B one. Kanch Mandir's script, for example, names Seth Hukumchand, gives the year it was built (1903) and points out the glass murals.

Why not let the model call the tools? Small Gemma models don't do native tool calling reliably. So the pipeline calls the tools in a fixed order instead of hoping the model remembers to search. That's simpler, and it never skips the facts.

Evals as the rules. The "touch grass" rules are tests, not hopes. npm test runs 13 evals:

every script is under 100 words, opens with "Namaste. Put your phone in your pocket", and never says screen, app, map, click, tap or scroll (whole words, so "approach" passes)
a real MP3 is written for each stop
if ElevenLabs fails, the walk still works: the script comes back with a warning and the phone's own voice reads it
the same stop twice costs one ElevenLabs call, and switching voice reuses the script
Hindi comes back in Devanagari, and Marathi is voiced with the right model and language code
geofences fire inside the radius, not 500 m away, and never replay a stop

GitHub Actions runs the fast evals on every push.

The eval that lied to me. My first version passed every check while Gemma described "a carved wooden balcony" and "a stone lion" at Rajwada. Neither exists. It had copied the example sentence from its own instructions. Format checks can't catch invented facts. What fixed it was grounding every script in search results, plus a rule to mention only features named in those facts.

The minute that wasn't the model's fault. A new stop took 60 to 100 seconds, and real people trying it said it felt stuck. I timed each step: the search took 1.4 seconds and the voice about 6. The rest was Gemma 4 thinking before every 80-word script. Setting its thinking level to minimal took the writing step from over a minute to about 6 seconds, with no drop in quality I could hear. A whole stop now takes about 13 seconds. Two more changes made the wait disappear: the walk starts as soon as stop 1 is ready, and the ready-made walks ship with their audio, so they're instant.

Caching. Each stop's script is cached, and its audio is cached per voice. The second person to walk past Rajwada gets it in under a second, and costs no model call and no ElevenLabs credits.

Agent tracing. The pipeline is instrumented for Sentry: each tour is one agent run, with separate spans for the search, the Gemma call (model, tokens, latency) and the voice. Each response also returns its own timing, which is how I found the thinking problem.

I built this with an AI coding agent (Claude Code). I set the idea, the rules and the evals. The agent wrote most of the code, ran the tests and fixed what failed, and I reviewed every change. The session is below.

Why Does Open Innovation Matter?

Local history belongs to locals. A temple trust, a heritage walk group or a college club can run Dharohar on its own hardware. I ran the whole thing on my laptop with Gemma through Ollama, with no API key for the model at all.

Swapping models is one line. This happened during the build: the Gemma version I first deployed was retired on one provider. Because the model is open-weight and the code doesn't depend on one vendor, I listed what was available and switched to Gemma 4 in one line. With a closed API, that's a rewrite or a shutdown.

Open data, open code. Walks come from Wikipedia's open geodata. The guide is grounded in public search results. The code is MIT-licensed, so anyone can add a walk for their own town.

What's next: a "local story" box at each stop, so people who live there can add the oral history that never reached Wikipedia, read aloud as part of the walk. That only works if the community can see and change how the guide works. That's what open is for.

My Agent Session

Building Dharohar: audio-first heritage walks with Gemma, Mastra, SerpApi and ElevenLabs

You

Concept: "Dharohar" – Audio-First Heritage Walking Tour Generator. A tool that generates hyper-local, self-guided walking tours of Indian neighborhoods, stepwells, temples, or colonial heritage sites. The user inputs their location, and …

Agent

Got the Dharohar concept. What do you want me to do with it? 1. Build a working MVP … 2. Write the pitch or submission … 3. Check it against a real event.

You

Agent

▸ tools Bash, Edit, Write, in-app browser

Input

Bash, Edit, Write, in-app browser

Output

10 tool calls

I built the Dharohar MVP as one HTML file. The Rajwada, Indore demo made a 3-stop tour: Rajwada, Lalbagh Palace, Indore Museum, each with Wikipedia history and walking directions.

You

use this key for elevenlabs - [REDACTED]

Agent

▸ tools Bash, Edit, Write

Input

Bash, Edit, Write

Output

12 tool calls

Dharohar is live on Cloudflare Pages. I didn't type your key in anywhere: the key belongs in a server-side secret, never in the page. A /api/tts function now proxies ElevenLabs.

You

[Hacktoberfest prize categories pasted]

Agent

Dharohar fits several of these tracks without a rebuild: ElevenLabs, Gemma, Render/DigitalOcean, MongoDB, Entire. Skip the forced fits.

You

mkdir dharohar-agent && npm install @mastra/core @mastra/evals ollama serpapi dotenv …

Agent

Those commands start a separate Node backend with a Mastra agent. Before running them, three things will break as written: Cloudflare can't run Ollama, the package names are wrong, and two packages are extra.

You

SERPAPI_KEY=REDACTED

Agent

▸ tools Bash, Write

Input

Bash, Write

Output

11 tool calls

Day 1 is done and committed. Both evals pass. Changes from the plan: Mastra 1.74 API, gemma3:4b instead of gemma2:2b, the search runs before Gemma because small Gemma can't call tools, and whole-word banned-word checks so 'approach' doesn't fail. One real problem: with no facts, Gemma invented a 'carved wooden balcony' copied from its own instructions — the evals still passed.

You

serpapi api key - [REDACTED]

Agent

▸ tools Bash

Input

Bash

Output

2 tool calls

SerpApi is working: the script now has real history (Malhar Rao Holkar, 1747). Removed the example from the rules so Gemma stops copying it.

You

Day 2 prompt: ElevenLabs TTS, audio caching, expanded eval tests

Agent

▸ tools Bash, Write

Input

Bash, Write

Output

8 tool calls

Day 2 is done. All evals pass, and a real Rajwada run produced a 32-second spoken MP3. Used fetch instead of the deprecated SDK, eleven_multilingual_v2 instead of the retired monolingual model, and a fake ElevenLabs in tests so they cost no credits.

You

Day 3 prompt: Next.js black-screen UI and geolocation triggers

Agent

▸ tools Bash, Write, in-app browser

Input

Bash, Write, in-app browser

Output

27 tool calls

Did Day 3 without Next.js: one static page served by the existing agent server. Phones stop GPS and audio when the screen locks, so the black screen uses Wake Lock to stay on but black. GPS geofences play each stop on arrival; double-tap is the no-GPS fallback.

You

we need to match and built everything in the claims

Agent

▸ tools Bash, Write, Chrome DevTools

Input

Bash, Write, Chrome DevTools

Output

17 tool calls

Built and verified: offline audio via a service worker (checked in real Chrome), Sentry agent tracing spans, GitHub Actions evals, DigitalOcean spec. Removed claims that can't be made true: 'data never leaves our infrastructure', '$0 per tour', 'built with Copilot without touching the keyboard', 'fine-tuned'.

You

Render (free) + Groq + ElevenLabs + SerpApi free tiers

Agent

Switched the post to Render. Flagged claims in the draft paragraph that weren't true or measured yet: Next.js, 'under 2 seconds', 'zero latency', and Gemma 2 on Groq.

You

I have deployed

Agent

▸ tools Bash

Input

Bash

Output

20+ tool calls

Debugged the live deploy from outside: added a short error reason to the 502, found gemma-3-27b-it retired on AI Studio, listed available models, switched to gemma-4-26b-a4b-it, and found the ElevenLabs env var held the key ID instead of the key. SerpApi takes 1.4 s; nearly all latency is Gemma on the free tier, so scripts and audio are cached per stop.

You

corrected elevenlabs key — but only the demo walks work

Agent

▸ tools Bash, Chrome DevTools

Input

Bash, Chrome DevTools

Output

16 tool calls

Live audio works. Added walks for any place or your current location, built from nearby Wikipedia heritage pages; widens to 10 km for spread-out sites. Gwalior Fort gives 5 stops; Mandu gives Jama Masjid, Lohani Caves, Hindola Mahal and Nilkanth temple.

Prize Categories

Best Use of Gemma: Gemma writes every grounded, length-capped script (Gemma 4 in production, Gemma 3 locally through Ollama), and tuning its thinking level cut a stop from over a minute to seconds.
Best Use of Render: the agent and the walk UI run as one free Render web service, deployed from a render.yaml blueprint.
Best Use of ElevenLabs: the guide's voice in ten languages across two models, four voices, audio cached per stop.
Best Use of SerpApi: live facts for every stop before Gemma writes a word.
Best Use of Mastra: the agent, its rules and its tools.
Best Use of GitHub Copilot: GitHub Actions runs the evals on every push.

Dawai Saathi: a medicine reminder my grandmother can use without typing or speaking

Preksha barjatya — Sun, 04 Oct 2026 17:59:07 +0000

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

What I Built

Dawai Saathi ("medicine companion") is a medicine reminder for my grandmother. She takes several tablets a day, finds speaking difficult, and reads Hindi and Marwari rather than English.

Someone in the family photographs her prescription or types it in. A Gemma model running on the family's own computer reads it into a medicine list. A person always confirms that list before anything is saved. The app flags known risky pairs (for example aspirin with ibuprofen) as "ask the doctor or pharmacist", and it never gives dose advice.

Her screen is deliberately simple: one medicine at a time in large Hindi type, one green button, and a voice that reads the reminder aloud. She needs no typing and no speaking, only taps. The family gets a separate page with the history and warnings.

Demo

Video (47s, with sound): https://youtube.com/shorts/asac9HyuAN0?feature=share
Live app: https://dawai-saathi.onrender.com (free tier, the first load after a quiet spell takes about a minute; it uses a simple stand-in reader and the browser's Hindi voice, and nothing is stored permanently)

Code

Prekshabarjatya / dawai-saathi

How I Built It

Gemma (via Ollama) reads the prescription photo into structured JSON, with a fixed schema so the output can be validated. It only reads; it never advises.
Interaction check is a small fixed table, not the model. A language model should not decide what is medically safe. The table needs a pharmacist's review before real use.
Temporal runs each dose as a durable workflow: remind, wait for a tap, repeat up to 3 times, then record a missed dose and alert the family. Failed steps retry instead of losing a dose.
Voice: the Hindi reminder is spoken by the browser or, if a key is set, by ElevenLabs.
Render hosts the web app.
The interface is plain HTML and CSS with system Devanagari fonts, high contrast and dark mode, so it works on an old phone.

Why Does Open Innovation Matter?

A prescription is some of the most private data a family has. With an open-weight model running on the family's own computer, the photo never has to be sent to someone else's server. I can also change the prompt, the language and the safety rules, and swap models, without asking anyone. A closed API would have meant uploading my grandmother's medicines to a third party and hoping the terms never change.

Prize Categories

Best Use of Render (the app is deployed there).

DEV Community: Preksha barjatya

SlothWeaver: a local summarizer that naps when your laptop does (and picks up where it left off) 🦥

What I Built

Demo

Code

How I Built It

Why open innovation matters here

Prize Categories

What I'd do next

Sentinel: Test Your AI Visibility Fixes Before You Ship Them

What I Built

Demo

Code

Prekshabarjatya / sentinel-ai-visibility

Open-model AI visibility audit for small brands, with a digital twin that tests fixes before you ship them

Sentinel AI: Phase 1 engine

Run

Optimization (needs internet; add --optimize)

How I Built It

Why Does Open Innovation Matter?

My First User

Prior art on DEV

Prize Categories

Dharohar: an open-source AI audio guide that makes you put your phone in your pocket 🌿

What I Built

Demo

Code

Prekshabarjatya / dharohar-agent

Dharohar agent

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Dawai Saathi: a medicine reminder my grandmother can use without typing or speaking

What I Built

Demo

Code

Prekshabarjatya / dawai-saathi

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Optimization (needs internet; add `--optimize`)