DEV Community: Pyla Neeraja

# Echoes of Yesterday 🕯️: Giving Old Memories a New Life with Local AI

Pyla Neeraja — Sat, 31 Oct 2026 16:51:30 +0000

🕯️ Echoes of Yesterday

Your memories are fragile. Their stories don't have to be.

What if an old photograph could become a story worth remembering?

Imagine finding an old school photograph. You remember the classroom, your friends, the lunch breaks, and those little moments that once felt ordinary but now mean everything.

But what happens when those memories begin to fade?

That question inspired me to build Echoes of Yesterday — a privacy-first, local AI-powered memory preservation and storytelling application.

This project is my contribution to the DEV.to Open-Source AI Challenge – Week 4: Ghost in the Machine.

💡 The idea

Photographs capture moments, but they cannot capture the complete stories behind them.

Many AI applications also rely on cloud services, which may require users to share personal photographs and information with external platforms.

I wanted to explore a different approach:

Can we use locally running AI models to transform personal memories into meaningful stories while keeping the memory archive on the user's device?

That idea became Echoes of Yesterday.

✨ What can it do?

📷 1. Memory Revival

This is the heart of the application.

Users can:

Upload an old photograph.
Describe the memory behind it.
Use a local vision model to analyse visible details.
Generate a story in different styles.
Save the original description and generated story.

The idea is to bring the story behind a photograph back to life without treating AI-generated details as historical facts.

🌼 2. Digital Ofrenda

Inspired by the Día de los Muertos tradition of remembering and celebrating loved ones.

Users can create a digital remembrance space with photographs and meaningful messages.

It is a place to celebrate memories and honour the people who matter.

👻 3. Ghost Story Mode

Not every story has to be real.

This feature explores the creative side of the Ghost in the Machine theme by generating mysterious and suspenseful fictional stories.

📚 4. Memory Vault

Memories should not disappear after generating a story.

The Memory Vault allows users to:

Browse saved memories.
View associated photographs.
Revisit generated stories.
Download stories as text files.
Delete memories and associated photographs.

🧠 How I built it

I used the following technologies:

Technology	Purpose
Python	Application logic
Streamlit	User interface
Ollama	Local AI execution
Qwen 2.5 3B	Text generation
Qwen 2.5 VL 3B	Photograph understanding
SQLite	Memory storage
Pillow	Image processing

Architecture

The user interacts with a Streamlit application.

Memory Revival connects to the AI engine, which uses local Qwen models through Ollama. Generated stories and user-provided descriptions can be stored in SQLite, while uploaded photographs are stored in a local folder.

Digital Ofrenda, Ghost Story Mode, and Memory Vault provide additional experiences around remembrance, storytelling, and archiving.

🔐 Why local AI?

Personal memories can contain sensitive information.

I wanted to explore an architecture where:

AI inference runs locally through Ollama.
No external AI API is required for inference.
Photographs and memory records are stored locally.
Users control their local archive.

The models used are open-weight models. This does not automatically mean they have OSI-certified open-source licences.

Local processing also does not automatically guarantee encryption or complete security.

🚧 Challenges and learnings

This project taught me that building an AI application is not just about connecting a model to a user interface.

Some challenges I encountered:

Running multiple AI models on CPU hardware.
Managing slower local AI generation.
Connecting image analysis with text generation.
Maintaining persistent records with SQLite.
Handling photograph uploads and deletion.
Designing an experience around emotionally sensitive memories.

One important lesson was that AI should support human memories, not replace them or invent personal history.

🔮 What's next?

Some ideas I would love to explore:

Chronological memory timelines.
Exportable family memory books.
Multilingual storytelling.
Memory backup and restoration.
Improved local photograph restoration.
Family-controlled shared memory archives.

🎥 See it in action

Project demo:

https://drive.google.com/file/d/1dO8DOck0pCMQD3CVSQmMw87Lh2RmGXDw/view?usp=sharing

GitHub repository:

https://github.com/Neeraja-Pyla/Echoes-of-Yesterday

The repository includes the application source code, dependencies, and setup instructions.

❤️ A final thought

A photograph captures a moment.

A story gives that moment meaning.

And a memory gives it a place to live.

I built Echoes of Yesterday around one simple belief:

Some memories deserve more than storage. They deserve to be remembered.

Thank you for reading! 🕯️

Built with Python, Streamlit, Ollama, and Qwen.

SlothSortAI: A Local AI File Organizer That Does the Work for You

Pyla Neeraja — Wed, 21 Oct 2026 08:08:54 +0000

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

What I Built

I built SlothSortAI 🦥, an open-source, local-first AI file organizer designed to explore how AI can make everyday file management easier.

We all accumulate documents, PDFs, screenshots, and other files until finding the right one becomes a task of its own. SlothSortAI explores how AI-assisted analysis can help reduce this repetitive work.

The application combines Python-based file scanning, a Streamlit interface, and a locally running language model through Ollama.

Key features

Folder scanning: Scans a selected folder to discover files.
Local AI analysis: Integrates the open-weight qwen2.5:3b model through Ollama.
Simple interface: Provides an interactive Streamlit UI.
Safety-focused design: Includes a dedicated module for file-handling safeguards.
Open-source code: Lets developers inspect, run, and extend the project.

My goal was to build a practical starting point for AI-assisted file management rather than another complicated AI demo.

Demo

Project repository: https://github.com/Neeraja-Pyla/SlothSortAI

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/wanf40smvse914khd5km.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/a1hl0aeb5sexhx5mc5mf.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/d88fr12uqg6tk0vud514.png]

![https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/3jnkwmmlx24nahzhk6qv.png]

The application currently runs locally and requires Python, Streamlit, Ollama, and the configured model. I have not deployed a public hosted demo.

Code

GitHub: https://github.com/Neeraja-Pyla/SlothSortAI

The repository contains the Python application, file scanner, database module, AI integration, safety logic, dependency list, and automated tests.

To try it locally:

git clone https://github.com/Neeraja-Pyla/SlothSortAI.git
cd SlothSortAI
python -m venv .venv

On Windows PowerShell, activate the environment:

.\.venv\Scripts\Activate.ps1

Install dependencies and download the model:

pip install -r requirements.txt
ollama pull qwen2.5:3b

Start the application:

streamlit run app.py

Ensure Ollama is installed and available before running the application. Refer to the repository README for any additional setup details.

How I Built It

I built SlothSortAI using Python, Streamlit, Ollama, and the open-weight qwen2.5:3b language model.

The application combines traditional programming for file scanning and application logic with local AI inference for AI-assisted analysis.

Here's the technology stack:

Python: Core logic and file handling.
Streamlit: User interface.
Ollama: Runs the language model locally.
Qwen 2.5 3B: Open-weight model used for AI integration.
Pytest: Automated testing.
GitHub: Source control and open-source distribution.

One important part of the process was keeping the application modular, with separate files for scanning, AI integration, database functionality, and safety-related logic.

I also ran the automated test suite, which passed all six existing tests.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with AI beyond a hosted API.

By using an open-weight model through Ollama, I could explore local inference and build an application without requiring a paid hosted model API for its AI inference.

This matters for a file-management tool because users may prefer to keep their workflows on their own machines. Local inference gives users more control over where model processing takes place, although privacy still depends on the complete application and how files are handled.

Open-source development also makes the implementation accessible to other developers. They can inspect the code, learn from the architecture, reproduce the setup, identify weaknesses, and contribute improvements.

For me, the biggest lesson is that open-weight AI makes experimentation more accessible. A developer can start with a small model, connect it to a practical application, and gradually improve the result.

InvoicePilot AI: Local-First Invoice Extraction with Open-Weight AI

Pyla Neeraja — Sun, 18 Oct 2026 12:29:39 +0000

🧾 InvoicePilot AI — Local-First Invoice Extraction with Open-Weight AI

What I Built

I built InvoicePilot AI, a local-first AI invoice extraction MVP designed to help freelancers and small businesses extract structured information from invoices.

Users can upload text-based PDF or TXT invoices, extract important fields using a locally running AI model, review and edit the results, and export the data as JSON or CSV.

✨ Features

Extract vendor name, invoice number, dates, currency, subtotal, tax, and total.
Process invoices using a locally running Ollama model.
Support text-based PDF and TXT files.
Review and edit extracted information.
Export results to JSON and CSV.
No hosted AI API is required for inference.

🛠️ How I Built It

Python — application logic
Streamlit — user interface
Ollama — local model runtime
Qwen 2.5 3B — invoice extraction
PyMuPDF — PDF text extraction

🎥 Demo

I recorded a short screen demonstration showing invoice upload, AI extraction, field editing, and data export.

invoiceAi video.mp4 - Google Drive

drive.google.com

💻 Source Code

GitHub repository: https://github.com/Neeraja-Pyla/InvoicePilotAI

🌱 Why Does Open Innovation Matter?

Open-weight AI models make it easier for developers to experiment, learn, and build useful applications without depending on paid hosted AI APIs. Running inference locally can also give users greater control over their invoice data.

This project helped me explore practical AI integration and build a working application with tools I can run on my own computer.

🔍 Current Limitations

Scanned PDF OCR is not implemented.
Extracted information must be verified by the user.
Invoice history is not saved between sessions.

🚀 What's Next?

I would like to explore OCR for scanned invoices, duplicate invoice detection, and batch processing.

devchallenge #hf26challenge

🌿 NatureQuest AI: Turn Screen Time into Outdoor Adventures

Pyla Neeraja — Sun, 11 Oct 2026 11:51:13 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

🌿 NatureQuest AI — Turn Screen Time into Outdoor Adventures

NatureQuest AI is an open-source web app designed to encourage people to step away from their screens and explore the outdoors.

Users select how much free time they have and an activity they enjoy. The app provides outdoor activity inspiration and practical steps for:

🚶 Nature walks
🐦 Birdwatching
🪴 Gardening
📸 Nature photography

The idea is simple: instead of spending every spare moment scrolling, use a little of that time to notice nature, learn about local biodiversity, or care for plants.

I built this project as a beginner developer to explore how open-source AI can support a simple, real-world idea.

Demo

🌐 Try NatureQuest AI:

https://naturequest-ai-drvqjysdphckzxeauycuub.streamlit.app/

Choose your interests, select your available time, and discover an outdoor activity.

Code

💻 GitHub repository:

https://github.com/Neeraja-Pyla/naturequest-ai

The repository includes the Python application, dependency list, setup instructions, and MIT license.

How I Built It

I built NatureQuest AI using:

Python for application logic
Streamlit for the interactive web interface
Hugging Face Transformers to integrate an open-source AI model
Google FLAN-T5 Small to generate activity inspiration
PyTorch to run the model
Git and GitHub for version control and source-code publishing

The app sends a prompt to FLAN-T5 Small based on the user's selected interests and available time. Since small language models can produce repetitive or imperfect responses, I also created predefined activity plans with practical steps and nature-related benefits.

I deployed the app using Streamlit Community Cloud so people can try it without installing Python locally.

One lesson I learned is that integrating AI is only part of the work. A useful application also needs thoughtful prompts, sensible fallback behaviour, and an interface that helps people achieve something in the real world.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with a language model and build a working application without relying entirely on a closed, paid AI API.

Using an open-source model gave me the opportunity to learn how model integration works, experiment with prompts, and understand some of the limitations of AI-generated text.

It also makes the project easier for other developers to inspect, learn from, adapt, and improve. Someone could contribute new outdoor activities, improve the prompts, or add features for local nature exploration.

For a beginner, access to open tools and models lowers the barrier to experimenting with AI and turning an idea into a working project.

My Agent Session

I built and tested this project with AI-assisted development. I have not published a DevRelay agent session for this submission.

Prize Categories

This project focuses on open-source AI and the Touch Grass theme. I am not claiming entry into any partner prize category unless it meets that category's specific requirements.

🌱 Let's turn a little screen time into time outdoors!

What outdoor activity would you add to NatureQuest AI?

devchallengesvg #hf26challengesvg #opensource #python