DEV Community: Nigel M Kutadzaushe

Midzimu: Keeping Family Stories Close with Local AI

Nigel M Kutadzaushe — Tue, 27 Oct 2026 10:02:22 +0000

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

What I Built

Midzimu is an offline-first family oral-history archive for preserving memories, proverbs, traditional practices, recipes, and the words elders choose to share. You can write and edit stories, record audio or attach a recording, search the archive, and save or restore a backup.

I built it as a place for families to keep these voices and memories close, with an optional local AI helper rather than making AI a requirement for using the archive.

Demo

There isn't a hosted demo yet. You can run the app locally with Python 3:

python -m http.server 4173 --bind 127.0.0.1

Then open http://127.0.0.1:4173. For microphone recording and local storage, use a supported browser; localhost counts as a secure context.

Code

Midzimu on GitHub

How I Built It

Midzimu is a progressive web app built with HTML, CSS, and vanilla JavaScript, with no third-party runtime dependencies. Story text and recordings are stored in the browser's IndexedDB. A service worker caches the app shell for offline visits after the first load.

The optional AI helper sends a transcript to an Ollama server at the address the user configures. It can draft a summary, suggest themes, and translate into a chosen language. The original transcript remains separate and unchanged. With Ollama running locally, the story text stays on the user's device; a remote Ollama address would receive it, so users should only configure an endpoint they trust.

Why Does Open Innovation Matter?

Family stories can be deeply personal. Keeping the archive in the browser, with backups the family controls, avoids requiring an account or cloud archive. The core archive works without AI, and the optional helper can use an open-weight model through a local Ollama installation. That gives people more control over where their stories go and lets them choose or change the model instead of depending on a hosted AI API.

The trade-off is that local AI is optional setup: users need to install Ollama and a model, and configure the local service to accept requests from the app. The archive itself remains useful without that setup.

The Spirit of It

Midzimu doesn't try to imitate an ancestor or invent their voice. It offers a place to preserve the words, recordings, and traditions people choose to share, so those memories can stay with the family.

🦥 LazyDesk AI: Let AI Handle the Reading While You Focus on What Matters

Nigel M Kutadzaushe — Tue, 20 Oct 2026 15:25:34 +0000

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

What I Built

I built LazyDesk AI 🦥, an AI-powered document summarisation and productivity assistant that helps people spend less time reading lengthy documents and more time focusing on what matters.

Have you ever opened a long PDF or report just to find one important deadline, a few key points, or something you need to act on? That's the problem I wanted to tackle.

LazyDesk AI allows users to upload PDF and plain-text (TXT) documents and receive structured summaries containing an overview, key points, important dates or deadlines, and recommended next actions. Users can also download their summaries in Markdown format.

I built it for students, professionals, and anyone who regularly deals with information-heavy documents. Instead of manually going through every paragraph to understand the essentials, users can start with a concise summary and return to the original document whenever they need more detail.

The idea behind the name is simple: let AI handle some of the reading while you focus on what matters.

Demo

The project currently runs locally through Streamlit.

To try it out, follow the setup instructions in the GitHub repository:

🔗 GitHub Repository: https://github.com/Nijel20/LazyDesk-AI

A hosted demo or recorded walkthrough would make the project easier to explore without installing it. For now, the repository provides the code and instructions needed to run the application.

Code

🦥 Explore LazyDesk AI on GitHub:

https://github.com/Nijel20/LazyDesk-AI

The project is built with Python and Streamlit, with separate modules for document reading, AI communication, summarisation, and configuration.

The repository includes the application source code, dependency list, environment configuration example, and README with setup instructions.

How I Built It

I built LazyDesk AI using Python, Streamlit, and the Ollama Cloud API.

The application follows a straightforward workflow:

Upload: The user selects a PDF or TXT document.

Extract: Python extracts readable text using pypdf for PDFs and standard text decoding for TXT files.

Analyse: The application sends a summarisation prompt and the extracted text to a configured model through the Ollama Cloud API.

Present: The AI returns a structured summary with key points, deadlines, and recommended next actions.

Save: The user can download the summary as a Markdown file.

I separated the application into modules so that document processing, AI requests, and summarisation logic are easier to maintain and extend.

For AI inference, I used Ollama Cloud with a configurable model identifier. This made it possible to integrate an AI model into a working application without requiring me to host a large model on my own computer.

One important detail is that my current implementation uses hosted inference rather than local inference. Document text included in requests is sent to Ollama Cloud for processing, so this version requires an internet connection.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers opportunities to experiment, learn, and build useful applications without having to create every component from scratch.

For this project, Python and Streamlit provided accessible building blocks for developing the application, while Ollama made AI model integration practical for a student project.

Using an open-weight model through an accessible model ecosystem also creates room for experimentation. I can explore alternative supported models, compare their summarisation quality, and potentially investigate local inference in a future version.

A closed API can also make AI applications possible, but open-weight models offer a different kind of flexibility: developers can explore model choices and, where the model licence and deployment setup permit, gain more control over how inference is run.

LazyDesk AI is still an early-stage project, but it demonstrates how these tools can turn a simple productivity idea into a working application.

For me, open innovation means making experimentation more accessible and giving more people the opportunity to turn ideas into practical tools.

I'd love to hear your feedback and suggestions for what LazyDesk AI should do next!

devchallenge #hf26challenge #python #ai #productivity

🦥 LazyDesk AI: Let AI Handle the Reading While You Focus on What Matters

Nigel M Kutadzaushe — Tue, 20 Oct 2026 15:18:54 +0000

Have you ever opened a long document, started reading, and realised that finding the important information would take almost as much time as reading the whole thing?

As a software engineering student, I wanted to explore how AI could make this everyday task easier. That led me to build LazyDesk AI, a document summarisation and productivity assistant built with Python, Streamlit, and Ollama Cloud.

This is my contribution to the Hacktoberfest 2026 DEV Challenge — Week 3: Slow and Steady.

💡 The Idea

LazyDesk AI helps users spend less time searching through documents and more time acting on the information that matters.

Instead of manually reviewing every paragraph, users can upload a PDF or plain-text document and request a structured AI summary.

The application currently provides:

📄 Document reading: Extract text from supported PDF and TXT files.

🧠 AI summarisation: Turn lengthy content into a concise overview.

🔑 Key points: Identify the main ideas and important information.

📅 Deadline awareness: Highlight dates and deadlines mentioned in the document.

✅ Next actions: Suggest follow-up steps based on the content.

📥 Downloadable results: Save summaries in Markdown format.

The goal is simple: reduce the effort required to understand a document without losing sight of what needs attention.

⚙️ How I Built It

I built LazyDesk AI using Python and Streamlit for the interface. The pypdf library extracts text from PDF files, while Python's standard text handling supports TXT documents.

For AI-powered summarisation, I integrated the Ollama Cloud API. The application sends extracted document text to the configured model, receives a response, and displays the summary in the browser.

I also separated the code into modules for document reading, AI communication, summarisation, and configuration. This structure should make the project easier to test and extend as new features are developed.

Technology stack:

Python

Streamlit

Ollama Cloud API

Requests

pypdf

python-dotenv

*🦥 Why “Slow and Steady”?
*
The idea behind this project is that productivity doesn't always mean working faster. Sometimes it means eliminating repetitive work so we can direct our attention where it is most useful.

Reading lengthy reports, assignments, meeting notes, and administrative documents can become repetitive. LazyDesk AI explores how AI can take some of that initial reading burden away and help users identify what deserves their attention.

Rather than replacing human judgement, it provides a starting point. Users can review the summary and return to the original document whenever accuracy or context matters.

🌍 Why Open Innovation Matters

Using an open-weight model gives developers more flexibility to explore how AI systems work, experiment with different supported models, and build applications without depending entirely on a closed AI ecosystem.

For LazyDesk AI, Ollama provides an accessible way to integrate a model into a practical application. Keeping the AI integration in a separate module also makes future experimentation with alternative models or inference setups easier.

There is an important limitation in my current implementation: it uses Ollama Cloud, so document text included in requests is sent to a hosted service. This version does not run entirely offline. A future version could explore local inference to give users more control over where their documents are processed.

That distinction matters because productivity tools should be designed with privacy and transparency in mind.

🔗 Explore the Project

GitHub repository:
https://github.com/Nijel20/LazyDesk-AI

The repository contains the application source code, dependency list, configuration example, and setup instructions.

I am continuing to improve the project, with potential future additions including structured task extraction, document categorisation, and a productivity dashboard.

🚀 What I Learned

Building LazyDesk AI has given me practical experience in integrating an AI API into a Python application, handling document uploads, organising application code into modules, managing configuration securely, and publishing a project to GitHub.

It also reminded me that a useful AI application doesn't have to be complicated. Sometimes a focused tool that solves one frustrating problem is a good place to start.

This is my take on Slow and Steady: let AI handle some of the reading, so people can focus on what matters.

I'd love to hear your feedback and suggestions for improving LazyDesk AI!

devchallenge #hf26challenge #python #ai #productivity

first

Nigel M Kutadzaushe — Mon, 05 Oct 2026 23:29:13 +0000

DEV Community: Nigel M Kutadzaushe

Midzimu: Keeping Family Stories Close with Local AI

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

The Spirit of It

Related Community Reading

🦥 LazyDesk AI: Let AI Handle the Reading While You Focus on What Matters

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

devchallenge #hf26challenge #python #ai #productivity

🦥 LazyDesk AI: Let AI Handle the Reading While You Focus on What Matters

devchallenge #hf26challenge #python #ai #productivity

first