DEV Community: Neha Bohrapi

GhostShell AI

Neha Bohrapi — Sat, 31 Oct 2026 13:41:14 +0000

👻 GhostShell: A Friendly Ghost That Warns You Before You Run Terminal Commands

Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine

Have you ever copied a command from Stack Overflow, a GitHub README, or a random tutorial and pasted it into your terminal without fully understanding what it does?

I have seen how easy it is to run a command first and ask questions later. A few characters can mean the difference between listing files and deleting them recursively, or between changing permissions and exposing an entire directory.

That inspired GhostShell: a friendly, ghost-themed AI assistant that explains terminal commands before you run them.

Instead of executing commands, GhostShell analyzes them, identifies potential risks, explains their flags in beginner-friendly language, and suggests safer next steps.

Think of it as a little ghost sitting beside your terminal, whispering:

“Wait a second. Do you know what this command is about to do?” 👻

🎬 Demo

GitHub repository: https://github.com/nehabohrapi/ghostshell-ai
GhostShell uses a purple-and-black terminal-inspired interface, a floating ghost, atmospheric fog, and a glowing risk indicator to make command analysis approachable rather than intimidating.

Try it locally by following the setup instructions below.

🛠️ What I Built

GhostShell is a local-first, AI-assisted terminal command analyzer built with Python and Streamlit.

Its purpose is to help developers understand potentially dangerous commands before running them, especially when they are learning Linux, Git, shell scripting, or developer tooling.

Key features

Rule-based risk detection: Approximately 40 patterns identify potentially dangerous command structures, including recursive deletion, disk formatting, privilege escalation, reverse shells, destructive Git operations, and curl | bash patterns.
Local AI explanations: An open-weight model, Qwen2.5 1.5B by default, runs through Ollama to explain commands in plain English.
Flag glossary: Explains flags such as -r, -f, and --hard, including combined flags such as -rf.
Safer next steps: Provides context about potential consequences and suggests more cautious alternatives where appropriate.
Graceful fallback: If Ollama is unavailable or the AI response fails validation, GhostShell falls back to rule-based explanations.
Safety-aware response validation: Rejects AI explanations that incorrectly describe a command as completely safe or risk-free.
Ghost-themed UI: Includes a terminal-inspired visual design, risk indicators, and reduced-motion-friendly effects.

One design decision is especially important: GhostShell never executes the command it analyzes.

It is an educational and preventive tool, not a shell, terminal agent, or automatic command runner.

🧠 How the AI and Rules Work Together

I designed GhostShell with a clear separation of responsibilities: deterministic rules classify risk, while the language model makes the explanation easier to understand.

Responsibility	Component	Why it matters
Risk classification	Rule engine	Provides deterministic, testable findings
Command explanation	Local AI model	Converts technical syntax into beginner-friendly language
Flag interpretation	Built-in glossary	Explains common options and combined flags
Consequences and safer steps	AI informed by rule findings	Makes warnings more useful and actionable
Fallback and response validation	Application logic	Avoids relying entirely on model-generated output

1. The rule engine: identify potential danger

The rule engine in safety.py analyzes commands against patterns associated with risky operations.

The classification levels are High, Medium, Low, and Unknown.

There is deliberately no Safe category. A command that does not match a known dangerous pattern has not thereby been proven harmless.

2. The local AI: explain what the command means

The AI integration in ghost_ai.py uses an Ollama-served model to generate natural-language explanations.

Rather than asking the model to determine risk entirely on its own, GhostShell supplies the rule findings and relevant flag glossary information as context.

The model can then explain:

What the command appears to do.
What its flags and arguments mean.
What could go wrong.
Which safer steps a beginner should consider before proceeding.

The model is also instructed to treat the submitted command as untrusted data, reducing the risk of command text being interpreted as instructions to the AI.

Application-level validation rejects outputs that claim a command is entirely safe or risk-free. If the model is unavailable or produces an unacceptable response, GhostShell can use rule-based explanations instead.

This separation helps prevent the language model from simply talking its way out of a rule-based warning. It does not eliminate every possible classification or explanation error, so users should still inspect unfamiliar commands.

🏗️ How I Built It

GhostShell uses a small, modular Python architecture.

app.py — Streamlit interface and user interaction.
safety.py — Risk detection rules, command analysis, and flag glossary.
ghost_ai.py — Ollama integration, AI response validation, and fallback handling.
prompts.py — System prompt and prompt construction.
tests/ — Automated tests for command analysis and application behavior.

The application combines deterministic Python logic with local language-model inference. This allows the rule engine to remain testable while the AI focuses on making its findings understandable.

Technology stack

Technology	Purpose
Python	Core application and rule engine
Streamlit	Interactive user interface
Ollama	Local model serving
Qwen2.5 1.5B	Default open-weight language model
pytest	Automated testing

🚀 Quick Start

Prerequisites

Install Python and Ollama.

1. Clone the repository

git clone https://github.com/nehabohrapi/ghostshell-ai.git
cd ghostshell-ai/ghostshell

2. Create a virtual environment

On Linux or macOS:

python -m venv .venv
source .venv/bin/activate

On Windows:

python -m venv .venv
.venv\Scripts\activate

3. Install dependencies

pip install -r requirements.txt

4. Download the default model

ollama pull qwen2.5:1.5b

Make sure the Ollama service is running.

5. Launch GhostShell

streamlit run app.py

Open http://localhost:8501 in your browser.

Try entering rm -rf * to see how GhostShell analyzes a command associated with destructive file deletion. Do not execute it as an experiment.

Configuration

Variable	Default	Purpose
`OLLAMA_HOST`	`http://localhost:11434`	Ollama server address
`GHOSTSHELL_MODEL`	`qwen2.5:1.5b`	Model used for explanations

Other Ollama-supported models may work, depending on their availability and compatibility. Larger models, such as Qwen2.5 3B or Llama 3.2 3B, may provide different explanation quality but require additional system resources.

🧪 Testing

GhostShell includes a pytest suite covering important behaviors, including:

High, Medium, Low, and Unknown risk classification.
Chained commands and command substitution.
Flag expansion and interpretation.
Input validation.
AI response parsing.
Fallback behavior when the AI is unavailable or returns an invalid response.
Rejection of claims that a command is completely safe.
UI smoke testing, including HTML escaping.

Run the tests with:

bash pytest``

The goal is to test not only expected command classifications but also edge cases and failure paths.

🌍 Why Does Open Innovation Matter?

I wanted GhostShell to be more than an interface wrapped around a closed AI API.

Using an open-weight model through Ollama makes local inference possible. Developers can experiment with supported models, inspect the surrounding application logic, and adapt the tool without making a hosted proprietary model API a requirement for its default workflow.

Open-source technologies also make the safety logic easier to inspect and improve. Contributors can add patterns, test edge cases, review fallback behavior, and propose better explanations.

This is particularly important for a command-analysis tool. Users should be able to understand how warnings are generated instead of blindly trusting a model's confidence.

The combination of a deterministic rule engine and a local language model reflects the kind of innovation I want to explore: systems where AI adds usability, but important decisions are supported by explicit logic and testable behavior.

Open innovation makes that experimentation accessible to more developers—and gives the community a way to challenge, improve, and extend the design.

🕯️ The Spirit of the Ghost

The terminal can be intimidating when you're learning.

You find a command that promises to fix an error or install a tool. It looks short. Someone online says it works. You copy it, paste it, and hope for the best.

But what if you had a friendly guide who explained the command before you took that step?

That is the spirit behind GhostShell.

The ghost isn't there to stop developers from learning or to frighten them away from powerful tools. It's there to encourage a pause—a moment to understand what a command does, what its flags mean, and what consequences it might have.

I also wanted the experience to feel welcoming. A playful ghost, atmospheric visuals, and approachable explanations turn command inspection into something less intimidating for beginners.

The project follows one simple principle:

Understand first. Execute only when you're confident.

And GhostShell itself never executes anything for you.

⚠️ Limitations and Responsible Use

GhostShell is an educational command analyzer, not a formal security guarantee.

It analyzes command text; it does not inspect the contents of referenced scripts, resolve every alias, or determine what a remote URL will return.
Pattern-based detection can miss unfamiliar commands and obfuscated behavior.
Low and Unknown risk ratings do not mean a command is safe.
A small language model may misunderstand unusual syntax or produce incomplete explanations.
The rules primarily target Linux and macOS shells, with some Windows patterns.
Users should consult trusted documentation, such as man pages or --help, when uncertain.

The tool is designed to support judgment, not replace it.

🤝 Contributing

GhostShell is designed to be approachable for first-time contributors.

One of the easiest ways to contribute is to add a well-tested detection rule.

Add a rule using the existing _r(...) pattern in safety.py.
Add corresponding test cases to tests/test_safety.py.
Run the test suite with pytest.
Submit a pull request explaining the behavior and the cases covered.

Other useful contributions include:

More Windows and PowerShell patterns.
Docker and Kubernetes command analysis.
SQL operations such as DROP.
Better handling of shell-specific syntax.
Improved explanations and translations.
Additional edge-case and regression tests.

The goal is to make GhostShell more useful without pretending that a finite set of rules can identify every dangerous command.

🔒 Privacy

With the default local setup, commands are sent to the Ollama server configured for GhostShell, normally running on the same machine.

This avoids sending command text to a hosted language-model API as part of the default explanation workflow. If you configure Ollama to use a remote server, the privacy implications change.

Streamlit may collect anonymous usage statistics unless disabled in its configuration.

🏆 Challenge and Project Links

Challenge: Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine

Project: GhostShell on GitHub

Prize categories:aourdino Q board

Final Thoughts

GhostShell is my attempt to make terminal commands a little less mysterious.

By combining rule-based risk detection, local AI explanations, flag documentation, response validation, and a friendly interface, I wanted to build something that helps developers learn while encouraging more careful decisions.

It is not a replacement for understanding the terminal. It is a tool to help build that understanding.

Because sometimes, the best AI assistant isn't the one that executes a command for you.

It's the one that explains what could happen before you press Enter.

Meet GhostShell. Summon the explanation, not the execution. 👻

Happy Hacktoberfest!

"SlothBrief: A Local AI Assistant That Reads Your Documents for You"

Neha Bohrapi — Sun, 25 Oct 2026 21:30:26 +0000

*---
title: "SlothBrief: A Local AI Assistant That Reads Your Documents for You"
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

Meet SlothBrief 🦥, a local AI assistant designed to make working with documents less tedious.

Instead of opening multiple files and manually searching for important information, SlothBrief lets users load a folder of PDF, TXT, and Markdown files, generate a concise summary, and ask questions about the loaded documents.

The goal is simple: let AI handle the repetitive first pass so people can spend more time on the work that matters.

Demo

Coming soon: I'll add a short screen recording showing SlothBrief scanning sample documents, generating a brief, and answering a question.

Code

GitHub repository:

How I Built It

SlothBrief is built with:

Python for the application logic.
Streamlit for the user interface.
Ollama for running an AI model locally.
Llama 3.2 3B as the example open-weight model.
pypdf for extracting text from PDF files.

The workflow is straightforward:

Select a local folder containing supported documents.
Extract text from the files.
Pass the relevant document text to the locally running model.
Generate a short brief or answer a question using the supplied documents.
Download the brief as a Markdown file.

The project is designed to run without a hosted LLM API. The initial model download requires internet access, but inference can run offline once the model is installed locally.

Why Does Open Innovation Matter?

Documents can contain private notes, plans, and information that users may not want to send to a third-party AI service.

By using an open-weight model with local inference, SlothBrief gives users more control over where their document content is processed.

Open innovation also makes the project easier to inspect, modify, and extend. Users can experiment with different compatible models, customize the workflow, and build additional capabilities without depending entirely on a closed AI API.

There is also a cost advantage: local inference avoids per-request hosted LLM API charges, although it still uses the computer's processing power, memory, and electricity.

For me, the important part is having the freedom to experiment and build around the model instead of treating AI as a black box.

My Agent Session

I'll add a DevRelay session link here if I capture one during development.

The Lazy Payoff

SlothBrief aims to reduce the repetitive work of opening documents, identifying key points, and writing an initial summary.

Instead of manually reviewing every file first, users can start with a compact brief and ask follow-up questions.

I'll compare the time required to review the same set of documents manually versus using SlothBrief and share the results after testing.

The idea is not to avoid reviewing important information. It's to make the first pass easier.

Prize Categories

Multiagentic Chatbot

Neha Bohrapi — Mon, 19 Oct 2026 04:37:07 +0000

Multiagentic Chatbot: A Document-Grounded AI Assistant

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

What I Built

I built a Multiagentic Chatbot that helps users ask questions about their own documents and get context-aware, evidence-grounded answers.

Traditional document-based chatbots can struggle with ambiguous questions, multi-part queries, and retrieving the right information from large documents. I wanted to build a system that handles these challenges through a custom multi-agent workflow instead of relying entirely on a ready-made RAG pipeline.

The chatbot is designed to:

Answer questions using uploaded documents.
Retrieve relevant evidence using hybrid search.
Handle summaries, comparisons, follow-up questions, and clarification.
Generate answers with document-based citations.
Validate citations before returning an answer.
Maintain conversation context for follow-up questions.

Who is it for? Students, researchers, and professionals who need to extract useful information from PDFs and other supported documents without manually searching through every page.

The long-term goal is to make document-based research faster, more reliable, and easier to use.

Demo

Live demo: [Add your deployed application link]

Demo video: [Add a short walkthrough video, if available]

The application currently uses a Streamlit interface. Add a publicly accessible demo link once the deployment is ready.

Code

GitHub Repository: Multiagentic System

The project focuses on building a custom backend workflow with explicit routing, retrieval, evidence curation, answer generation, and validation.

How I Built It

I built the backend around a custom multi-agent architecture using Python and LangGraph, with Streamlit as the user interface.

Architecture

Document Ingestion: Extracts text and prepares uploaded documents for retrieval.
Orchestrator: Determines whether the query needs a direct response, clarification, a summary, or document retrieval.
Retrieval Workers: Search document content using vector retrieval and keyword-based search.
Evidence Curation: Combines relevant results, removes redundant evidence, and ranks passages.
Answer Generation: Produces an answer grounded in the retrieved evidence.
Citation Validation: Checks citation references against the available evidence before returning the response.

Tech Stack

Language:Python
Agent orchestration:LangGraph
Interface:Streamlit
Vector database:ChromaDB
Keyword retrieval and local state:SQLite / FTS5
Embeddings and reranking:Sentence Transformers
LLM inference:Groq API with a configurable model

The central design decision is to make the workflow explicit. Rather than sending every question through the same sequence of LLM calls, the orchestrator routes each query according to its needs. This helps avoid unnecessary model calls for simpler questions while reserving additional verification for answers that need it.

Why Does Open Innovation Matter?

Open innovation made it possible to build and customize the individual parts of the system instead of treating document question-answering as a black box.

Frameworks such as LangGraph, ChromaDB, and Sentence Transformers provide building blocks that can be inspected, tested, and adapted. This gives me more control over how queries are routed, how evidence is retrieved, and how citations are checked.

Using open-source components also makes experimentation more accessible. I can improve retrieval strategies, replace models, evaluate failure cases, and modify the architecture without rebuilding the entire application from scratch.

For me, this project is also a way to learn how AI systems work beyond a single prompt and model call.

Built as part of my journey toward creating practical, reliable AI applications with open-source tools.

🌿Simple Voice Care Assistant

Neha Bohrapi — Mon, 12 Oct 2026 06:33:46 +0000

🌿 Simple Voice Care Assistant: AI That Helps You Step Away From the Screen

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

What I Built

We spend so much time looking at screens that even simple daily activities can become difficult to manage without checking our phones repeatedly.

I wanted to explore how AI could make everyday routines simpler and more accessible, especially for elderly people and individuals who may benefit from voice-based assistance.

That's the idea behind Simple Voice Care Assistant — a voice-first assistant designed to help users manage everyday routines through natural language instead of relying entirely on a screen.

The project aims to support:

🎙️ Voice interaction: Communicate with the assistant using voice.
💊 Medicine reminders: Help users remember their medication schedules.
🥗 Daily routine reminders: Support regular meals and hydration.
📚 Context-aware answers: Use Retrieval-Augmented Generation (RAG) to answer questions based on relevant information.
🔊 Voice responses: Make information accessible without requiring users to read everything on a screen.

How does it help people touch grass?

The goal isn't to build another chatbot that keeps people online longer. It's to explore how voice-based AI can make technology less intrusive, help users maintain daily routines, and encourage them to take breaks from screens.

The project is intended as a starting point for a more accessible, hands-free assistant.

Demo

🚧 Live demo: [Add your deployed application link]

🎥 Video demonstration: [Add your demo video, if available]

The demo will showcase the voice interaction flow and the daily routine assistance supported by the implemented features.

Code

💻 GitHub Repository:

The project is being developed with a focus on simplicity, accessibility, and open-source AI components.

How I Built It

The assistant is designed around a voice-based interaction pipeline and a Retrieval-Augmented Generation (RAG) architecture.

The planned workflow is:

Voice input: Capture the user's spoken query and convert it into text.
Information retrieval: Retrieve relevant information from a knowledge base using embeddings and vector search.
Context-aware response: Use an LLM to generate an answer grounded in the retrieved information.
Voice output: Convert the response into speech so users can listen instead of reading.
Daily reminders: Support routine reminders for medicines, meals, and hydration.

Technology Stack

Python — Core application logic
Streamlit — Simple user interface
ChromaDB — Vector storage and retrieval
Embeddings — Semantic search over relevant information
Open-source/local LLM — Language generation
Speech-to-text and text-to-speech — Voice interaction

The exact models and integrations will be documented according to the components used in the working implementation.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to experiment with AI without depending entirely on closed, proprietary APIs.

For a project like this, open-source tools offer several advantages:

Accessibility: Developers can experiment with different models and components.
Flexibility: Individual parts of the system can be replaced or improved independently.
Learning: Building the retrieval and response pipeline helps me understand how AI applications work beyond simply calling an API.
Community collaboration: Other developers can contribute improvements, suggest features, and help make the assistant more useful.

My goal is to keep the project simple enough to understand and extend while exploring how open-source AI can support everyday life.

My Agent Session

This section is optional and can be removed if no session has been recorded.

What's Next?

Some improvements I would like to explore include:

Improving voice interaction and response accuracy.
Making reminders easier to configure.
Improving retrieval quality and reducing unsupported answers.
Exploring ways to encourage healthy breaks and offline routines.

This project is a small step toward exploring AI that supports people in their daily lives rather than demanding more of their attention.

Build with AI. Live beyond the screen. 🌱

AI Powered Personal Finance Manager💸

Neha Bohrapi — Sun, 04 Oct 2026 17:11:24 +0000

💰 AI Personal Financer — Built for a Friend

This is a submission for the [Hacktoberfest Weekend Challenge: Build for a Friend]

What I Built

I built AI Personal Financer, a personal finance assistant designed to help a friend who finds it difficult to understand where their money goes every month.

Managing expenses manually can be time-consuming, especially when transactions are spread across different statements and files. The goal of this project is to make personal finance tracking simpler and easier to understand.

The application allows users to upload their PDF or CSV transaction data and get useful insights from it.

It can help with:

📊 Expense analysis
🏷️ Expense categorization
💰 Monthly budget planning
📈 Spending reports and visualizations
🔮 Expense prediction
🤖 AI-powered financial assistance
📄 Processing uploaded PDF/CSV financial data

Instead of looking through a long list of transactions, the user can get a clearer picture of their spending habits and make better budgeting decisions.

Demo

🎥 Demo Video: https://drive.google.com/file/d/1RO2G2CSxfIBVnrnjMUmV14wQ8eCVhFL6/view?usp=drivesdk

🌐 Live Demo:https://aipoweredpersonalfinancer-awvxkdxzzzutxoek8p4eue.streamlit.app/

Code

💻 GitHub Repository:https://github.com/nehabohrapi/AI_Powered_Personal_Financer

The project is open source and available for others to explore, learn from, and contribute to.

How I Built It

I built the application using Python and Streamlit.

The application processes financial data from uploaded PDF and CSV files and uses Python-based data processing and machine learning techniques to generate insights.

Main technologies used

Python
Streamlit
Pandas
NumPy
Scikit-learn
Plotly
pdfplumber
FPDF2

For the machine-learning component, I used Multiple Linear Regression to work with monthly financial data and generate expense-related predictions.

The application also includes a chatbot component to make interacting with financial information more natural.

How it works

User uploads PDF / CSV
        ↓
Extract financial data
        ↓
Clean & preprocess data
        ↓
Categorize expenses
        ↓
Analyze spending patterns
        ↓
Generate charts & reports
        ↓
Budget / prediction insights
        ↓
AI-powered financial assistance

Why Does Open Innovation Matter?

Open innovation makes it possible for developers and students to build useful applications without having to create every component from scratch.

For this project, open-source libraries provided the building blocks for:

Data processing
Machine learning
PDF extraction
Data visualization
Application development

This allowed me to focus on solving the actual problem rather than rebuilding basic tools myself.

Open-source technology also makes the project easier for other developers to inspect, learn from, modify, and improve.

For students and independent developers especially, this accessibility makes experimentation with AI and machine learning much easier.

Prize Categories

[Add the partner prize categories you are entering here.]

1. SerpApi
2. MongoDB Atlas

What I Learned

Building this project helped me understand how machine learning and data processing can be applied to a real-world problem.

I worked with:

Data preprocessing
Exploratory data analysis
Feature engineering
Machine learning
Financial data analysis
Data visualization
PDF and CSV processing
Building an interactive application with Streamlit
Integrating AI into a practical application

More importantly, this project taught me that AI doesn't have to be used only for complicated or futuristic applications.

Sometimes, a simple problem like "Where did my money go this month?"can be a great starting point for building something genuinely useful.

Why I Built It for a Friend

I wanted to build something that could help someone close to me understand their finances without needing to manually analyze every transaction.

The idea was simple:

Take complicated financial data and turn it into information that is easier to understand and act on.

That became the motivation behind AI Personal Financer.

Final Thoughts

AI Personal Financer started as a project to experiment with machine learning and financial data, but it became much more meaningful when I focused on solving a real problem for someone I know.

The Hacktoberfest Build for a Friend challenge gave me the opportunity to take that idea and turn it into a practical open-source project.

I hope the project can help people understand their spending better and encourage more developers to build technology around real problems faced by the people around them.

🔗 Project Links

GitHub:https://github.com/nehabohrapi/AI_Powered_Personal_Financer
Live Demo://aipoweredpersonalfinancer-awvxkdxzzzutxoek8p4eue.streamlit.app/
Demo Video: https://drive.google.com/file/d/1RO2G2CSxfIBVnrnjMUmV14wQ8eCVhFL6/view?usp=drivesdk