DEV Community: Shivam Maurya

The Last Echo: Keeping Memories Alive with Offline AI

Shivam Maurya — Fri, 30 Oct 2026 12:54:26 +0000

The Last Echo is a privacy-first, offline AI memory keeper that helps preserve the stories, voices, photographs, and memories of people we love.

Inspired by Día de los Muertos, I wanted to build something that celebrates the idea that people never truly disappear as long as their stories continue to live.

Imagine being able to sit down, open your laptop, and ask:

"What was Grandma's favorite recipe?"
"Tell me the story about Dad's childhood."
"What songs did Grandpa love?"
"What advice did Mom always give me?"

The Last Echo uses locally stored memories and an open-weight AI model to retrieve relevant stories and respond conversationally.

Rather than pretending to bring someone back, it helps people reconnect with the memories and stories they have chosen to preserve.

The goal is simple: Technology should help us remember, not replace the people we miss.

Demo
https://github.com/eugeneblack161/the-last-echo

The demo will showcase:

Adding personal memories and stories.
Asking questions about saved memories.
Retrieving relevant stories using AI.
Having private conversations with the local AI assistant.
Code

💻 GitHub Repository:https://github.com/eugeneblack161/the-last-echo

The project is designed around open-source technologies and local-first architecture.

How I Built It

The Last Echo is built around locally running AI rather than depending on a proprietary cloud-based AI API.

My planned technology stack:

Ollama: Runs open-weight language models locally.
Llama 3.1 / Qwen: Provides conversational intelligence.
Whisper: Converts recorded family stories into text.
ChromaDB: Stores vector embeddings for semantic memory retrieval.
Python: Powers the backend and AI orchestration.
React: Provides a simple, welcoming user interface.
How it works
Users add memories through text, photographs, or recorded stories.
Whisper transcribes recorded stories locally.
The application converts memories into searchable embeddings.
ChromaDB retrieves relevant memories when someone asks a question.
The local language model generates a response grounded in the retrieved memories.

The entire AI pipeline is designed to work locally, without requiring an external AI API.

Why Does Open Innovation Matter?

For a project like The Last Echo, open-source AI isn't just a technical preference. It's the foundation of the idea.

Privacy matters

Family memories can contain deeply personal information. Running AI locally means users don't have to upload those memories to an external AI provider.

Memories shouldn't depend on a subscription

A person's memories shouldn't disappear because an API becomes expensive, a subscription expires, or a company shuts down a service.

Freedom to experiment

Open-weight models let developers experiment with different models, customize behavior, and improve retrieval without being locked into a single provider.

Offline accessibility

The long-term goal is to make The Last Echo work entirely offline. Your memories should remain accessible even without an internet connection.

Community-driven innovation

Open-source tools make it possible for developers everywhere to contribute improvements, build extensions, and adapt the project for different languages and cultures.

A closed AI API might make the initial prototype easier, but an open-source architecture gives this project something much more important: independence and long-term control.

The Spirit of It

Día de los Muertos reminds us that remembering someone is an act of love.

I imagined a family sitting together, sharing stories about someone they miss. A grandchild asks a question about their grandfather, and instead of searching through old boxes of photographs, they can find a story that someone carefully preserved.

Maybe it's a recipe. Maybe it's a childhood memory. Maybe it's a small piece of advice that would otherwise have been forgotten.

The Last Echo isn't about creating digital ghosts or replacing human relationships.

It's about making sure the stories we carry don't disappear with time.

Because sometimes, the most meaningful thing technology can do is help us remember.

Prize Categories
https://github.com/eugeneblack161/the-last-echo

Built with ❤️, open-source AI, and the belief that every story deserves to be remembered.

SlothDesk: Let AI Handle the Digital Chores You Keep Putting Off 🦥

Shivam Maurya — Tue, 20 Oct 2026 16:34:45 +0000

What I Built:
I built SlothDesk, a local-first AI assistant designed to make everyday digital housekeeping less painful.

We all have that folder full of vaguely named documents, notes we meant to summarize, and information we know we'll need later. The problem isn't that these tasks are difficult. It's that they're repetitive enough to keep getting postponed.

SlothDesk helps by:

Summarizing long text files into short, useful notes.
Suggesting clear, descriptive filenames.
Categorizing documents by their content.
Creating a daily digest of important information.
Preparing proposed file changes for review before applying them.

The goal is simple: spend less time managing information and more time doing whatever actually matters.

Think of it as a tiny digital sloth that does the boring work at its own pace.

Demo
https://github.com/rudrakshk25060-csds/slothdesk-ai

The ideal demo is straightforward: drop a messy collection of text files into SlothDesk, run the assistant, and show the summaries, suggested filenames, and organized output.

Code
https://github.com/rudrakshk25060-csds/slothdesk-ai

How I Built It

SlothDesk is designed around open-source AI rather than a closed AI API.

The planned stack is:

Ollama for running models locally.
An open-weight language model, such as Qwen2.5 or another compatible model, for summarization and categorization.
Python for file handling, task orchestration, and validation.
A lightweight interface for reviewing suggested changes and approving actions.

The workflow is deliberately simple:

The user selects a folder or supplies text files.
The application extracts the relevant text.
The local model generates summaries, categories, and filename suggestions.
The application validates the results and prepares proposed changes.
The user reviews the proposals before any files are renamed or moved.

This keeps the model focused on understanding and organizing information while ordinary code handles predictable file operations.

The architecture also makes it possible to switch compatible models as better options become available.

Why Does Open Innovation Matter?

For a tool that reads personal documents, where the AI runs matters just as much as what it can do.

Privacy: With local inference, document contents can remain on the user's machine instead of being sent to a third-party inference API. The application must also avoid unnecessary network calls in its own implementation.

Freedom to experiment: Open-weight models let developers compare different models, tune prompts, and adapt the system to their specific workflow without tying every decision to one hosted provider.

Control over costs: Local inference avoids per-request API charges, although running the model still consumes hardware resources and electricity.

Offline potential: Once the application and model weights are downloaded, the core workflow can operate without an internet connection, provided all dependencies are installed locally.

A simpler, more transparent agent: SlothDesk uses deterministic code for file operations and AI for tasks that benefit from language understanding. That makes its behavior easier to inspect and its changes easier to review.

A closed API might provide a convenient starting point, but a local, open-model architecture gives this project more control over privacy, deployment, and long-term flexibility.

The Lazy Payoff

The real win is eliminating the small decisions that accumulate throughout the week.

Instead of opening every document, reading it, inventing a filename, and deciding where it belongs, users get a first pass prepared for them.

To measure the payoff, I plan to compare the time required to organize the same set of files manually against the time required with SlothDesk, including review and correction time.

The goal isn't to remove people from the process entirely. It's to make the tedious 80% easier, leaving people to handle the decisions that actually need their attention.

Less clicking. Less procrastinating. More doing nothing when you finally have free time.

I Built a Private AI Bookkeeper for Freelancers — Without Paying Per API Call

Shivam Maurya — Sun, 18 Oct 2026 15:50:52 +0000

What I Built
Freelancers spend too much time sorting receipts, categorizing expenses, and preparing records for tax season.

So I built PocketLedger AI, a local-first bookkeeping assistant that turns receipts and invoices into structured, searchable expense records.

The workflow is simple:

Upload a receipt, invoice, or bill.
Extract the merchant, date, total, currency, and line items.
Suggest an expense category.
Review and correct the result.
Export everything to CSV for a spreadsheet or accounting workflow.
The target customers are freelancers, independent consultants, designers, developers, and other solo business owners who want to spend less time on administration.

The business model is straightforward: a one-time purchase for the desktop app, with optional paid upgrades for advanced features and support.

The goal isn't to replace an accountant. It's to eliminate repetitive data entry before the records reach one.

Demo
Live demo: https://github.com/tribhu05/pocketledger-ai

The most useful demo would show the complete workflow: receipt upload, extracted fields, category suggestion, human correction, and CSV export.

Code
GitHub repository: https://github.com/tribhu05/pocketledger-ai

The project is designed around replaceable AI components rather than a proprietary API that controls the entire workflow.

How I Built It
The core idea is to use open-weight AI for document understanding and expense categorization while keeping ordinary application logic deterministic.

The proposed stack:

Python for document processing and the application backend.
Ollama for running an open-weight language model locally.
Qwen or another compatible open-weight model for structured field extraction and category suggestions.
Pydantic for validating the model's structured output.
SQLite for storing expense records locally.
Pandas for generating CSV exports.
A local OCR engine for reading scanned receipts and image-based PDFs.
The processing pipeline looks like this:

Receipt or invoice → OCR → open-weight model → schema validation → user review → SQLite → CSV export.

The model doesn't get to invent a final expense record without validation. Required fields are checked, amounts are normalized where possible, and uncertain values are presented for human review.

The model is also replaceable. A user can experiment with a smaller model for faster processing or a larger one for difficult receipts without rebuilding the entire application.

The intended deployment is local-first: once the required model and software dependencies have been downloaded, the core workflow can run without an internet connection.

Why Does Open Innovation Matter?
For this project, open innovation isn't just a technology preference. It's part of the business model.

Privacy becomes a product feature.

Receipts can contain customer names, addresses, transaction details, and other sensitive information. Local inference lets users process those documents on their own computers instead of sending every receipt to an external AI provider.

The economics work for a small side hustle.

A per-request AI API charge might look insignificant at first, but it creates an ongoing variable cost. With local inference, the user supplies the computing hardware, so there is no mandatory per-receipt model API fee.

There are still costs for development, support, distribution, and hardware, but the marginal inference cost can be substantially lower.

I can change the model without rebuilding the product.

Different customers have different hardware and accuracy requirements. An open-weight approach lets me compare compatible models, tune prompts, and potentially fine-tune a model on representative receipt formats.

Offline operation is possible.

After the model and dependencies are installed, receipt processing can work without a network connection. That makes the tool useful to people who don't want their bookkeeping workflow to depend on an external service being available.

I control the product roadmap.

I'm not forced to redesign the core workflow around a proprietary API's pricing changes, model retirement, or rate limits.

A closed API might provide better performance on certain difficult documents or work on low-powered devices without requiring users to manage local models. Those are real trade-offs. The point is to give customers a useful alternative when privacy, predictable operating costs, and control matter more than outsourcing inference.

Open-weight models make this product possible as a small, independent business rather than requiring a paid AI backend for every transaction.

My First User
The first people I'd put this in front of are freelancers who currently track expenses manually in spreadsheets.

I'd ask one person to process a batch of real receipts and measure three things:

How many fields were extracted correctly?
How many receipts required manual correction?
How much time did the workflow save compared with manual entry?
I'd also ask whether they'd pay for a local-first tool and which export format they actually need.

I want the first validation to be a real workflow test, not just a successful model demo.

What's Next?
The next steps are better OCR for crumpled and faded receipts, duplicate detection, support for multiple currencies, and export templates for popular bookkeeping workflows.

I'd also like to explore an optional review screen that explains why the model suggested a particular expense category, making corrections easier and helping users catch mistakes.

The guiding principle is simple: use AI where it saves time, use deterministic code where correctness matters, and keep the user's financial data under their control.

A small tool doesn't need to automate an entire business to be worth paying for. Sometimes saving a freelancer an hour of tedious bookkeeping every month is enough.

Built for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

Note: PocketLedger AI is the proposed project concept for this submission. Replace the implementation details with the components actually used, add the real repository and demo, and include user feedback only after testing with a real person.

Hello Everyone...

Shivam Maurya — Mon, 12 Oct 2026 18:20:11 +0000

Hey everyone, My name is Shivam Maurya (scriptedbyshivam). I am new to this community. Happy to be the part of DEV.