DEV Community: Anton Luckshman

Ghost Archive: a home for stories that stay, powered by local open-weight AI

Anton Luckshman — Sat, 31 Oct 2026 06:55:09 +0000

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

What I Built

Ghost Archive is a small, private writing room for two kinds of stories: the ones that make an empty hallway feel occupied, and the ones that make a person feel a little less far away.

In ghost-story mode, a few fragments become supernatural fiction. A light that comes on at 3:17. A radio without a power cord. A second cup on an empty table.

In remembrance mode, those fragments become a tribute: a favorite song, a windowsill full of marigolds, a small ritual someone left behind. This mode has a separate prompt that forbids inventing biography, impersonating a loved one, or claiming contact with the dead. A tribute is something to review and keep, rather than a simulated conversation.

The app is inspired by Halloween and by the act of keeping memories alive. It does not claim to reproduce an ofrenda or speak for any cultural tradition.

Try It Locally

The source is available in the Ghost Archive repository. To use it on your own computer:

Start Ollama and download Qwen3-4B with ollama pull qwen3:4b.
Run python server.py and open http://127.0.0.1:8787.
Open Model & settings, refresh, and choose the downloaded model.
Begin a story, watch the prose stream in, and keep or export it.
Disconnect from the internet after setup and repeat the writing flow.

Three labeled illustrative samples let someone explore the archive before installing a model. They are sample content, not evidence of live model inference.

Code

View the source on GitHub: antonluckshman/ghost-archive

The app is MIT-licensed. It contains a Python standard-library server, plain HTML/CSS/JavaScript, original SVG artwork and tests. There is no frontend build step, Python package installation or external asset dependency.

How I Built It

The writing engine is Qwen3-4B, an Apache 2.0 open-weight model, served by the MIT-licensed Ollama runtime. Other locally downloaded chat models can be selected in settings.

The browser posts fragments to a loopback Python server. The server checks the input and verifies the model is in Ollama's local model list, excluding models marked as remote or cloud. It sends the source material with the appropriate fiction or remembrance system prompt to Ollama's chat endpoint.

The response is streamed back as newline-delimited JSON. If the stream fails, the reader keeps the words that arrived as an unfinished draft. A successful completion saves the prose in browser storage. The source fragments are not saved to the server.

flowchart LR
    A[Browser editor] --> B[Python on loopback]
    B --> C[Ollama]
    C --> D[Local open-weight model]
    C -->|Streamed prose| B
    B --> A
    A --> E[Local browser archive]
    A --> F[Text or JSON export]

A simple bridge was enough for this task. Damiano's dependency-free Python/Ollama article helped ground that choice. Nazar Boyko's discussion of local inference informed the explicit context budget and attention to local-model memory and latency.

Validation so far: 13 Python HTTP contract tests and 8 frontend behavior checks pass. They cover streaming, partial output, Unicode, invalid requests, remote-model filtering, storage failures and backup validation. Browser review covered category filters, sample provenance, saving, favorites, persistence across reload, search empty states, the remembrance editor and a mobile layout with no horizontal overflow. These checks used a simulated Ollama service; actual model inference was not tested on the build machine.

Why Does Open Innovation Matter?

A memory should not require an account on a service that may disappear.

Open weights let the writing engine live alongside the archive. Once the runtime and model are downloaded, a session does not depend on an internet connection. The app sends no memories to a hosted model provider.

The prompts are editable Python source. The model can be replaced. If another model writes better in a family's language, the app does not need to be rebuilt around a new provider. The archive can leave the app too, as plain text or JSON.

There is no per-request AI service fee. Local hardware, disk space and electricity still have costs, and a small CPU model will not match the speed or quality of every hosted model. This project chooses local control because its material can be personal, and the task is narrow enough for a small model.

The Spirit of It

The visual design leaves room for both a shiver and a memory: lavender shadows, candlelight, a small floating ghost, and a book that remains open.

The idea is simple: let a spooky story be fiction, and let a remembrance belong to the person who brings it.

AI Assistance

AI assistance was used to implement this application, create illustrative sample prose and draft this write-up. The included sample stories are illustrative examples.

Slow and Steady: a local AI file tidier for my inner sloth

Anton Luckshman — Sun, 25 Oct 2026 03:12:20 +0000

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

What I Built

My downloads folder is a list of decisions I keep postponing. Slow and Steady is a local AI assistant that suggests where files belong, so I can review a list instead of sorting everything manually.

It uses Qwen2.5 1.5B through Ollama to classify filenames into categories such as finance, work, personal and reading. An invoice and meeting notes can both be text files while belonging in different folders.

The workflow is: plan → review → approve → tidy → undo. Planning never moves existing files. Applying displays the proposed paths and requires approval tied to that exact plan. Uncertain files stay put.

Demo

To try the disposable sample inbox after installing Python and local Ollama:

ollama pull qwen2.5:1.5b
python -m sloth_tidy demo demo-inbox
python -m sloth_tidy plan demo-inbox
~~~

The planner saves a JSON file. Review it and pass its path to:

~~~text
python -m sloth_tidy apply "PATH_TO_SAVED_PLAN"
~~~

The displayed approval token is required before any files move.

## Code

**GitHub repository:** [antonluckshman/slow-and-steady-ai](https://github.com/antonluckshman/slow-and-steady-ai)

The project uses Python 3.11+ and has no third-party Python runtime dependencies. Setup and undo instructions are included in the README.

## How I Built It

Ollama's [structured output API](https://docs.ollama.com/capabilities/structured-outputs) returns category decisions. The model sees filenames, suffixes, byte counts and integer IDs. File contents and absolute inbox paths are excluded from requests.

The model cannot choose arbitrary paths or run commands. Python validates every decision, constructs destinations under the inbox and checks file hashes before moving anything. Existing destinations are refused. Recent files, partial downloads, links and junctions are left alone.

A journal records intent before each move. Exclusive hard-link creation followed by removal of the original directory entry avoids overwriting destination data. Approved undo can restore the original paths and reconcile an interrupted move on supported filesystems.

The existing automated suite completed with **27 passing tests and one skipped symlink test** because Windows denied symlink-creation privileges. The separate junction test passed. Tests cover the HTTP contract, approval, collisions, stale files and interrupted undo. Model accuracy and latency have not been independently benchmarked.

## Why Does Open Innovation Matter?

The open pieces provide the actual semantic planner: [Ollama](https://github.com/ollama/ollama) runs inference, and the default [Qwen2.5 1.5B weights](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct) use Apache 2.0. This assistant's source is MIT-licensed.

After downloading the model and disabling Ollama's cloud features, the workflow can run offline. Personal filenames need not visit a hosted model. There is no per-request API charge, although hardware and electricity still cost resources.

I can inspect the prompt, edit categories or replace the local model while keeping the same approval and movement checks. That control over data location, model choice and behavior matters more for this chore than access to a hosted model. Small-model judgment still needs human review.

## Related Community Reading

🦥 [sloth-sorter: a lazy file tidier that runs Gemma locally](https://dev.to/ghalmeidadev/sloth-sorter-a-lazy-file-tidier-that-runs-gemma-locally-21lc), by [@ghalmeidadev](https://dev.to/ghalmeidadev), reports an imperfect classification in its small demo—a useful reminder to review suggestions. [Read Full Discussion on DEV](https://dev.to/ghalmeidadev/sloth-sorter-a-lazy-file-tidier-that-runs-gemma-locally-21lc).

⚙️ [Ollama Structured Outputs in Practice — Getting Type-Safe JSON from Local LLMs with Pydantic](https://dev.to/jangwook_kim_e31e7291ad98/ollama-structured-outputs-in-practice-getting-type-safe-json-from-local-llms-with-pydantic-m38), by [@jangwook_kim_e31e7291ad98](https://dev.to/jangwook_kim_e31e7291ad98), discusses schema-based output and small-model limitations; this project uses a standard-library validator. [Read Full Discussion on DEV](https://dev.to/jangwook_kim_e31e7291ad98/ollama-structured-outputs-in-practice-getting-type-safe-json-from-local-llms-with-pydantic-m38).

*AI assistance disclosure: this project and article were created with AI assistance.*

InvoiceMate Local: A Private Invoice Assistant Powered by Open-Weight AI

Anton Luckshman — Sat, 17 Oct 2026 02:21:30 +0000

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

What I Built

Meet InvoiceMate Local 🧾 a local-first AI invoice assistant designed for freelancers and small businesses.

Managing invoices can be surprisingly time-consuming. You receive PDFs and receipt images, manually copy supplier details and amounts into spreadsheets, organize expenses, and double-check everything.

InvoiceMate Local aims to make that process easier.

With InvoiceMate Local, users can:

📄 Extract invoice information from digital PDFs and receipt images.
🤖 Use AI to identify suppliers, invoice numbers, dates, currencies, subtotals, taxes, and totals.
🗂️ Organize expenses into categories.
✅ Review and correct extracted information before saving it.
💾 Store invoice records in a local SQLite database.
📊 View expense summaries and export records to CSV.
🔒 Process documents locally instead of sending invoice text to a cloud AI API.

The intended users are freelancers, independent contractors, and small business owners who want to reduce repetitive data entry while keeping control of their financial documents.

The side-hustle idea: Start with a free local tool and explore paid features such as bulk invoice processing, customizable expense categories, and advanced reporting if users find them valuable.

Demo

Project status: Local MVP implementation.

GitHub repository: https://github.com/antonluckshman/InvoiceMate-Local
Screenshots:

The application is designed to run locally using Streamlit and Ollama. It is not presented as a publicly deployed web service.

The planned demo workflow is straightforward:

Upload a sample invoice.
Extract the document text.
Let the local AI model identify the invoice fields.
Review and correct the extracted information.
Save the record and export the results to CSV.

The demo will use fictional invoice data rather than real customer documents.

Code

Repository: https://github.com/antonluckshman/InvoiceMate-Local

The project is built with Python and organized into small modules:

app.py — Streamlit interface and application workflow.
invoice_extractor.py — PDF/image text extraction and local AI inference.
validators.py — Field normalization, validation warnings, and duplicate detection.
database.py — Local SQLite storage.
exporter.py — CSV generation.
tests/ — Automated tests for validation logic.

The goal is to keep the code understandable and make it easy to extend the application without depending on a proprietary AI service.

How I Built It

I chose a local-first architecture using Python, Streamlit, Ollama, and an open-weight language model.

Here is how the pipeline works:

Invoice PDF or image → Text extraction/OCR → Local AI → Structured data → Human review → SQLite → CSV export

The technology stack

Python: Application logic and data processing.
Streamlit: A simple interface for uploading documents, reviewing extracted fields, and viewing expenses.
Ollama: Runs the language model locally.
Qwen2.5 3B Instruct: The selected starting model for extracting structured invoice information from text.
PyMuPDF: Extracts text from digital PDF documents.
Tesseract OCR: Reads text from supported receipt images.
Pydantic: Validates the structure of the AI-generated output.
SQLite: Stores invoice records on the user's computer.
Pandas: Prepares CSV exports.

I deliberately avoided training a model from scratch. For this task, a pretrained open-weight model combined with structured output, deterministic validation, and a simple user interface is a more practical starting point.

Why combine AI with conventional code?

A language model can help interpret different invoice layouts, but it can also misread a date or invent a plausible-looking value.

That is why InvoiceMate Local does not treat the model's response as unquestionable truth.

The model proposes structured fields. Python validates the output, checks for missing information, flags possible arithmetic inconsistencies, and helps identify duplicate invoices. Users can then correct the information before saving it.

The validation checks are warnings rather than a guarantee of accounting or tax correctness.

Why Does Open Innovation Matter?

For InvoiceMate Local, open innovation is about giving users more control over their data, AI model, and operating costs.

Invoices can contain supplier information, addresses, business expenses, and other sensitive details. Some freelancers and small businesses may not want to send these documents to an external AI provider.

Running an open-weight model locally offers a different approach.

1. Privacy by design

The application uses local inference through Ollama instead of relying on a cloud AI API for invoice extraction.

After installing the application dependencies and downloading the model, the core workflow is designed to operate without an internet connection. Offline operation still needs to be verified in the target environment.

2. No per-document cloud AI API fees

The local inference approach avoids a separate cloud AI API charge for every document processed.

That makes experimentation easier for a small tool intended for freelancers. However, local processing still has hardware, electricity, and maintenance costs.

3. Freedom to experiment

The model can be replaced with another compatible model, and the extraction prompts, validation rules, and expense categories can be customized.

This makes it possible to experiment with different models and workflows without rebuilding the entire application around one provider's API.

4. A practical local-first alternative

A cloud AI API can be convenient, but it introduces an external service dependency and potentially recurring usage costs.

InvoiceMate Local explores whether a small open-weight model running on an ordinary computer can provide enough value for a focused business task.

The important part is not simply using an open model. It is building the actual workflow around local inference, local storage, and user-controlled verification.

Local storage is not automatically encrypted, so users still need to protect their computers and database files.

My Agent Session

I used AI-assisted development to help build the application structure, document-processing pipeline, validation logic, and supporting documentation.

I'll add a DevRelay session link here if I capture and publish one.

Limitations and Next Steps

InvoiceMate Local is an early MVP, not a replacement for accounting software or professional tax advice.

The current implementation needs further testing with different invoice layouts, OCR quality, ambiguous dates, unusual tax structures, and malformed model outputs.

My next steps are to:

Test extraction quality using a documented set of fictional invoices.
Measure field-level accuracy instead of assuming the model is correct.
Improve handling of scanned PDFs and difficult receipt images.
Test offline operation after installation and model download.
Get feedback from a freelancer or small business owner.
Explore which features users would actually pay for.

I'd love to hear from people who deal with invoices regularly:

Would you use a local AI invoice assistant to organize your expenses? What would it need to do before you trusted it with your business documents?

# StudyBuddy AI: I Built an AI Study Buddy for My Friend Linuka 📚

Anton Luckshman — Thu, 15 Oct 2026 04:05:19 +0000

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

What I Built

I built StudyBuddy AI for my friend Linuka, who could use a simpler way to turn lecture notes into practice questions.

The idea is pretty straightforward: instead of reading through notes again and again, Linuka can upload a PDF, TXT, or Markdown file or simply paste notes into the app and generate a quiz from the content.

Users can choose the number of questions, difficulty level, and an optional topic. StudyBuddy AI then creates multiple-choice questions, provides feedback and explanations, and calculates a score at the end.

I wanted to make studying a little more interactive and help turn passive reading into active practice. 📚

Code

GitHub Repository: [https://github.com/antonluckshman/StudyBuddy-AI]

The project uses React for the frontend, FastAPI for the backend, and Ollama to run a local AI model.

How I Built It

I used React and Vite to build the user interface, Python with FastAPI for the backend, and Ollama to generate quizzes using the Qwen2.5 3B model by default.

The workflow is simple:

Upload study materials or paste notes.
Choose the quiz difficulty and number of questions.
Let the AI generate multiple-choice questions from the material.
Answer the questions and get feedback, explanations, and a final score.

I also added basic input validation and error handling to make the experience easier to use.

One current limitation is that scanned PDFs aren't supported because OCR hasn't been implemented yet.

Why Open Innovation Matters

I wanted to experiment with AI without depending on a paid, hosted AI API.

Using open-source tools gives me the flexibility to experiment with different models and run inference locally through Ollama. When configured for local inference, the study material can stay on the user's computer instead of being sent to a hosted AI service.

It also gives me more control over how the application works and makes it easier to learn by building something practical.

Of course, the project is still a work in progress, and there's plenty of room to improve the quiz quality and user experience.

Built with open-source tools, for my friend Linuka and for more focused, interactive studying. 🌱

TrailMate AI — Make Room for Outside

Anton Luckshman — Sun, 11 Oct 2026 03:57:42 +0000

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

What I Built

🌿 TrailMate AI — Your AI-powered outdoor activity planner

TrailMate AI helps people spend less time staring at screens and more time exploring the outdoors. Instead of endlessly scrolling for things to do, users can generate personalized outdoor activity plans based on their starting location, available time, preferred activity pace, and favorite scenery.

Whether you have just 20 minutes for a short walk or 90 minutes for a nature adventure, TrailMate AI suggests activities, provides a simple itinerary, recommends what to bring, and includes basic outdoor safety reminders.

The project is designed for students, busy professionals, travelers, and anyone who wants to make getting outside easier.

The main idea is simple: use AI to help people leave their screens, not spend more time on them.

Demo

🌐 Live Demo: [Not Ready Yet]

📸 Screenshots:

The demo currently includes a sample-planning mode, so users can explore the experience without configuring an AI model.

Code

💻 GitHub Repository: [https://github.com/antonluckshman/TrailMate-AI]

TrailMate AI is built with React and Vite. The source code includes the user interface, activity-planning logic, sample plans, and optional local AI integration.

Feel free to explore the code, suggest improvements, report issues, or contribute new outdoor activities and planning features!

How I Built It

I built TrailMate AI using React, Vite, and open-source AI models that can run locally.

The application has two planning modes:

Demo mode: Generates sample outdoor plans immediately, allowing users to try the application without setting up an AI model.
Local AI mode: Can connect to Ollama to run a supported open-weight language model locally, such as Llama 3.2 or Qwen2.5.

Users choose their starting location, available time, preferred pace, and scenery. The application uses those preferences to generate an outdoor activity plan with suggested activities, a checklist, and safety reminders.

I wanted to make the project accessible to people who don't have access to paid AI APIs. By supporting local inference, TrailMate AI provides a path toward experimenting with AI without requiring a paid model API key.

The current version is an MVP. Its plans are suggestions, not verified hiking routes or live recommendations based on weather, trail conditions, or real-time maps.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to experiment, learn, and build useful applications without depending entirely on proprietary platforms.

For TrailMate AI, open-weight models and local inference offer several advantages:

Accessibility: Developers and users can experiment without necessarily paying for a commercial AI API.
Privacy and control: With a properly configured local setup, prompts can be processed on the user's machine rather than sent to a hosted AI provider.
Flexibility: Different supported models can be tested and compared for activity planning.
Community collaboration: Other developers can contribute new activity types, improve prompts, add local outdoor knowledge, and extend the application.
Learning by building: Open tools make it easier to explore how AI fits into a complete application, from the user interface to model inference.

A closed API could also generate outdoor plans, but open-weight models give developers more flexibility over where inference happens and which model they choose. They also make experimentation more accessible.

I believe open innovation is especially valuable when building small projects: it lowers barriers to experimentation and gives the community a starting point that others can adapt to their own needs and locations.