DEV Community: samruddhi

# 👻 GhostShell AI: A Haunted Terminal Powered by Local AI

samruddhi — Fri, 30 Oct 2026 16:56:45 +0000

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

What I Built

I built GhostShell AI, a haunted terminal powered by local AI. 👻

The idea is simple: instead of treating the terminal as just a developer tool, I imagined a ghost living inside the machine that reacts whenever you enter a command.

Users can enter commands such as:

git status

GhostShell analyzes the command and uses a local AI model to generate a spooky response while briefly explaining what the command normally does.

The project includes three ghost personalities:

👻 Whispering Ghost
💀 Angry Poltergeist
🧙 Ancient Programmer

I interpreted the "Ghost in the Machine" theme by turning normal developer interactions into a supernatural conversation with a ghost trapped inside the computer.

Demo

🎥 Video Demo: Add your demo video link here.

The demo shows GhostShell AI running locally, entering terminal commands, changing ghost personalities, and receiving AI-generated spooky responses.

Code

💻 GitHub Repository:

https://github.com/Samruddhipathrikar/GhostShellAI

The complete source code is available in the repository.

How I Built It

GhostShell AI is built using:

Python
Streamlit for the user interface
Ollama for local AI inference
Llama 3.2 3B as the open-weight AI model
Python subprocess to communicate with the local Ollama installation

The application works like this:

User enters a command
        ↓
Command Analyzer
        ↓
Command Classification
        ↓
Ghost Personality
        ↓
Ollama + Llama 3.2 3B
        ↓
Spooky AI Response
        ↓
Haunted Terminal UI

I also added command classification for:

Developer commands
System commands
Potentially dangerous commands
Unknown commands

GhostShell does not execute the commands entered by the user. It only analyzes the command and generates a response.

This keeps the project focused on creating an AI-powered terminal experience without giving the AI direct control over the user's system.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with AI locally instead of depending completely on a closed cloud API.

Using an open-weight model with local inference gave me more control over the AI experience and allowed me to customize the prompts, personalities, and behavior of the application.

It also makes experimentation more accessible because the project does not require a paid cloud AI API for every interaction.

For GhostShell AI, this was especially important because the idea is about a ghost living inside the machine. Running the AI locally makes that concept feel much more natural.

My Agent Session

I used DevRelay while working on the project and exploring the Hacktoberfest challenge workflow.

Agent Session: Add the DevRelay session link here if available.

The Spirit of It

The idea behind GhostShell AI came from a simple question:

What if your terminal wasn't just a tool, but actually had a personality? 👻

Instead of simply seeing:

git status

you get a response from something that feels like a ghost trapped inside your computer.

👻 "The repository reveals its unfinished business..."

The goal was to combine something developers use every day with a little Halloween-style mystery and humor.

That is the spirit of GhostShell AI — making an ordinary developer workflow feel slightly supernatural.

Prize Categories

Open-Source AI / Local AI
Ghost in the Machine
AI-powered developer experience

Thanks for checking out GhostShell AI! 👻💻

SlothSort-AI-Let-AI-Organize-Your-Files-While-You-Do-Nothing

samruddhi — Wed, 21 Oct 2026 14:07:56 +0000

What I Built
I built SlothSort AI, a local AI-powered file organizer that helps users organize messy folders without manually opening, understanding, renaming, and sorting every file.

SlothSort AI scans a selected folder and supports files such as PDF, DOCX, TXT, CSV, and XLSX. It reads the file contents and uses local AI to understand the documents and help classify them.

The goal is simple: let AI handle the boring file organization while you do less work. 🦥
Demo
🎥 Demo video: Coming soon

The application is currently being developed and tested locally using Streamlit and Ollama.
Code
SlothSort AI GitHub Repository
How I Built It
I built SlothSort AI using Python, Streamlit, and Ollama.

For local AI processing, I use the Llama 3.2 3B open-weight model through Ollama.

The project uses different Python libraries to read different file formats:

PDF → PyPDF
DOCX → python-docx
TXT → Python file handling
CSV → Python CSV module
XLSX → openpyxl The basic workflow is:

Select Folder → Scan Files → Read Content → AI Classification → Suggest Organization → User Review → Organize Files

The local AI approach allows the application to work with document content without requiring a cloud AI API for every file.
Why Does Open Innovation Matter?
Open innovation makes it possible to build an AI-powered file organizer using local, open-weight AI instead of depending completely on a closed AI API.

Documents can contain private information such as resumes, certificates, financial records, educational documents, and work files.

Using local AI provides more control over how that information is processed.

It also allows developers to:

Experiment with different open-weight models
Customize AI prompts and classification logic
Modify the application according to their needs
Add support for new file formats
Contribute improvements to the open-source project
Avoid depending on a single closed AI provider For SlothSort AI, open innovation makes AI more accessible, customizable, and useful for personal productivity. My Agent Session Not used for this project. The Lazy Payoff Organizing files manually can involve a lot of repetitive work:

Open file → Read file → Understand it → Rename it → Create folder → Move it

SlothSort AI aims to reduce that process to:

Select folder → Scan → Let AI understand the files → Review → Organize → 🦥 Relax

The project is designed around the idea that repetitive and boring file-management tasks should require as little human effort as possible.

The less time spent organizing files, the more time there is to focus on useful work—or simply do nothing. 😴🦥

Local AI Document Assistant: Read, Search, and Chat with PDFs Using Local AI

samruddhi — Wed, 14 Oct 2026 13:59:17 +0000

Local AI Document Assistant: Read, Search, and Chat with PDFs Using Local AI

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

What I Built

I built Local AI Document Assistant, a Python-based application that combines a simple PDF reader with AI-powered document understanding.

Working with long PDF documents can be time-consuming. Finding specific information, understanding lengthy reports, and extracting invoice details often require manual effort. I wanted to build a tool that makes these tasks easier while allowing users to process documents locally.

Features

📖 Read PDF: Extract and view text from PDF documents.
🔍 Search Text: Find specific words and phrases.
🤖 Ask AI: Ask questions about a document and get answers based on its content.
📝 Summarize PDF: Generate short, medium, or detailed summaries.
🧾 Extract Invoice Details: Extract invoice numbers, dates, customer and seller names, subtotal, tax, total amount, and currency.
⬇️ Download Results: Download extracted text, summaries, and invoice data.

Who Could Benefit?

Students can use it to understand study materials and reports. Freelancers and professionals can search project documents, while small businesses can experiment with extracting information from invoices.

Potential customers could include freelancers, small businesses, and professionals who regularly work with documents. Possible future business models include a premium desktop tool or a customized document-processing solution. The project is currently a prototype, and I have not yet validated a paid business model.

Demo

The application currently runs locally on my computer.

GitHub repository: https://github.com/Samruddhipathrikar/local-ai-document-assistant
Live demo: Not deployed yet.

The application can be launched locally using Streamlit and Ollama.

Code

GitHub: Local AI Document Assistant

The source code includes the Python application, PDF text extraction, the Streamlit interface, and integration with a locally running AI model.

How I Built It

I used Python and open-source tools to build a web interface for PDF processing and local AI inference.

Technologies

Python — application logic.
Streamlit — interactive web interface.
PyMuPDF — PDF text extraction.
Ollama — local model execution and API access.
Qwen2.5 3B — open-weight language model.
Requests — communication with the Ollama API.
Pandas — invoice data handling and CSV downloads.

How It Works

A user uploads a PDF.
PyMuPDF extracts the document's selectable text.
The user chooses to read, search, summarize, ask questions, or extract invoice details.
The application sends the relevant text and instructions to the local Qwen model through Ollama.
The response is displayed in the Streamlit interface.
Users can download supported results.

I selected a small language model to experiment with local inference on my personal computer without depending on a paid cloud AI API.

The current version works best with text-based PDFs. OCR for scanned documents is a potential future improvement.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to individual developers and small teams.

Using an open-weight model with Ollama allowed me to experiment with local AI inference, build a practical application around an existing model, and learn how to integrate AI into a Python application without training a model from scratch.

It also gave me more control over where document processing happens. In this application, document text is processed through a locally running Ollama service rather than a cloud AI API.

This project helped me explore how open-source AI tools can be combined to solve everyday problems with limited resources.

What I Learned

While building this project, I explored:

Integrating a local language model into a Python application.
Extracting text from PDF documents.
Designing prompts for question-answering, summarization, and structured extraction.
Handling JSON responses and downloadable CSV files.
Combining traditional document processing with AI features in one interface.

What's Next?

I would like to improve the project by adding:

OCR support for scanned PDFs.
Better support for long documents and multiple PDFs.
Page references for AI-generated answers.
More reliable extraction and validation.
A polished interface and a public demo.

This is an ongoing project, and I look forward to improving it through testing and feedback.

Thanks for checking out my submission!

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

🌱 TouchGrass AI: Stop Scrolling, Start Exploring

samruddhi — Thu, 08 Oct 2026 16:10:11 +0000

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

🌱 TouchGrass AI — Stop Scrolling. Start Exploring.

What I Built

I built TouchGrass AI, a local AI-powered outdoor activity companion designed to help people spend less time on screens and more time in the real world.

The idea is simple:

Use AI for a few seconds → get an outdoor mission → put the phone away → go outside. 🌱

The user chooses:

⏱️ How much time they have
🌿 What outdoor activity they want
👥 Who they are with

TouchGrass AI then uses a locally running AI model to generate a short, practical outdoor mission.

For example, a user with 30 minutes who chooses Nature can receive a simple nature exploration challenge with 3–5 steps.

The project is designed for anyone who wants a quick reason to walk, explore, observe nature, or spend time outdoors with friends and family.

The goal isn't to create another app that keeps users chatting with AI.

The goal is to make the screen the shortest part of the experience.

Demo

The project currently runs locally using Streamlit and Ollama.

I will include a short screen recording showing:

Selecting the available time
Selecting an outdoor activity
Selecting who I'm with
Generating an outdoor mission
Taking the generated mission outside

Code

The complete source code is available on GitHub:

https://github.com/Samruddhipathrikar/TouchGrassAI

The repository contains the Streamlit application and its dependencies.

How I Built It

I built TouchGrass AI using Python, Streamlit, Ollama, and the open-weight Llama 3.2 3B model.

Tech Stack

Python
Streamlit
Ollama
Llama 3.2 3B
Requests

The user interacts with a simple Streamlit interface.

The application collects the user's:

Available time
Preferred outdoor activity
Company

These inputs are converted into a prompt for the local Llama 3.2 model.

The application sends the prompt to Ollama through its local API:

http://localhost:11434/api/chat

The generated response is then displayed as the user's outdoor mission.

Architecture


text
User
  ↓
Streamlit UI
  ↓
Time + Activity + Company
  ↓
Prompt
  ↓
Ollama Local API
  ↓
Llama 3.2 3B
  ↓
Outdoor Mission
  ↓
🌱 Go Outside