DEV Community: Kalebe Szlachta

👻 Arquivo Fantasma (Ghost Archive): Giving Forgotten Digital Fragments a Voice with Open-Weight AI

Kalebe Szlachta — Tue, 27 Oct 2026 19:47:10 +0000

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

What I Built

👻 Arquivo Fantasma (Ghost Archive): Giving Forgotten Digital Fragments a Voice

What if an abandoned file could tell you a story? What if a mysterious commit, an old note, or a forgotten line of text was the beginning of something that should never have been remembered?

Arquivo Fantasma is a local-first, command-line micro-horror generator inspired by the idea of a ghost haunting a machine. It transforms user-provided text fragments into eerie short stories, exploring the thin line between digital memory, forgotten history, and the supernatural.

I interpreted Ghost in the Machine literally: the ghost doesn't haunt a house — it haunts the archive.

The project supports three narrative styles:

🕯️ Horror: psychological tension and unsettling endings.
🌼 Folklore: ancestral memories, legends, and the atmosphere of remembrance.
🌐 Cyberpunk: haunted repositories, abandoned systems, and digital ghosts.

The goal is to keep the project lightweight, transparent, and easy to run, while making local AI inference an optional part of the experience.

Code

🔗 GitHub repository: kalebers/Ghost-Archive

The project is built in Python and includes a command-line interface, sample text fragments, automated tests, documentation, and an MIT license.

Example:

python3 ghost.py \
  --file samples/fragmento.txt \
  --style cyberpunk

When an approved local model is available, the application can also use Ollama for inference:

python3 ghost.py \
  --model <YOUR_LOCAL_MODEL> \
  --text "A commit appeared ten years after its author disappeared."

The model must already be installed and available locally. No hosted AI fallback is used.

How I Built It

I built Arquivo Fantasma around a simple principle: the story should belong to the person who provides the fragment, not to a remote service.

The core is Python, with no mandatory third-party Python dependencies. For AI-powered generation, the project integrates with the local Ollama API, allowing a compatible open-weight model to generate stories on the user's own machine.

The architecture separates the narrative prompt, the local inference interface, and a deterministic offline fallback. This keeps the application usable in restricted environments while making the AI integration explicit and replaceable.

Privacy and simplicity were design priorities:

No hosted LLM API or API key is required.
The application does not scan directories or execute commands from supplied text.
Only explicitly selected text or files are processed.
The AI integration targets localhost rather than sending prompts to an external inference endpoint.
The fallback works without a model, network connection, or additional Python packages.

I also included automated tests for prompt construction, offline generation, CLI behavior, and rejection of remote inference endpoints.

Why Does Open Innovation Matter?

A closed AI API would have made the first prototype easy, but it would also have introduced a dependency on an external provider, network access, service availability, and potentially additional costs.

Open innovation makes a different approach possible.

Privacy: A local inference workflow can keep personal stories, private notes, and other sensitive fragments on the user's own machine instead of sending them to a third-party AI service.

Freedom to experiment: A compatible local model can be replaced with another model, allowing developers to compare writing styles, performance, resource requirements, and model behavior.

Offline resilience: Once the runtime and model are installed, the AI-powered experience can operate without an internet connection, subject to the local environment's configuration.

Transparency and ownership: The code can be inspected, modified, tested, and extended by anyone. The project does not depend on a proprietary hosted inference endpoint to define its architecture.

For me, the most interesting part is that open AI can turn a playful Halloween experiment into something more meaningful: a private, customizable way to give forgotten digital fragments a new life.

The offline fallback is also intentional. The application remains usable when local AI is unavailable, without pretending that deterministic text generation is the same as running an LLM.

The machine may be silent, the network may be gone, and the original author may have disappeared. But the archive can still tell a story.

The ghost is local. The data stays yours. 👻

devchallenge #hf26challenge #opensource #AI #Python #Hacktoberfest

Organizing files with a little help from ai

Kalebe Szlachta — Tue, 20 Oct 2026 18:14:44 +0000

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

What I Built

LazySort — Let AI Handle Your Messy Downloads Folder

LazySort is a local-first AI-powered file organizer designed to make one of those boring computer tasks disappear: organizing files.

Instead of manually opening documents, figuring out what they contain, renaming them, and moving them into folders, LazySort uses AI to suggest descriptive filenames and meaningful categories.

The goal is simple: spend less time managing files and more time doing what actually matters.

Built with privacy and accessibility in mind, LazySort aims to make AI-powered automation practical even on modest hardware, without depending on expensive AI subscriptions.

Code

https://github.com/kalebers/lazysort

How I Built It

I built LazySort around Python and open-source AI technologies, with a focus on keeping the application lightweight and adaptable.

The project explores how compact open-weight language models and local inference can help automate everyday file management tasks without requiring a powerful GPU or a large language model.

The application is designed to analyze document content, generate structured classification suggestions, and help users organize their files through a reviewable workflow.

Rather than blindly trusting AI-generated actions, the idea is to keep users in control of file operations while reducing repetitive manual work.

Why Does Open Innovation Matter?

Your personal documents shouldn't have to leave your computer just to be organized.

Open-source AI makes it possible to experiment with local inference, inspect the implementation, switch between compatible models, and adapt the system to different needs without being locked into a proprietary AI provider.

For a project like LazySort, this matters in three ways:

Privacy: Local inference can keep document contents on the user's machine.
Accessibility: Compact models make experimentation possible on older laptops and resource-constrained hardware.
Freedom: An open architecture lets developers replace models, customize behavior, and improve the project without depending entirely on a closed API.

I wanted to explore a simple idea: AI automation shouldn't require expensive hardware, a paid subscription, or handing your personal files to a service you don't control.

Sometimes, the best technology is the kind that quietly takes care of the boring stuff.

Thanks for checking out LazySort, and happy Hacktoberfest! 🦥

Flashcards for study

Kalebe Szlachta — Sat, 17 Oct 2026 21:03:18 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built StudyBuddy AI, a simple, locally running AI study assistant designed to help a friend study more effectively.

The idea is straightforward: paste your study notes into the app, and it generates five practice questions with answers based on the provided material. This gives students a quick way to review what they have learned and test their understanding.

I wanted to keep the project small and practical. Instead of building another complex study platform, I focused on one useful feature that someone can start using in minutes.

Code

GitHub Repository — StudyBuddy AI

Demo: [Add your YouTube demo link here]

How I Built It

StudyBuddy AI is built with Python, Streamlit, and Ollama, using the llama3.2:1b open-weight language model.

Ollama runs the model locally on the user's computer, while Streamlit provides a simple web interface for entering notes and viewing generated questions and answers.

The application is designed to download the model locally when needed, making setup straightforward without requiring paid API keys or external AI services.

The goal was to create a lightweight, beginner-friendly tool that can run on a personal computer without relying on a cloud-based AI provider.

Why Does Open Innovation Matter?

For a study tool, the content users provide can be personal. Keeping that content on their own computer gives them more control over their notes and reduces the need to trust an external service with their study material.

Open-weight models also make experimentation more accessible. Anyone can run the model locally, explore how it behaves, and adapt the application without depending on a proprietary AI API or usage-based fees.

For this project, open innovation makes AI-powered studying more accessible, private, and independent of paid cloud services.

Most importantly, this project is a reminder that AI doesn't need to solve a huge problem to be useful. Sometimes, a small tool built for someone you care about is enough.

Thanks for checking out StudyBuddy AI! 🎓

devchallenge #weekendchallenge #hf26challenge #ai #opensource

A brazilian invoice organizer

Kalebe Szlachta — Fri, 16 Oct 2026 16:58:11 +0000

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

What I Built

InvoicePilotBR is a local AI-powered receipt and expense organizer designed for Brazilian freelancers, independent professionals, and small business owners.

It helps users turn receipts and expense documents into structured financial records without manually entering every piece of information. Users can upload PDFs or images, extract details such as supplier, date, amount, and expense category using local AI, review and correct the results, and export approved records to CSV for use in spreadsheets.

The problem it addresses is simple: organizing receipts is repetitive, time-consuming, and often involves sensitive financial information.

InvoicePilotBR aims to make this process faster while keeping document processing on the user's own computer.

Potential users include freelancers, MEIs (Brazilian individual microentrepreneurs), and small businesses that want a simpler way to organize their expenses.

Code

GitHub repository: InvoicePilotBR

How I Built It

InvoicePilotBR is built with Python and Streamlit, with local AI inference powered by Ollama and an open-weight language model.

The main components are:

Python and Streamlit: provide the application logic and user interface.
Ollama: runs the language model locally, without requiring a paid cloud AI API.
Qwen3: serves as the initial model for extracting structured information from document text.
PyMuPDF: extracts text from digital PDF documents.
Tesseract OCR: recognizes text in images and scanned documents.
Pydantic: validates extracted fields and data structures.
Pandas: prepares expense records for CSV export.
Pytest: supports automated testing.

The workflow is straightforward: users upload documents, the application extracts their text, the local model identifies relevant expense information, and the user reviews the results before exporting them.

The application is designed to handle missing or ambiguous information explicitly instead of blindly trusting the model's output.

Why Does Open Innovation Matter?

Open innovation is central to InvoicePilotBR because it makes private, locally executed AI processing practical for a small utility.

Privacy by design: Receipts can contain names, addresses, business information, and transaction details. Running inference locally allows the application to process documents without sending their contents to an external AI provider.

Lower operating costs: Once the model is downloaded, ordinary inference does not require a paid API subscription or per-token cloud charges. Users still need compatible hardware and incur electricity and maintenance costs.

Freedom to experiment: Using Ollama makes it possible to switch between compatible models, compare extraction quality, and adapt the application to different hardware and document types.

Less vendor lock-in: The application is not tied to a single commercial AI provider's pricing, availability, or API policies.

Most importantly, open-weight models make it possible to build a practical tool that users can run and control on their own computers. For freelancers and small businesses, that combination of privacy, flexibility, and predictable operating costs can make AI-powered automation more accessible.

InvoicePilotBR explores a simple idea: useful AI tools do not always need to send your data to someone else's server.