DEV Community: Tanmay Dalvi

Echoes: A Private Memory Garden Powered by Local AI

Tanmay Dalvi — Wed, 28 Oct 2026 15:35:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What if the most important things we preserve with AI aren't generated images, productivity metrics, or chat histories—but the stories of the people we love?

Family traditions, childhood memories, the sound of a grandparent telling an old story, and the little moments that shaped us can easily disappear with time. Yet sharing these deeply personal memories with cloud-based AI raises an important question: Should preserving our memories require giving up control over them?

That question inspired me to build Echoes — a private digital memory garden powered by open-weight AI.

🌿 What I Built

Echoes is a local-first memory archive designed to help people preserve family stories, oral histories, personal milestones, and meaningful moments.

Users can record memories with dates, people, places, categories, and tags, then explore them through a searchable archive or chronological timeline.

Echoes also uses a locally running open-weight model to help transform saved memories into thoughtful, structured keepsakes.

Key features

Memory Garden: Preserve and organize personal stories in one place.
Chronological Timeline: Revisit memories across years without inventing dates for undated recollections.
AI Reflections: Generate remembrance cards, reflective tributes, grounded summaries, and oral-history narratives.
People and Places: Keep the context surrounding each memory connected to its story.
Backup and Restore: Export memories as portable JSON and restore them with duplicate-conflict handling.
Fictional Demo Archive: Explore the experience using sample stories rather than anyone's personal memories.

The design deliberately avoids pretending to recreate deceased people or simulate their consciousness. Echoes works with the memories people choose to preserve—not fabricated messages from those who are gone.

🚀 Live Demo

Try Echoes: https://echoes-frontend-1mss.onrender.com/

Source code: https://github.com/Tanmay-Dalvi/echoes

For the best first look, explore the fictional demo archive, open the timeline, and visit the AI Reflections and Backup & Data sections.

🛠️ How I Built It

The central design decision was to keep the AI component replaceable and support local inference through Ollama with the open-weight gemma3:1b model.

The application combines a web interface, a backend API, local database storage, and an AI provider layer. The local installation is designed to keep saved memories on the user's machine while using the locally running model for AI-assisted writing.

The major components are:

Frontend: React, TypeScript, and Vite.
Backend: Python and FastAPI.
Data storage: SQLite with full-text search indexing.
AI inference: Ollama running gemma3:1b locally.
AI tasks: Remembrance cards, reflective writing, grounded summarization, and oral-history narratives.
Data portability: JSON export and validated restore workflows.
Deployment: Render-hosted web demo, with local inference remaining a separate deployment mode.

The architecture is intentionally modular: the memory archive is useful on its own, while AI adds another way to revisit and reflect on preserved stories.

Architecture

The following diagram describes the intended local installation. The Render demo is a separate deployment mode and must not be assumed to have access to Ollama running on a user's computer.

🔓 Why Open Innovation Matters

For Echoes, open innovation is not just about choosing a different model. It changes the relationship between the user, their memories, and the technology processing them.

1. Personal stories deserve privacy

A family memory can contain names, relationships, locations, grief, and details that were never meant for a third-party service.

With local inference, the model can process memories on the same machine where the application runs. The local architecture avoids sending those memories to a remote AI provider for inference.

2. AI should remain replaceable

Using an open-weight model through Ollama gives developers greater control over their inference environment. Models can be evaluated, replaced, and adapted as requirements evolve, without designing the entire product around one proprietary model API.

3. The experience can work without cloud inference

Once the application and model are installed locally, the core memory archive and supported AI features can work without an internet connection, provided the required dependencies and model are already available.

That makes local-first AI especially meaningful for a tool whose purpose is to preserve personal history rather than depend on a continuously available cloud service.

4. The user should own the archive

Portable JSON export and restore make memories easier to back up and move. The archive should remain useful even when a particular model, hosting provider, or AI service is unavailable.

Open innovation gives Echoes a path toward privacy, portability, and user control that a cloud-only architecture would make harder to achieve.

🕯️ The Spirit of It

The theme Ghost in the Machine naturally brings to mind haunted technology, simulated personalities, and machines that appear to remember.

I wanted to explore a quieter interpretation.

The most meaningful echoes aren't artificial voices claiming to be someone we've lost. They are the real stories that person left behind: a recipe, a family tradition, an unforgettable afternoon, a lesson, or a small detail that would otherwise fade.

AI can help us organize and reflect on those stories, but it should never replace the person behind them.

Echoes is my attempt to build technology that helps memories stay human.

🔮 What's Next

I'd like to keep improving Echoes with stronger local-model support, more robust backup and recovery, accessibility improvements, and additional ways to preserve oral histories while maintaining the project's privacy-first principles.

The long-term goal is simple: make it easier for people to preserve the stories they want future generations to remember.

🏆 Challenge

Built for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

Live demo: https://echoes-frontend-1mss.onrender.com
GitHub: https://github.com/Tanmay-Dalvi/echoes

I'd love feedback on the local-first architecture, the memory-preservation experience, and how open-weight AI can be used responsibly for deeply personal applications.

devchallenge #hf26challenge #opensource #ai

SlothSort: I Built a Local-First AI File Organizer That Asks Before It Moves Anything

Tanmay Dalvi — Thu, 22 Oct 2026 14:53:03 +0000

Hacktoberfest Open-Source AI Challenge 2026 — Week 3: Slow and Steady

Ever opened your Downloads folder and found final_v2_REAL.pdf, screenshot_2026.png, backup.zip, and a bunch of files you promised yourself you'd organize someday? 😅

That tiny organizational task somehow becomes a whole afternoon.

So I built SlothSort — an AI-powered file organizer designed to make that process safer, simpler, and less tedious.

🔗 Live Demo: https://slothsort-web.onrender.com/

💻 Source Code: https://github.com/Tanmay-Dalvi/slothsort

🧩 What is SlothSort?

SlothSort scans a selected folder, analyzes file metadata, and proposes an organization plan with suggested destination folders and filenames.

But there's one important difference from a fully autonomous file agent:

The AI proposes. Deterministic code validates. You approve.

Files aren't moved just because a model suggested something. You can inspect the plan, edit individual destinations, select which operations to approve, and execute only after confirmation.

And if you change your mind, SlothSort supports undo for eligible operations.

📸 Screenshots

The main dashboard, provider selection, and folder scanning interface.

Review proposed file moves and destinations before approving them.

An execution result showing the completed batch and available undo action.

Operation history and the ability to reverse eligible changes.

These are placeholders. Replace each ADD_SCREENSHOT_URL_X_HERE with the corresponding uploaded image URL before publishing.

✨ Key Features

AI-assisted organization: Generate proposed categories, destination paths, and filenames.
Local AI with Ollama: Run inference locally using an available model such as gemma3:1b.
Optional hosted provider: Google Gemini can be selected explicitly when cloud processing is acceptable.
Deterministic validation: Validate proposed operations before execution.
Human approval: Review, edit, and select proposed operations before applying them.
Collision protection: Detect conflicts instead of silently overwriting existing files.
Undo and history: Track operations and reverse eligible batches.
Safety-focused design: No file deletion operation is part of the intended organization workflow.
Demo mode: Test the workflow with a dedicated sample folder instead of risking personal files.

🔐 Why local-first AI?

File metadata can reveal more than we realize. Filenames may contain names, project details, financial information, or other personal context.

That's why provider choice matters.

SlothSort supports three modes:

Deterministic Mock: Rule-based suggestions for testing and demonstrations.
Local Ollama: Model inference runs on your machine.
Hosted Gemini: Sends the metadata required by the implementation to Google's API.

The local option helps keep processing on-device. The hosted option is explicit rather than a silent fallback.

One important distinction: local inference does not automatically mean every part of an application is network-free. The privacy boundary depends on the selected provider and application configuration.

🏗️ How I Designed It

I wanted to avoid giving an AI model unrestricted control over filesystem operations.

The system separates suggestions from execution:

Scan an authorized directory and collect file metadata.
Ask the selected provider to propose an organization plan.
Validate the proposed paths and operations deterministically.
Let the user review and approve the plan.
Execute the approved operations.
Record the results so eligible operations can be undone.

Architecture at a glance

Architecture diagram: frontend, API, provider layer, validation, execution, and undo.

🧠 Technology Stack

Frontend: React, TypeScript, Vite, Tailwind CSS
Backend: Python, FastAPI
Local AI: Ollama with Gemma
Hosted AI: Optional Google Gemini API integration
Testing: Pytest and Vitest
Deployment: Render for the hosted web interface

🛠️ Challenges I Worked Through

1. Keeping AI suggestions separate from file operations

A model response should never be treated as trusted filesystem instructions. The application needs deterministic validation and an explicit approval boundary.

2. Making undo safer

Undo is not simply moving everything back blindly. If a file has changed or a destination is no longer safe, restoration needs to respect those conditions rather than overwrite unrelated data.

3. Explaining privacy honestly

Local inference, hosted inference, backend connectivity, and browser connectivity are different things. I wanted the UI to make provider selection and metadata handling visible instead of hiding them behind a generic “AI is working” message.

4. Making the project reproducible

A project is more useful to the open-source community when contributors can understand the architecture, run tests, and try a safe demo without pointing it at their real files.

🧪 Try It Yourself

Live interface: https://slothsort-web.onrender.com/

Repository: https://github.com/Tanmay-Dalvi/slothsort

The hosted interface is deployed on Render. Because SlothSort's real file operations depend on a backend with access to the target filesystem, use the documented local setup and demo workflow for actual filesystem operations. Do not assume the public website can access files on your computer.

For a safe first test:

Clone the repository.
Follow the setup instructions in the README.
Configure a supported provider.
Use the dedicated demo folder.
Scan, generate a plan, review it, and approve selected operations.
Test undo after execution.

🌱 What I Want to Improve Next

There is still room to improve SlothSort:

Better categorization for ambiguous files.
More comprehensive collision and recovery tests.
A polished first-run experience.
Automated CI for pull requests.
Better visual documentation and onboarding.
Clearer provider-specific privacy reporting.

I'd love feedback on the workflow, safety model, and what would make this more useful for everyday file organization.

🤝 Contributing

SlothSort is open source, and contributions around testing, usability, documentation, and safe file operations are welcome.

Check the repository for setup and contribution guidelines:

https://github.com/Tanmay-Dalvi/slothsort

🦥 Final Thoughts

I wanted to build something that uses AI without turning every action into an unpredictable autonomous decision.

SlothSort is built around a simple principle:

Let AI suggest the plan. Let deterministic code enforce the rules. Let the human make the final decision.

Slow and steady — and no files moved without your approval.

If you try it, I'd appreciate your feedback!

Hacktoberfest #OpenSource #AI #Python #React #Ollama #Gemma #DevTools

Batchwise: Turning Messy Food Business Expenses into Real Profit Insights 🇮🇳

Tanmay Dalvi — Sat, 17 Oct 2026 10:12:29 +0000

Every batch. Every cost. Every rupee.

What if a home baker or a small snack seller could stop guessing their profits and actually understand the numbers behind every production batch?

That question inspired me to build Batchwise, an AI-assisted costing and profit intelligence tool designed for India's home-based food businesses.

Built for the Hacktoberfest 2026 Week 2 — Side Hustle Challenge, Batchwise combines AI-powered note parsing with deterministic financial calculations to help small business owners understand their costs, pricing, and profitability.

🔗 Live Demo: https://batchwise-henna.vercel.app/

💻 GitHub Repository: https://github.com/Tanmay-Dalvi/batchwise

1. The Problem: Revenue Isn't Profit

Imagine running a small homemade ladoo business.

You buy besan, oil, packaging materials, and other ingredients. You spend money on gas, electricity, labour, and transportation. Then you sell your products.

At the end of the day, you know how much money you received. But do you know how much you actually earned?

Many small food businesses still rely on notebooks, rough estimates, or manual calculations. Costs get missed, profit margins become unclear, and selling prices may not cover the actual production expenses.

I wanted to build something that could make these calculations simpler, more transparent, and more reliable.

2. Meet Batchwise

Batchwise is an AI-assisted costing and profit tracking application for home bakers, homemade snack sellers, tiffin services, and other small food businesses.

The name has a simple meaning:

Batch means one real production run, whether it is a batch of ladoos, a set of bread loaves, or a day's tiffin orders.
Wise represents making informed, data-driven financial decisions instead of relying on guesswork.

Together, Batchwise means making smarter business decisions, one production batch at a time.

Its core promise is simple: Every batch. Every cost. Every rupee.

3. Cost Every Batch, Not Just Every Ingredient

The Batch Costing Engine lets users enter ingredients, quantities, purchase pack sizes, purchase prices, packaging, labour, fuel, delivery, and other expenses.

It converts purchase costs into the quantities actually used in a batch, then calculates the financial results using Python's Decimal arithmetic.

Users can see:

Total production cost
Cost per sellable unit
Break-even selling price
Projected revenue and net profit
Profit margin versus markup
Break-even sales volume
Target-margin pricing recommendations
A transparent calculation audit trail

Users can also save recipes, reuse them for future batches, and maintain a history of recorded production runs.

A real calculation

Consider a sample batch with these costs:

Item	Cost
Besan	₹600
Oil	₹180
Packaging	₹80
Total batch cost	₹860

Suppose the batch produces 75 sellable packets, each priced at ₹25.

Metric	Result
Cost per packet	₹11.47
Projected revenue	₹1,875
Projected profit	₹1,015
Profit margin	54.13%
Markup on cost	118.02%
Break-even quantity	35 packets

These figures assume all 75 packets are sold at the planned price, with no additional costs beyond those entered.

An important distinction: profit margin measures profit as a percentage of revenue, while markup measures profit as a percentage of cost. They are not interchangeable.

4. From Messy Notes to Structured Data with AI

One of the most useful features is the AI Note Parser.

Small business owners don't always record expenses in a neat spreadsheet. They might write something like:

Sourdough batch: 2 kg flour 140, yeast 30, butter 120, electricity 50, baked 8 loaves, selling for 90 each.

Manually converting that note into structured ingredient entries takes time.

Batchwise uses AI to extract candidate fields from natural-language notes and prepare them for the costing workspace.

The important part is that the AI does not get to decide the final financial result.

The workflow is:

The user pastes a purchase or production note.
The AI extracts candidate ingredients, quantities, prices, and yield information.
Batchwise highlights missing or ambiguous information.
The user reviews and corrects the extracted fields.
The confirmed information is transferred into the costing workspace.
Python performs the actual financial calculations.

For example, a note that says “yeast 30” does not establish how much yeast was used. Batchwise can flag the missing quantity instead of silently treating an assumption as fact.

5. Why Deterministic Math Matters

AI is useful for understanding unstructured language, but financial calculations need to be predictable and verifiable.

That is why Batchwise separates AI-based extraction from financial computation.

The AI helps interpret what the user wrote. The Python calculation engine handles the numbers.

The engine uses Decimal arithmetic to avoid common binary floating-point representation issues in monetary calculations. It validates units, rejects invalid production yields, and maintains a calculation audit trail.

This separation makes the results easier to verify and reduces the risk of an AI-generated numerical answer being mistaken for an accurate financial calculation.

6. Built Local-First, with Privacy in Mind

Batchwise was designed with local-first usage in mind because recipes, ingredient prices, and supplier costs can be sensitive business information.

The local development setup supports Gemma 3 1B through Ollama. This allows AI parsing to run locally without requiring a paid AI API.

The hosted demo has a separate deployment environment. Any external AI provider used in hosted mode must be configured explicitly, and users should be told when their notes are sent to that provider.

The principle remains the same: AI should help structure the data, but users should retain control over what they submit and confirm.

7. The Technology Stack

Batchwise brings together a lightweight frontend, a Python backend, a deterministic calculation engine, data persistence, and AI-assisted extraction.

React, TypeScript, and Vite: Interactive frontend
FastAPI: Backend API
Python Decimal: Financial calculations
SQLite and SQLAlchemy: Data persistence
Gemma 3 1B with Ollama: Local AI note parsing
Gemini API: Hosted AI parsing when configured
Vitest and React Testing Library: Frontend tests
Pytest: Backend tests
Vercel and Render: Frontend and backend hosting

[INSERT DIAGRAM 4 HERE — Batchwise technology stack]

Suggested caption: The technologies powering Batchwise, from its mobile-friendly interface to its AI-assisted parsing and financial engine.

8. Testing and Verification

The project has a backend test suite covering calculation logic, unit handling, API endpoints, database operations, and AI parser behavior.

The frontend includes tests for currency formatting, financial summaries, the AI review flow, and costing workspace behavior.

During development, the reported verification results included:

67 backend tests passing
16 frontend tests passing
A successful frontend production build
End-to-end checks of calculation, recipe management, batch history, and AI extraction

These tests are important because a financial tool should be more than visually appealing. It should handle invalid inputs, make assumptions visible, and produce reproducible results.

9. What's Next?

Batchwise is a starting point for making financial clarity more accessible to small food businesses.

Future improvements could include better multilingual note extraction, more detailed expense tracking, downloadable reports, and reliable persistent storage for hosted users.

The goal is not to overwhelm small business owners with complicated accounting software. It is to give them a practical way to understand the economics of each batch they produce.

Final Thoughts

Building Batchwise reinforced one idea for me: useful AI products don't need to hand every decision over to a language model.

Sometimes the strongest design is to let AI handle the messy human input and let deterministic software handle the math.

For a small business, understanding the difference between revenue and profit can matter more than a flashy dashboard.

Batchwise is my attempt to make that understanding simpler, one production batch at a time.

🔗 Try Batchwise: https://batchwise-henna.vercel.app/

💻 Explore the code: https://github.com/Tanmay-Dalvi/batchwise

Built for the Hacktoberfest 2026 Week 2 — Side Hustle Challenge.

Hacktoberfest #AI #Python #BuildInPublic #SmallBusiness

GreenQuest 🌿 — Turning Open-Weight AI into Real-World Outdoor Adventures

Tanmay Dalvi — Sun, 11 Oct 2026 11:31:57 +0000

🌿 GreenQuest: Turning Open-Weight AI into Real-World Outdoor Adventures

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

What I Built

What if AI could help us spend less time looking at screens and more time experiencing the world around us?

That's the idea behind GreenQuest, a local-first, offline-capable outdoor companion that turns 15–60 minutes of free time into personalized nature micro-adventures.

Instead of endlessly scrolling through a phone, users can choose their environment, available time, mindset, physical energy, sensory interests, and companions. GreenQuest turns those preferences into a structured outdoor quest with practical activities, progress tracking, and safety guidance.

Whether you're visiting a forest, walking through a city park, exploring a garden, or spending time near a waterfront, GreenQuest encourages you to slow down and notice things you might otherwise overlook.

A typical quest might invite you to listen to the sounds beneath a tree canopy, observe the textures of tree bark, or discover the miniature world growing on a fallen log.

Each quest includes:

Personalized outdoor activities with step-by-step instructions.
A duration suited to the user's available time.
Sensory prompts for sight, sound, touch, scent, and spatial awareness.
Progress tracking and completion feedback.
Outdoor safety guidance and Leave-No-Trace principles.

GreenQuest also keeps a local history of saved quests, allowing users to revisit their experiences without creating an account.

Built for the real world, including offline situations

GreenQuest is designed to remain useful when the internet isn't available. Its Progressive Web App (PWA) caches essential assets, quest history is stored locally, and a browser-side deterministic generator can create activities when the backend cannot be reached.

The application also includes safeguards against risky activities such as consuming wild plants, trespassing, disturbing wildlife, and unsafe exploration.

The objective is simple: use technology to help people disconnect from technology.

Demo

🌐 Live application: https://greenquest-pwa.onrender.com

Try creating a quest, completing its steps, and revisiting it through the saved history panel.

The hosted demo uses a deterministic nature-quest engine on the backend. The local version supports open-weight AI inference through Gemma 3 1B and Ollama.

Code

💻 GitHub repository: https://github.com/Tanmay-Dalvi/greenquest

GreenQuest is open source under the MIT License.

The repository contains the React/TypeScript frontend, FastAPI backend, AI orchestration logic, safety validation, tests, and deployment configuration.

How I Built It

GreenQuest uses a modular architecture so the application doesn't depend on a single proprietary AI provider.

Technology stack

Frontend: React, TypeScript, Vite, and Tailwind CSS.
Progressive Web App: Service Worker caching and local browser storage.
Backend: Python, FastAPI, and Pydantic.
Local AI: Gemma 3 1B running through Ollama.
Orchestration: Lightweight Python state machine coordinating generation and validation.
Testing: Pytest for the backend and Node's built-in test runner for API URL normalization.
Deployment: Render for the hosted frontend and backend.
Version control: Git and GitHub.

System architecture

The frontend collects user preferences and sends a request to the backend. The backend coordinates mission generation, validates the result, and returns a structured quest. Local storage preserves progress and history, while the browser-side fallback provides an alternative when the backend is unavailable.

The AI quest-generation pipeline

The local AI implementation uses Gemma 3 1B through Ollama. A lightweight orchestration flow separates the work into three responsibilities:

Planner Agent: Organizes a quest around the user's preferences and available time.
Nature Activity Agent: Produces concrete sensory activities and instructions.
Safety Validation: Checks the generated content against deterministic application rules before it is presented.

The application uses structured JSON output, response repair, and bounded retries to handle malformed model responses. If generation cannot be completed reliably, a deterministic fallback keeps the experience usable.

Local AI, hosted demo, and offline browser mode

These are three distinct execution modes:

Local mode: Ollama runs Gemma 3 1B on the user's machine. Inference does not require a paid cloud AI API, and the model can run without an internet connection once installed.

Hosted demo: Render hosts the frontend and backend. The public demo uses the deterministic backend rule engine by default; visitors are not downloading or running Gemma model weights in their browsers.

Browser offline mode: When the backend is unreachable, the PWA can use its browser-side deterministic generator and locally saved data. This is separate from running Gemma locally.

Safety and reliability

Generated content is treated as untrusted until it passes application-level validation. GreenQuest includes deterministic safeguards against:

Eating or tasting wild plants, mushrooms, berries, or unpurified water.
Trespassing or entering restricted areas.
Dangerous climbing or unsafe water crossings.
Touching, chasing, or feeding wildlife.
Activities that conflict with Leave-No-Trace principles.

The backend test suite has 31 passing tests, covering API behavior, schemas, safety rules, provider behavior, orchestration, and model-output repair. The frontend production build also passes, and API URL normalization has dedicated unit tests.

Why Does Open Innovation Matter?

Open innovation makes GreenQuest more accessible, inspectable, and adaptable.

1. Local inference and user control

Gemma 3 1B and Ollama give users a way to run the AI locally instead of sending every prompt to a proprietary cloud service. This offers greater control over data and a path toward reducing recurring inference costs.

2. Freedom to experiment

The provider abstraction makes it possible to inspect the orchestration and change the inference provider without rebuilding the entire application around one vendor.

3. Accessibility without mandatory paid APIs

The deterministic fallback keeps the basic experience usable without a paid API key or a cloud GPU. The hosted demo can also operate without a hosted AI provider.

4. Transparent safety logic

The safety rules are part of the source code. Developers can inspect them, test them, and propose improvements rather than relying entirely on an opaque model response.

5. AI with a purpose beyond the screen

The most important part of GreenQuest isn't generating more text. It's turning a simple intention—“I have 30 minutes and want a mindful break”—into a real-world activity.

Open models let me experiment with this idea on ordinary hardware, while open-source code lets others learn from it, adapt it, and build on it.

My Agent Session

I used AI-assisted development to build and debug the application, improve structured-output handling, test safety behavior, and resolve deployment configuration issues.

I don't have a verified public DevRelay session link to include here. If I publish one, I'll add it to this section.

Prize Categories

GreenQuest uses Gemma 3 1B locally through Ollama and is deployed on Render. I'll select the partner prize categories only after verifying their official eligibility requirements.

GreenQuest is a reminder that AI doesn't always need to make us more productive, more connected, or more engaged with a screen.

Sometimes, it can help us notice the world just outside the door.

🌲 Explore less digitally. Experience more naturally.