This is a submission for the Hacktoberfest Open-Source AI Challenge
Week 4: Ghost in the
Machine.
What I Built
Afterlight: The Memory Keeper is a privacy-first, local-first AI
memory preservation platform created individually for Hacktoberfest Week
4: Ghost in the Machine.
Afterlight helps people preserve and rediscover meaningful stories,
photographs, voice recordings, family traditions, and personal memories.
It brings together two interpretations of the challenge theme:
- Ghost in the Machine: Forgotten stories and recordings can feel like voices trapped in old photographs, tapes, and folders. Afterlight uses local AI to transcribe, organize, search, and creatively reinterpret saved memories.
- Día de los Muertos: The Virtual Ofrenda offers a customizable digital space to honor loved ones through photographs, remembrance messages, favorite foods, songs, flowers, traditions, and associated stories.
Afterlight is designed around a simple principle:
Your memories belong to you. Your stories should not depend on a
server you do not control.
The Problem
Family stories and personal histories are often scattered across paper
notes, old photographs, audio recordings, phones, and disconnected
folders. Finding a particular detail can be difficult, and valuable oral
histories may remain inaccessible because they have never been
transcribed or organized.
At the same time, sending intimate memories, photographs, and voice
recordings to third-party AI services can create privacy and
data-ownership concerns. Hosted AI services can also introduce recurring
usage costs and dependence on a provider's availability, pricing, and
terms.
The Solution
Afterlight brings memory preservation and AI-assisted discovery into a
local-first application:
- Memory Vault: Preserve stories, photographs, dates, people, locations, tags, and personal experiences in an organized archive.
- Voice of the Past: Transcribe uploaded oral-history recordings with locally running speech recognition, review the transcript, and save it with related memories.
- AI Memory Companion: Ask natural-language questions about saved memories. Retrieval-augmented generation (RAG) finds relevant records and presents the supporting sources.
- Virtual Ofrenda: Create a customizable Día de los Muertos-inspired remembrance altar with portraits, candles, marigold-inspired decorations, offerings, and tribute messages.
- Ghost Echoes: Create atmospheric fictional stories inspired by selected memories, with a clear notice that generated stories are creative fiction---not real communications from deceased people.
- Memory Timeline: Explore saved stories and events chronologically.
- Privacy & Model Control Center: Inspect the local AI runtime, available models, local data controls, export options, and setup status.
The application is designed to keep personal records and AI inference on
the user's machine. Any offline claims in this submission should reflect
the exact features verified with the network disconnected.
Demo
<!-- Replace these placeholders with real links before publishing. -->
- GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4
- Video Demonstration: [Insert a Loom, YouTube, or other walkthrough link]
- Live Demo: Afterlight is designed for local execution. [Add a hosted demo only if one is actually available.]
- DevRelay Agent Session (Optional): [Insert the real session link if saved.]
Feature Walkthrough
Feature What to demonstrate AI / technical
foundation
Memory Vault Create, edit, search, Local database and file
filter, and revisit storage
saved memories
Voice of the Past Upload an audio file, faster-whisper
transcribe it, review
the transcript, and
save it
AI Memory Companion Ask a question and Ollama, an open-weight
inspect the retrieved model, embeddings, and
source memories ChromaDB
Virtual Ofrenda Create a remembrance Local records and
profile and customize frontend presentation
its altar
Ghost Echoes Generate and save a Local LLM and
fictional story controlled prompts
inspired by selected
memories
Memory Timeline Browse memories by year Local database queries
and date
Privacy & Model Control Inspect runtime/model Ollama and local
Center status, export data, file/database storage
and review
local-storage controls
Screenshots
<!-- Add screenshots captured from the actual running application. Suggested screenshots: -->
- Landing page and local-first privacy explanation.
- Dashboard populated with real saved records.
- Memory Vault showing a saved memory and its details.
- Voice of the Past showing an actual transcript.
- AI Memory Companion answer with supporting source-memory cards.
- Virtual Ofrenda with a user-created remembrance profile.
- Ghost Echoes showing a generated story and its fiction disclaimer.
- Privacy & Model Control Center showing actual local runtime/model status.
Code
GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4
<!-- Optional GitHub embed. Replace the URL before publishing. -->
AFTERLIGHT — THE MEMORY KEEPER
"Some stories deserve to live beyond a lifetime."
-black.svg){kind=icon}
-red.svg){kind=icon}
📖 Executive Summary
AFTERLIGHT is a privacy-first, locally powered AI memory preservation platform developed for the Hacktoberfest Week 4 Challenge — "Ghost in the Machine".
It unifies two poignant themes:
- The Ghost in the Machine: Awakening forgotten family memories, cassette recordings, and heirloom photographs through local open-source AI retrieval and atmospheric creative storytelling.
- Día de los Muertos (Day of the Dead): Honoring departed ancestors through an interactive, culturally reverent virtual altar (ofrenda) adorned with flickering candlelight physics, golden cempasúchil petals, traditional offerings, and printable tribute keepsakes.
Every AI capability in Afterlight—from speech-to-text audio transcription and dense semantic vector retrieval to conversational memory companion RAG—runs 100% locally on your own machine using open-weight models (Qwen2.5 3B, faster-whisper, ChromaDB).
Core Philosophy: "Your memories belong to you. Your stories should…
Project Structure
The planned application structure separates the frontend, backend, AI
services, and local user data. Adjust this tree to match the repository
that is actually submitted.
afterlight/
├── frontend/ # React, TypeScript, Vite, Tailwind CSS
│ └── src/
│ ├── components/ # Memory, altar, audio, story, and layout UI
│ ├── pages/ # Dashboard, Vault, Ofrenda, Companion, etc.
│ ├── services/ # Backend API clients
│ ├── hooks/
│ ├── contexts/
│ └── types/
├── backend/ # Python, FastAPI, SQLAlchemy
│ ├── app/
│ │ ├── api/ # REST endpoints
│ │ ├── core/ # Configuration and shared utilities
│ │ ├── database/ # SQLite setup
│ │ ├── models/ # Database models
│ │ ├── schemas/ # Request/response validation
│ │ └── services/
│ │ ├── ai/ # Ollama/model adapter
│ │ ├── embeddings/ # Local embeddings and retrieval
│ │ ├── memory/ # Memory operations
│ │ ├── transcription/ # faster-whisper integration
│ │ └── storytelling/ # Grounded creative generation
│ └── tests/
├── local_data/ # User data; excluded from Git
│ ├── database/
│ ├── photographs/
│ ├── audio/
│ ├── embeddings/
│ └── exports/
├── docs/
├── scripts/
├── .env.example
├── .gitignore
├── README.md
└── LICENSE
How I Built It
Afterlight uses a modular, local-first architecture. The frontend
communicates with a local FastAPI backend. The backend manages
persistent records, local files, retrieval, transcription, and requests
to the local model runtime.
Architecture Overview
+--------------------------------------------------------------+
| Afterlight Frontend |
| React + TypeScript + Vite + Tailwind |
+------------------------------+-------------------------------+
|
Local REST API
|
+------------------------------v-------------------------------+
| Python FastAPI Backend |
| |
| +----------------+ +----------------+ +----------------+ |
| | Memory Service | | Audio Service | | Story Service | |
| +----------------+ +----------------+ +----------------+ |
| | | | |
| v v v |
| +----------------+ +----------------+ +----------------+ |
| | SQLite | | faster-whisper | | Ollama Adapter | |
| | Local Records | | Local Speech | | Local LLM | |
| +----------------+ +----------------+ +----------------+ |
| | | |
| v v |
| +----------------+ +----------------+ |
| | ChromaDB |<-------------------| Embedding Model| |
| | Vector Search | | Local Embedding| |
| +----------------+ +----------------+ |
+--------------------------------------------------------------+
|
v
+--------------------------------------------------------------+
| User-Controlled Local Data |
| Database / Photographs / Audio / Exports |
+--------------------------------------------------------------+
1. Frontend & Experience
- Framework: React with TypeScript and Vite.
- Styling: Tailwind CSS with a dark, cinematic visual identity.
- Visual direction: Midnight backgrounds, warm amber and candlelight accents, marigold-inspired details, framed photographs, and restrained atmospheric animation.
- Interface: Responsive pages for the dashboard, Memory Vault, Voice of the Past, AI Memory Companion, Virtual Ofrenda, Ghost Echoes, Memory Timeline, and privacy controls.
2. Backend & Local Persistence
- Backend: Python and FastAPI for local REST APIs.
- Database: SQLite for structured memory records, people, photographs, recordings, transcripts, ofrendas, stories, and related metadata.
- File storage: Photographs and audio are stored as local files; the database stores their metadata and local references rather than Base64 copies.
- Validation: Pydantic schemas and file validation are used at API boundaries.
- Data ownership: Local records can be backed up and exported by the user.
3. Open-Weight AI & Local Inference
- Runtime: Ollama provides a local interface for running compatible open-weight language models.
- Default model target:
qwen2.5:3b(or another compatible model selected in the application). - Model flexibility: The AI service is separated behind a model adapter so compatible local models can be changed without rewriting feature logic.
- AI tasks: Memory summaries, contextual question answering, categorization, remembrance-writing assistance, and fictional story generation.
- No mandatory hosted LLM: The core AI design does not require OpenAI, Gemini, Claude, or another hosted LLM API.
Model availability, model licenses, and actual tested model names should
be confirmed against the implementation before publishing.
4. Local Speech Recognition
- Engine:
faster-whisper, using a locally available Whisper model. - Workflow: Upload audio → transcribe locally → review/edit transcript → save transcript and associate it with a memory.
- Formats: Support depends on the installed FFmpeg configuration and the formats enabled by the application.
- Privacy: Audio is processed locally when the local transcription pipeline and model are installed.
5. Semantic Search & Grounded Memory Companion
- Embeddings: A locally installed
sentence-transformersmodel, such asall-MiniLM-L6-v2. - Vector store: ChromaDB for semantic retrieval.
- Retrieval flow: Embed the question → retrieve relevant memory chunks → load their source records → provide context to the local LLM → return an answer with source references.
- Grounding: The assistant should state when saved memories do not contain enough information. It should not present unsupported model-generated details as facts.
- Source visibility: Responses should link to the memory records used as context, allowing users to inspect the original material.
6. Creative Storytelling & Remembrance
- Ghost Echoes: Generates original atmospheric fiction inspired by user-selected memories.
- Virtual Ofrenda: Provides a customizable digital remembrance space for portraits, stories, offerings, and messages.
- Ethical boundary: Generated stories are clearly labeled as fiction. The application does not claim to contact, recreate, or speak for deceased people.
- Cultural respect: Ofrenda elements are customizable; the experience does not assume that every user follows the same traditions.
7. Testing & Verification
<!-- Replace this section with actual commands, results, and test counts from your final run. -->
- Backend tests: [Add test command and actual result.]
- Frontend checks: [Add lint/type-check/build commands and actual result.]
- AI integration: [State which local model and AI workflows were tested.]
- Offline verification: [List only the workflows personally tested with the network disconnected.]
- Known limitations: [Document hardware, model, performance, or platform limitations.]
Why Does Open Innovation Matter?
For Afterlight, open innovation is directly connected to privacy,
ownership, accessibility, and long-term control.
Memories can include intimate family stories, personal photographs, and
recordings of people who trusted us with their words. A
memory-preservation tool should not require those materials to be sent
to a third-party AI provider.
1. Privacy & Data Sovereignty
Local inference allows supported AI operations to run on the user's own
machine. Afterlight is designed to keep its memory archive, photographs,
recordings, and local database under the user's control rather than
making a hosted AI service the default destination for personal
material.
2. Model Choice & Freedom to Experiment
A local model adapter makes it possible to test and switch between
compatible models. Developers can compare model quality, hardware
requirements, languages, and response behavior without redesigning the
entire application around one provider.
3. Offline Access & Independence
Once the application dependencies, model weights, and required assets
have been downloaded, supported local workflows can operate without an
internet connection. This reduces dependence on a hosted service being
available whenever someone wants to revisit a memory.
4. Accessibility Without Per-Request AI Fees
Local inference avoids mandatory per-request hosted LLM charges. It does
not mean the application has no costs: users still need suitable
hardware, storage, electricity, and initial downloads. However, it gives
people another way to use AI without a recurring API bill.
5. Community Adaptation & Longevity
An open implementation can be inspected, modified, extended, and adapted
by contributors. Communities can experiment with language support,
oral-history workflows, accessibility improvements, and culturally
appropriate remembrance experiences.
Honest Technical Trade-offs
- Hardware: Local inference performance depends on RAM, CPU/GPU, quantization, and model size.
- Storage: Model weights, audio recordings, photographs, and vector indexes require disk space.
- Initial setup: Ollama, Python packages, frontend dependencies, and model assets generally need to be installed or downloaded before offline use.
- Performance: CPU-only transcription and LLM inference may take longer than hosted GPU services.
- Model licensing: Each model has its own license and usage conditions. Check and document the exact license of every model distributed or recommended.
- Offline scope: Do not describe the entire application as offline unless every claimed workflow has been tested without network access.
What Worked Better With an Open-Based Approach?
The local-first architecture makes privacy and model choice design
properties rather than optional settings in a hosted service. It also
allows the project to keep working with locally installed models without
requiring a particular commercial AI provider's API.
My Agent Session
This project was developed individually with assistance from Google
Antigravity as an agentic coding environment.
- Developer: Individual project submission.
- AI coding tool: Google Antigravity.
- Development work: [Describe the architecture, implementation, debugging, and testing work actually completed.]
- DevRelay Session (Optional): [Insert a real DevRelay session link if one was saved.]
<!-- Do not claim a DevRelay session was recorded unless you have a real shareable link. -->
Individual Submission Note
Afterlight is submitted as an individual project for the Hacktoberfest
Open-Source AI Challenge Week 4: Ghost in the Machine.
I independently conceived and developed the project, including its
application design, implementation, integration, and documentation, with
AI coding assistance where applicable. Any external libraries, models,
frameworks, and third-party assets are credited through their respective
licenses and attributions.
Prize Categories
<!-- Only list categories that are officially available and that you are eligible to enter. Do not assume a category or prize exists. -->
- Challenge: Hacktoberfest Week 4 --- Ghost in the Machine.
- Submission Type: Individual.
- Partner / Special Categories: [Add only verified eligible categories, if applicable.]
Closing
Afterlight explores a different kind of ghost in the machine: not a
supernatural presence, but the stories and voices that risk being
forgotten in old recordings, photographs, and disconnected archives.
By combining local open-weight AI with memory preservation, oral-history
transcription, grounded search, creative storytelling, and a digital
remembrance altar, Afterlight aims to make technology a respectful
bridge between generations.
The machine may be artificial. The memories are real.
Built individually with care, cultural respect, and open-source AI for
Hacktoberfest 2026. 🎃 🕯️ 🌼
Top comments (0)