DEV Community: Shubham Kondekar

Sloth - a local file tidier that runs entirely on your laptop

Shubham Kondekar — Mon, 26 Oct 2026 05:09:52 +0000

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

What I Built

Sloth is a local file tidier that runs entirely on your laptop.

You point it at a folder — usually the downloads folder you have been avoiding for months — and it reads the files, groups them into piles, renames them into something you can actually search for, and shows you the whole plan before a single byte moves. When you approve it, everything goes into Sloth Sorted/, and Sloth leaves a short morning note describing what happened.

The person who gets to be lazier is anyone who has ever opened their Downloads folder, felt a small wave of dread, and closed it again. That is the entire audience. Sloth does the reading and the sorting; you keep the judgement call.

The model is Qwen2.5-1.5B-Instruct — open weights, Apache-2.0 — running locally through llama.cpp. No account, no API key, no cloud, no telemetry. The app itself is Python standard library only. The only thing it asks of the network is one setup step to download the engine and the weights.

Demo

There is no hosted demo, on purpose: the whole point is that your files never leave your machine. Here is what it looks like running locally.

A scan of a 42-file messy folder (about 26 seconds on an M-series Mac):

Every row shows the new name, the original name, the model's reason, and a confidence score. The two files it is unsure about start unticked. Nothing moves until you press the button.

After applying, a receipt and a morning note:

To reproduce locally:

git clone https://github.com/kondekarshubham123/sloth.git
cd sloth
./setup.sh          # builds llama.cpp, fetches ~1 GB of weights, makes a demo folder
./sloth ui --open   # http://127.0.0.1:8765

Or stay in the terminal:

./sloth scan ~/Downloads
./sloth apply last --yes
./sloth undo
./sloth night --once --apply   # tidy now, then leave a note

Code

The repository is here: kondekarshubham123/sloth

git clone https://github.com/kondekarshubham123/sloth.git

The interesting parts are small and readable:

src/sloth/scanner.py — a careful folder walk that skips junk, symlinks, and its own output, and reads a bounded snippet from text-like files.
src/sloth/planner.py — batching, rule hints, model reconciliation, and filename sanitising.
src/sloth/llm.py — spawns and supervises a local llama-server; talks to it over loopback.
src/sloth/store.py — plans, apply, a JSONL journal, undo, and the morning note.
src/sloth/netguard.py — a socket-level guard that refuses non-loopback connections.
src/sloth/ui/ — the dashboard in plain HTML, CSS, and JavaScript, with inline SVG illustrations and no external assets.

Twelve unit tests cover the boring-but-important bits: name sanitising, extracting JSON from a chatty model, scan skip rules, path escapes, idempotent apply, undo, and the airgap.

How I Built It

I wanted the model to be genuinely load-bearing, not a chat bubble bolted onto a file sorter. But I also knew a 1.5B model would occasionally be confidently wrong. So Sloth is a hybrid, and the split is deliberate.

The model decides. For each batch of six files, the planner sends a compact JSON view — name, extension, size, modification date, a short text snippet, and a rule hint — to a local llama-server. It asks for strict JSON back: bucket, a kebab-case name, a reason under twelve words, and a confidence score.

The rules keep it honest. A small deterministic engine supplies an objective hint for every file. If the model agrees with a hard signal, confidence gets a small bump. If it disagrees about something objective — an .mp3 is not a document, a file named screenshot-2026-03-14 is a screenshot, a boarding pass is travel — the rule wins, and the override is visible in the why line. Semantic corrections are more conservative and only apply when the model itself is unsure.

While testing, the model kept stamping today's date onto filenames that had no date in them. That is a very small, very believable hallucination, and exactly the kind of thing a person would not notice until next year. So drop_bogus_date() strips a YYYY-MM-DD prefix unless those digits appear in the original name or the file's actual modified date. Small guardrail, big difference in trust.

The prompt treats filenames and snippets as untrusted data, never instructions, because a file called ignore-previous-instructions.txt should be a file, not a command.

Everything else is intentionally boring. The HTTP server is http.server. The UI streams scan progress as newline-delimited JSON. The journal is JSONL. Undo reads the journal backwards and refuses any move that would escape the scan root. The morning note is Markdown written to ~/.sloth/briefings/.

And the airgap is real rather than decorative: netguard.install() replaces the socket connection path so non-loopback connections fail for the life of the process, the UI binds to 127.0.0.1, and llama-server is launched with a loopback host. ./sloth doctor prints the model checksum, the engine backend, and the airgap state. The dashboard loads no CDN, no web fonts, and no analytics. The sloth drawing is inline SVG.

The slow part is the point. Batches of six, a visible "reading files 13–18 of 42" line, and a plan you have to approve. It is a file tidier that behaves like a careful person rather than a progress bar.

Why Does Open Innovation Matter?

A closed API would have made this project easier and worse.

The easy version sends your filenames, and possibly snippets of your contracts and medical notes, to someone else's server. That is a strange price to pay for tidying a Downloads folder. With open weights and open inference, the private version is also the capable version. Qwen2.5-1.5B is small enough to run on a laptop, good enough to name a file sensibly, and licensed so that I can ship it without asking permission.

Open weights also made the design possible. I could inspect how the model behaved, notice the invented-date pattern, and build a guardrail around it. I could swap in a larger model by changing one environment variable. I could build the entire thing offline, on a train, without a billing dashboard. And anyone reading the repo can verify the privacy claim in the code instead of trusting a landing page.

The agent harness matters here too. llama.cpp is open, hackable, and runs on the hardware people already own. That is what turns "local AI" from a demo into something a normal person can actually use on a Tuesday night.

My Agent Session

I did not publish a DevRelay session for this build, so there is no embed to share. Being honest about that feels better than linking to something that does not exist.

What I can share is the loop I actually worked in. I used an AI coding agent to scaffold the project, then spent most of the time on the unglamorous parts: making the model's JSON parse reliably, reducing the batch size until the 1.5B model stopped truncating output, catching the bogus date prefixes, fixing the apply button's disabled state, and re-running the same 42-file demo until apply and undo were both correct. The screenshots in this post are from the final build, not a mockup.

The most useful agent contribution was not code generation. It was being able to run the app, read the model's output, and iterate on the prompt and the reconciliation rules in the same session.

The Lazy Payoff

On the demo folder, Sloth read and classified 42 files into 12 piles in about 26 seconds. I approved 40 of them; the two low-confidence files stayed put. Apply moved all 40 into Sloth Sorted/ in under a second. Undo put all 40 back, from the journal, just as quickly.

The honest number is not the 26 seconds. It is the twenty minutes I would have spent opening files called scan0001.pdf and q3 budget final FINAL v3.xlsx to work out what they were, plus the future minutes I will not spend searching for them. The folder is now something I can look at without flinching, and I did not have to make a single decision about a .HEIC file.

That is the laziness Sloth is selling: not zero effort, just the effort moved to a place where it is cheap. The sloth reads slowly so you do not have to.

Prize Categories

Best Use of Gemma
Use Gemma, Google's open-weight model, in building your project: run it locally, fine-tune it, or serve it through Google Cloud or another provider.

ReceiptRack: a receipt sorter that never sends your receipts anywhere

Shubham Kondekar — Sun, 18 Oct 2026 18:44:46 +0000

Every freelancer I know has the same shoebox: a folder of receipt photos and invoice PDFs that gets sorted once a year, in a panic, before taxes. Cloud OCR APIs exist for this — and for exactly one reason (my clients' financial data never leaving my laptop, and paying $0 instead of per-page forever), I built ReceiptRack on a local open-weight model instead.

Drop receipts in → a vision model running on your machine transcribes and structures them → suspicious extractions get flagged for a 10-second human review → keyword rules file them to the right client → export a CSV your accountant accepts.

flowchart LR
    A[Receipt / invoice<br/>PNG · JPG · PDF] --> B[Preprocess<br/>Pillow]
    B --> C[Vision pass<br/>gemma3:4b via Ollama<br/>faithful transcription]
    C --> D[Structuring pass<br/>schema-constrained JSON<br/>temperature 0]
    D --> E{Validator<br/>flags · sum check}
    E --> F[(SQLite, local)]
    F --> G[Human review UI]
    G --> H[Client sorting<br/>rules + model]
    H --> I[CSV export]

Why open is the business model, not a preference

	Cloud OCR API	ReceiptRack
Data	Clients' spend leaves the machine	Never leaves it — the pitch
Cost	Per-page, forever	$0 marginal — scan 10 or 10,000
Lock-in	Someone else's pricing	Swap the model via one env var
Niche fit	Generic	Fine-tune on your clients' invoice formats

The open pieces are the product: gemma3:4b (open-weight vision model), Ollama (local runtime), FastAPI + SQLite, MIT-licensed. A closed API structurally cannot promise "this runs on your laptop" — the privacy claim is only true because of what's open.

What the community had already figured out (and what it hadn't)

Two DEV posts shaped the design:

Bytefer's Ollama-OCR for High-Precision OCR with Ollama established the local vision-OCR pipeline — including a receipt demo. But the most interesting part is what the comments didn't resolve: "Does it hallucinate with large tables with lot of numbers?" went unanswered except by "go test the 90B demo yourself."
Ajit Kumar's Complete Guide to Ollama makes the economics case plainly: "Your data never leaves your machine… no API costs."

And from an open-source invoice extractor's published eval: invoice # 20%, date 60%, total 60% field accuracy with a small vision model. Read that before you ship anything that auto-files money documents. So ReceiptRack's core rule became: the model proposes, a human disposes. Every extraction lands in a review queue with flags:

missing_total, missing_vendor, date_not_iso
line_items_mismatch — line items (+ tax) don't sum to the stated total

That last flag caught a real case in testing: an Uber receipt where the $4 tip isn't a line item. A human glances at it; the model never silently files a wrong number.

The five things that broke, and the fixes that stuck

1. Two passes beat one. First version: image → JSON. Final: image → faithful transcription → JSON from the transcription. Same accuracy ceiling, but you get an auditable raw transcript in the UI, and re-parsing doesn't re-run the vision model.

2. Optional schema fields = missing data. The model happily returned vendor: "" and skipped category entirely when they had defaults. Making them required in the JSON schema — with Ollama's schema-constrained decoding — turned "usually present" into grammatically impossible to omit.

3. A prompt that returns null for the total, deterministically. The docs clearly said TOTAL DUE 65.69; three runs in a row, total: null. The fix was one unambiguous line:

- total: the grand total the customer pays (TOTAL, TOTAL DUE, Amount Due).
  If the document says "TOTAL DUE 65.69", then total = 65.69.
  Never null when a total line exists.

Temperature 0 doesn't save a confusing prompt — it just makes the confusion reproducible.

4. The model echoing the vendor as the client name. Auto-sorting asked "which client should this go to?" and gemma3:4b kept answering "Figma Inc." (the vendor) no matter how sternly the prompt said "only names from the list." Instructions lost. So I stopped asking nicely and constrained the grammar:

schema = {
    "type": "object",
    "properties": {
        "client": {
            "anyOf": [
                {"type": "string", "enum": [c["name"] for c in clients]},
                {"type": "null"},
            ]
        }
    },
    "required": ["client"],
}

Wrong answers became unrepresentable. This is the single best argument for open, schema-constrained local inference I have: a closed chat API gave me a JSON "format" hint; Ollama gave me a grammar.

5. Malformed JSON still happens. Even under schema constraints, one extraction in three crashed the parser. Retries (strict schema → loose JSON → validate) turned a hard failure into noise.

The numbers

~5–15 s per receipt on an M-series Mac, 100% GPU, 16 GB RAM
3/3 correct vendor/date/total/tax/line items on the test set after fix #3
Cost per receipt: $0.00 — forever

Honest limitations

Small open-weight models misread faded thermal prints — that's what the review queue is for. The LLM client-assignment fallback makes defensible-but-imperfect choices (a 4B model thinks every travel expense belongs to the design agency); deterministic keyword rules run first for that reason. Single-user, localhost-only by design.

Try it

ollama pull gemma3:4b
git clone https://github.com/kondekarshubham123/ReceiptRack.git && cd receipt-rack
uv sync
uv run uvicorn app.main:app --port 8300   # → http://127.0.0.1:8300
uv run python scripts/make_samples.py     # demo receipts

Repo: https://github.com/kondekarshubham123/ReceiptRack · MIT · README has the full architecture and the env vars (RECEIPT_RACK_MODEL, OLLAMA_URL).

Sources:

🌐 Community Wisdom: [Ollama-OCR for High-Precision OCR with Ollama]

Source: [Bytefer]
Tags: webdev, programming, javascript, ai

Establishes the local vision-model OCR pipeline as a proven pattern; the comments' unresolved question about hallucinated numbers in tables is why this project validates arithmetic instead of trusting the model.

🔗 Read Full Discussion

🌐 Community Wisdom: [The Complete Guide to Ollama: Run Large Language Models Locally]

Source: [Ajit Kumar]
Tags: ollama, llm, rag, ai

The privacy/no-API-cost case this project's pitch rests on — with the honest tradeoff surfaced by readers: hardware is the real cost of going local.

🔗 Read Full Discussion

DeadZone Drill: offline flashcards that only work when you walk away from the internet

Shubham Kondekar — Sun, 11 Oct 2026 04:35:27 +0000

The pitch in one sentence

DeadZone Drill turns your study notes into a spoken flashcard drill you run on a walk, with a local open-weight model writing and grading the cards — no account, no API key, no internet.

The problem I actually had

I revise with flashcards, and flashcards are a screen activity: sit down, stare at a card, tap "again". Studies on recall and the challenge's own framing kept pointing the same direction — I learn better when I'm moving, and I sit too much. The best moments of my last study session weren't at the desk at all. They were on a walk where I was muttering answers to myself.

So I stopped trying to make the desk better and made the walk the study session. DeadZone Drill is the tool I wanted: it talks, I answer out loud, and the screen stays in my pocket.

Demo

$ python3 -m drill build notes.md --deck foliage
Added 12 card(s) to deck 'foliage' (source: gemma).

$ python3 -m drill walk --deck foliage
TTS engine: macOS say (default voice)
----------------------------------------------------
  12 card(s) due. Answer out loud, then grade yourself.
----------------------------------------------------
[1/12] deck=foliage box=1
Listening to the question...
> "What is the primary trigger for autumn colour?"
Recall it, then press Enter to hear the answer...
A: Day length
Did you know it? [y/N, q to quit] y
...
----------------------------------------------------
  Reviewed 12 card(s). 9 correct (75%).
  Session over. Get outside.

How it works

Everything that matters runs on the machine. The only network call is to localhost.

flowchart LR
    A["Your notes<br/>(.md / .txt)"] --> B["Gemma 3 via Ollama<br/>local, offline"]
    B --> C["Q/A cards<br/>SQLite + Leitner schedule"]
    C --> D{"Walk mode"}
    D -->|"speak question"| E["macOS say / Piper<br/>offline TTS"]
    E --> F["You answer<br/>out loud"]
    F --> G{"grade"}
    G -->|"typed / spoken"| H["Gemma grades<br/>local"]
    G -->|"self-grade"| I["one keypress"]
    H --> C
    I --> C

Pipeline:

Generate — drill build notes.md sends your notes to a local Gemma 3 (via Ollama) with a strict prompt and asks for JSON flashcards. If no model is running, a dependency-free cloze generator still produces a usable deck.
Recall — drill walk pulls the cards due today and speaks each question with offline TTS.
Grade — answer out loud and self-grade with one keypress, type it for model grading, or speak it if you have a local Whisper build.
Schedule — a small Leitner scheduler moves the card to the next box and sets the next review date in SQLite.

The whole thing is standard-library Python. pip install is not required; the Ollama client is 60 lines of urllib.

Why open matters here (not as a slogan — as a requirement)

The theme asks me to build something that gets people off the screen and into the world. The open pieces aren't decoration; they're the reason the product works:

It works with no internet, because the model is local. Card generation, text-to-speech, grading, and scheduling all run on-device. Airplane mode is a supported configuration, not a degraded one. A closed API would have made "study on a trail with no signal" impossible — which is exactly the scenario the app exists for. To prove it, drill prerender writes all question audio to disk so a walk needs zero synthesis work in the moment.
My notes stay mine. Lecture notes, personal study material, and every review I've ever done live in a SQLite file in ~/.deadzone-drill. There is no upload step to remember to disable, and no server holding what I'm weakest at. This is the "keep someone's data off a server they don't control" clause of the prompt, made concrete.
The brain is swappable. Any Ollama model works. I developed against one model and changed one environment variable to run Gemma. No vendor migration, no rate limits, no deprecation notice.
It costs nothing to run. There's no token meter between me and my own revision. I can drill 10 cards or 10,000 and the cost is identical: zero.
The open tools let the edges degrade and still work. When Whisper isn't installed, the app doesn't break — it falls back to self-grading. When no model is running, it falls back to cloze cards and token-overlap grading. Open, composable pieces made graceful degradation cheap to build.

I'm not claiming a local 4B model out-writes GPT-5 at flashcard creation. I am claiming that the fraction of usefulness that requires the internet was zero, and that's the whole point.

Built with

Gemma 3 (via Ollama) — the open-weight model that writes and grades cards
Python standard library — no runtime dependencies
macOS say, with Piper as a pluggable open-weight TTS engine
whisper.cpp / faster-whisper — optional offline speech-to-text
SQLite — local card storage and review schedule

What was hard

Grading free-form recall without a cloud service. Exact string matching punishes correct answers phrased differently. I solved it in two layers: a local model judges paraphrase and partial credit, and a token-overlap heuristic catches the case where no model is available.
Making "offline" real instead of aspirational. Pre-rendering audio and testing with the network off forced every hidden assumption into the open.

Try it

git clone https://github.com/kondekarshubham123/deadline-drill deadzone-drill
cd deadzone-drill

# optional: local model
ollama pull gemma3:4b

python3 -m drill sample               # seed a demo deck (works offline)
python3 -m drill walk --deck sample   # drill it

# or use your own notes
python3 -m drill build notes.md --deck mine
python3 -m drill walk --deck mine

Repo: https://github.com/kondekarshubham123/deadline-drill
License: MIT
Live demo: not applicable — it's a local-first tool, which is the point. The repo runs on any laptop in two commands.

What's next

Optional spoken answers with a bundled Whisper build so the loop is fully hands-free
Deck export/import for sharing a good set of cards
A "grass streak" that tracks how many days you studied outside rather than how many cards you ground through

Built for the Hacktoberfest Open-Source AI Challenge, Week 1 (Touch Grass). If you try it, take it somewhere with no signal — that's where it's happiest.

Hive - A Local AI Life Assistant for My Family, Running on a Raspberry Pi

Shubham Kondekar — Sun, 04 Oct 2026 20:00:49 +0000

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

What I Built

Hive is a private, multi-user AI life assistant that runs entirely on a Raspberry Pi 4B — no cloud, no subscriptions, no data leaving your home network.

I built it for my family. We needed a shared space to manage our week: upcoming events, daily expenses, and a clear picture of what actually matters each day. Every existing tool either costs money every month, sends your data somewhere, or needs a good internet connection. Hive does none of those things — it lives on a Pi on the shelf and is accessible from any phone on the home Wi-Fi.

What it does:

💬 AI Chat — talk naturally: "I spent ₹150 on paav bhaji" or "Schedule a gym session tomorrow at 7am" — Hive routes your message to the right agent and writes to the database
📅 Event Planner — add, view, and delete calendar events; the AI checks for conflicts automatically
💸 Expense Tracker — log spending by category with a monthly budget summary and INR formatting; export to JSON or CSV
🎯 Priority Ranking — AI scores your upcoming events and expenses by urgency so you always know what to focus on
🎙️ Voice Input — speak instead of type, transcribed locally by OpenAI Whisper (no audio leaves the Pi)
🌅 Morning Briefings — the Pi pushes a daily summary to all connected users via WebSocket at a scheduled time
📱 Multi-user, multi-device — family members register by name + PIN, each has their own data, accessible from any phone on the same Wi-Fi

Demo

The app runs on a Raspberry Pi 4B (8 GB) on the local network. Any device on the same Wi-Fi opens http://<pi-ip>:8000 to get the full PWA.

🎥 Watch the demo:

https://youtu.be/ykFI4QWlZVs

Code

🐙 GitHub Repository:

https://github.com/kondekarshubham123/Hive

Key file structure:

hive/
├── server/
│   ├── main.py              # FastAPI app, WebSocket, SPA routing
│   ├── agents/
│   │   ├── orchestrator.py  # LangGraph StateGraph — keyword classify → route → tool-call loop
│   │   ├── tools.py         # LangChain tools: create_event, log_expense, get_open_tasks, ...
│   │   └── state.py         # HiveState TypedDict
│   ├── routers/
│   │   ├── auth_router.py   # Register / login by name+PIN, JWT issue
│   │   ├── chat.py          # POST /chat — SSE streaming, history fetch, message persist
│   │   ├── events.py        # CRUD /events
│   │   ├── expenses.py      # CRUD /expenses + budget summary
│   │   ├── priorities.py    # GET + POST /refresh — LLM priority scoring
│   │   └── voice.py         # POST /voice — Whisper transcription
│   └── database.py          # aiosqlite, 6-table schema, single DB_PATH
├── client/                  # React 19 + Vite + Tailwind CSS PWA
└── setup/
    ├── install_pi.sh        # One-shot Pi setup: apt, Ollama, venv, Node, systemd
    └── Modelfile            # hive-fast: gemma2:2b + tuned context/temperature/stop

How I Built It

Open-source AI stack

Layer	Technology
LLM runtime	Ollama — runs `hive-fast`, a custom build of Gemma 2 2B (Google's open-weight model)
Agent framework	LangGraph 0.2 — `StateGraph` with conditional routing
LLM library	LangChain / langchain-ollama
Voice transcription	OpenAI Whisper `base.en` — runs locally, no API key
Backend	FastAPI with SSE streaming and WebSocket
Database	SQLite via aiosqlite
Frontend	React 19, Vite, Tailwind CSS

Agent architecture

The core insight is a keyword intent classifier in front of the LangGraph router. Instead of running a second LLM inference to classify intent (which added 4–7 s per request), a simple keyword scan routes messages effectively instantly:

_INTENT_KEYWORDS = {
    "expense": ["spent", "pay", "₹", "rs ", "cost", "bill", ...],
    "schedule": ["schedule", "meeting", "remind", "tomorrow", ...],
    "priority": ["priority", "focus", "what should i", ...],
    "share":    ["share", "send to", "notify", ...],
}

def _keyword_classify(message: str) -> str:
    msg = message.lower()
    for intent, keywords in _INTENT_KEYWORDS.items():
        if any(kw in msg for kw in keywords):
            return intent
    return "general"

Once classified, LangGraph routes to the matching node (planner_node, expense_node, etc.), which binds the appropriate tools and runs a tool-call loop (up to 5 rounds). The LLM's system prompt always includes the caller's user_id so every tool call writes to the right user's data.

Performance on Pi

The hive-fast Modelfile tunes Gemma 2 2B with num_ctx 2048, num_thread 4, temperature 0.2 — responses arrive in 2–4 s on the Pi's ARM Cortex-A72 CPU.

A keyword intent classifier avoids an additional LLM call before the model is invoked, cutting out the extra 4–7 s that a second "classify intent" LLM call would cost.

Voice pipeline

Whisper's base.en model runs as a subprocess via openai-whisper (not faster-whisper, which has a C extension that fails to build on Python 3.13 + aarch64 + FFmpeg 6.x). Audio is uploaded as WebM, converted by ffmpeg, and transcribed in ~2 s.

Why Does Open Innovation Matter?

A closed API version of this — GPT-4o + a hosted database — would cost money every month and would mean every family member's schedule, spending habits, and daily priorities live on someone else's server.

Open weights made it possible to run a capable model on a ₹7,000 single-board computer that sits on a shelf and consumes 5–8 W. The entire stack — model weights, inference runtime, agent framework, voice transcription — is open source. That means:

Privacy: no application data needs to leave the home network.
Cost: the ongoing infrastructure cost is essentially electricity.
Longevity: no API key to rotate, no service to deprecate, no pricing change to break the family's workflow.
Customizability: the Modelfile lets us tune the model's personality, context size, and stop tokens without touching the inference server.

Open innovation didn't just make this cheaper — it made it possible to build a private AI assistant that can live in the home.

My Agent Session

Built with Claude Code — iterative development over multiple sessions: architecture → scaffolding → Pi deployment → bug fixes → performance tuning.

Prize Categories

Gemma — Best Use of Gemma 🏆

Hive runs Gemma 2 2B as its core reasoning model — fully locally on a Raspberry Pi 4B, with no cloud LLM calls or API key required.

The model is loaded via Ollama and wrapped in a custom Modelfile (hive-fast) that tunes it for the Pi's constraints:

FROM gemma2:2b
PARAMETER num_ctx 2048     # fits chat history + tool responses
PARAMETER num_thread 4     # all 4 Pi CPU cores
PARAMETER temperature 0.2  # decisive, low-variance answers
PARAMETER repeat_penalty 1.1
PARAMETER stop "<end_of_turn>"

Gemma 2 2B handles all three AI tasks in Hive:

Agentic tool calls — understands the user's natural-language request and generates the arguments needed for tools such as log_expense, create_event, and get_open_tasks
Priority scoring — reads a JSON list of upcoming events and expenses, scores each 0–1 by urgency and deadline proximity
General conversation — answers follow-up questions and summarises the day

The keyword classifier routes intent without another LLM call, so Gemma only needs to run for the actual reasoning/tool-use step.

On Pi 4B (ARM Cortex-A72, 4 cores, 8 GB), first-token latency is typically 2–4 s — fast enough for a family assistant that people can use throughout the day.

Architecture at a Glance

                         ┌──────────────────┐
                         │   Family Device  │
                         │ Phone / Laptop   │
                         └────────┬─────────┘
                                  │
                                  ▼
                         ┌──────────────────┐
                         │     FastAPI      │
                         │   Hive Backend   │
                         └────────┬─────────┘
                                  │
                         ┌────────▼─────────┐
                         │ Keyword Intent   │
                         │    Classifier    │
                         └────────┬─────────┘
                                  │
                                  ▼
                         ┌──────────────────┐
                         │    LangGraph     │
                         │ Agent Orchestrator│
                         └────────┬─────────┘
                                  │
                         ┌────────▼─────────┐
                         │    Gemma 2 2B    │
                         │      Ollama      │
                         └────────┬─────────┘
                                  │
                         ┌────────▼─────────┐
                         │   Hive Tools     │
                         │ Events / Expense │
                         │ Priorities / etc │
                         └────────┬─────────┘
                                  │
                         ┌────────▼─────────┐
                         │      SQLite      │
                         │   Local Storage  │
                         └──────────────────┘

Final Thoughts

Hive started with a simple idea:

Build something useful for the people around me, not just another AI demo.

It became an experiment in:

Local AI
Small Language Models
Agentic workflows
Raspberry Pi inference
Voice AI
Privacy-first software
Multi-user AI systems
Open-source infrastructure

And most importantly, it became something my family can actually use.

AI doesn't always need a data center. Sometimes it can live on a Raspberry Pi sitting on a shelf at home. 🐝

Links

🐙 GitHub: https://github.com/kondekarshubham123/Hive

🎥 YouTube Demo: https://youtu.be/ykFI4QWlZVs

🏆 Hacktoberfest Challenge: https://dev.to/challenges/hacktoberfest-weekend-2026-10-01