What I Built
What if an AI could help us preserve the memories we fear losing, without asking us to hand those memories over to someone else?
That's the question behind GhostVault, an AI-powered digital memory archive that I'm planning to build using open-weight AI models and local inference.
The idea came from the themes of Halloween and Día de los Muertos. Halloween makes us think about ghosts, forgotten places, and things that linger long after they've disappeared. Día de los Muertos reminds us that photographs, stories, traditions, and memories can keep the people we love close to us.
I wanted to bring these two ideas together into something that is both a little spooky and genuinely meaningful.
Meet GhostVault: a haunted digital archive where forgotten photographs, old letters, personal stories, and cherished memories come back to life through an AI companion called The Ghost. 👻
But there's a twist.
The Ghost won't simply be another chatbot that generates random spooky stories. It will be able to search a user's personal archive, retrieve relevant memories, and weave them into interactive narratives.
Imagine uploading an old photograph of your childhood home and adding a note about the summers you spent there.
A few days later, you ask:
Ghost, what do you remember about my childhood home?
Instead of returning a generic answer, GhostVault will retrieve your saved memories and use them to create a personalized response.
It might say:
"Ah, the old house... You told me about the summers you spent there, the familiar rooms, and the moments that seemed ordinary at the time. Funny how the smallest details become the memories we treasure most. Shall we uncover another fragment of that story?"
The response will be generated from the information you actually saved, rather than pretending the AI has supernatural knowledge or memories of its own.
The goal is to create an experience that feels like exploring a forgotten archive with an intelligent, mysterious companion.
🕯️ The Features I Plan to Build
1. The Ghost — An AI Memory Companion
This will be the heart of GhostVault.
Users will be able to interact with their personal archives using natural language.
For example:
- "Tell me a story about my childhood."
- "What memories have I saved about my grandfather?"
- "Find the happiest memory I've shared."
- "What do my photographs tell me about my college days?"
- "Help me turn this old photograph into a mysterious story."
I'll use a retrieval-augmented generation (RAG) pipeline so that The Ghost can search saved memories and use the relevant information when generating responses.
The idea is to make the AI feel personal without allowing it to invent facts about someone's life.
2. The Haunted Photo Archive 📸
A photograph can hold an entire story, even when its original context has been forgotten.
GhostVault will allow users to upload photographs and attach descriptions, dates, locations, and personal notes.
Users will be able to browse their collection and search for memories using natural language.
For example, searching for "the family gathering during Durga Puja" should retrieve relevant photographs and stories if that information exists in the archive.
I'll begin with manually entered descriptions and metadata. Later, I plan to experiment with open-weight vision-language models to help describe photographs and connect them with existing memories.
The photographs and associated information will be stored locally in the privacy-focused version of the application.
3. The Memory Séance 🕯️
This is where the Halloween side of the project comes alive.
Users will be able to select a photograph, letter, or saved memory and ask The Ghost to turn it into a story.
I'll introduce different storytelling modes:
👻 Haunted Mode: Transform a memory into an eerie, atmospheric narrative.
🌼 Remembrance Mode: Create a warm, reflective story celebrating a cherished memory or loved one.
📜 Historical Mode: Construct a narrative grounded in the available facts, clearly identifying missing information.
🌑 Fiction Mode: Create a supernatural fictional story inspired by the user's archive.
For example, a photograph of an abandoned house accompanied by the note "My grandfather grew up here" could inspire a mysterious story about the house and the generations that once lived in it.
The application will distinguish fictional storytelling from factual recollections, so users can enjoy the atmosphere without confusing invented details with real memories.
4. Forgotten Fragments 🔍
Sometimes, we save something with the intention of returning to it later, only to forget about it entirely.
This feature will help users rediscover unfinished stories and incomplete memories.
GhostVault will identify photographs without descriptions, stories that need additional context, and recurring people or places across saved memories.
It might ask:
"You saved three photographs from your first college trip, but none has a description. Do you remember where these were taken?"
Instead of merely storing information, GhostVault will help users gradually build a richer personal archive.
5. The Digital Ofrenda 🌼
Inspired by Día de los Muertos, this feature will allow users to create a digital remembrance space for someone important to them.
An ofrenda is a place for honoring and remembering loved ones. I want to bring that spirit into a digital experience without reducing it to a spooky gimmick.
Users will be able to add photographs, personal anecdotes, favorite foods, songs, important dates, and letters.
The AI will help organize these materials into a remembrance narrative that celebrates the person's life and preserves the stories associated with them.
Users will remain in control of what they save, edit, share, or delete.
The result will be a personal digital memorial that can help preserve stories for future generations.
Demo
I'll initially focus on building a working local version of GhostVault.
The demonstration will showcase:
- Creating a personal memory and adding a photograph.
- Asking The Ghost a question about saved information.
- Retrieving relevant memories using semantic search.
- Generating a spooky story inspired by an archived photograph.
- Switching between Haunted and Remembrance modes.
- Creating a digital ofrenda.
- Demonstrating that the core AI workflow can function without an internet connection after the required models and dependencies have been installed.
Demo link: I'll add the deployed application or demonstration video here once it's available.
The initial version will use sample memories so that anyone can explore the application without uploading personal photographs or private stories.
For deployment, I plan to explore a public web demo alongside a local version. The local version will be the primary demonstration of privacy and offline inference; the hosted demo will use fictional sample data rather than promising that a public server offers the same privacy guarantees.
Code
I'll publish the source code on GitHub so that developers can explore the implementation, run the application locally, and contribute improvements.
GitHub repository: I'll add the repository link here once it's created.
The repository will include the frontend, backend, AI integration, local storage implementation, setup instructions, and sample data for testing.
I'm also planning to document how to configure the local model, initialize the memory database, and run GhostVault on a personal computer.
My goal is to make the project approachable for developers who want to experiment with open-weight AI without needing a paid AI API.
How I Built It
The central design decision behind GhostVault is that the AI should be able to work with personal memories without requiring those memories to leave the user's computer.
Rather than making a hosted AI API the foundation of the application, I'll build the core workflow around local inference and open-source components.
The Technology Stack
Here's the stack I'm planning to use:
| Component | Technology | Purpose |
|---|---|---|
| Frontend | React + Vite | Build the interactive archive and chat interface |
| Styling | Tailwind CSS | Create the dark, atmospheric visual experience |
| Backend | Python + FastAPI | Handle memory management, retrieval, and AI requests |
| Local AI runtime | Ollama | Run compatible open-weight language models |
| Language model | A suitable instruction-tuned open-weight model | Power The Ghost's conversations and storytelling |
| Embeddings | Sentence Transformers | Convert memories into numerical representations for semantic search |
| Vector database | ChromaDB | Retrieve memories relevant to a user's question |
| Metadata database | SQLite | Store memory descriptions, dates, tags, and archive metadata |
| File storage | Local filesystem | Store photographs and other uploaded files |
I'll choose the language model based on its quality, hardware requirements, license, and performance on my machine.
The first version will prioritize a reliable local text-based memory assistant. Vision-language models and additional features can be integrated once the core workflow works well.
How The Ghost Will Work
The main AI workflow will follow a retrieval-augmented generation architecture.
Here's the planned pipeline:
Step 1: Save a memory
A user uploads a photograph and adds a description.
For example:
"My family celebrated Durga Puja at my grandmother's house every year when I was a child."
GhostVault stores the photograph locally and saves its description and associated metadata in the database.
Step 2: Create an embedding
The application uses a local embedding model to convert the memory description into a numerical representation.
This representation captures semantic information, allowing the system to find related memories even when a user's query doesn't contain exactly the same words.
Step 3: Ask The Ghost a question
The user asks:
"Where did my family celebrate Durga Puja when I was younger?"
Step 4: Retrieve relevant memories
The backend searches the stored embeddings and retrieves relevant descriptions.
The Ghost receives the question along with the matching records.
Step 5: Generate a response
Ollama passes the relevant context to the selected local language model, which generates a natural-language response.
The model will be instructed to prioritize retrieved information, distinguish known facts from fictional details, and admit when the archive doesn't contain enough information to answer a question.
Step 6: Preserve the result
The user can save the generated story alongside the original memory, creating a growing archive of personal narratives.
The complete process can run locally, without a mandatory external AI API.
A Simplified Architecture
The application will follow this structure:
GHOSTVAULT
|
React + Tailwind
|
FastAPI
|
+-----------+-----------+
| | |
Memory Story Archive
Retrieval Engine Manager
| | |
ChromaDB Ollama SQLite
| |
Local Embeddings |
| |
+-----+-----+
|
Open-Weight LLM
|
Generated Response
The architecture will separate the user interface, memory retrieval, AI generation, and storage layers.
This will make it easier to replace the language model, change the embedding model, or experiment with alternative retrieval strategies without rewriting the entire application.
Building the Haunted Experience
I also want GhostVault to feel like an interactive digital archive rather than a conventional productivity application.
The interface will use a dark, gothic-inspired design with aged-paper textures, muted colors, candlelight-inspired accents, and subtle animations.
The landing page will introduce the experience with a simple message:
"Every memory leaves a trace."
The main dashboard will have three central areas:
- The Archive: Browse photographs, letters, and personal stories.
- The Ghost: Ask questions and generate personalized narratives.
- The Ofrenda: Build a digital remembrance space.
I'll keep the animations lightweight and make sure that the interface remains functional even on modest hardware.
The AI model will run independently of the visual effects, so users won't need a powerful GPU simply to navigate the archive.
Development Roadmap
I'll approach the project incrementally.
Phase 1 — Bring The Ghost to Life
- Set up the React frontend and FastAPI backend.
- Integrate Ollama with a compatible open-weight language model.
- Create the Ghost persona and conversation interface.
- Implement basic local conversation handling.
Phase 2 — Give The Ghost a Memory
- Implement memory creation and retrieval.
- Add local embedding generation.
- Integrate ChromaDB and SQLite.
- Build the RAG pipeline.
- Test whether responses are grounded in retrieved memories.
Phase 3 — Build the Haunted Archive
- Implement photograph uploads and metadata management.
- Create the haunted storytelling interface.
- Add Haunted, Remembrance, Historical, and Fiction modes.
- Allow users to save generated stories.
Phase 4 — Preserve the Past
- Implement the digital ofrenda.
- Add tools for organizing and completing forgotten fragments.
- Improve the interface and accessibility.
- Test the core workflow with the internet disconnected.
- Document installation and local deployment.
The priority will be to deliver a working core application before experimenting with more advanced AI features.
Why Does Open Innovation Matter?
For GhostVault, open innovation isn't simply a way to avoid paying for API calls.
It's a fundamental part of the product's philosophy.
I'm building an application around photographs, personal stories, family traditions, and memories of people who may no longer be with us.
These aren't ordinary pieces of data.
They can be deeply personal, and users should have meaningful control over where that information goes.
That's why I want the default experience to run locally.
1. Privacy Should Be a Design Decision
A conventional implementation built around a hosted AI API could send personal memories to an external service for processing.
GhostVault will instead use a local model for its core AI workflow.
Photographs, saved stories, embeddings, and generated narratives can remain on the user's machine when the application is configured for local operation.
This doesn't automatically make every deployment private. The application will still need to avoid unnecessary external requests, handle local files securely, and document its storage behavior.
But the architecture gives us the ability to build privacy into the product instead of treating it as an afterthought.
2. A Personal Archive Shouldn't Depend on a Single Provider
Imagine spending years collecting photographs, writing family stories, and organizing personal memories in an application.
Now imagine losing access because a company changes its pricing, discontinues its service, or removes a feature.
I want GhostVault to avoid making its core functionality dependent on a single hosted AI provider.
By separating the model runtime from the application logic, I'll be able to experiment with compatible models and maintain the archive independently of the AI engine.
The database and original photographs will remain separate from generated responses, making the underlying memories easier to preserve even if the language model changes.
The archive belongs to the user. The AI is a tool that helps them explore it.
3. Offline AI Makes the Experience More Resilient
Once the necessary models and dependencies are installed, GhostVault's core local workflow should be usable without an internet connection.
Users will be able to browse their archives, retrieve memories, and generate stories without depending on a remote inference endpoint.
This is particularly important for a personal archive: its basic functionality shouldn't disappear just because an external service is unavailable.
The main limitations will be the computer's available memory, processing power, and storage.
4. Experimentation Without a Closed AI API
Using an open-weight model will give me more flexibility to experiment with the application's behavior.
I want to compare models on their ability to:
- Retrieve and accurately summarize personal memories.
- Produce compelling but grounded narratives.
- Maintain a consistent character and storytelling style.
- Distinguish between recorded facts and fictional additions.
- Run efficiently on ordinary consumer hardware.
I'll also be able to experiment with different system prompts, retrieval strategies, embedding models, and context sizes.
This flexibility is especially useful for a project like GhostVault because its quality depends on more than producing fluent text. The system must retrieve the right information and handle missing context responsibly.
A closed API could certainly provide similar functionality, but local inference gives me greater control over the execution environment and removes mandatory per-request API charges.
5. Open Innovation Makes the Project Easier to Extend
I want developers to be able to modify GhostVault rather than simply use it as a finished product.
Someone might want to add a different language model, improve semantic search, introduce multilingual storytelling, or integrate local speech recognition.
Another developer might want to adapt the archive for oral histories, historical research, or preserving endangered languages.
By keeping the system modular and publishing its implementation, I'll make these experiments easier to pursue.
I'll also document the licenses of the models and libraries I use, because an open-weight model and an open-source application are not automatically the same thing.
Ultimately, open innovation gives me the freedom to build an application whose core capabilities are not tied to a single provider's pricing, infrastructure, or product decisions.
My Agent Session
I plan to use an AI coding assistant during development to help implement and refine GhostVault.
The work will involve building the application architecture, integrating local inference, developing the retrieval pipeline, and testing how the AI responds when relevant information is missing.
I'll document the development process and, if I use DevRelay to capture a suitable agent session, include it here using the submission format requested by the challenge.
Agent session: I'll add the link here if I capture one.
I want the final project to demonstrate not just the generated experience, but also how open-source AI can be integrated into a practical application.
The Spirit of It
There's something unsettling about an old photograph.
You recognize the faces, the room, perhaps even the exact moment it was taken.
But the sounds are gone.
The conversations have faded.
And sometimes, the people who could explain the photograph are no longer around to tell you the story.
GhostVault is my attempt to build something that helps preserve those missing fragments.
Imagine finding an old photograph of your grandfather and asking The Ghost to help you organize everything you remember about it.
The AI won't actually know what happened that day. It won't recover memories that were never recorded.
But it can help you connect the information you have, ask questions you hadn't considered, and turn scattered notes into a story worth preserving.
And perhaps that's enough.
Not every ghost needs to be frightening. Sometimes, the most meaningful ghosts are the memories we don't want to lose.
With the digital ofrenda, I also want to honor the spirit of Día de los Muertos: remembering the people who shaped our lives and preserving the stories that connect generations.
GhostVault isn't about bringing the dead back. It's about making sure their stories don't disappear.
And by building it with open-weight AI and local inference, I want those stories to remain with the people who own them.
Because some memories deserve to live forever. 🕯️
Prize Categories
I'll review the challenge's official partner categories and list the ones that genuinely apply to the completed project.
Potential areas of alignment include open-weight AI, local inference, and open-source development, depending on the challenge's actual category requirements.
I'll update this section before submitting the final post.
GhostVault is currently a planned project. I'll update this post with the repository, working demo, implementation details, and actual model choices as development progresses.
Top comments (0)