DEV Community: Arya Joshi

TidyMind AI: A Local AI Productivity Assistant | Hacktoberfest Week 3

Arya Joshi — Fri, 23 Oct 2026 17:28:29 +0000

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

What I Built

I built TidyMind AI, a privacy-focused productivity assistant designed to reduce the time and effort spent organizing everyday tasks, notes, and files.

We often waste time sorting through messy to-do lists, extracting important points from long notes, and deciding how to organize files. TidyMind AI aims to make these repetitive activities easier with the help of open-source AI.

The application helps users:

Organize tasks: Turn an unstructured list of tasks into categorized, prioritized, actionable items.
Summarize notes: Extract key points and action items from long text.
Organize files: Preview suggested file categories and filename changes before applying them.
Track activity: Review previous operations and manage history.
Work with privacy in mind: Use a locally running AI model instead of relying on a third-party AI API for inference.

My goal is simple: spend less time organizing work manually and more time actually getting things done.

Demo

Live demo: https://youtu.be/7x0-tReEUZk

Screenshots:

If a public deployment is not available, I will provide screenshots or a short video demonstration showing the main features.

Code

GitHub repository: https://github.com/arya179/tidymind-ai

The project is built with a simple full-stack architecture that separates the user interface, backend logic, and AI integration.

I am building TidyMind AI as an open-source project so other developers can explore the implementation, contribute improvements, and adapt it to their own workflows.

How I Built It

I used Antigravity IDE as my development environment and built the application incrementally, starting with the dashboard and then implementing the core functionality.

Technology stack:

React + Vite: Frontend and interactive user interface.
Tailwind CSS: Responsive styling and interface design.
Python + FastAPI: Backend API and request validation.
Ollama + Gemma: Local inference using an open-weight AI model.
SQLite: Local activity history, if enabled in the implemented version.
Git + GitHub: Version control and open-source collaboration.

The AI integration is designed to send requests from the frontend to the backend, which communicates with the locally running model through Ollama.

For task organization, the model receives an unstructured list and returns structured results that the application validates before displaying them.

For file organization, the application is designed around a preview-first workflow. Users can review proposed changes before confirming them, reducing the risk of accidental file modifications.

I am also including a demo mode so the interface can be explored without requiring an AI model to be installed.

Why Does Open Innovation Matter?

Open innovation matters because productivity tools should be adaptable, transparent, and accessible.

Using an open-weight model gives this project the flexibility to run inference locally, customize prompts, experiment with different models, and avoid depending entirely on a paid third-party AI API.

It also makes the project easier for other developers to learn from and extend. Developers can inspect the code, understand how AI responses are handled, and improve the application through community contributions.

Local inference can also help keep user-provided text on their own machine, provided the application is configured to use local services and does not send that data elsewhere.

For me, this challenge is an opportunity to explore how open-source AI can make small, repetitive tasks easier without requiring every user to depend on a closed AI service.

My Agent Session

I used Antigravity IDE to build TidyMind AI step by step, from project setup and dashboard development to backend integration and testing.

I used an iterative development workflow: implement one feature, test it, fix issues, and then continue to the next milestone.

The Lazy Payoff

TidyMind AI is designed to reduce the manual effort involved in organizing tasks, extracting action items from notes, and planning file changes.

Instead of manually rearranging a long task list, users can get a structured starting point from AI and review it before making decisions.

I plan to measure the actual time saved by comparing manual organization with the application's results. I will avoid claiming specific time savings until I have tested the workflow with real usage.

Prize Categories

Best Use of Gemma — if TidyMind AI uses Gemma through Ollama for its AI-powered task organization and summarization.

Thanks to the Hacktoberfest community for encouraging developers to experiment with open-source AI and build practical tools that make everyday work a little easier.

InvoiceMate AI: A Local AI-Powered Invoice Manager for Small Businesses

Arya Joshi — Mon, 19 Oct 2026 06:34:39 +0000

What I Built

I built InvoiceMate AI, a Python-based invoice management application designed to help freelancers, small businesses, and independent professionals save time managing invoices.

Small businesses often spend valuable time manually reading invoices, entering invoice numbers, checking totals, and organizing financial records. InvoiceMate AI helps simplify this process by extracting invoice information and organizing it in one place.

Key Features

📄 Upload invoice PDFs.
🔍 Extract invoice text using PDF processing and OCR tools.
🤖 Use local AI to identify important invoice details.
✏️ Review and edit extracted information before saving.
🗃️ Store invoice records in a local SQLite database.
📊 View invoice information and totals on a dashboard.
📤 Export invoice data to CSV.

Who would pay for it?

Freelancers, consultants, bookkeepers, and small businesses that want a straightforward way to organize invoices and reduce manual data entry could benefit from a tool like this. A future version could offer paid features such as bulk processing, advanced reporting, and integrations with accounting software.

Demo

Code

🔗 GitHub Repository: https://github.com/arya179/invoicemate-ai

The project is built with Python and Streamlit, with local database storage and AI-assisted invoice extraction.

How I Built It

I built InvoiceMate AI using open-source tools and a locally running AI model.

Technology stack:

Python — application logic
Streamlit — interactive user interface and dashboard
Ollama + Gemma 2B — local AI-powered invoice information extraction
PyMuPDF — extracting text from PDF invoices
Tesseract OCR — supporting text extraction from scanned documents
SQLite — storing invoice records locally
Pandas — handling invoice data and CSV exports

The workflow is simple: upload an invoice, extract its text, use the local AI model to identify relevant fields, review the results, and save the information.

I chose a local model because I wanted to learn how open-weight AI can be integrated into a practical application without relying entirely on a paid hosted AI API.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with AI without building a model from scratch or depending entirely on a closed, paid API.

Using open-source libraries and the Gemma model through Ollama gave me the flexibility to run inference locally, customize the application, and learn how the different components work together.

Local inference can also reduce the need to send invoice contents to an external AI service. This can be valuable when handling financial documents, although privacy still depends on the application's configuration, storage, and deployment.

Most importantly, open-source tools made this project accessible for learning and experimentation, with the possibility for other developers to inspect, improve, and extend it.

My Agent Session

I used Antigravity IDE to help with the development workflow and project organization. I also explored DevRelay as part of my Hacktoberfest workflow.

Optional: Add your saved DevRelay agent session here if you have one available.

Prize Categories

Check the official challenge page and list the partner categories that apply to your project. Remove this section if none apply or if the template does not require it.

Building InvoiceMate AI helped me explore how local AI can solve a real business problem. I hope to keep improving it with better extraction accuracy, duplicate detection, and support for more invoice formats.

Thanks for checking out my project! 🚀

hacktoberfest #python #ai #opensource

🌿 GardenBuddy AI: Less Scrolling, More Growing

Arya Joshi — Fri, 09 Oct 2026 19:02:34 +0000

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

What I Built

🌿 GardenBuddy AI — Less Scrolling, More Growing

GardenBuddy AI is an AI-powered gardening companion designed to help people make better gardening decisions and spend more time outdoors.

Gardening beginners often struggle to choose suitable plants, understand plant care, and organize everyday activities. GardenBuddy AI brings these workflows together in one application.

Key Features

🌱 Plant Finder: Explore plant recommendations based on sunlight and available space.
🤖 AI Gardening Advisor: Ask gardening questions and receive contextual advice powered by a locally running Gemma 2B model.
🪴 Gardening Task Management: Organize watering, pruning, harvesting, and other gardening activities.
💾 Local Data Storage: Store gardening records in SQLite.
🌦️ Location and Weather Integration: Use Open-Meteo services to support location-aware gardening workflows.

The project is designed for gardening beginners, home gardeners, and anyone who wants practical help caring for plants.

The idea behind GardenBuddy AI is simple: use technology to make gardening easier, then get outside and put the advice into practice.

Demo

Demo video: [Insert your public demo video URL here]

The demonstration showcases the GardenBuddy AI application, including plant recommendations, the local AI gardening advisor, and gardening task management.

The video also demonstrates how the application connects AI-generated guidance with practical gardening activities.

Code

GitHub Repository: https://github.com/arya179/GardenBuddy-AI

The repository contains the source code, installation instructions, and implementation of GardenBuddy AI.

Explore the code, run the application locally, and contribute improvements to make gardening more accessible.

How I Built It

GardenBuddy AI combines a React frontend, a Python backend, local AI inference, and a lightweight database.

Technology stack:

Frontend: React + Vite
Backend: Python + FastAPI
Database: SQLite + SQLAlchemy
AI model: Gemma 2B
Local inference: Ollama
Weather and geocoding: Open-Meteo services

The frontend provides the gardening interface, while FastAPI handles application requests and coordinates the underlying services.

The AI gardening advisor uses Gemma 2B through Ollama. Users submit gardening questions, and the backend sends the question and available plant context to the locally running model to generate advice.

This makes local AI inference a core part of the application rather than an optional external API integration.

The application also uses SQLite for gardening records and Open-Meteo services for location and weather information.

Local AI inference does not require a hosted AI API, although location and weather lookups require internet access.

Why Does Open Innovation Matter?

Open innovation makes it possible to build useful AI applications without depending entirely on proprietary, hosted inference services.

By using Gemma 2B with Ollama, GardenBuddy AI can run its AI advisor locally. This gives users more control over their inference environment and allows developers to inspect, modify, and extend the application.

It also makes experimentation more accessible. Developers can explore local AI workflows without requiring a paid hosted AI API for every request.

For a gardening application, this approach has practical benefits:

Privacy: Prompts processed by the local model do not need to be sent to a hosted AI inference provider.
Accessibility: Users can experiment with the application without a hosted AI API subscription.
Transparency: The source code is publicly available for inspection and improvement.
Community innovation: Contributors can improve gardening workflows, accessibility, testing, and AI integration.

Open innovation is not only about making code available. It is about giving people the freedom to learn from, adapt, and improve technology for real-world needs.

With GardenBuddy AI, the goal is to make AI useful beyond the screen and encourage people to engage more actively with nature.

My Agent Session

Optional: [Add your DevRelay agent session link here if available.]

Prize Categories

Potential category: Best Use of Gemma

GardenBuddy AI uses Gemma 2B through Ollama as its local AI gardening advisor.

I will select this category if it is listed in the official challenge submission options and the project meets its specific eligibility requirements.

🌿 Less scrolling. More growing.

Built for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

devchallenge #hf26challenge #gemma #python #react

Introduction to Python for AI and Machine Learning

Arya Joshi — Mon, 05 Oct 2026 05:12:10 +0000

Python is one of the most popular programming languages in the world. It is simple to learn, easy to read, and has a large community of developers. Because of these advantages, Python is widely used in areas such as web development, automation, data science, Artificial Intelligence (AI), and Machine Learning (ML).

Artificial Intelligence is the field of creating systems that can perform tasks that normally require human intelligence, such as understanding language, recognizing images, making decisions, and solving problems.

Python is widely used in AI because it provides many useful libraries and frameworks. Some popular ones include:

TensorFlow: used for building and training machine learning and deep learning models.
PyTorch: widely used for deep learning and AI research.
OpenCV: used for computer vision and image processing.
Transformers: used for working with modern AI and language models.

Python in Machine Learning

Machine Learning is a part of AI where computers learn patterns from data and use those patterns to make predictions or decisions.

Python makes machine learning easier because of libraries such as:

NumPy: numerical computing and working with arrays.
Pandas: data manipulation and analysis.
Matplotlib: creating visualizations.
Scikit-learn: building and evaluating machine learning models.

For example, Python can be used to load a dataset, clean the data, train a machine learning model, and make predictions.

from sklearn.linear_model import LinearRegression

model = LinearRegression()

This is one reason Python has become an important language for AI and ML development.

Why is Python Popular for AI and ML?

Python is popular in AI and ML because it offers:
Simple and readable syntax
A large collection of AI and ML libraries
Strong community support
Easy data handling and visualization
A large number of learning resources