DEV Community: Akshat Shah

Trail Whisperer: Identify the Bird. Save the Moment. Keep Walking.

Akshat Shah — Mon, 12 Oct 2026 05:02:32 +0000

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

What I Built

A bird calls somewhere above you. A plant catches your eye. You take a photo, promise yourself you’ll identify it later, and eventually lose it among hundreds of other pictures.

I built Trail Whisperer to give those small discoveries somewhere to live.

It’s an offline-first trail companion and personal memory book for curious walkers, beginner birders, and anyone who wants to notice more outside.

The workflow is simple:

Capture a plant or animal photo, or upload a short bird recording.
Review the AI’s identification suggestion.
Save the discovery with a trail name and optional notes.
Keep exploring.
Revisit your discoveries in your memory book at home.

The memory book includes a discovery timeline, species collection, trip summaries, and encounter statistics. At basecamp, you can search saved encounters by meaning and explore reference links about a species.

My design goal was to make the screen a brief stop during an outing: capture something interesting, save the moment, and return your attention to the world around you.

What “offline” means: a prepared laptop runs the backend and downloaded AI models. A phone connects to that laptop over local Wi-Fi. The network does not need upstream internet, but the laptop must remain reachable. The models do not run directly on the phone.

Demo

The video is an AI-assisted product showcase made using app screenshots.

The retained Squirrel and Kingfisher images are labeled demo photos, not verified trail observations. Species identifications are suggestions to review rather than confirmed sightings.

Trail Whisperer currently runs locally. There is no public hosted website.

After following the setup instructions, open http://localhost:8000 on your laptop, or access the laptop’s LAN address from your phone.

Get the code and follow the local setup instructions

I initially tried hosting basecamp on Render, but discontinued that deployment after encountering hosting costs. The current setup runs on my own machine, with optional connected services available at home.

Code

akshatshahh / trail-whisperer

Local-first trail companion with offline BirdNET and Gemma inference, a personal memory book, and optional online basecamp integrations.

Trail Whisperer

A trail ends. The wonder stays. An offline trail companion and a memory book for Hacktoberfest 2026 · Touch Grass.

Act I: listen to a bird or photograph a plant, save the discovery, put the phone away. Act II: at home, revisit a timeline, grow a lifelist, explore species field notes and search your own encounters.

Local application: http://localhost:8000 (after setup) · Source: GitHub · Evidence: VALIDATION.md

There is no public hosted website. GitHub hosts the source code; run the application on your own laptop. For offline trail use, open the laptop's LAN address on your phone as described below. Optional online integrations can run from a local basecamp service when connected.

Technologies and sponsor integrations

Gemma: gemma3n for trail Q&A, field notes and journal summaries; gemma3:4b for vision. Ollama serves downloaded open-weight models locally on your laptop. No Google/Gemini API key is used.
MongoDB Atlas: sightings…

View on GitHub

Browse the repository

The repository includes the frontend, backend, model setup scripts, local startup instructions, and regression tests. Credentials, databases, and personal uploads are excluded from Git.

How I Built It

Trail Whisperer has two modes: trail and basecamp. Both can run locally.

On the trail

The React interface communicates with a FastAPI backend. Ollama serves downloaded Gemma models for questions, summaries, and field notes. Gemma 3 4B handles photographs, while BirdNET analyzes short bird recordings.

SQLite stores discoveries, and uploaded media stay in the local data directory.

The request path is:

Phone → local Wi-Fi → laptop → local models → local journal

One implementation detail mattered more than I expected: the installed Gemma 3n build exposed text completion but not vision. I used a separate local vision model for photographs instead of assuming one model could handle everything.

All model assets must be downloaded before leaving home. Identification and journaling then work without a remote inference API.

Back at basecamp

An explicit sync sends records and media to a second local service.

Basecamp uses SQLite without additional credentials, or MongoDB Atlas when configured. Atlas Vector Search uses locally generated nomic-embed-text embeddings to retrieve related encounters.

Optional connected features extend the journal:

ElevenLabs transcribes saved voice notes through an authenticated basecamp endpoint. Local Gemma summarizes the transcript.
SerpApi retrieves public species reference links and snippets for sourced field notes.
Sentry Agent Tracing records model and research workflow timings and statuses, excluding prompts, recordings, location, and credentials from trace payloads.

These integrations remain disabled in trail mode. They require internet at basecamp; the core local workflow does not require their keys or paid web hosting.

What I tested

The latest verification passed 27 automated tests and the production frontend build.

Real-model checks identified a rose photograph and returned a Black-capped Chickadee candidate from a bird recording.

An offline regression blocked external backend network connections while photo identification, bird identification, local questions, saving, and retrieval continued working. Saved records and media survived a backend restart, and the application’s cloud-call counter remained at zero.

I also exercised the photo workflow in a mobile-width browser. That checks layout and browser behavior; it does not substitute for a physical phone-and-hotspot field test. The README includes the manual procedure for that check.

Atlas semantic search, the local ElevenLabs-to-Gemma pipeline, SerpApi research, and Sentry tracing were also exercised.

The tests establish these workflows. They do not establish identification accuracy for every species, photo, or recording.

Why Does Open Innovation Matter?

For Trail Whisperer, where inference runs determines whether the application can help when connectivity disappears.

Downloadable model weights and local inference let a prepared setup identify and journal discoveries without contacting a remote inference API. Photos, recordings, and notes remain on the trail machine until the user chooses to sync.

The modular implementation also gives me room to adapt it. I can replace a vision model, inspect uncertain outputs, change prompts, or improve the bird-recording pipeline without rebuilding the application around one hosted provider.

There are tradeoffs: advance downloads, CPU latency, and a laptop that must remain reachable. Gemma has its own model terms, and BirdNET weights have separate licensing requirements. Those constraints are documented in the repository.

What this approach made possible is a useful local workflow that I can run, inspect, and improve on hardware I control.

My Agent Session

I used Codex during development to help implement the application, troubleshoot deployment, and add regression coverage.

The repository’s incremental commits document the implementation, fixes, and validation work.

Prize Categories

I’m entering the categories for technologies meaningfully used in the current project:

Best Use of Gemma: local photo identification, questions, summaries, and field notes.
Best Use of MongoDB Atlas: optional basecamp journal storage and vector search over encounter embeddings.
Best Use of ElevenLabs: basecamp voice-note transcription.
Best Use of Sentry Agent Tracing: observability for model and research workflows.
Best Use of SerpApi: species research with public reference links.

Trail Whisperer is built around a small interaction: notice something, learn a little, save the memory, and keep exploring.

The Offline Interrogator: Interview Practice for Avinash, Even Without Internet

Akshat Shah — Mon, 05 Oct 2026 06:45:31 +0000

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

What I Built

I built The Offline Interrogator for my friend Avinash, who lives in India and often travels by train.

Avinash wants to feel more confident in interviews, especially when choosing words and explaining his thinking. Practicing with someone else can feel intimidating, and unreliable internet during train journeys makes online tools less dependable.

This app gives him a private place to practice on his own schedule. He chooses DSA, Behavioral, or System Design, sets a difficulty and duration, and answers one question at a time. The interviewer gives hints, scores his answers, adjusts difficulty, and creates a report showing what to practice next.

After downloading the model and installing dependencies, the text-based interview can run without internet. Cloning the repository alone is not enough—the initial setup requires connectivity.

Demo

The demo shows question generation, spoken questions, answer scoring, the timer pausing during model processing, and the final report. It also shows MongoDB Atlas persistence and Sentry traces.

Code

akshatshahh / offline-interrogator

A local-first mock interviewer made for Avinash. Gemma 3 + Ollama + Mastra, with Atlas, ElevenLabs and Sentry.

The Offline Interrogator

A local-first AI mock interviewer built for Avinash, a friend preparing for FAANG interviews. Hacktoberfest 2026 Weekend Challenge: Build for a Friend.

Pick DSA, Behavioral, or System Design. Get one question at a time, explain your answer, ask for a hint, and receive a strict report card. Difficulty rises after strong answers and falls when fundamentals need work. Topic history makes weak spots visible across sessions.

Open-source AI at the core

Gemma 3 4B open weights → local Ollama → ollama-ai-provider → Mastra tools. All question generation, answer scoring, and hint generation use this path. There are no OpenAI, Anthropic, or Gemini API calls in the app's reasoning code. Gemma is open-weight under Google's Gemma terms; Ollama and Mastra are open-source. This distinction matters: Gemma weights are available, but their license is not an OSI software license.

server/llm.ts is the sole inference entry point. server/tools.ts registers…

View on GitHub

How I Built It

Gemma 3 4B, served locally through Ollama, performs all interview reasoning. The app accesses it through ollama-ai-provider. No OpenAI, Anthropic, or Gemini API generates questions or scores answers.

Mastra provides five registered tools: generate a question, score an answer, provide a hint, retrieve weak spots, and finish a session. The Express API controls the interview sequence and invokes Mastra's tool execution layer.

Scores are validated against a strict JSON schema. The rubric covers correctness, approach, complexity analysis, edge cases, and communication.

The frontend uses React, Vite, and TypeScript. The timer pauses while the model scores an answer, generates a question, or prepares a hint, so processing time does not consume Avinash's answering time.

Supporting services have specific roles:

MongoDB Atlas: stores sessions, answers, scores, reports, and 24 starter questions. Stored history supports weak-spot analysis.
ElevenLabs: converts generated questions into speech, with playback controls when browsers block autoplay.
Sentry: records tool and inference spans with model, latency, and prompt/completion token counts.

Missing optional credentials do not prevent an interview. Storage falls back to memory, voice falls back to text, and console telemetry remains available.

Why Does Open Innovation Matter?

Avinash can practice without depending on a cloud LLM connection for every answer.

Once the weights and dependencies are downloaded, Gemma runs on his laptop. We can inspect the implementation, change the interviewer prompts, and control the reasoning model ourselves.

Local reasoning does not make every feature offline: Atlas, ElevenLabs, and Sentry require internet when enabled, and browser microphone recognition may use an online service. For offline train journeys, Avinash can use typed answers with the optional cloud services disabled.

Gemma is an open-weight model under Google's Gemma terms; Ollama and Mastra are open-source software.

Prize Categories

I’m entering:

Best Use of Gemma: Gemma 3 generates questions, hints, and answer scores.
Best Use of Mastra: the interviewer executes five registered Mastra tools.
Best Use of MongoDB Atlas: persisted interview history supports reports and weak-spot analysis.
Best Use of ElevenLabs: generated interview questions become spoken audio.
Best Use of Sentry Agent Tracing: tool and inference spans expose latency and token usage.

During development, an expired-session test exposed a monitoring issue: an expected 409 response was reported as an incident. I fixed this by excluding expected client errors from incident reporting and disabling Sentry telemetry during tests.

The repository includes verification notes, and all six automated tests pass.

The goal is to give Avinash a place to practice, make mistakes, and become more comfortable explaining his answers—on his own schedule.