DEV Community: Amit Verma

demo

Amit Verma — Tue, 13 Oct 2026 10:50:27 +0000

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

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

Field Notes: an offline birding companion (BirdNET + Gemma + TabPFN)

Amit Verma — Wed, 07 Oct 2026 13:39:10 +0000

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

What I Built

I built Field Notes, an offline command-line birding companion designed for hiking, walking, and birdwatching in places where mobile coverage is unreliable.

The idea is simple:

Record → Identify → Journal → Forecast → Go outside again.

You record around 10 seconds of bird audio while you're outside. Later, Field Notes processes the recording locally and uses BirdNET to identify the birds.

A local Gemma 3 1B model then turns the detected species into a short field-journal entry. Your previous observations are stored locally in SQLite and used by TabPFN to forecast which species you might hear at that location and time the next morning.

The screen is intentionally not the main part of the experience.

The forecast exists to give you a reason to put your phone away and go outside again.

Field Notes is designed for:

Birdwatchers
Hikers and walkers
Nature enthusiasts
People exploring areas with poor connectivity
Anyone who wants to keep their observation history private

The core workflow doesn't require a cloud AI API, and observation data stays on the device.

Demo

The intended workflow looks like:

Record ~10 seconds of audio
          ↓
       BirdNET
          ↓
    Bird species detected
          ↓
        Gemma
          ↓
   Field journal entry
          ↓
       SQLite
          ↓
       TabPFN
          ↓
  Tomorrow's bird forecast

I plan to include a short terminal recording showing this complete pipeline.

Code

The complete project is open source on GitHub:

The repository contains the application code, local data pipeline, BirdNET integration, Gemma/Ollama integration, and TabPFN forecasting workflow.

How I Built It

Field Notes combines several open-source AI components, with each one having a specific job.

BirdNET — Bird Identification

I use BirdNET through birdnetlib to analyze the recorded audio and identify likely bird species.

The goal is to perform the identification locally rather than sending recordings to a hosted API.

This is particularly useful when you're already somewhere with poor or no network coverage.

Gemma — Local Field Journal

After BirdNET produces the detected species, I pass those results to Gemma 3 1B running locally through Ollama.

Gemma turns the structured detection results into a short 3–4 sentence field-journal entry.

The prompt is intentionally constrained to the detected species so that the model isn't encouraged to invent birds that weren't detected.

The journal model is configurable using:

FIELDNOTES_MODEL

This means I can experiment with different local models without changing the rest of the application.

If Ollama isn't available, the application gracefully falls back to a plain observation log instead of failing completely.

TabPFN — Personal Bird Forecast

The project stores previous observations in a local SQLite database.

The current prediction features include:

Latitude
Longitude
Day of year
Time of day

I use TabPFN to learn from this personal observation history and predict which species are likely to be observed at a particular place and time.

This is intentionally a personal forecast, not an attempt to create a universal bird-distribution model.

The current implementation supports up to 10 classes, so the forecast uses the 9 most common species plus an other category.

If TabPFN isn't available or there isn't enough data, Field Notes falls back to a nearest-neighbour baseline and labels the result accordingly.

SQLite — Local Storage

All observations are stored locally using SQLite.

This keeps the observation history available for future predictions without requiring a remote database.

Why Does Open Innovation Matter?

Open innovation is especially important for a project like this because the environment where the application is used can be the exact environment where cloud services become inconvenient.

Offline

Birdwatching often happens away from reliable internet connectivity.

Local AI models allow the application to continue working without depending on a hosted API.

Privacy

A birding history can reveal more than the species you've seen.

Repeated observations can reveal where you walk, when you visit a location, and which trails you regularly use.

Keeping this information locally means it doesn't automatically become another dataset stored on someone else's server.

Experimentation

Because the models and tools are open and replaceable, I can experiment with different approaches.

For example, the journal-generation model can be changed without rebuilding the entire application.

The forecasting component can also be compared with different tabular machine-learning approaches.

Cost

There is no per-request cloud AI charge for every bird recording or journal entry.

Once the required models are available locally, additional observations don't create another API bill.

Community

Open-source tools made it possible to combine audio classification, local language generation, tabular prediction, and local storage into one small project without building every component from scratch.

That's the part of open innovation I found most interesting: different projects can solve different pieces of the problem, and they can be combined into something new.

My Agent Session

I haven't included an agent session yet.

Prize Categories

I'm entering the following partner categories:

Best Use of Gemma — Gemma 3 1B is used locally to transform BirdNET detections into readable field-journal entries.
Best Use of TabPFN — TabPFN is used to forecast likely bird species from a small, personal observation dataset.
Best Use of Entire — Field Notes combines local audio classification, local language generation, tabular prediction, and persistent local data into a single offline workflow.

Limitations

This is an experimental hobby project rather than a professional wildlife-monitoring system.

Some limitations include:

BirdNE

I Built StudySaathi, a Private AI Study Buddy That Runs on Your Own Computer

Amit Verma — Sun, 04 Oct 2026 11:36:16 +0000

StudySaathi: A Local Gemma Study Buddy with Flashcards, Quizzes and Dark Mode

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

What I Built

StudySaathi ("study companion") is a local-first AI study buddy. You paste in your class notes, pick how you want to study, and it turns them into something easier to learn from:

☼ Explain it turns notes into a beginner-friendly explanation, split into clear cards (summary, key ideas, example, key terms, recap).
? Quiz me creates a 5-question multiple-choice quiz. You answer one question at a time and get instant right/wrong feedback with a short explanation, then a final score.
▤ Flashcards creates flip cards for quick revision. You mark each card "Got it" or "Still learning", shuffle the deck, and review only the ones you missed.

I built it for a friend who finds studying stressful. Big textbook chapters feel overwhelming, so I wanted a tool that breaks notes into small, calm steps he can go through at his own pace, without pressure and without needing an account or an internet connection to an AI service.

Demo

I haven't deployed it, because it runs on your own computer with Ollama. Here is what it looks like, using Biology notes on photosynthesis:

Explain it

Quiz me

Flashcards

The app also has a light/dark mode toggle in the top bar.

Testing

I tested all three modes myself with Biology notes on photosynthesis, and the testing shaped the app:

Small models don't always follow the format. gemma3:1b sometimes added stray labels like "Flashcard 5" to answers, or laid out quizzes differently each time. I made the parsers tolerant of those variations, and if a response still can't be read, the app shows it as plain text instead of breaking.
Interactive beats a wall of text. My first version dumped raw text into the result panel. Turning it into flip cards, a one-question-at-a-time quiz and sectioned explanations made it feel much less overwhelming, which was the whole point.

Code

Amitverma0509 / Hacktoberfest_Challenge

StudySaathi 📚

StudySaathi is a local-first AI study buddy built with Flask, Ollama, and Gemma. Paste your class notes and choose how you want to study: get a simpler explanation, generate a practice quiz, or create revision flashcards.

It was built for the Hacktoberfest Weekend Challenge: Build for a Friend — the idea is to make studying feel a little less stressful and help a friend revise at their own pace.

Demo

Screenshot of StudySaathi generating a practice quiz from Biology notes about photosynthesis:

Screenshot of StudySaathi generating a Explanation from Biology notes about photosynthesis:

Screenshot of StudySaathi generating a flashcard from Biology notes about photosynthesis:

Features

Explain it: turn notes into a beginner-friendly explanation.
Quiz me: generate five multiple-choice questions, with answers and explanations.
Flashcards: create quick revision cards from notes.
Responsive interface for desktop and smaller screens.
Local inference through Ollama and Gemma; the core study workflow does…

View on GitHub

How I Built It

Model: Google's open-weight Gemma (gemma3:1b by default), run locally through Ollama.
Backend: a small Flask app with one endpoint, /api/study. It takes the notes and a mode, wraps them in a task-specific prompt (explain, quiz or flashcards), and sends it to Ollama running on the same machine.
Frontend: plain HTML, CSS and JavaScript, with no framework.
Turning text into an interface: the model returns plain text, so the frontend parses it into the interactive views above. Flashcards use a strict FRONT: / BACK: format, and the quiz and explanation parsers handle the different layouts small models produce. If a response doesn't match the expected format, the app shows it as plain text instead of breaking.
Configurable: you can switch to any model you have installed in Ollama by setting the OLLAMA_MODEL environment variable.

Why Does Open Innovation Matter?

A study tool is only useful to the people who can actually use it, and many students can't pay for API subscriptions or don't want to send their notes to a third party. Open-weight models made a different design possible:

Privacy: notes go from Flask to Ollama on the same computer, not to a hosted AI API.
No cost or keys: there is no usage bill and no API key to manage, so the app stays free for anyone to run.
Control: I could choose and swap the model, tune the prompts, and build the app around what the model can do.

A closed API would have meant ongoing costs and sending a student's notes elsewhere, which is the wrong trade-off for something meant to make studying feel safe and low-pressure.

Prize Categories

Best Use of Gemma: StudySaathi runs on Google's open-weight Gemma model (gemma3:1b), served locally through Ollama. All three study modes (explanations, quizzes and flashcards) are generated by Gemma, and the app is built around turning its text output into interactive study views.