DEV Community: Rushindhra Marri

GHOST: A Private AI Memory Guardian That Never Leaves Your Computer

Rushindhra Marri — Wed, 28 Oct 2026 11:28:13 +0000

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

What I Built

Most of the stories in my family exist in exactly one place: somebody's head. Recipes nobody wrote down, how two grandparents met, what a flood felt like in 1983. When that person is gone, so is the story.

GHOST (Generative Human-memory Offline Storytelling & Tracking) is a private memory archive that runs entirely on your own computer. You save letters, photos, recipes and voice recordings, and then you can ask your archive questions in plain language:

"Who taught Lily to knead bread dough?"

and get an answer that points to the exact memory it came from. If the answer isn't in your archive, GHOST says so: "I couldn't find that in your saved memories." It never guesses.

I took "Ghost in the Machine" two ways. The practical one: the archive is the ghost, a place where people live on through their words. The playful one: Ghost Mode turns memories you pick into a clearly labelled spooky story. It shows a "verified facts" panel (copied straight from your archive) next to a list of what the AI invented. There's also a Remembrance setting, which is warm, gentle and has no horror at all. GHOST never claims to contact or speak for anyone who has died, and I wanted that to be built into the design, not just a disclaimer.

Other things it does: record or upload oral histories and transcribe them locally, a timeline with filters, family-history summaries built only from records you select, a passphrase lock, JSON/Markdown/ZIP backups, and a small "Life Documents" section for warranties and important dates with calendar reminders.

Code

Rushindhra / ghost-memory-guardian

Private, offline-first family memory archive powered by local open-weight AI (Ollama, sentence-transformers, faster-whisper). Cited answers, oral-history transcription, and respectful Ghost Mode storytelling.

👻 GHOST — Generative Human-memory Offline Storytelling & Tracking

A private memory archive for the stories your family could lose, powered by open-weight AI that runs on your own computer.

Preserve letters, recipes, photographs and oral histories. Ask questions in plain language and get answers that cite the exact memories they came from — or say "I couldn't find that in your saved memories." Nothing is sent to a cloud AI. No account, no telemetry, no vendor to disappear.

Built for the Ghost in the Machine open-source AI challenge. Ghost Mode is an optional, clearly-labelled fiction layer; GHOST never claims to contact or speak for anyone who has died.

Screenshots in docs/img show the real UI on the synthetic demo archive. Where AI text appears (Ask, summary, Ghost Mode) it was produced by a throw-away test stub standing in for Ollama, not by Qwen — the sandbox that built…

View on GitHub

How I Built It

The whole point was that the AI had to be open and local, not just mentioned in the README:

Language model: Ollama running an open-weight model (default qwen3:4b, swappable from the Settings page). It runs on CPU, no GPU needed.
Search: sentence-transformers with the multilingual multilingual-e5-small model, plus a FAISS index, so you can search by meaning and in different languages.
Speech: faster-whisper for local transcription, with the weights stored on disk.
App: FastAPI + SQLite on the back end, React + TypeScript + Vite + Tailwind on the front end.

The part I care about most is how GHOST handles trust. Instead of just asking the model nicely not to make things up, the code enforces it:

If retrieval doesn't find strong evidence, the model is never even called, and you get the fixed "couldn't find that" reply.
Every claim must carry a citation like [1]. Citations that don't point at a real retrieved memory are stripped out.
An answer with no valid citation at all is thrown away.
Names and years in an answer that don't appear in the sources get flagged for the user.
If Ollama or a model isn't installed, the app says so and shows setup steps. It never fakes a response.

Checks I actually ran: 46 backend tests and 10 frontend tests pass, and I ran the app in a real browser against a real server (that browser run caught a threading bug the unit tests missed, which I fixed and added a regression test for). On the small synthetic dataset with the keyword-search fallback, all relevant memories showed up in the top 5, and all 5 out-of-archive questions were correctly refused.

What I haven't verified yet (honest bit): I built this in an environment that couldn't download model weights, so I tested the Ollama connection against a stand-in server, not a real model. That means I don't have real-model answer quality or CPU speed numbers, and I haven't run the full "disconnect the internet and try it" test, so I'm not claiming it as proven offline. The repo's docs/STATUS.md lists exactly what was and wasn't checked.

Why Does Open Innovation Matter?

A family archive is about the most private thing there is: voices of people you love, names, illnesses, arguments, forgiveness. A closed API would mean sending all of that to someone else's servers, and trusting that company to still exist and still have the same rules in twenty years.

Open weights changed what was possible here:

Privacy: the model comes to the data instead of the data going to the model. GHOST's only network address is Ollama on your own machine, and it refuses non-local addresses unless you explicitly allow one.
Choice: a family can use a tiny model on an old laptop, or a bigger one on a workstation, or one that's better at their heritage language.
Reproducibility: pinned dependencies, a synthetic dataset and an evaluation script mean anyone can re-run my results, and see what I measured and what I didn't.
Preservation: the archive is just SQLite and plain files, exportable as JSON or Markdown. It stays readable even if GHOST disappears, and the AI parts can be rebuilt from open models for as long as anyone wants.

SkillMatch AI

Rushindhra Marri — Sat, 17 Oct 2026 10:54:54 +0000

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

What I Built

I built SkillMatch AI, a local AI-powered job-readiness assistant that helps students and job seekers understand how well their resumes match a job description.

It identifies matching skills, highlights skill gaps, suggests resume improvements, recommends important keywords, and creates a personalized 7-day preparation plan with interview questions.

The idea came from a common problem: many students apply for jobs without knowing which skills they are missing or how to prepare effectively. SkillMatch AI helps them focus on what matters instead of guessing.

Students, job seekers, and placement-training institutes could benefit from this tool.

The application is designed to run locally using Ollama, so users can explore its core AI features without relying on a paid AI API.

Code

GitHub Repository: https://github.com/Rushindhra/SkillMatch-AI

The project includes a React frontend, a Node.js and Express backend, and integration with Ollama for local AI inference.

How I Built It

I built SkillMatch AI using React, Vite, Tailwind CSS, Node.js, and Express. For the AI component, I used Ollama with an open-weight model such as Qwen, which can be configured based on the available hardware.

The application extracts text from a resume, compares it with the job description, identifies matching and missing skills, and generates personalized recommendations.

I also designed the analysis to combine deterministic skill matching with AI-generated suggestions, making the results more transparent and useful.

My goal was to build something practical that students could actually use, rather than just another AI chatbot.

Why Does Open Innovation Matter?

For me, open innovation means having more control over how AI works and where our data goes.

Resumes contain personal information, so I wanted SkillMatch AI to support local processing instead of sending documents to an external AI service. Using Ollama makes it possible to run inference locally, experiment with different models, and customize the analysis without depending on a paid AI API.

It also makes the project more accessible to students and small organizations that may not have the budget for recurring API costs.

Open-source AI gave me the flexibility to experiment, learn, and build a useful application while keeping privacy and affordability in mind.

PlacementPiolt

Rushindhra Marri — Mon, 05 Oct 2026 06:57:31 +0000

🚀 Placement Preparation Portal — A Simple Companion for Campus Placements

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

What I Built

Campus placements can get hectic very quickly.

Students often have to manage aptitude preparation, DSA, core CS subjects, mock tests, tasks, and job opportunities at the same time. It can become difficult to keep track of what has been completed and what still needs attention.

So, I built a Placement Preparation Portal — a simple web application designed to help students organize their placement preparation in one place.

The main goal was to build something that would actually be useful to a friend going through campus placements.

What the portal provides

🔐 Student Registration & Login
📊 Personalized Dashboard
📚 Subject Preparation
📝 Topic and Preparation Tracking
✅ To-Do Task Management
🧪 Mock Tests
⏱️ Test Timer
📈 Test Scores and Results
💼 Job & Internship Listings
👨‍💼 Admin Portal
🗃️ Database-backed student progress

Instead of using multiple platforms for different parts of preparation, the idea is to provide a single place where students can organize their placement journey.

Code

The complete source code is available on GitHub:

👉 GitHub Repository: https://github.com/Rushindhra/Placement-Preparation-Portal

The repository contains:

Java Servlets
DAO layer
Model/POJO classes
JDBC database connectivity
MySQL database schema
HTML/CSS frontend
Authentication
Placement preparation modules
Mock test functionality
Job management
Admin functionality

How I Built It

I wanted to keep the project simple and focus on understanding how a complete Java web application works from the backend to the database.

Tech Stack

Backend

Java
Java Servlets
JDBC

Frontend

HTML
CSS
JavaScript where required

Database

MySQL

Server

Apache Tomcat

Architecture

MVC Architecture
DAO Pattern
POJO/Model Layer

Project Structure

PlacementPreparationPortal/
│
├── src/
│   └── main/
│       └── java/
│           └── com/
│               └── placement/
│                   │
│                   ├── servlets/
│                   │   ├── LoginServlet.java
│                   │   ├── RegisterServlet.java
│                   │   ├── LogoutServlet.java
│                   │   ├── DashboardServlet.java
│                   │   ├── TaskServlet.java
│                   │   ├── SubjectServlet.java
│                   │   ├── MockTestServlet.java
│                   │   ├── JobServlet.java
│                   │   └── AdminServlet.java
│                   │
│                   ├── dao/
│                   │   ├── UserDAO.java
│                   │   ├── TaskDAO.java
│                   │   ├── SubjectDAO.java
│                   │   ├── QuestionDAO.java
│                   │   ├── TestResultDAO.java
│                   │   └── JobDAO.java
│                   │
│                   ├── models/
│                   │   ├── User.java
│                   │   ├── Task.java
│                   │   ├── Subject.java
│                   │   ├── Topic.java
│                   │   ├── Question.java
│                   │   ├── TestResult.java
│                   │   └── Job.java
│                   │
│                   └── utils/
│                       └── DBConnection.java
│
├── webapp/
│   ├── index.html
│   ├── login.html
│   ├── register.html
│   ├── dashboard.html
│   ├── subjects.html
│   ├── tasks.html
│   ├── mock-tests.html
│   ├── jobs.html
│   │
│   ├── admin/
│   │   ├── dashboard.html
│   │   ├── subjects.html
│   │   ├── questions.html
│   │   └── jobs.html
│   │
│   └── css/
│       └── style.css
│
└── database/
    └── schema.sql

The application follows a basic MVC approach:

User
 ↓
HTML/CSS Interface
 ↓
Java Servlet
 ↓
DAO Layer
 ↓
JDBC
 ↓
MySQL

This separation makes the application easier to understand, maintain, and extend.

📚 Main Modules

1. Authentication

Students can create an account and log in to the portal.

The application maintains the user's session so that their preparation data can be associated with their account.

2. Dashboard

The dashboard gives students a quick overview of their preparation.

For example:

Completed tasks
Pending tasks
Subject progress
Mock test performance
Available job opportunities

The idea is to make the dashboard the student's starting point whenever they open the portal.

3. Subject Preparation

Students can prepare for important placement areas such as:

Aptitude
Data Structures & Algorithms
Operating Systems
DBMS
Computer Networks
Object-Oriented Programming
Other Core CS topics

Topics can be marked as completed so students can keep track of their progress.

4. To-Do Management

Students can create and manage their preparation tasks.

They can:

Add tasks
View tasks
Update tasks
Delete tasks
Mark tasks as completed

This helps turn placement preparation into smaller and manageable goals.

5. Mock Tests

The portal includes a mock-test module where students can answer multiple-choice questions.

The system can:

Display questions
Track answers
Handle the test timer
Calculate scores
Store test results
Display previous performance

6. Jobs & Internships

The portal also provides a place to manage job and internship opportunities.

Students can view relevant opportunities while preparing for placements.

The admin can add and manage job postings through the admin portal.

7. Admin Portal

The administrator can manage the content available to students.

The admin functionality includes managing:

Subjects
Topics
Questions
Mock tests
Job/internship opportunities
Student-related information

This makes the portal easier to maintain without directly modifying the database every time new content needs to be added.

🗄️ Database

I used MySQL as the database.

The database contains entities such as:

Users
Tasks
Subjects
Topics
Questions
Test Results
Jobs
Admin

Relationships between these tables allow student-specific preparation data and test results to be stored separately.

JDBC with PreparedStatement is used for database operations.

Why Does Open Innovation Matter?

For this version of the project, I focused on open-source Java technologies and a simple architecture rather than depending on external AI or paid APIs.

Using Java Servlets, JDBC, MySQL, and Apache Tomcat allowed me to understand and build the complete flow myself:

Frontend → Servlet → DAO → JDBC → MySQL

This also makes the project easy for other students to understand, run locally, modify, and extend.

One of the things I like about open-source development is that a project doesn't have to start as a huge system.

It can start with a simple idea, be built using accessible technologies, and gradually evolve based on real user feedback.

💬 What My Friend Said

I built this project around the problems students face during hectic campus placement seasons, so I also discussed the idea with a friend.

Their feedback was:

"It would be really useful if job posting links and aptitude tests could be provided through the admin portal. Having everything in one place would make preparation easier, especially during hectic on-campus placements."

That feedback helped me focus on making the portal more practical rather than trying to add too many complicated features.

The goal is simple:

Give students one place to organize their placement preparation.

My Agent Session

I used AI-assisted development while working on parts of the project.

Agent Session: YOUR_DEVRELAY_SESSION_LINK

If you don't have a DevRelay session, you can remove this section. I don't want to claim or fabricate an agent session that doesn't exist.

🏆 Prize Categories

This project is submitted for the Hacktoberfest Weekend Challenge: Build for a Friend.

Partner categories:

Add the applicable categories here, or remove this section if none apply.

What's Next?

This is the first practical version of the portal, and there is plenty of room to improve it.

Some ideas for future versions include:

Better progress analytics
More comprehensive question banks
Company-specific preparation modules
Resume tracking
Interview preparation
More advanced test analytics
AI-powered personalized preparation in a future version

For now, I wanted to make sure the core placement preparation workflow actually works before adding more advanced features.

The project started with a simple question:

"Can I make placement preparation a little less confusing for a student?"

This portal is my attempt at doing that. 🚀