DEV Community: Gamaliel Dashua

The Forest Symphony: Turn a Bird's Song Into a Melody You Can Keep

Gamaliel Dashua — Tue, 20 Oct 2026 15:12:51 +0000

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

What I Built

You're on a forest trail. A bird starts singing, and a few seconds later the moment has passed.

The Forest Symphony lets you keep that moment. You record the bird on your device, and in about ten seconds you get:

The bird's name, with how sure the app is (for example, American Robin, 79% match)
A few facts about where it lives and how it sings
A short melody built from the notes the bird actually sang, which you can play right away
A Download button that saves the melody as an audio file (WAV)

It works without internet. Everything runs on your own device, so it still works deep in the woods with no signal. Your recordings and where you made them stay on your device.

Who it's for: hikers, birdwatchers, musicians, parents out on a walk with curious kids, and anyone who has stopped to listen to a bird and wished they could take the song home.

How it gets people outside: the app is useless indoors on purpose. The only way to get a new melody is to go outside, find a bird, and listen closely enough to record it. Every melody you collect comes from a real bird you heard on a real day. It works like a sound journal that you build by spending time outdoors.

Demo

https://drive.google.com/file/d/1PUcd4IlFDC5NfZWIdGX1syxjSyWxyfmw/view?usp=sharing

What the demo shows:

Morning Robin Chirp. A real robin recording becomes "American Robin's Morning Song", which you can play and download.
Deep Woods Owl. A Tawny Owl is recognised with a 93% match and turned into a slow, low melody.
Windy Ridge. A recording of plain wind. The app politely replies: "We couldn't hear a bird in this recording. Try again closer to the bird…". It doesn't invent a bird that isn't there.

The app ships with these three recordings built in, so a live demo never depends on a bird turning up.

Code

https://github.com/Gamey001/forest-symphony

To run it yourself:

python3.12 -m venv .venv
.venv/bin/pip install -r requirements-dev.txt
ollama pull llama3.1                 # one-time download of the AI composer
ollama serve                         # in its own terminal
.venv/bin/uvicorn app.main:app --port 8000

Then open http://localhost:8000. The first run downloads the bird-recognition model once; after that, everything works offline.

How I Built It

The app works like a small assembly line. A recording goes in one end and a melody comes out the other. Each station does one job:

🎙️ Recording
   ↓
1. Clean up     – remove wind rumble, background hiss and silent gaps
   ↓
2. Identify     – BirdNET names the bird (or says "that's not a bird")
   ↓
3. Listen       – follow the bird's pitch, 100 times per second
   ↓
4. Draft        – turn the pitch into notes, in a key, at a human tempo
   ↓
5. Compose      – a local AI (Llama 3.1) arranges the draft and calls a "make the melody" tool
   ↓
6. Synthesize   – plain maths turns the notes into sound waves → WAV file
   ↓
🎵 Result card: bird name, facts, play button, download button

The open-source AI pieces

🐦 BirdNET: the bird expert. BirdNET is a free, openly available model from the Cornell Lab of Ornithology and Chemnitz University of Technology. It has been trained to recognise over 6,000 bird species by sound. It runs on my laptop through birdnet, the official Python package. I chose it over a general-purpose AI because it is built for exactly this one job, and it does it well. It also recognises things that aren't birds, such as human voices, engines and wind noise. The app uses that to say "we couldn't hear a bird" instead of guessing.

🎼 Llama 3.1 (8B) via Ollama: the composer. Llama 3.1 is a language model whose files you can download and run yourself (an "open-weight" model). Ollama is a free tool that runs models like this on your own computer. In this app, the model plays the role of a composer. It receives a short text description of what the bird sang (species, key, draft notes) and responds by calling a tool named generate_melody with its final arrangement.

🔧 Plain Python for everything else: FastAPI for the small web server, NumPy and SciPy for the audio maths, and a plain HTML page for the interface.

Choices that made it work

1. Let each AI do what it is good at.
My first plan had the language model "listen" to the bird. That doesn't work: language models read and write text and cannot hear. If you ask one for the notes in a recording, it will make some up. So the work is split:

Hearing the bird is done with signal maths: find the loudest frequency in each tiny slice of sound. It gives the same answer every time.
Naming the bird is done by BirdNET, the specialist.
Arranging the music is done by the language model, which works with text and makes creative choices.

2. Never trust the AI blindly, and always have a backup.
Every tool call from the AI is checked before anything plays. Are the notes real notes? Is the melody within two octaves? Are the rhythms valid? If the answer is wrong, the AI is told exactly what was wrong and gets one more try. If it still fails, or if the AI isn't running at all, the app uses its own draft melody. You always get a song.

3. Facts come from a fact file, never from the AI.
Language models sometimes state made-up facts with total confidence. That's harmless in a chat, but bad on a card that teaches kids about birds. The species facts come from a small, hand-checked file and are looked up by the name BirdNET gives.

4. Be honest about what the AI did.
In testing, the model would say "I smoothed out the melody" when it hadn't changed a single note. So the app doesn't show what the AI says it did. It compares the melodies before and after and reports what actually changed, for example "The AI composer reshaped 5 of the bird's 24 notes."

Problems I ran into (and what I learned)

🦉 The owl kept disappearing. The noise cleaner learned what "background noise" sounded like from the whole recording. Owl hoots are long and steady, so the cleaner decided the owl was the background and erased it. The fix was to treat a sound as background only if it's there almost all the time. Hoots come and go, so they now survive.
🦉 The owl sounded twice as high as it should. Owl calls have overtones (fainter copies of the note at higher pitches) that are louder than the note itself, so the app followed the wrong one. It now checks for a real note underneath the loudest one, and picks that note when it's there.
🎙️ Browsers were deleting birdsong. Browsers clean up microphone audio for video calls, and that cleanup treats birdsong as noise to remove. The app turns those filters off when it records.
🐦 Real birds are too high for music. A robin sings at around 2,500 Hz, which is higher than the top of a piano. The app moves the melody down by whole octaves, so it keeps its shape but lands in a range that's pleasant to listen to.
📻 Static was "a woodpecker". Fed pure static, BirdNET reported a woodpecker with 45% confidence. The app now needs at least 50% confidence before it believes something is a bird.

Why Does Open Innovation Matter?

It works where the internet doesn't. The place you hear the best birdsong, deep in the woods, is usually the place with no signal. An app that depends on a paid online AI service stops working at the trailhead. Because BirdNET and Llama 3.1 run on the device itself, the Forest Symphony works on a mountain or in a forest, or anywhere else.

Your walks stay private. Recordings, times and places say a lot about where you go and when. With open models running locally, none of that leaves your device. There's no account to sign up for and nothing to upload.

The best tool for the job was already open. No general-purpose online AI matches BirdNET at recognising birds. It exists because researchers spent years collecting and labelling bird recordings and then shared the result. The demo recordings in this app also come from volunteers who share their recordings on xeno-canto. The whole project is built on things people chose to share.

I could look inside and fix things. When the owl went missing and the AI's descriptions didn't match its output, I could test each piece on its own, see what was going on, and change it. With a closed service, I would only have seen the final wrong answer, with nothing I could inspect.

It costs nothing to use. There are no per-request fees or rate limits, and no API key that can expire before demo day.

Credits

Bird identification: BirdNET by the Cornell Lab of Ornithology and Chemnitz University of Technology (model licence: CC BY-NC-SA 4.0)
AI composer: Llama 3.1 by Meta, running on Ollama
Robin recording: Jonathon Jongsma, xeno-canto XC130246, CC BY-SA 3.0
Owl recording: Benoît Van Hecke, xeno-canto XC603209, CC BY-SA 4.0

Expense Auditor: How I Built a Private AI Expense Assistant That Uses Tools for Flawless Math

Gamaliel Dashua — Sun, 18 Oct 2026 22:36:52 +0000

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

What I Built

Expense Auditor is a private AI bookkeeper that runs entirely on your own laptop. You chat with it like a person ("How much did I spend on software last month?") and it answers with numbers that are always exactly right, because the AI is never allowed to do the maths.

The problem

Anyone who earns money on the side (freelancers, small shop owners, online sellers, consultants) has to track expenses. It's tedious, and getting it wrong costs real money at tax time.

AI chat assistants look like the perfect helper, but they have two serious flaws:

AI is bad at arithmetic. A language model predicts the next word; it doesn't calculate. Ask it to total 40 receipts and you'll often get a confident, wrong number.
Your finances end up on someone else's servers. Every receipt, vendor and amount you upload to a cloud AI leaves your control.

The solution

Expense Auditor splits the work between two very different "workers":

🤖 The AI understands your question and writes the friendly answer. That's all it does.
🧮 Ordinary code looks up your records, adds up the numbers, converts currencies and works out dates, with exact precision.

So when you ask "How much did I spend in May?", the AI doesn't guess. It asks the calculator tool, gets back exactly $78.57, and tells you. Under every answer there's a "Verified by tool calls" panel showing the exact records and date range used, so you can check the AI's work yourself.

What it can do

💬 Chat about your spending: totals, averages, biggest expenses, breakdowns by category.
🧾 Read any receipt: drop in a PDF invoice, a phone photo of a paper receipt or a screenshot, and it fills in the vendor, date, category and total by itself.
💱 Handle US dollars and Nigerian naira: everything is stored in dollars. A naira receipt is converted automatically (at 1 USD = ₦1,400), and you can ask for any answer in naira.
📅 Understand everyday date language: "May", "August 1 to 15", "last quarter", "since March".
🔒 Stay 100% private: the AI and the database both live on your computer. Nothing is uploaded anywhere.
📊 Show a dashboard: total spend, a chart by category and a table of every record.

Who would pay for it?

Freelancers and side-hustlers who want quick, trustworthy answers without learning accounting software.
Small businesses in Nigeria and other countries with two currencies, where expenses arrive in naira but reports are needed in dollars.
Bookkeepers and accountants who handle many clients' receipts and can't legally or ethically upload them to a cloud AI.
Privacy-conscious professionals (lawyers, therapists, consultants) whose expense records reveal who their clients are.

The pitch is simple: an assistant that's as easy as ChatGPT, as accurate as a calculator, and as private as a notebook in your drawer. Because it runs on hardware the customer already owns, there's no cloud bill per question. That makes a low one-off licence or a small monthly fee viable.

Demo

🎥 Screen recording:

https://drive.google.com/file/d/1npxs7l64g2gMtJamKkeA4OE4Fv1UHEZE/view?usp=sharing

Code

https://github.com/Gamey001/expense-auditor-with-calculator.git

The repository includes:

a step-by-step setup guide written for non-experts
124 automated tests that run in about 2 seconds without needing the AI
a sample-data script so you can try it straight away

The code is organised like this:

File	What it does
`backend/agent.py`	Talks to the local AI and decides when to use tools
`backend/tools.py`	The "accountant": database queries and exact maths
`backend/periods.py`	The calendar tool: turns "May" into May 1 to May 31
`backend/currency.py`	Dollar and naira conversion
`backend/receipts.py`	Reads PDFs and photos
`frontend/app.py`	The chat window and dashboard

How I Built It

The open-source AI stack

Piece	What I used	Its job
Local AI runtime	Ollama	Runs AI models on my own laptop
Chat model	Meta Llama 3.1 (8B), open-weight	Understands questions and picks the right tool
Vision model	Alibaba Qwen2.5-VL (3B), open-weight	Reads photos and scanned receipts
Backend	FastAPI (Python)	Runs the tools and connects everything
Interface	Streamlit (Python)	The chat window and dashboard
Database	SQLite	One small file on your computer

The key idea: "the AI talks, the code counts"

Modern open models support tool calling. Instead of answering straight away, the model can say "please run this tool with these settings." I gave the model six tools:

Query and calculate: finds expenses and computes a sum, average, count, minimum or maximum.
Breakdown by category: a total per category.
Calendar lookup: turns phrases like "last quarter" into exact dates.
Convert currency: dollars ↔ naira.
List categories: so the AI uses the category names that actually exist.
Add expense: so you can say "log a ₦14,000 taxi ride today".

The AI's only job is to pick the right tool and describe the result. Every number comes from code, using exact decimal maths, so 0.10 + 0.20 is always 0.30 and never 0.30000000000000004.

What testing taught me (the honest part)

The most valuable part of this project was watching the AI fail and building guardrails so it couldn't fail the same way again.

🐛 Bug 1: "May" became October. I asked "What transactions did I make in May?". The AI said I had 26, then listed made-up transactions with the wrong amounts and dates. The real answer was one. Here's what had happened:

The AI sent two contradictory instructions to the tool: "May 1 to May 31" and "this month".
My code obeyed "this month", so it returned October's records.
The AI then wrote "May" on top of October's data and filled in details it invented.
In another test, it guessed the year 2023 for "August".

The fix: a calendar tool. I took date maths away from the AI completely, just as I'd already done with arithmetic:

The AI now passes the user's own words ("May") to the calendar tool, and code turns them into exact dates.
Any instruction the AI invents outside the tool's definition is ignored and flagged.
Every answer must state the date range that was actually used, and the screen shows it.

After the fix, the same question returned the one correct transaction. I added an automated test that replays the AI's exact wrong instructions, so this bug can't come back.

🐛 Bug 2: photos of receipts crashed. The first vision model I tried (llama3.2-vision) wouldn't load on my version of Ollama. I switched to Qwen2.5-VL, which is smaller (3.2 GB instead of 7.8 GB) and better at reading documents. It read my test receipts in about 6 seconds and correctly picked the final total rather than the subtotal. It also read the Nigerian date format (15/10/2026) correctly.

🐛 Bug 3: naira was treated as dollars. A ₦32,235 grocery receipt would have been saved as $32,235. Now the AI only spots the currency, and code does the conversion: ₦32,235 is saved as $23.03, with the original naira amount kept for the records.

The lesson: don't trust the model with anything that has a single right answer. Let it handle language, and let code handle facts.

Why Does Open Innovation Matter?

For this product, open-source AI isn't a nice extra. The product couldn't exist without it.

🔒 Privacy is guaranteed, not promised. With a closed cloud AI, every receipt (who you paid, how much, when) goes to a company's servers, and you have to trust their privacy policy. With open models running locally, the data physically never leaves the laptop. For accountants handling client records, that's the difference between "allowed" and "not allowed".
💸 No per-question bill. A cloud AI charges for every question and every receipt scanned. Here, the model runs on hardware the customer already owns, so the thousandth question costs the same as the first: nothing. That's what makes a cheap side-hustle product possible.
✈️ It works offline. No internet, no outage, no rate limits, no API key to leak.
🔧 I could swap models when one failed. When the first vision model wouldn't load, I switched to another open model in minutes by changing one setting. With a closed API you get the provider's model, and you can't move to another one.
🧭 Every layer can be inspected. The models, the runtime and the code are all open. A cautious customer, or their auditor, can check exactly what happens to their data.
🌍 It fits local needs. Open tools let me build in Nigerian naira, local date formats and local receipt styles without waiting for a large company to prioritise my market.

Closed AI would have given me a smarter chatbot. Open AI let me build a trustworthy, private, affordable one, and those are the qualities people actually pay for in a financial tool.

My First User

https://drive.google.com/file/d/1PUcd4IlFDC5NfZWIdGX1syxjSyWxyfmw/view?usp=sharing