Memory Lantern: Turning Precious Memories into Keepsakes with Open-Weight AI

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

What I Built

I built Memory Lantern, an AI-powered digital remembrance and storytelling platform that helps people preserve meaningful memories of someone they love.

Sometimes, the smallest things are the ones we remember most: someone's laughter, their favourite song, the way they made chai every evening, or the little things they always said.

I wanted to build something that could help people turn these everyday memories into something meaningful that they could revisit and keep.

With Memory Lantern, users can enter someone's name, their relationship, personal memories, important moments, favourite things, and additional context. They can then transform those memories into three different formats:

• Personal Letter: A heartfelt letter written from the user's perspective and addressed to the person they remember.
• Short Story: A reflective narrative built around the memories and details provided.
• Remembrance Card: A beautifully structured keepsake with a title, meaningful details, and a closing message.

Users can also choose different emotional tones, regenerate their writing, copy the result, and download it as a text file.

One important design decision was that Memory Lantern should never pretend to communicate with someone who has passed away. It should help people express their own memories rather than impersonate the person they remember.

The idea fits the spirit of Ghost in the Machine and the theme of preserving stories, memories, and connections across time.

Demo

Project screenshots:

I've included screenshots showing the memory creation form, AI-generated personal letter, short story, and remembrance card.

https://memory-lantern.vercel.app/

The demo walks through entering memories, selecting a writing format, generating content, and using the copy and download functionality.

Code

GitHub Repository:

https://github.com/nehaprasad-dev/memory-lantern

The repository contains the application source code, AI integration, prompt engineering logic, reusable components, and setup documentation.

How I Built It

I built Memory Lantern using:

• Next.js and React for the application frontend.
• TypeScript for type safety and maintainable code.
• Tailwind CSS for styling and responsive design.
• GPT-OSS 20B as the open-weight language model.
• Groq for hosted model inference.

The core AI functionality uses OpenAI's openai/gpt-oss-20b model through Groq's inference API.

Rather than using a closed proprietary model API as the application's writing engine, I wanted to experiment with an open-weight model and understand how it could be integrated into a real product.

The generation flow works as follows:

1. The user enters personal memories and relevant details.
2. The frontend sends the information to a server-side API endpoint.
3. The backend validates the input and constructs a structured prompt.
4. The prompt is sent to GPT-OSS 20B through Groq.
5. The model generates content according to the selected writing format and tone.
6. The application displays the generated keepsake, allowing the user to copy, download, or regenerate it.

An important part of the implementation was prompt engineering.

I wanted the model to preserve the user's original details instead of producing generic emotional writing or inventing personal experiences. I added instructions to guide the model to respect the supplied memories, follow the selected format, and write from the user's perspective.

This is especially important for a product like Memory Lantern, where factual accuracy and emotional sensitivity matter more than simply generating beautiful sentences.

The model is open-weight, but my current implementation uses hosted inference through Groq. It does not run the model locally or provide offline inference.

Why Does Open Innovation Matter?

For a project dealing with personal memories, having flexibility and control over the underlying AI model matters.

Using an open-weight model gives developers more freedom to understand the model they are building with, customize its behaviour, and choose where and how it is deployed.

GPT-OSS is available under the Apache 2.0 license, which allows broad use, modification, and redistribution subject to its usage policy.

For this project, it gave me the opportunity to build around an open-weight model instead of depending entirely on a closed proprietary model API.

Although Memory Lantern currently uses Groq for hosted inference, the availability of the model weights means the architecture can evolve towards self-hosted inference or a different supported infrastructure in the future.

I also wanted to be transparent about privacy. Memory Lantern does not provide a permanent personal memory library or user account in this MVP. The memories are sent to the application backend and then to the hosted inference provider for generation. This means the current version is not an offline or fully local AI application.

Open innovation is not just about having access to a model. It is also about having choices as developers and being able to build, adapt, and improve technology around our own ideas.

The Spirit of It

I think the most meaningful part of remembering someone is often not a big event. It is the ordinary details that stay with us.

A familiar song. A cup of tea. A conversation that seemed ordinary at the time but became something we wish we could experience again.

Memory Lantern is my attempt to give those details a place to live.

I did not want to build another chatbot that simply generates emotional paragraphs. I wanted to build something that starts with the user's own memories and helps them turn those memories into something worth keeping.

The goal is simple: not to recreate someone, but to help keep their stories alive.

Thanks for reading! 🕯️