DEV Community: Sai Ganesh S T

👻 QueriumAI: The Ghost in Your Data — An AI Agent That Turns Natural Language into SQL, Visualizations & Insights

Sai Ganesh S T — Sat, 31 Oct 2026 16:49:27 +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/saiganeshst/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. 👻📊

SlowSort — A direct, clean simplification that still keeps the relaxed core concept.

Sai Ganesh S T — Sun, 25 Oct 2026 18:25:28 +0000

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

What I Built

🦥 SlowSort — A direct, clean simplification that still keeps the relaxed core concept.

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/saiganeshst/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. 🦥