DEV Community: Shamik Das

# EchoVault: Keeping Memories Alive with Open-Weight AI

Shamik Das — Tue, 27 Oct 2026 17:07:02 +0000

What I Built

EchoVault is a privacy-conscious AI memory archive that turns voice recordings into searchable, preserved stories.

Inspired by the Ghost in the Machine theme and the idea of preserving memories across generations, I wanted to build something that gives personal stories a longer life without turning them into conversations with a fictional version of someone who is gone.

EchoVault takes an audio recording, transcribes the conversation, and uses AI to organize it into a structured memory. It can generate summaries and extract details such as people, places, dates, themes, and memorable quotations.

The resulting memories can be reviewed, edited, searched, and exported.

The goal is simple: preserve the original story, make it easier to revisit, and keep control of the archive with the person who owns it.

Code

GitHub Repository: https://github.com/ShamikDas-Dev/EchoVault

The repository will contain the source code, setup instructions, and configuration needed to run EchoVault.

How I Built It

EchoVault combines a lightweight web application with open-source speech recognition and an open-weight language model.

Technology stack:

Python and FastAPI: Backend API and application logic.
HTML, CSS, and JavaScript: User interface and memory archive.
faster-whisper: Local speech transcription.
Gemma: Open-weight language model for organizing transcripts and generating memory summaries.
Ollama: Runs Gemma locally when local inference is selected.
OpenRouter: Provides an alternative inference route, with configurable models and fallback handling.
SQLite and local file storage: Store memory records, transcripts, and associated recordings.

The workflow is:

Import an audio recording.
Transcribe the audio using faster-whisper.
Review and correct the transcript.
Generate a structured memory using the selected AI provider.
Save the memory and search or export it later.

I also worked on handling unreliable model responses. A model returning an error, empty content, or malformed structured output should not silently be treated as a successful AI operation. EchoVault validates responses and can attempt configured fallback models when appropriate.

The application supports both local Ollama inference and OpenRouter-based inference. This gives me room to experiment with different models without rebuilding the entire application around one provider.

Why Does Open Innovation Matter?

Memories are personal. The tools used to preserve them should give people meaningful control over where their data goes and how it is processed.

That is why open-weight AI matters to EchoVault.

With local transcription and local Ollama inference, the application can process recordings and generate summaries on the user's machine without sending transcript text to a hosted AI provider.

When OpenRouter is selected, transcript text is sent to the remote inference service for summarization. I want that distinction to remain explicit: local inference and hosted inference have different privacy trade-offs.

Open models also make experimentation possible. I can change the model, adjust prompts, inspect the application logic, and run the same workflow locally without being permanently tied to one commercial AI API.

For a personal archive, there is another important consideration: the application should not depend entirely on the continued existence of a particular AI service. The original recordings and stored memories should remain accessible independently of the model used to summarize them.

Open innovation does not automatically make a system more accurate or more private. Those properties still depend on the implementation. What it gives EchoVault is more flexibility, more control over inference, and a clearer path toward a user-controlled archive.

The Spirit of It

I did not want to build another chatbot that pretends to speak for someone who has passed away.

I wanted to build something that helps preserve what a real person actually said.

Imagine having an old recording of a grandparent describing a childhood home, a festival, or a family tradition. Years later, finding that one detail in a long recording can be difficult. EchoVault is designed to make those stories easier to preserve, revisit, and share.

The AI should help organize the memory, not replace the person behind it. The recording remains the source, and the generated summary remains something the user can review and correct.

For me, that is the spirit of EchoVault: not creating a ghost, but making sure a real voice does not disappear into an forgotten folder.

Prize Categories

Best Use of Gemma

EchoVault supports Gemma through local Ollama inference and configurable OpenRouter model integration.

The project is designed to let users choose between local and hosted inference while keeping the memory-management workflow independent of a single model provider.

SlothDesk: Let AI Handle Your Digital Clutter

Shamik Das — Tue, 20 Oct 2026 06:05:19 +0000

What I Built

Meet SlothDesk 🦥 — a document organizer that does the boring work for you.

Students and developers accumulate PDFs, notes, reports, and text files every day. Organizing them manually means opening files, figuring out what they contain, renaming them, and moving them into the right folders. I wanted to make that process easier.

SlothDesk uses AI to analyze documents and suggest descriptive filenames, categories, tags, and short summaries. You review the suggestions, select the files you approve, and download the organized result as a ZIP.

It supports TXT, Markdown, PDF, DOCX, CSV, LOG, and JSON files.

The goal is simple: spend less time managing files and more time doing actual work.

Demo

Live application: https://slothdesk-ai.streamlit.app/

The deployed version lets users upload documents, analyze them with AI, review suggested changes, and download the organized output.

Code

GitHub repository: https://github.com/ShamikDas-Dev/SlothDesk

The project is built with Python and Streamlit, with a reusable document-processing module and an AI-powered analysis workflow.

How I Built It

I built SlothDesk with Python, Streamlit, and open-weight AI models.

The project has two approaches to AI inference:

Local mode: Ollama with Qwen2.5 1.5B. This lets users analyze documents locally without sending their contents to a cloud AI API, once the model is downloaded.
Cloud mode: Groq API with OpenAI GPT-OSS 20B, an open-weight model served through Groq.

The application extracts text from supported documents and asks the model to return structured metadata, including a category, a descriptive filename, tags, and a summary.

The workflow is intentionally straightforward:

Upload documents or select a local folder.
Let the AI analyze their contents.
Review and edit the suggested categories and filenames.
Select the files you want to organize.
Generate organized copies and download the resulting archive.

I also added safeguards: the application does not automatically delete or move original files, and users can review suggestions before applying them.

Why Does Open Innovation Matter?

I wanted SlothDesk to be more than another interface built around a closed AI API.

Using an open-weight model gives the project more flexibility. I can experiment with different models, change the inference setup, and potentially self-host the model instead of depending on a particular proprietary model API.

Open innovation also lets the same application serve different needs.

Someone who prioritizes privacy can use the local Ollama version, keeping document analysis on their own computer. Someone who prefers a hosted application can use the Groq version without having to run a model locally.

There is a trade-off: the hosted version sends extracted document text to Groq for inference, so it should not be treated as an offline or fully local solution. The local version is the better option when keeping documents on the user's own machine is important.

For me, that flexibility is the main value of open-weight AI. The model is not just a hidden dependency; it is a component I can replace, run differently, and build around.

The Lazy Payoff

The real payoff is removing repetitive decisions from everyday file management.

Instead of manually opening every document, choosing a category, inventing a filename, and sorting everything yourself, SlothDesk prepares suggestions in one workflow. You only need to review the results and approve the changes.

I have tested the application workflow, but I have not yet benchmarked the exact time saved across a large collection of files. I would rather measure that properly than invent a number.

My idea of being productive is not doing every small task faster. Sometimes, it is eliminating the task altogether.

Conclusion

SlothDesk is my attempt to make AI useful for an ordinary, repetitive problem.

It combines document understanding with a practical organizing workflow, gives users control over the final changes, and offers both local and hosted inference options.

The sloth has the right idea: conserve your energy for things that matter.

ShopScribe AI: Open-Weight AI for Small Retailers

Shamik Das — Tue, 13 Oct 2026 15:45:41 +0000

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

What I Built

I built ShopScribe AI, an AI-powered product content generator designed for small retailers, starting with cosmetics and skincare shops.

Small business owners often need to write product descriptions, Instagram captions, and WhatsApp promotional messages. Creating this content manually takes time, while hiring someone to handle marketing may not be practical for a small shop.

ShopScribe AI turns basic product information into a ready-to-edit marketing content pack.

Users can provide a product name, brand, category, verified features, selling price, target audience, and preferred tone. The application generates:

Instagram captions for product promotion.
WhatsApp promotional messages for customers.
Product descriptions for online catalogues and listings.

It also includes price validation, checks for potentially unsupported product claims, and local history storage.

The target customers are independent retailers who want to create marketing content without needing dedicated marketing staff.

The business model I want to explore is a free trial followed by an affordable monthly subscription for regular use. This is an initial hypothesis that needs validation with actual retailers.

Demo

Live demo: https://shopscribe-ai.streamlit.app/

The demo allows users to enter product details, generate a content pack, edit the results, and copy or export the generated content.

The AI integration can use a locally running model through Ollama or a hosted open-weight model through the Groq API.

Code

GitHub repository: https://github.com/ShamikDas-Dev/shopscribe-ai

The project is built with Python and Streamlit, with separate modules for prompt construction, model inference, data validation, pricing calculations, and local history.

The repository includes setup instructions and tests for key application logic.

How I Built It

I built ShopScribe AI with Python, Streamlit, Ollama, and open-weight language models.

The application supports two inference approaches:

1. Local inference with Ollama

The application can run an open-weight model such as Qwen3 4B locally on the user's computer. Once the model and dependencies are downloaded, generation can work without an internet connection.

This is useful for retailers who prefer to keep their product information on their own computer.

2. Hosted inference with Groq

The application can also use the Groq API to access an available open-weight model, such as openai/gpt-oss-20b.

This option makes the application easier to demonstrate through a publicly hosted Streamlit interface without requiring every visitor to download and run a model locally.

The other technologies include:

Streamlit: User interface and content-generation workflow.
Pydantic: Structured data validation.
SQLite: Local content history.
Python validation logic: Discount calculations and checks for suspicious claims or inconsistent prices.
pytest: Automated tests for core functionality.

I focused on prompt engineering, structured output, and validation rather than fine-tuning a model. For a small-business tool, generating usable content consistently is more important than adding unnecessary model complexity.

Why Does Open Innovation Matter?

A closed AI API could generate marketing copy, but I wanted ShopScribe AI to offer more control over how inference happens.

Open-weight models make that flexibility possible.

With local inference, the user can generate content without sending product information to a remote AI inference provider. After downloading the model, the workflow can also operate offline.

Running the model locally avoids a per-request fee from a proprietary inference API, although the user still needs suitable hardware and must account for electricity and setup costs.

The hosted option makes the application more accessible to people who do not want to install a model themselves. It also lets me experiment with different available open-weight models without redesigning the entire application.

The choice between local and hosted inference is deliberate:

Local mode: More control over data and offline use after setup.
Hosted mode: Simpler access, with usage subject to the provider's limits and policies.
Model flexibility: The generation layer can be adapted to different models as requirements change.

Open innovation is not automatically better in every situation. Local models require hardware, smaller models can produce weaker results, and hosted inference introduces a dependency on an external provider. The benefit is having the ability to choose and change the approach rather than building the product around one proprietary API.