DEV Community: Harish S T

QueriumAI — Bringing Hidden Data Stories to Life with an AI Data Analyst

Harish S T — Sat, 31 Oct 2026 16:39:29 +0000

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

👻 QueriumAI — Bringing Hidden Data Stories to Life with an AI Data Analyst

What I Built

Have you ever looked at a database full of tables and thousands of rows but struggled to find the story hidden inside the data?

That's the problem I wanted to solve with QueriumAI.

QueriumAI is an LLM-powered data analyst agent that transforms natural-language questions into SQL queries, interactive visualizations, diagrams, and structured insights.

Instead of manually writing SQL, switching between database tools, and building charts yourself, you can simply ask questions in plain English.

For example:

Which products generate the highest revenue?
How has monthly sales performance changed?
Which countries contribute the most revenue?
What trends can we discover in customer segments?

QueriumAI investigates the database, generates SQL, executes the query, visualizes the results, and explains the findings.

I like to think of it as uncovering the ghosts hidden inside data — the patterns, trends, and insights that aren't immediately visible when looking at raw database tables.

Key Features

💬 Natural Language to SQL: Ask questions in plain English.
🔍 SQL Transparency: Inspect generated SQL, row counts, and execution time.
📊 Interactive Visualizations: Generate bar, line, area, pie, and scatter charts.
🧩 Mermaid Diagrams: Generate ER diagrams, workflows, and decision trees.
🧠 Structured Insights: Get findings, trends, and recommendations.
🕵️ Reasoning Trace: Inspect the agent's reasoning trace.
📚 Query History: Save, favorite, and rerun previous queries.
📌 Pinned Dashboard: Keep important analyses organized.
🎙️ Voice Input: Ask questions using speech.
🛡️ SQL Safety: Read-only query validation and an optional SQL approval step.
📥 Exports: Export tables as CSV and charts or diagrams as PNG.

Demo

🎬 Watch QueriumAI in action:

https://youtu.be/jYxZIr66gws

The demo walks through the application and demonstrates how natural-language questions can become database queries, visualizations, and useful insights.

Code

💻 GitHub Repository:

https://github.com/harishhardik/queriumai

🌐 Live Application:

https://queriumai.vercel.app

Feel free to explore the code, try the application, and share your feedback!

How I Built It

QueriumAI is built around an AI agent that can interact with a database through a set of specialized tools.

Tech Stack

TanStack Start: Application framework.
React 19 + Vite: Frontend and development tooling.
Vercel AI SDK: Agent runtime, streaming responses, and tool calling.
AI Gateway + OpenAI Responses API: Model integration.
PostgreSQL: Database and data persistence.
Recharts: Interactive charts.
Mermaid: Diagrams and flowcharts.
Tailwind CSS + shadcn/ui: User interface.

How the Agent Works

The agent uses five specialized tools:

get_schema — Inspects database tables, columns, data types, and relationships.
execute_query — Executes validated, read-only SQL queries.
generate_chart — Selects appropriate chart types and visualizes query results.
generate_flowchart — Creates Mermaid diagrams.
explain_data — Turns query results into understandable insights and recommendations.

The workflow looks like this:

User Question → Schema Inspection → SQL Generation → Query Execution → Visualization → Insights

I also focused on database safety. QueriumAI uses multiple layers of SQL validation, restricts execution to read-only queries, applies a query timeout, and limits returned rows.

The goal is not just to generate answers, but to make the process transparent and safer to inspect.

Why Does Open Innovation Matter?

QueriumAI currently uses the OpenAI Responses API through AI Gateway for its model integration, rather than an open-weight model or local inference.

I want to be transparent about that because open innovation is an important part of this challenge.

The project uses technologies such as React, PostgreSQL, Recharts, Mermaid, and other open-source libraries. Their ecosystems make it possible to build, inspect, and extend complex applications without reinventing every component.

However, I recognize that using open-source libraries is not the same as having open-source AI at the core. Exploring open-weight model integration and local inference is a potential next step for QueriumAI.

I believe open innovation matters because developers should have the freedom to inspect systems, experiment with different models, adapt tools to their needs, and build beyond the limitations of a single provider.

My Agent Session

QueriumAI was developed through an iterative workflow involving application architecture, agent tool design, database integration, SQL validation, and visualization.

I haven't published a DevRelay agent session link for this project.

The Lazy Payoff

Imagine answering a business question without spending time writing SQL, exporting data, opening a spreadsheet, and manually building a chart.

That's the convenience QueriumAI aims to provide.

It brings database exploration, query execution, visualization, and explanations into one conversational interface.

Instead of spending time on repetitive analysis steps, users can focus more on understanding their data and making decisions.

I haven't measured a specific time-saving figure yet, but the goal is to reduce the friction between asking a question and discovering an answer.

Building QueriumAI taught me that an AI agent becomes much more useful when it can interact with real tools and data rather than simply generate text.

The interesting part isn't just asking AI a question. It's watching it investigate, query, visualize, and explain.

Turn questions into queries. Turn data into insights. 👻📊

🦥 SlothSort — Slow Down, Sort Smarter

Harish S T — Sun, 25 Oct 2026 18:17:50 +0000

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

What I Built

🦥 SlothSort — Slow Down, Sort Smarter

Have you ever opened your Downloads folder and found a chaotic mix of PDFs, screenshots, videos, ZIP files, and code files? I built SlothSort, a local AI-powered file organizer designed to help bring order to that chaos.

SlothSort scans a dedicated sample folder and uses AI to suggest categories such as Documents, Images, Videos, Audio, Archives, Code, and Other.

But here’s the important part: SlothSort suggests; you stay in control.

It generates a preview of the suggested categories, explains why a file was classified, flags uncertain results for review, and lets users manually adjust categories before taking any action.

Currently, SlothSort is a safe, preview-only prototype. It does not automatically move, rename, or delete files.

Demo

🎬 Watch the demo: https://youtu.be/tEevBQMDpMk

The demo showcases the file scanning workflow, AI-powered classification preview, and manual category editing.

Code

💻 GitHub repository: https://github.com/harishhardik/SlothSort

The project is built with React, TypeScript, Python, FastAPI, and Ollama for local AI inference.

Contributions, feedback, and ideas are welcome!

How I Built It

I built SlothSort around Ollama and the open-weight Qwen2.5 1.5B model, running locally instead of relying on a hosted AI API.

Here’s the stack:

React + TypeScript + Vite: Interactive dashboard and file classification review.
Python + FastAPI: Backend API for scanning files and generating classification previews.
Ollama + Qwen2.5 1.5B: Local inference for AI-assisted categorization.
Lucide React: Icons for the dashboard interface.

The workflow is straightforward:

Scan files in a dedicated sample directory.
Send filenames and extensions to the local AI model for classification.
Validate the model's suggestions and fall back to extension-based rules if necessary.
Flag uncertain classifications so users can review them.
Let users manually edit categories in the interface.

Privacy and safety were important design decisions. The current implementation uses a restricted sample directory and sends filenames and extensions—not file contents—to the model. The preview workflow does not modify files.

Why Does Open Innovation Matter?

Open innovation makes experiments like SlothSort possible without requiring a paid, hosted AI API.

Using an open-weight model with local inference gave me the opportunity to explore AI-assisted automation while keeping the inference workflow on my own machine. It also helped me learn how to integrate a language model into a practical application, validate its output, and handle uncertain predictions instead of blindly trusting them.

For a tool that works with personal files, local inference is especially valuable. It provides a foundation for privacy-conscious design and gives users more control over where their data goes.

Open-source tools also make the project easier to inspect, learn from, improve, and extend.

My Agent Session

I built SlothSort through an iterative development workflow: setting up the backend, integrating local AI classification, adding uncertainty handling, and connecting everything to a React dashboard.

I haven't added a DevRelay session link yet.

The Lazy Payoff

The goal is simple: spend less time figuring out where files belong and more time doing useful work.

Instead of manually sorting every file from scratch, users can review AI-generated suggestions and correct the exceptions. The uncertainty flags help draw attention to files that may need a closer look.

SlothSort is still a prototype, so I haven't measured real-world time savings yet. For now, the payoff is a working foundation for smarter, human-controlled file organization.

Building SlothSort reminded me that useful AI doesn't always need to be complicated. Sometimes, a small local model, a focused workflow, and a human-in-the-loop design are enough to create something practical.

Slow down. Sort smarter. Stay in control. 🦥

ReplyCraft AI: Local AI Customer Support for Small Businesses

Harish S T — Sun, 18 Oct 2026 17:28:33 +0000

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

What I Built

I built ReplyCraft AI, a local-first AI customer communication assistant designed for freelancers, small businesses, and independent service providers.

Small businesses often spend valuable time answering repetitive customer questions, drafting emails, and explaining their services. ReplyCraft explores how AI can help reduce this repetitive work.

The project includes three main features:

AI Reply Generator: Generates customer-service replies in professional, friendly, firm, and apologetic tones.
Business-Specific Chatbot: Answers customer questions using information about a business, such as its services, opening hours, and policies.
Website Chat Widget: An embeddable JavaScript chat interface that lets website visitors interact with the chatbot.

I demonstrated the widget using a sample repair business called QuickFix Repairs.

The potential customers are repair shops, freelancers, local service providers, and small businesses that want a basic AI-assisted customer support experience without relying on a paid hosted AI API for every request.

A potential future business model could include paid setup and customization, optional maintenance, or a hosted version for businesses. These are ideas to validate with real users; I have not yet established paying customers.

Demo

🎥 Watch the ReplyCraft AI Demo on YouTube

The video demonstrates the dashboard, AI reply generator, chatbot, and website chat widget.

Code

💻 View the ReplyCraft AI GitHub Repository

The project is built with Python, FastAPI, React, TypeScript, Vite, and Ollama.

How I Built It

I built ReplyCraft AI with a React and TypeScript frontend and a Python backend powered by FastAPI. The backend exposes API endpoints for generating customer replies and handling chatbot conversations.

For local AI inference, I used Ollama with open-weight language models, including Qwen 2.5 (1.5B) and Llama 3.2 (3B) during development.

The application sends user prompts and business-specific context to the backend, which communicates with the locally running Ollama service to generate responses.

I chose this architecture to experiment with AI-powered customer communication without making a paid external model API a core requirement.

The main development challenges included connecting the frontend and backend, generating replies in different tones, providing relevant business context to the chatbot, and connecting a standalone JavaScript widget to the API.

The current project is a working local prototype. Persistent settings, stronger security controls, and production deployment are future improvements.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers more flexibility to experiment, build, and adapt technology to real-world problems.

Using open-weight models through Ollama allowed me to experiment with different models locally instead of depending entirely on a proprietary hosted AI API. This made it possible to explore local inference, compare model options, and build a practical prototype without per-request charges from a hosted model provider.

Local inference can also help keep prompts on a user's machine when the application is configured to operate locally. However, privacy depends on the complete system configuration, and local inference still has hardware, electricity, and maintenance costs.

Open-weight models are not automatically unrestricted or identical to fully open-source software; their licenses and usage terms still matter.

For ReplyCraft, the most important benefit is control and flexibility. I can experiment with different models and improve the application around the needs of small businesses without tying the entire project to one paid AI API.

Open-source tools such as FastAPI and React also made it possible to build the application using accessible development technologies.

This project showed me that building a useful AI application is not only about generating text. The user experience, business context, reliability, privacy, and deployment decisions are equally important.

Prize Categories

ReplyCraft AI focuses on local inference and open-weight language models. I would only select partner prize categories for which the project meets the official eligibility criteria.

What's Next?

My next goals for ReplyCraft AI are:

Persist business settings and reply history.
Improve how the chatbot handles questions it cannot confidently answer.
Strengthen security before exposing the backend beyond local development.
Make the website widget easier to configure.
Gather feedback from small business owners and validate which features they would actually pay for.

I'm excited to keep improving the project and explore how open-weight AI can make useful tools more accessible to small businesses.

I'd love to hear your feedback: What feature would make an AI customer support assistant genuinely useful for a small business?

Thanks for reading, and happy Hacktoberfest! 🚀

🌿 TouchGrass AI: I Built a Local AI That Encourages People to Go Outside

Harish S T — Sun, 11 Oct 2026 16:33:46 +0000

What if AI could help us spend less time on our screens instead of giving us another reason to stare at them?

That question inspired me to build TouchGrass AI, a local-first AI application that turns your interests, available time, and energy level into personalized outdoor missions.

I built this project for the Hacktoberfest Open-Source AI Challenge — Week 1, themed Touch Grass.

🚀 What I Built

TouchGrass AI helps users discover simple outdoor activities instead of spending more time scrolling.

Users can explore activities such as:

🚶 Walking and exploring nearby places
🌱 Gardening and connecting with nature
🐦 Birdwatching and observing wildlife
📸 Outdoor photography
🧘 Mindfulness and relaxing outdoors

Users choose their preferences, and the app generates a personalized mission with practical steps to follow.

The goal is straightforward: make getting outside easier, more engaging, and accessible to more people.

🎬 Demo

Watch the project demonstration on YouTube:

▶️ Watch TouchGrass AI Demo

The demo shows the interface, activity selection, personalized mission generation, and local AI functionality.

💻 Source Code

GitHub repository: github.com/harishhardik/TouchGrassAi

The project is open source under the MIT License.

🛠️ Tech Stack

Frontend: React, TypeScript, and Vite
Backend: Python and FastAPI
AI runtime: Ollama
Model: Qwen2.5 1.5B
Web experience: Progressive Web App (PWA)
Testing: Pytest

I chose this stack to keep the application lightweight, understandable, and capable of running AI inference locally.

🧠 How I Built It

1. A simple, preference-based experience

The frontend lets users select their interests and available time. These preferences are sent to the FastAPI backend, which prepares the request for the local language model.

2. Local AI inference

Instead of relying on a hosted AI API for every request, TouchGrass AI uses Ollama with Qwen2.5 1.5B to generate outdoor missions on the user's machine.

The model receives the user's preferences and generates a relevant activity with actionable instructions.

3. Fallback handling

AI output isn't always predictable. The backend validates the generated response and falls back to predefined missions if the model returns invalid output or the request fails.

This helps prevent a model error from breaking the entire experience.

4. Testing and offline verification

I added automated backend tests covering health checks, request validation, successful local AI responses, invalid model output, and connection failures.

The backend test suite passed all six tests, and the frontend production build completed successfully.

I also verified local mission generation with the internet disconnected after downloading the model.

Important distinction: the AI model must be downloaded first, and the web app must be loaded or installed beforehand. The local inference workflow can then operate without an internet connection.

🌍 Why Open Innovation Matters

For this project, open innovation isn't just about using an open model. It's about having greater control over how the application works.

Privacy: With local inference, mission-generation requests can stay on the user's machine rather than needing to be sent to a hosted AI inference provider.

Accessibility: Once the model and app are available locally, users can generate missions without requiring a continuous internet connection.

Transparency: Developers can inspect the backend, modify prompts, improve fallback behavior, and experiment with different models.

Flexibility: The project can evolve as new models and local inference tools become available.

These benefits come with trade-offs. Local models require disk space and computing resources, and their speed and output quality depend on the device.

For this project, I wanted to explore how local AI could support a useful everyday experience without making a remote AI service a runtime dependency.

🔬 What I Learned

Building TouchGrass AI helped me explore more than connecting a frontend to a language model.

I worked on integrating local inference with a web application, handling unpredictable model output, testing failure scenarios, and checking how the experience behaves offline.

It also reinforced an idea I want to explore further: AI doesn't always need to keep users engaged with technology. Sometimes, it can help them step away from it.

🔮 What's Next?

Some improvements I'd like to explore include:

More personalized missions based on weather and location
Mission history and progress tracking
Additional local models and configurable inference settings
Better offline support and accessibility
Feedback that helps improve the quality of generated missions

🤝 Try It and Contribute

Check out the repository, explore the implementation, and share suggestions or improvements.

🌱 GitHub: https://github.com/harishhardik/TouchGrassAi

🎥 Demo: https://youtu.be/i8BnZB_kX8o

For me, TouchGrass AI is an experiment in using open-source AI to encourage a healthier relationship with technology.

Less scrolling. More growing. More time outside. 🌿

🏆 Challenge Details

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

Prize categories: No partner-specific category is claimed in this submission.

Agent session: No DevRelay session link included.

devchallenge #hf26challenge #hacktoberfest #opensource #localai #ollama #react #python