DEV Community: vaishnavi Banthe

PhantomShell AI

vaishnavi Banthe — Tue, 27 Oct 2026 11:09:40 +0000

title: "PhantomShell AI: A Ghost in the Terminal 👻"
published: false
tags: devchallenge, hf26challenge

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

What I Built

👻 PhantomShell AI — Ghost in the Terminal

PhantomShell AI is a spooky terminal assistant designed to help beginners understand Linux commands and recognize potentially dangerous operations.

Inspired by the Ghost in the Machine theme, I wanted to make learning terminal safety more engaging while helping users understand what commands might do before they run them.

Key Features

💻 Beginner-friendly explanations of terminal commands.
🛡️ Risk classification for potentially dangerous operations.
👻 A spooky terminal-inspired interface.
📜 Local interaction history using SQLite.
🌙 Lightweight design intended to work without downloading large AI models.
🧪 Automated tests for core functionality.

The application is designed to analyze submitted commands rather than execute them.

Demo

GitHub Repository:
https://github.com/banthevaishnavi/PhantomShell_AI

Live Demo:

Screenshots:

Code

Explore the source code:

https://github.com/banthevaishnavi/PhantomShell_AI

The project uses Python and Streamlit for the interface, SQLite for local history, and a separate safety-analysis module.

How I Built It

I built PhantomShell AI with a focus on simplicity, limited hardware resources, and beginner-friendly security education.

The project uses:

Python for application logic.
Streamlit for the interactive interface.
SQLite for local storage.
pytest for automated testing.
GitHub for source control.

One important design decision was to avoid requiring users to download large model weights onto their computers.

The current implementation uses deterministic explanations and command-safety rules when no inference backend is configured. These rules operate locally and do not require an external AI service.

A genuine open-weight model inference integration remains necessary for the project to fully meet this challenge's central AI requirement.

Why Does Open Innovation Matter?

Open innovation gives developers the freedom to inspect, modify, and extend the tools they build with.

For PhantomShell AI, a lightweight local architecture means that command analysis and history can remain on the user's machine without requiring a cloud service.

It also allows the project to evolve: a compatible open-weight model can be integrated without redesigning the entire application.

The goal is to keep the tool accessible to developers with limited hardware resources while maintaining control over how commands are analyzed and how user data is stored.

The current deterministic implementation works without an AI service, but it does not replace the need for genuine open-weight inference to satisfy the challenge.

The Spirit of It 👻

A terminal can feel intimidating when you're learning Linux. A single unfamiliar command can look like a spell, and some commands can have serious consequences.

PhantomShell AI turns that experience into a small encounter with a helpful ghost: one that explains commands, highlights risks, and encourages users to understand before executing.

The idea is simple: make terminal learning less intimidating while encouraging safer computing habits.

Prize Categories

Overall challenge: submission intended for consideration.
Partner categories: none claimed at this stage.

What's Next?

My next step is to integrate and test a genuine open-weight inference backend that fits the project's lightweight design.

I'd love to hear suggestions for improving command-risk detection, beginner-friendly explanations, and privacy-conscious AI integration.

Thanks for checking out PhantomShell AI! 👻

Lazy Ticket AI

vaishnavi Banthe — Wed, 21 Oct 2026 11:34:29 +0000

title: "LazyTicket AI: Automate Support Tickets with Open-Weight AI"
published: false
tags: devchallenge, hf26challenge, opensource, python

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

What I Built

🎫 LazyTicket AI — Stop managing tickets. Let AI do the busywork.

Support teams spend valuable time reading tickets, identifying issues, assigning priorities, summarizing complaints, and drafting responses.

I built LazyTicket AI to automate these repetitive tasks using open-weight AI. Instead of processing tickets manually, users can process a batch with a single action.

Key features include:

AI classification: Categorizes tickets into bugs, billing, account issues, technical support, and general inquiries.
Smart prioritization: Assigns priority levels based on ticket content.
Sentiment analysis: Identifies customer frustration and emotional tone.
Automatic summaries: Converts lengthy descriptions into concise summaries.
Response drafting: Generates suggested replies for human review.
Duplicate detection: Identifies potentially duplicated tickets using text similarity.
Smart routing: Recommends the appropriate support team.
Dashboard and CSV support: Tracks processing results and supports bulk ticket import and export.

The goal is simple: spend less time organizing tickets and more time solving problems.

Demo

🎬 Project demonstration

The demonstration will show the ticket dashboard, batch processing, AI-generated results, and exported ticket data.

Code

💻 GitHub Repository:
https://github.com/banthevaishnavi/lazyticketai

The project is built with Python and Streamlit, with SQLite for persistent storage and an open-weight AI model for ticket analysis.

How I Built It

I built LazyTicket AI using Python, Streamlit, SQLite, Pandas, and scikit-learn.

The AI component uses Gemma, an open-weight model, through a configurable inference provider. The application sends ticket descriptions for analysis and uses the returned results to classify tickets, determine priority, analyze sentiment, generate summaries, recommend support teams, and draft responses.

SQLite stores ticket information and processing results. TF-IDF and cosine similarity help identify potentially duplicated tickets.

The workflow is straightforward:

Import or select support tickets.
Run the automation.
Review the generated classifications, summaries, priorities, and responses.
Edit results when necessary.
Export the processed tickets.

The application is designed to keep humans in control of important decisions. Generated responses remain drafts rather than being sent automatically.

Why Does Open Innovation Matter?

Open-weight AI gives developers more flexibility in how they build and operate AI-powered applications.

For LazyTicket AI, it provides several advantages:

Model flexibility: The AI component can be adapted to compatible open-weight models.
Reduced API dependence: The project is not inherently tied to a single proprietary model provider.
Cost awareness: Open-weight models can reduce per-request inference costs, depending on how they are hosted.
Greater control: Local inference can help keep ticket data on the user's machine.
Learning and experimentation: Developers can modify prompts and experiment with different models.

My implementation uses a configurable inference provider, so privacy and cost benefits depend on the selected deployment. Hosted inference sends ticket data to the selected provider, whereas local inference can keep processing on the user's machine.

Open innovation makes it easier to experiment, adapt, and build practical automation without locking the entire application to one closed AI ecosystem.

My Agent Session

Optional: Add a DevRelay agent session here if available.

The Lazy Payoff

Imagine manually processing 20 support tickets. Each one requires reading the description, identifying the issue, deciding its urgency, summarizing it, and preparing a response.

LazyTicket AI brings these steps into one batch-processing workflow.

Instead of repeating the same administrative tasks for every ticket, a support worker can review AI-generated results together and focus on cases that need human attention.

The actual time saved depends on ticket complexity, model latency, and the amount of review required. Performance claims should be based on measured results rather than unverified estimates.

Built with Python, Streamlit, SQLite, and open-weight AI.

devchallenge #hf26challenge

RFQFlow AI: Automating RFQ Email Processing with Python and Open-Weight AI

vaishnavi Banthe — Sat, 17 Oct 2026 10:38:05 +0000

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

RFQFlow AI: Automating RFQ Email Processing

What I Built

Businesses receive Request for Quotation (RFQ) emails containing customer details, product specifications, quantities, currencies, and delivery dates.

Manually extracting this information, validating it, detecting duplicates, and transferring it into an ERP system can be repetitive and time-consuming.

I built RFQFlow AI, a lightweight application that demonstrates how this workflow can be automated.

The application processes synthetic RFQ emails, extracts structured information, validates fields, detects duplicates, stores records in SQLite, and routes eligible records to a mock ERP service.

Incomplete records are flagged for human review instead of being silently accepted.

Live Demo

🚀 Try the application:

https://banthevaishnavi-rfqflow-ai-app-rp7isz.streamlit.app/

Code Repository

💻 GitHub:

https://github.com/banthevaishnavi/rfqflow-ai

Screenshots

1. RFQFlow AI Dashboard

The dashboard provides an overview of processed RFQs, including validated records, records requiring review, duplicates, and ERP submission statuses.

2. Human Review and Mock ERP

Incomplete RFQs can be reviewed by a human. Eligible records can be submitted to the mock ERP service, which returns a simulated success response.

3. RFQ Validation and Duplicate Detection

The application allows users to filter records by status and inspect duplicate RFQs.

How I Built It

The project uses:

Python for processing and business logic.
Streamlit for the interactive dashboard.
SQLite for local database storage.
FastAPI for the mock ERP service.
Pytest for automated testing.
Ollama and Gemma for optional local open-weight model integration.

The default extraction mode uses deterministic rules. An optional integration can send email text to a locally hosted model through Ollama.

Regardless of the extraction method, the application validates the resulting fields and flags missing information for review.

Why Does Open Innovation Matter?

Open innovation gives developers greater flexibility in how AI applications are built and deployed.

For RFQ processing, locally hosted open-weight models offer several potential benefits:

Privacy: A properly configured local inference setup can keep email contents on infrastructure controlled by the business rather than sending them to an external model API.

Cost control: Businesses can evaluate local inference instead of relying entirely on paid AI APIs. Actual costs depend on hardware and operational requirements.

Flexibility: Developers can experiment with different models and adapt the extraction workflow to different email formats, subject to each model's license.

Human oversight: Commercial workflows require more than extracting text. Validation, duplicate detection, and human review help prevent incomplete information from being treated as reliable business data.

This project demonstrates the surrounding workflow and provides an optional integration path for local open-weight inference. The default extraction mode is deterministic; the screenshots do not claim that a language model generated the displayed results.

What I Learned

Building RFQFlow AI helped me explore how email processing, structured data extraction, validation, database persistence, human review, and ERP integration can work together.

It also reinforced the importance of handling missing information and duplicates before allowing records to proceed to the next stage.

Future Improvements

Potential improvements include:

Connecting Outlook through Microsoft Graph with appropriate authorization.
Evaluating extraction quality using a locally hosted open-weight model.
Adding authentication and audit logging.
Integrating with a test ERP environment.
Improving error handling and production readiness.

These are future improvements and are not part of the current demo.

Thanks for checking out RFQFlow AI!