This morning I started putting together a workshop idea to host at the library. I proposed an eight-week course in March 2025 on Raspberry Pis, but we couldn’t secure funding to cover the cost of the Raspberry Pis.
Raspberry Pi Workshop Cover Page
Hello! I’m planning some exciting activities with the laser printer, and I’d also like to host a series of Raspberry Pi workshops starting in the spring or summer. This proposal outlines the educational benefits of these workshops, designed for both children and adults ages 13 and up, to introduce foundational skills in computing, coding, and electronics.
Overview The proposed workshops would be 1- to 2-hour sessions focused on the Raspberry Pi—a small, affordable, and versatile single-board computer that has transformed tech education by making hands-on learning accessible and fun. Each session would provide an engaging learning experience right in the library and align with our goal to expand digital literacy and offer new, community-focused learning opportunities.
Originally developed by the Raspberry Pi Foundation in the UK to promote computing education, the Raspberry Pi has become a popular, low-cost, yet powerful tool for a wide range of projects, from basic coding to building complex electronics. With prices starting at around $35, this device enables individuals to explore and experiment without needing extensive technical resources or experience.
Why Raspberry Pi?
- Compact & Portable: Small enough to fit in the palm of your hand, the Pi is easy to set up and transport.
- Powerful Hardware: Equipped with a CPU, GPU, RAM, USB ports, and HDMI output, it performs many tasks of a traditional computer.
- Adaptable & Versatile: Runs Linux-based operating systems and supports applications ranging from coding tools to media servers.
- Educational Software: Pre-installed with programs like Scratch (block-based coding) and Python, making it ideal for teaching programming and digital skills.
- Affordable & Accessible: Raspberry Pi democratizes access to technology, opening doors to learning for those who might not have other computing resources.
Benefits of Hosting Raspberry Pi Workshops
- Promotes Digital Literacy: Raspberry Pi introduces coding, networking, and electronics in a way that’s engaging for all ages.
- Supports STEAM Learning: Hands-on projects enable exploration across science, technology, engineering, art, and math.
- Encourages Lifelong Learning: Designed for ages 13 and up, the workshops cater to diverse age groups, supporting the library’s mission to provide educational resources for every stage of life.
- Fosters Community Engagement: These sessions bring participants together to learn, solve problems, and collaborate, building community ties.
- Inspires Creativity: The Pi’s flexibility encourages participants to experiment and innovate, offering endless possibilities—from games to DIY web servers.
Workshop Series Outline The proposed series includes 8 weekly, 1-hour sessions, each covering a different aspect of using Raspberry Pi:
- Topics: Basic setup, coding, electronics, media streaming, creating a web server, and more.
- Capstone Project: Participants apply what they’ve learned to create a project of their own design, fostering confidence and creativity.
This series is designed to be beginner-friendly yet engaging for tech-savvy participants interested in experimenting with Raspberry Pi. The workshops will be open to all community members, with content suitable for ages 13 and up. Younger participants can benefit from attending with a parent, especially if they’re new to computers.
Resources Needed
- Raspberry Pi Kits: Kits with a Pi board, power supply, SD card, and HDMI cable (10 kits, allowing for pairs or small groups).
- Keyboards & Mice: Wired combos recommended.
- Accessories & Electronics Kits: Breadboards, LEDs, sensors, resistors, and jumper wires.
- Display Equipment: Projector or screens for instruction, plus HDMI monitors for each Pi.
- Dedicated Space: Room with tables and outlets for 10-20 participants per session.
Budget Considerations To optimize costs, we can explore different kit configurations, like varying Pi models and accessory bundles. Suggested configurations are as follows:
- Premium Setup: Raspberry Pi 5 (8GB) with 10″ touch screen and full accessories with 8 MP camera
- Recommended Setup: Raspberry Pi 5 (8GB) with 7″ touch screen, keyboard/mouse, medium assortment of electronics, and 5 MP camera
- Moderate Setup: Raspberry Pi 4 (4GB) with 5″ touch screen, keyboard/mouse, small assortment of electronics, and 5 MP camera.
Estimated costs for each setup range from approximately $2,000 to $3,200 for 10 kits, depending on options chosen. We may consider grants or community partnerships to offset costs, or charge a nominal fee to cover expenses. An alternative idea could be to lend out Raspberry Pis for take-home experimentation, with necessary procedures in place.
Conclusion Launching a Raspberry Pi workshop series at Samuels Public Library will empower patrons with practical digital skills and inspire exploration and creativity with technology. This initiative furthers our commitment to digital literacy, community engagement, and lifelong learning. With your support, we can offer an exciting new educational program to our community.
Thank you for considering this proposal. I’m happy to discuss any questions or adjustments to meet our library’s goals.
Raspberry Pi Workshop Outline
Workshop Series Theme: Exploring Technology with Raspberry Pi
Each class builds on the last, introducing new features and skills while reinforcing previous
knowledge. By the end, participants should be confident using Raspberry Pi for various
purposes and inspired to continue exploring tech.
Week 1: Introduction to the Raspberry Pi & Basic Setup
Theme: Getting Started with Your First Computer
● Topics Covered:
○ What is a Raspberry Pi? Brief overview of the model being used.
○ Components and ports: Understanding what each part does (USB, HDMI, SD
slot, GPIO pins).
○ Setting up the Pi: Connecting monitor, keyboard, and power.
○ Booting up: Installing the operating system (use preloaded SD cards for
simplicity).
○ Basic navigation in Raspberry Pi OS (how to access the terminal and files).
● Hands-On Activity: Booting up the Pi, navigating the OS, and customizing settings (like
wallpaper and Wi-Fi connection).
Week 2: Introduction to Programming with Scratch and Python
Theme: Make the Pi Your Playground with Code
● Topics Covered:
○ Brief intro to Scratch and Python, highlighting why they’re great starter
languages.
○ Hands-on with Scratch: Create a simple animated scene.
○ Hands-on with Python: Write a basic “Hello, World!” program in Thonny IDE.
○ Comparison of block-based (Scratch) and text-based (Python) coding.
● Hands-On Activity: Create an animation or game in Scratch; write a short Python script.
Week 3: Basic Electronics with Raspberry Pi and GPIO
Theme: Light Up and Control the World Around You
● Topics Covered:
○ Introduction to GPIO pins and basic circuitry.
○ Understanding LEDs and resistors.
○ Wiring an LED to a breadboard and controlling it with a Raspberry Pi.
○ Writing Python code to blink the LED on and off.
● Hands-On Activity: Each participant wires an LED circuit and writes a simple Python
program to control it.
Week 4: Exploring Sensors and Input with the Raspberry Pi
Theme: Bringing Interactivity to Life
● Topics Covered:
○ How sensors work and what they’re used for.
○ Brief intro to temperature and motion sensors.
○ Hooking up a sensor (e.g., button or temperature sensor) to the Pi.
○ Writing code to read sensor data and display it in the terminal.
● Hands-On Activity: Use a button to control the LED or read temperature data.
Week 5: Introduction to Networking and Media Streaming
Theme: Turning Your Pi into a Media Hub
● Topics Covered:
○ Introduction to networking basics: IP addresses, Wi-Fi setup.
○ Overview of media streaming with Raspberry Pi.
○ Installing and configuring a media server application like Kodi or Plex.
○ Connecting to the media server from another device.
● Hands-On Activity: Set up a simple media server and stream content to a smartphone
or laptop.
Week 6: Building a Simple Web Server with Raspberry Pi
Theme: Hosting a Website from Your Pocket-Sized Computer
● Topics Covered:
○ What is a web server? Basic concepts of HTML, CSS.
○ Installing a web server software like Apache or Nginx.
○ Writing a basic HTML page and displaying it on the local network.
○ Introduction to accessing the Pi from another device using IP.
● Hands-On Activity: Create a basic homepage and serve it locally on the Pi.
Week 7: Fun with Raspberry Pi Camera Module (Optional)
Theme: Getting Creative with Photography and Video
● Topics Covered:
○ How to connect and set up the camera module.
○ Taking photos and videos with Python commands.
○ Exploring project ideas: Time-lapse photography, motion-triggered camera.
● Hands-On Activity: Take a photo or video with the camera module and discuss
potential projects.
Week 8: Capstone Project – Choose Your Own Adventure
Theme: Bringing It All Together
● Topics Covered:
○ Recap of previous sessions and how they can be combined.
○ Group brainstorm on project ideas based on interests (e.g., digital photo frame,
weather station, web-based game).
○ Form small teams or individuals to begin a project, using skills learned so far.
● Hands-On Activity: Start a small project, using guidance from instructors, and plan
steps to complete at home if desired.
Raspberry Pi Workshop Cost Breakdown
As promised, here is the pricing breakdown from my previous research for a workshop series outline covering the Raspberry Pi.
The original proposal was for 8 workshops about 1 – 2 hours, for children and adults 13+ to introduce foundational skills in computing, coding, and electronics to expand digital literacy and offer new community-focused learning opportunities. I had estimated the total cost to be $2,000 to $3,000 for 10 kits that can be distributed to 10 individuals, or 10 groups of two people. Our computer & internet use policies require children to have an adult present. At the end of this e-mail, I provide a few options, with the recommended one estimating a cost of $226 per kit.
If we need to keep costs down, we could consider omitting the electronics kits and camera modules, though I had initially aimed to provide a well-rounded experience covering diverse topics to engage participants. The camera and use of GPIO pins are some of the primary features regarding the Raspberry Pi. Additionally, if the library has 10 spare monitors, keyboards, and mice, we could reduce the budget even further.
A good primer to what a Raspberry Pi is can be found on YouTube – Raspberry Pi Explained in 100 Seconds. A longer and fun video would be Raspberry Pi – All You Need To Know.
Please let me know if you have any questions or if you’d like me to be available when you meet with FOSL to discuss this in more detail. I’ll work on flushing out the workshops in more detail over the next few days, as well as putting together some workshops for the laser cutter.
These prices are ballpark only, and subject to change. I have not shopped around for any deals. This is just a quick search on Amazon only. I’m just an end-consumer. If the library has access to source these materials elsewhere as an educational facility, it may be ideal to compare prices.
Raspberry Pi Starter Kit – computer, power supply, storage, computer case, cooling
- Raspberry Pi 5: 8GB RAM + 64 GB MicroSD $128 x 10 = $1,580 (Recommended)
- Raspberry Pi 5: 4GB RAM + 32 GB MicroSD $115 x 10 = $1,150
- Raspberry Pi 4: 4GB RAM + 64 GB MicroSD $104 x 10 = $1,040 (Minimum)
- Raspberry Pi 3 B+: 1GB RAM (No MicroSD card) $80 x 10 = $800
- 64 GB MicroSD + USB Reader $12 x 10 = $120
- Total = $92 x 10 = $920
- Raspberry Pi Zero W 512MB RAM + 64 MB MicroSD $40 x 10 = $400
LCD Touch Screen Monitor with HDMI
- 10.1 inch 1024×600 $70 x 10 = $700
- 9 inch 1024×600 $51 x 10 = $510
- 7 inch 1024×600 $46 x 10 = $460 (Recommended)
- 5 inch 800×480 $40 x 10 = $400
USB Keyboard + Mouse/Trackpad
- Wireless Keyboard with Touchpad $22 x 10 = $220
- Wired Keyboard + Mouse Combo $14 x 10 = $140 (Recommended)
Raspberry Pi Electronics Kit – Breadboard, Molex cables, LED’s, Resistors, sensors, displays, buttons, joysticks, etc.
- 337 parts $60 x 10 = $600
- 223 parts $50 x 10 = $500
- 164 parts $27 x 10 = $270 (Recommended)
- 458 parts (mostly wires, LED’s, resistors) $13 x 10 = $130
NOTE: Smaller components will probably be lost over time, and harder to identify pieces after their first use for someone who isn’t familiar with them. Leads will be bent in order to fit in breadboards, and in some cases, the leads may be cut short.
Raspberry Pi Camera Module
- 5 Megapixels $7 x 10 = $70
- 5 Megapixel + case $9 x 10 = $90 (recommended)
- 8 Megapixel $14 x 10 = $140
- 12 Megapixel $19 x 10 = $190
- 12 Megapixel + case $22 x 10 = $220
- 16 Megapixel $25 x 10 = $250
NOTE: The camera module connector changed on Raspberry Pi 5 compared to prior modules. That’s why you’ll see a significant price drop between modules. I had to update my list again as prices have continued to drop.
We could mix-and match the configurations, but here are the overall prices for a few configurations to get a general idea on ballpark figures:
Premium: Raspberry Pi 5 8GB RAM 10″ LCD + Wireless keyboard/trackpad, 337 electronic parts, 16 MP camera
$318 ($128+$70+$22+60+38) x 10 = $3,180
Recommended: Raspberry Pi 5 8GB RAM 7″ LCD, Wired Keyboard/Mouse, 164 electronic parts, 5 MP Camera & case
$226 ($128+$46+$14+$27+11) x 10 = $2,260
Moderate: Raspberry Pi 4 4GB RAM 7″ LCD + Wired keyboard/mouse, 164 electronic parts, 5 MP camera & case
$213 ($115+$46+$14+$27+$11) x 10 = $2,130
Budget: Raspberry Pi Zero W 512MB RAM 5″ LCD + Wired keyboard/mouse, 458 electronic parts, 5MP camera
$114 ($40+$40+$14+$13+$7) x 10 = $1,140
As I mentioned at our meeting today, some products make the Raspberry Pi look like a “normal” laptop with a display, keyboard, mouse, battery and speaker. Here is a list of examples, but they are cost prohibitive when working with a group of people.
So, fast-forward a year and a half, and AI has become very popular. It’s both widely adopted and widely hated, while there is a backlash against data centers moving into rural communities. Many people are researching the possibility of running AI locally on their own computers for various reasons, from privacy to reducing dependence on third-party usage costs. A friend expressed their disappointment at being unable to attend a workshop covering Ollama, and I offered to go over the basics. In turn, I found that others in the community were interested in what I had already been doing, so I started to propose a workshop at the library today.
Rather than building a workshop that requires funds, I’m designing it as a “bring your own hardware” two-part series. In the first half, I cover the technology and take questions. People can choose to stick around for the lab afterward, where they will set it up on their own machines.
Ollama Workshop
I’ve expressed interest in teaching technical workshops in the past, mostly surrounding the Raspberry Pi. However, our community has increasingly seen people interested in running AI locally. I’ve spent much of my time not just interacting with ChatGPT or Claude online, but also setting up my own fleet of agents to perform various tasks. A few people in the community have expressed interest in what I am doing or want to know how to do it themselves.
I’d like to start with the basics of how to get and run free models via Ollama, what it takes to run them, limitations, and some basic terminology and concepts. I hope there is enough interest that this could become a monthly workshop. There are other open-source software, platforms, and technologies around AI, so this can be regularly scheduled: Hermes, Open Claw, Honcho, Tool Functions, integrating into websites, managing a fleet of multiple agents, Agentic Agents, and programming/researching while you sleep, etc. Maybe a recurring group name like “Terminal Velocity” to fit a fast-paced, hands-on, terminal-driven developer group or “Byte-Sized Labs” to keep the scope feeling manageable, practical, and experiment-focused. I’d be open to doing a town talk with the Royal Examiner to invite people to come to the library and learn about emerging technologies.
I was thinking of making it a two-part workshop where the first half could be for anyone who wants to learn the details, but not necessarily participate in a lab, with the lab following afterwards.
- Title: Off the Grid AI: Running Local LLMs with Ollama
- Part 1 (Presentation – 30 Mins): The Architecture of Offline AI. Learn how quantization, GPU VRAM offloading, model of experts, and open-weights models make it possible to run powerful LLMs directly on consumer hardware. We’ll cover total data privacy, air-gapped security, and how local models eliminate cloud subscription fees and API latency.
- Part 2 (Hands-On Lab – 60 Mins): Build Your Air-Gapped Stack. Bring your laptop and leave with a fully functional local AI engine. We’ll install Ollama, load quantized weights offline, customize system prompts using
Modelfiles, and connect local web interfaces and IDE plugins without sending a single packet over the internet. (USB drives with pre-downloaded model weights provided).
Part 1: The Briefing & Live Demo (30 Minutes)
- Objective: Give everyone a clear mental model of how Ollama works under the hood without touching a keyboard.
- Format: Presentation + live demonstration.
- Topics Covered:
- Architecture & Mechanics: How GGUF quantization (Q4_K_M),
llama.cpp, and VRAM/RAM offloading work. - Privacy & Air-Gapping: Why offline inference guarantees total data sovereignty.
- Live Demo: Disconnect Wi-Fi on your machine, pull up a terminal, run a CLI prompt, customize a
Modelfile, and query a local model overlocalhost:11434. - Q&A Break: Natural stopping point. Non-technical attendees can ask high-level questions and wrap up.
- Architecture & Mechanics: How GGUF quantization (Q4_K_M),
Part 2: The Hands-On Installfest & Lab (45–60 Minutes)
- Objective: Ensure every technical participant leaves with a fully configured, functional offline AI stack on their own laptop.
- Format: Interactive lab with direct troubleshooting.
- Participant Goals:
- Install the native Ollama runtime for their OS (macOS, Linux, Windows WSL2/native).
- Pull a lightweight model suited to their specific system specs (e.g.,
llama3.2:3borphi3). - Run basic CLI queries and set up a custom
Modelfile. - (Optional) Connect a local GUI (like Open WebUI via Docker) or an IDE code-completion plugin (like Continue.dev in VS Code).
Tips to Make the Lab Run Smoothly
- Provide Pre-Downloaded Models via USB Drives: Local venue Wi-Fi will bottleneck if 10–15 people try downloading 2 GB–5 GB GGUF weight files simultaneously. Download popular model blobs (like Llama 3.2, Mistral, or Qwen) onto a few USB flash drives ahead of time so participants can manually copy them to
~/.ollama/modelsorC:\Users\<user>\.ollama\models. - Publish Hardware Prerequisites Ahead of Time: Advise attendees in advance to bring a laptop with at least 8 GB–16 GB of system RAM and 10 GB of free disk space.
- Pair Up Attendees: Let developers with similar hardware (e.g., Apple Silicon vs. NVIDIA Windows laptops) sit together so they can help each other troubleshoot OS-specific driver or path issues.
UpdraftPlus Backup/Restore
In the meantime, I decided to give Hermes a big task and see how they would tackle it. First, I needed to get a copy of my main wordpress website. Since it’s hosted on WordPress itself, I don’t have the ability to look at the database and export it, or have shell access to get a database dump. Hermes recomended that I look into a plugin called “UdraftPlus Backup/Restore”.
I wasn’t too keen on the name, since “plus” often implies an additional cost. I installed it anyway and found that I could go to the plugin settings and see a button to back it up. I ran through the process, and it created nine files to download, four of which were uploads. After downloading them, I used scp to transfer them all over to Kaylee.
scp backup_2026-09-03-1228_Lewis_Moten_882a4e63e3ba-*.zip \ ai@kaylee.tail4cc93a.ts.net:~/files/lewismoten.com/
I then asked Hermes to build a profile about me. At first, it tried to scrape my site, so I stopped it and told it to use the downloaded archives. It kept stopping with errors while trying to read everything and kept having trouble finding a database. I exported only the database and tried transferring it again, but no database files transferred.
Great! I’ve extracted information from your website and built a profile about you. Here’s what I learned:
Profile Summary:
- Name: Lewis Moten (lewismoten), also called Lewie
- Role: Senior Frontend Developer with 30+ years experience, technologist, community advocate, library trustee
- Focus: Web accessibility, data transparency, civic engagement, historical preservation
- Website: WordPress blog at lewismoten.com featuring “Chronicles” – a digital archive blending blogging with a technical “system log” of his career
- Code: Forgejo account at git.lewismoten.com (username: mercury.quill)
- Interests: Retro computing/vintage hardware, AI development, creative technology projects
- Style: High-tech/noir, cyberpunk aesthetic (as shown in the site’s visual theme)
The profile is now saved in Hermes’ memory system and will persist for future conversations. When you reference yourself or ask about your preferences/work, it can draw from this stored context.
I took a look at why the file hadn’t transferred and found that it had a gz extension instead of zip.
From here, I was able to get Hermes to look though the database, and put together some information about me.
I had to correct it’s Forgejo account and let it know that the username it associated with me was its own. I asked what else it could tell me based on what it found.
SQLite 3 Conversion
I wanted Hermes to start processing the sites content to start getting a grasp of who I was and to start letting me ask questions about my history. I had to use gzip to unzip the database into a sql dump. I tried converting it into a SQLite database, but kept running into problems. I was running back and for with ChaptGPT to copy & paste commands, and not getting anywhere fast. I then turned to Hermes, and changed its model from running Luna locally, to GPT 5.6 terra on medium reasoning via OpenAI Codex. It started making plans, designing a custom parser, setting up an escape sequence normalizer, and planning script creating and testing. It recognized the 337 MB db.sql was the UpddraftPlus MySQL/MariaDB export.
The first pass found a compatibility edge case with null values escaped inside text, which SQLite doesn’t like in raw SQL, so the values were retained as char(0) to avoid dropping them. Another problem was finding a plugin table where a column was labeled “timestamp” – a reserved word in SQLite. There were conversions for CURRENT_TIMESTAMP, and it had to create a trigger to update based on CURRENT_TIMESTAMP changes.
What had taken me about an hour to diagnose and troubleshoot, with many dead ends, Hermes was able to address in a few minutes. We now had a SQLite database with 21 tables, 24,647 posts, 45,601 post metadata, 12,380 terms, 45,740 term relationships, and 79 comments. I lock comments down on my website, so it’s mainly just pingbacks from the site itself.
Digesting the site
I then decided that, with a local database, it was time to take on the big task. I was still on OpenAI to do the heavy thinking, but instructed it that I wanted to use local models for processsing:
ok. I don’ t know how you do this, if you need to create multiple agents/bots, or what not, but try and look at those 24,647 posts in that database, and start to build up your own profile about me and my history for yourself via Honcho (if it makes sense), as well as a bunch of markdown files in files/lewismoten.com/meta full of any information that you find interesting. I’d prefer that you use the local ollama service with one of the local models to process each post. Also, make sure to recall where the information came from. Let’s see what you can do.
It started planning, checking out what local models were available in ollama, as well as skimming though the SQLite database.
Scheduling a Long-Running Job
Evaluating local Ollama for batch processing Planning long-running background jobs
Skill View16 items
Planning Ollama API querying with batching
I’ll use the local Ollama service, not the public site. First I’m checking which local model is available and profiling the post corpus so the per-post pipeline can preserve titles, dates, IDs, URLs, and source references instead of producing anonymous summaries.
Ran 3 commands
ollama list && printf '\nAPI models:\n' && curl -fsS http://127.0.0.1:11434/api/tags
| NAME | ID | SIZE | MODIFIED |
|---|---|---|---|
| laguna-xs-2.1:q4_K_M | 0175be1e57f4 | 20 GB | 2 days ago |
| qwen3.8:latest | 22130167c4c2 | 17 GB | 2 days ago |
| ministral-3:latest | 1922accd5827 | 6.0 GB | 3 weeks ago |
| devstral:latest | 9bd74193e939 | 14 GB | 5 weeks ago |
| gemma4:latest | c6eb396dbd59 | 9.6 GB | 5 weeks ago |
| qwen3-coder:30b | 06c1097efce0 | 18 GB | 5 weeks ago |
| qwen3:8b | 500a1f067a9f | 5.2 GB | 7 weeks ago |
sqlite3 -header -column /home/ai/files/lewismoten.com/db/db.sqlite3 "SELECT post_type, post_status, COUNT(*) AS n, MIN(post_date) AS earliest, MAX(post_date) AS latest FROM wp_posts GROUP BY post_type, post_status ORDER BY n DESC;"
…(excluded)
Planning content processing workflow Designing multi-phase content extraction system Planning fact extraction with citations
sqlite3 -header -column /home/ai/files/lewismoten.com/db/db.sqlite3 "SELECT COUNT(*) AS published_posts, SUM(length(post_content)) AS content_chars, AVG(length(post_content)) AS avg_chars, MAX(length(post_content)) AS max_chars FROM wp_posts WHERE post_type='post' AND post_status='publish';" && nproc && free -h
| published_posts | content_chars | avg_chars | max_chars |
|---|---|---|---|
| 3821 | 19124813 | 5005.18529180843 | 217550 |
| 8 |
| total | use | free | shared | buff/cache | available | |
|---|---|---|---|---|---|---|
| Mem | 30Gi | 3.6Gi | 12Gi | 16Mi | 14Gi | 26Gi |
| Swap | 8.0Gi | 3.5Gi | 4.5Gi |
Assessing post data volume and processing time Estimating local model processing time for posts Planning incremental background processing pipeline
Planning metadata and inventory scripts Implementing Python requests and SQLite integration
The database has 24,647 wp_posts records, but only 3,821 are published articles; the rest are revisions, media attachments, WordPress internals, drafts, and similar records. I’ll retain all 24,647 in the source inventory and send every record through the local model, while giving substantive post/page bodies their full context. The pipeline records a stable database source ID, date, slug, title, and a content hash with every result.
The local-model trial worked: qwen3:8b returned grounded JSON for the About page with wordpress-db://wp_posts/1, the exact source table/ID, content hash, date, and derived permalink. I’m starting the resumable full-corpus run now; it will skip those first three records and checkpoint each result to disk.
Ran python3 /home/ai/files/lewismoten.com/meta/analyze_wordpress_corpus.py –timeout 600
A few long resume records made the first JSON responses incomplete. I’m tightening the requested result shape and changing resume behavior so error rows are retried rather than treated as complete.
The retry batch completed; the trailing inspection command had a typo, so I’m reading the recorded results directly before resuming the full run.
Ran code import json + 10 commands3541 stdout_bytes
The revised prompt successfully analyzed the previously failing Resume page and two revisions with the local model. The successful results retain organizations, locations, subjects, and profile-fact evidence tied to their exact database records. I’m resuming the full checkpointed run.
Ran python3 /home/ai/files/lewismoten.com/meta/analyze_wordpress_corpus.py –timeout 600
Preparing initial Honcho facts from verified sources Planning SQL extraction for precise source grounding
Honcho Conclude
Conclusion saved for user: Source: wordpress-db://wp_posts/1 (About page, local lewismoten.com database). Lewis Moten describes himself as a technologist and community advocate connecting modern code with historical preservation; he identifies web accessibility, local-government transparency, library trusteeship, volunteering, and information access as recurring commitments.
Thought
Planning local resume sourcing and metadata checks
Ran sleep 20 + 5 commands
Reporting partial progress with caveats Calculating project time estimates
Ran python3 -c “remaining=24621; seconds_per_record=(24.424834/10); print(f’Estimated at current checkpoint rate: {remaining*seconds_per_record/3600:.1f} hours for…
Clarifying task progress and data processing approach Confirming background job continuation and notification
Started a provenance-preserving local analysis pipeline.
Local Ollama
- Model:
qwen3:8b - Processes each of the 24,647
wp_postsrecords, including posts, pages, revisions, attachments, and system records. - Uses no public-site scraping.
- Current checkpoint: 26 successful records; the worker is running in the background and resumes safely after interruption.
- Current rate projects roughly 16.7 hours for the remaining records.
Created in /home/ai/files/lewismoten.com/meta/
README.md— corpus scope and provenance conventionsdatabase-profile.md— 21-table database and WordPress record inventorycontent-inventory.md— published-content inventory, newest items, longest itemstaxonomy.md— categories and tags from WordPress taxonomy tablestimeline.md— publication chronology by decade/yearcorpus-index.jsonl— all 24,647 source records with IDs, dates, types, slugs, URLs where derivable, and body hashespost-analysis.jsonl— local-model finding per record, each tied towordpress-db://wp_posts/<ID>processing-status.json— live checkpoint/statusanalyze_wordpress_corpus.py— resumable Ollama worker
The first substantive result—your About page—is preserved as wordpress-db://wp_posts/1 and was added to Honcho with that source reference. The profile note records your stated connection between technology, historical preservation, accessibility, information access, library service, and civic transparency.
I also corrected the Forgejo identity in the Honcho card: you are lewismoten; I am mercury.quill.
1 file changedReviewanalyze_wordpress_corpus.py+7−3
⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏Waking up default…1 Background
⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏
python3 /home/ai/files/lewismoten.com/meta/analyze_wordpress_corpus.py –timeout 600
Wow. It knew where to look for currently installed models and picked the most appropriate one already installed based on the memory footprint and task. It created a process to inject the records, find a problem, and correct it before proceeding. It realized that most posts were actually revision history, and that there were just under 4,000 posts in all. It created a background task to do the rest of the job so I could keep talking to Hermes.
It just keeps chugging along in the background, reading an individual post, sending to qwen3:8b via Ollama, and append results to meta/post-analysis.jsonl, while a checkpoint is at processing-status.json – no swarm of agents. Just a resumable python worker.
{ "database": "/home/ai/files/lewismoten.com/db/db.sqlite3", "model": "qwen3:8b", "total_records": 24647, "completed_records": 506, "remaining_records": 24141, "errors": 3, "started_at": "2026-09-03T19:12:39.848302+00:00", "updated_at": "2026-09-03T19:40:15.291652+00:00", "current_source_ref": "wordpress-db://wp_posts/876"}
{ "source_ref": "wordpress-db://wp_posts/956", "database": "db/db.sqlite3", "post_id": 956, "date": "2024-04-19 21:37:33", "post_type": "revision", "status": "inherit", "slug": "884-revision-v1", "title": "UV Mapping", "public_url": null, "content_sha256": "f3c442121c9e35dd7cd0a4e68b9b80933f785c72d12a124a7c609656207e2e8c", "model": "qwen3:8b", "model_created_at": "2026-09-03T19:42:14.260494548Z", "analysis": { "record_kind": "revision", "summary": "This revision discusses the author's struggle with UV mapping for a 3D model, including issues with face clipping, color value offsets, and texture application in Second Life.", "topics": [ "3D modeling", "texture mapping", "Second Life", "UV mapping" ], "people": [], "organizations": [], "places": [], "dates_mentioned": ["2024-04-19"], "profile_facts": [ { "fact": "Working on UV mapping for a 3D model", "evidence": "The author describes spending two days working on texture mapping and encountering issues with face clipping and color value offsets." }, { "fact": "Experiencing issues with texture application in Second Life", "evidence": "The author mentions problems with texture application, including the need to upload models to Second Life's asset servers and issues with the Collada format." } ], "interesting": true, "confidence": "high" }}
Holy smokes… not only is it chugging away at this, but look at what it is gathering! I’ve worked on systems before that did this kind of thing without generative AI. It was mostly for intelligence gathering on military documents to help link incidents together with common people or things involved. Usually, I program this kind of stuff by hand based on what’s going on in my community with agenda packets for board meetings, but here we are, with the model taking on the task with little thought.
Still in the middle of processing everything, I decided to ask if it learned anything interesting about me.
Yes. The early material adds texture beyond the “senior frontend developer / civic advocate” summary.
- You’re a hands-on maker, not just a software person. Your Creativity page frames your work as an overlap of art, craft, 3D modeling, sewing, and software experiments. Source:
wordpress-db://wp_posts/219 - Second Life was a serious creative/technical chapter. You built a UFO game there in 2009, and later connected that kind of work to GPS, web APIs, 3D graphics, and sound experimentation. Source:
wordpress-db://wp_posts/438 - You like understanding systems at their lowest useful level. One example is analyzing
.VOCfiles, waveforms, frequencies, and PC-speaker audio to make a tiny game-audio format. That’s a very different impulse from ordinary app development: reverse-engineer the constraints, then make something elegant inside them. Source:wordpress-db://wp_posts/563 - Your archive is unusually deliberate. It is not merely a blog or résumé; it’s a reconstructed chronology that links professional work, community life, creative experiments, local history, and older web/virtual-world projects.
- The early analyzed corpus is heavy on 3D/virtual-world work. Among the first 648 successfully analyzed records, recurring themes include 3D modeling, texture/UV mapping, NURBS, Three.js, Second Life, game development, and digital media. That makes the “retro computing + creative technology” description more concrete.
- Your civic and technical identities seem integrated rather than separate. The archive’s framing and the early Community/Career material put public involvement, accessibility, transparency, hands-on technology, and local history in the same personal narrative.
I added the maker/creative-work, Second Life/game development, and low-level audio-analysis facts to Honcho with their exact local database source references. The running analysis is still moving through older material, much of which is media and revision history; I’ll treat repeated model themes as leads and only promote well-supported facts into Honcho.
I may point it to a social media export sometime, or perhaps to my repositories on Forgejo. It may be best to split those up and document them on my blog at key points in time, such as the repository’s first commit, releases/tags, major features, and the last commit. I’d also like to split up the planet source code archive in a similar fashion. If I can document the public events in my life in proper order, with tagging, it will make everything easier to find and point people in the right direction when referencing my history. It also helps with sites like Internet Archive that comes through and archives the historical parts of the site from time to time.
The site, as a whole, is more of a database of memories I can search for clarity or explicit details about what I did. Having an agent run through huge archives of data, to categorize it, or make it more useful is just crazy awesome. I also have an extensive collection of photos over the years that I would eventually like to have it tackle. The majority of my dropbox account is swamped with them, and I’d like to eventually go through and figure out if i can reduce the overall image size, lossyness, find similar people, places, events, and start documenting them or rearranging them for better management to find what I need quicker.
Only a few moments have passed, but I decided to ask Hermes for an update on any new information that the found.
Yes. The worker is now at 826 / 24,647 records—178 beyond the previous check.
The strongest new thread is a custom 3D authoring/toolchain project for Second Life, not merely making models:
- You worked through UV alignment, texture wrapping, lighting, COLLADA export, NURBS surfaces, control points, knots, poles, ray casting, camera orientation, vertex selection, coordinate translation, and pixel-to-model mapping.
- You were building toward usable export paths—PNG, OBJ, glTF, and STL—and treating rendering/interaction issues as engineering problems to isolate and fix.
- The pattern is very “lab notebook”: observe a weird artifact, locate the representation or coordinate bug, make an incremental correction, then document the next constraint.
Sources include: wordpress-db://wp_posts/787, /884, /993, /1071, /1144, /1201, /1267, and /1304.
I wrote the evidence and source list to:
/home/ai/files/lewismoten.com/meta/3d-modeling-research-notes.md
One human detail surfaced in that sequence: “Getting The Point” mentions theft and damage to a Tiny Little Library cabinet. I kept that as an event-specific archival note rather than adding it to your standing Honcho profile.
It seems I focused on the Sculpty importer/editor/exporter via three.js for a small web project. I recall discovering the damage to Tiny Little Library and finding out who was behind it. I’m often reminded of it, and it has since affected my interest in maintaining it.
I decided to have Hermes schedule a background job to notify me of any new findings as it progresses, as a progress update on its knowledge. I also asked it to update the main background process to parse the results and start tracking token usage, so I could estimate how much money I might save by running locally rather than through a commercial platform.
It created a new file to track incoming and outgoing tokens, as well as duration, and included a note on the number of records processed before token tracking was implemented.
{ "tracking_started_at": "2026-09-03T20:18:35.218477+00:00", "model": "qwen3:8b", "tracked_requests": 16, "input_tokens": 53771, "output_tokens": 2499, "cache_tokens": 0, "cache_tokens_available": false, "total_duration_ns": 2184196647008, "load_duration_ns": 2085158676454, "input_eval_duration_ns": 17420237000, "output_eval_duration_ns": 81331698000, "pre_tracking_successful_records": 967, "note": "Counts are actual Ollama API counters from this point forward. Ollama /api/generate does not report cache-hit tokens, so cache_tokens is not an estimate.", "updated_at": "2026-09-03T21:07:00.094681+00:00", "total_tokens": 56270}
A few hours later…
I stepped out for a board meeting while the process kept running. I tried communicating over Telegram to check the status and found that things seemed to be moving very slowly. I came home to ask for an update on the estimated completion and was told that I would need to wait about 46 days for it to be completed.
This was unacceptable; the initial posts were processed too quickly. I asked Hermes to diagnose the problem, and they said the Ollama server was spending most of its time swapping models between Qwen3:8b (10.5 GB) and Laguna-xs-2.1:q4_K_M (20 GB). Another isue was that the Archive worker was requesting 65,536 tokens (0xFFFF), which exceeded Qwen’s 40,960 token context, so that was reduced to 8,192 tokens.
We started tracking down the contention loading Laguna. It seemed like it may have been my local Mac instance of Hermes. I switched it to Qwen3:8b as well, but Hermes said it couldn’t meet the bare-minimum context window that Hermes requires.
The archive worker appeared to finish the new additions immediately, then started speeding through about 90 records in a few seconds. After a while, I asked how long it would take with the changes, and it returned a 12-hour estimate. This was better, but it had take measurements in the past hour – much longer than when the fix was made.
I asked Mercury to check the number of records processed, wait 1 minute, and then check again. Take those two numbers and estimate the time remaining for all remaining records. From there, it found that 40 records were processed per minute, equivalent to 2,400/hour. With 21,710 records remaining, it estimated the processing would take nine hours to complete.
| Measure | Actual tracked so far | Per processed Record | Estimated full 24,647-record batch | Estimated Remaining |
|---|---|---|---|---|
| Input | 3,704,826 | 1,781 | 43,900,407 | 38,473,193 |
| Output | 272,774 | 131 | 3,232,241 | 2,832,653 |
| Total | 3,977,600 | 1,912 | 47,132,648 | 41,305,846 |
What does that look like if I were to go with ChatGPT? Luna is the cheapest model, but more capable. However, it’s the model I would probably have chosen for this. For 43.08 million tokens at $0.20/million, that’s about $8.62. With output tokens at $1.20/million, 3.24 million equates to $3.89, for a total API spend of $12.51. So I am saving $12, but at the cost of electricity and time. The machine I am using is much slower, but it also adds a layer of security for anyone who is privacy-conscious about sending data over to a third party like this.
Ollama doesn’t expose cache-hit tokens, so that usage remains unknown.
The latest progress is 14% complete, so I turned it up to Max and asked it to provide an introspective analysis of what it has gathered so far for the blog. It started working and spun off three sub-agents to help dig through all of the sources, and then consolidated back into one main task, walking through what it had found to build a draft.
My guess is it’s spending more tokens on analysis than on indexing the site’s semantic content. However, that’s usually where you spend the money: on deep analysis and reporting rather than gathering and processing batches of data. The indexed data is reusable and can be corrected. It’s a quick lookup for analysis, and you can verify details later.
