DEV Community: V C Mohit Rao

EchoVault: I Built an Open-Source AI That Helps Forgotten Memories Live On

V C Mohit Rao — Mon, 26 Oct 2026 20:35:47 +0000

EchoVault: I Built an Open-Source AI That Helps Forgotten Memories Live On

Some of the most valuable things we own aren't expensive devices or files stored in the cloud.

They're the stories we hear from our grandparents. The recordings we make during family gatherings. The letters we keep but rarely revisit. The little details that seem ordinary today but become priceless years later.

And yet, these memories are surprisingly easy to lose.

Recordings remain buried in folders. Audio files are difficult to search. Handwritten notes get separated from their context. Eventually, the people who remember these stories might no longer be around to tell them.

For Hacktoberfest Week 4, I wanted to explore a different interpretation of Ghost in the Machine.

What if AI could help preserve the voices, stories and memories that time might otherwise erase?

That idea became EchoVault.

What I Built

EchoVault is an AI-powered memory archive designed to help people preserve, organize and rediscover personal stories.

Instead of treating old recordings and written memories as files that simply sit on a device, EchoVault helps turn them into a searchable collection of stories.

The workflow is simple:

Upload an audio recording or written memory.
Transcribe supported audio recordings.
Generate a concise summary and extract useful details.
Save the original material alongside its transcript and metadata.
Search the archive and ask questions about the saved stories.
Create a remembrance page that brings the material together in a readable format.

The goal isn't to make AI replace the people behind these memories. It's to make their stories easier to preserve, revisit and share.

EchoVault is about helping memories survive, not pretending that AI can bring someone back.

Demo

In the demonstration, I'll upload a sample recording, show how EchoVault transcribes and summarizes it, and retrieve a detail from the saved story.

I'll also demonstrate how the original recording and its generated content remain connected, so users can verify the archive entry against its source.

Code

The repository contains the application source code, setup instructions, model configuration, dependencies and documentation for running EchoVault.

The goal is to make the project reproducible so other developers can experiment with the models, improve the archive workflow or adapt it to their own use cases.

How I Built It

I built EchoVault around Python, Streamlit and open-source AI tools.

The architecture separates transcription, language-model processing, storage and retrieval so that each component can be tested independently.

1. Transcription

For supported audio recordings, EchoVault uses OpenAI Whisper running locally to convert speech into text.

The transcript makes a recording searchable and gives the next stage a text representation to work with.

Transcription accuracy still depends on recording quality, accents, background noise and the languages supported by the selected model.

2. Memory extraction

An open-weight Gemma model processes the transcript and generates structured metadata such as a title, summary, key events and people mentioned.

I designed this stage to distinguish the original story from AI-generated interpretations. The original transcript remains available for verification.

3. Searchable archive

EchoVault stores the original files and associated metadata, making it possible to revisit individual memories rather than repeatedly processing every recording.

4. Grounded question answering

The question-answering feature retrieves relevant material from the archive and uses it to formulate an answer.

Rather than treating the model as an unrestricted storyteller, the application is designed to ground responses in the saved records.

If a question cannot be answered from the available material, the system should say so instead of inventing a memory.

5. A human-centered interface

I used Streamlit to create an interface for uploading recordings, reviewing transcripts, exploring archived stories and generating remembrance pages.

I wanted the experience to feel more like a digital archive than a generic chatbot.

This part of the project taught me that building a useful AI application involves more than prompting a model. Data handling, validation, retrieval and the way users verify generated content all matter.

Why Does Open Innovation Matter?

For a project dealing with personal memories, the choice of AI infrastructure matters as much as the interface.

Privacy and control

Family recordings and personal stories can contain sensitive information.

Running transcription and language models locally can reduce the need to send this material to external AI services. In a fully local configuration, recordings and generated content can remain on the user's device.

This is an architectural goal, not an automatic guarantee: the complete application must be checked for external network calls, telemetry, cloud storage and other data transfers before claiming that it is fully offline.

Freedom to experiment

Open-weight models give developers more flexibility to choose models, change prompts, compare performance and adapt the application to their requirements.

For EchoVault, this means being able to experiment with different transcription and language models without designing the entire product around a single proprietary AI API.

Preservation beyond a single service

An archive should not become inaccessible simply because a hosted service changes its pricing, API or availability.

Keeping original recordings, transcripts and metadata in portable formats makes the collection easier to back up and migrate independently of a particular model provider.

Making the technology accessible

A local-first approach can reduce dependence on recurring hosted inference charges, although users still need compatible hardware, storage and electricity.

The larger point is that useful AI tools should be adaptable and understandable, rather than locked into an infrastructure that their users cannot control.

My Agent Session

I used python to implement and test EchoVault.

The session documents the decisions, experiments and debugging steps that shaped the final application.

The Spirit of It

The theme Ghost in the Machine made me think about how technology interacts with memory.

A recording is only a collection of bits until someone listens to it. A transcript is only text until someone recognizes the person, place or moment behind it.

AI cannot replace the human experience of remembering someone. It can, however, help make the material we leave behind easier to preserve and understand.

I want EchoVault to make it easier for someone to rediscover a story they had almost forgotten, find a detail in an old recording, or bring together memories that would otherwise remain scattered across devices.

The most meaningful result isn't an AI-generated story that sounds convincing.

It's helping someone find a real story worth remembering.

What's Next?

I'd like to explore better multilingual transcription, additional document formats, richer search, exportable remembrance pages and tools for organizing large collections of recordings.

I also want to improve source attribution so users can move directly from a generated summary or answer to the original passage that supports it.

EchoVault began with a simple question: what if we could use open-source AI to help preserve the stories that matter to us?

My answer is a small step toward making personal archives more accessible, searchable and useful.

Because sometimes the most valuable thing an AI can do isn't generate something new.

It's help us hold on to something we already have.

devchallenge #hf26challenge

LazyDesk: I Built a Local AI That Organizes My Files So I Don't Have To

V C Mohit Rao — Wed, 21 Oct 2026 12:03:30 +0000

This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady]

LazyDesk: I Built a Local AI That Organizes My Files So I Don't Have To

My Downloads folder has a habit of becoming a digital junk drawer.

PDFs from college, screenshots, documents, random images, project files, and files with names like final_v2_latest_REAL.pdf all end up in the same place.

I could organize them manually. I could also keep postponing it.

For Hacktoberfest Week 3, I decided to build something that takes the repetitive work off my hands: LazyDesk, a local AI-powered file organizer.

The idea is simple: let AI handle the tedious parts while keeping me in control of the final changes.

What I Built

LazyDesk is a small desktop-friendly application that helps users organize files with the assistance of an open-weight AI model.

Instead of asking users to manually inspect every file, rename it, decide where it belongs, and move it into the right folder, LazyDesk prepares an organization plan.

The workflow is straightforward:

Select a folder containing files you want to organize.
Let the application inspect file metadata and relevant content.
Ask the local AI model to suggest descriptive filenames and categories.
Review the suggestions and make corrections.
Approve the changes and let the application apply them safely.

The goal isn't to let an AI run wild across someone's computer. It's to eliminate repetitive decisions while leaving the user in control.

The principle: automate the boring work, not the user's judgment.

Demo

In the demo, I'll show a folder containing disorganized files, the AI-generated organization plan, and the resulting folder after approving the changes.

Code

The repository includes the application source code, setup instructions, dependencies, example files, and documentation explaining how the local AI integration works.

How I Built It

I built LazyDesk using Python, Streamlit, Ollama, and an open-weight Gemma model.

The application is divided into four main parts:

1. File inspection

The application collects basic metadata such as filenames, extensions, and file sizes. Where necessary, it can extract relevant text from supported documents to make more informed suggestions.

2. AI-powered classification

The model receives a limited description of each file and proposes a category, a clearer filename, and a short explanation. Structured output helps the application validate the suggestions before using them.

3. Human review

The proposed changes appear in a review interface. Users can edit, reject, or approve suggestions instead of trusting every AI output blindly.

4. Safe file operations

The application applies approved changes through ordinary Python file operations. It checks paths, handles naming conflicts, avoids silently overwriting files, and records the changes made.

The language model proposes actions; the application validates them; the user approves the final plan.

This separation is important because a language model can make mistakes, and a file organizer should never treat every generated suggestion as automatically correct.

The technical challenge

One interesting challenge is that file organization requires more than generating a plausible filename.

A model might suggest a filename that already exists, misunderstand a document, or return a category that doesn't match the application's allowed options.

I address this by validating model output, constraining category choices, checking destination paths, and requiring approval before moving files.

Why Does Open Innovation Matter?

For this project, using an open-weight model isn't just a technical preference. It changes where the work happens and who controls the data.

Privacy by design

Files can contain academic work, personal documents, financial records, and other information that users shouldn't casually upload to an external service.

Running inference locally allows the application to analyze supported files without sending their contents to a third-party AI API, provided the complete workflow is configured to remain local.

Control over the model

An open-weight model gives developers more flexibility to choose an appropriate model, adjust prompts, change inference settings, and experiment with different models as their requirements evolve.

Fewer recurring API dependencies

Once a compatible model is downloaded, local inference can avoid per-request charges from a hosted language-model API. The trade-offs include local hardware requirements, model storage, electricity, and inference speed.

Learning by building

Open AI tooling makes it possible to inspect the surrounding implementation, experiment with different models, and understand how the application behaves instead of treating the model as an inaccessible service.

For LazyDesk, the important advantage is that AI-assisted file organization can be built around user-controlled data and transparent file operations.

My Agent Session

[OPTIONAL: EMBED OR LINK YOUR DEVRELAY AGENT SESSION HERE.]

I used [INSERT YOUR ACTUAL DEVELOPMENT WORKFLOW OR TOOLS] to build and test the application. The session shows how the project evolved, the implementation decisions I made, and the problems I worked through.

The Lazy Payoff

The point of LazyDesk is to replace a repetitive manual process with a reviewable, AI-assisted workflow.

For my demonstration, I tested it with [NUMBER] files across [NUMBER] categories.

Files processed: [MEASURED COUNT]
Suggestions accepted: [MEASURED COUNT]
Suggestions corrected or rejected: [MEASURED COUNT]
Time taken by LazyDesk: [MEASURED TIME]
Time taken by my manual baseline: [MEASURED TIME]

These measurements come from my actual test run, not estimated performance figures.

The most useful outcome is not simply that AI can rename files. It's that a user can review an entire proposed cleanup in one place instead of making every decision individually.

Prize Categories

[LIST ONLY THE PARTNER CATEGORIES THAT YOUR IMPLEMENTATION ACTUALLY QUALIFIES FOR, OR REMOVE THIS SECTION.]

What's Next?

I'd like to explore additional capabilities such as duplicate-file detection, customizable organization rules, scheduled cleanup suggestions, and support for more document formats.

The guiding idea will remain the same: let local AI handle the tedious parts, keep potentially sensitive data under the user's control, and make consequential actions reviewable.

Building LazyDesk for the Hacktoberfest Slow and Steady challenge has been a reminder that a useful AI project doesn't have to be enormous. Sometimes, the best automation is the one that quietly gives people their time back.

If you've built a tool that saves you from a repetitive task, I'd love to hear about it.

devchallenge #hf26challenge