DEV Community: 一郎支

I Built LocalLedger: An Offline Receipt Organizer That Runs Gemma on Your Own Laptop

一郎支 — Wed, 14 Oct 2026 06:49:34 +0000

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

What I Built

LocalLedger is an offline invoice and receipt organizer for freelancers. You point it at a folder of receipts; it reads them on your own laptop, sorts every line into a category, writes an accounting-ready CSV plus a plain-language quarterly review, and ends with a list of questions to ask your accountant.

Who would pay for it, and why: freelancers and one-person businesses. Every freelancer I know does their books the same way — a shoebox of PDFs in July, an evening of typing numbers into a spreadsheet, and a nagging worry that they missed a deduction. The existing tools solve this by taking your data: connect your bank feed, upload your receipts to their cloud OCR, pay $15–40 a month forever. For someone billing three clients from a kitchen table, that is real money and a real privacy cost — client names, addresses and rates all sitting in someone else's database.

LocalLedger is the opposite trade. The entire thing runs locally on an open-weight model, so the numbers never move and the cost per receipt is zero.

Demo

No install, no API key, no internet:

python -m localledger scan examples/receipts.txt --no-llm

LocalLedger - scanning examples/receipts.txt
engine: deterministic-offline

  DATE        VENDOR                          AMOUNT  CATEGORY       NOTE
  ------------------------------------------------------------------------
  2026-07-03  ADOBE SYSTEMS INCORPORATED   22.99 USD  Software       Creative Cloud - monthly subscription
  2026-07-07  UBER TRIP                    18.40 USD  Travel         Ride to client meeting downtown
  2026-07-09  STARBUCKS STORE 1042          6.75 USD  Meals          Team coffee meeting
  2026-07-14  AMAZON MARKETPLACE           31.20 USD  Office         Printer paper and toner
  2026-07-21  LUFTHANSA                   210.50 EUR  Travel         Flight FRA-LHR return
  2026-07-28  MYSTERY VENDOR LTD            9.99 USD  Uncategorized  Misc supplies

  Totals: 210.50 EUR, 14.99 GBP, 224.33 USD
  Documents: 9   Uncategorised: 1

Questions to ask your accountant
  - Meals & entertainment total 6.75 - confirm the deductible percentage in your jurisdiction.
  - 1 uncategorised item(s) (MYSTERY VENDOR LTD) - can they be assigned to a deductible category?
  - Largest single expense: LUFTHANSA at 210.50 EUR - is this a capital asset rather than a one-off cost?
  - Expenses span EUR, GBP, USD - which exchange rate applies on the tax return?

There is also a local web console (python -m localledger serve) that renders the same result as a printable review page, and it reads PORT, so it drops onto any host unchanged.

Two outputs land in out/: a ledger.csv you can import straight into your accounting software, and a quarterly-review.html with totals per currency, a category breakdown, every document read, and the accountant questions.

Code

The whole project is on GitHub and is MIT-licensed:

https://github.com/Zhiyilang/localledger

Zero third-party dependencies — the core, the CLI, the web console and the test suite all run on the Python standard library alone.

How I Built It

LocalLedger has two interchangeable engines, and that split is the whole design:

Engine	When it runs	What it does
`deterministic-offline`	Always	Regex parser + keyword categories. Zero setup, no model, no network.
`local-open-weight-model`	When Ollama or any OpenAI-compatible server is reachable on localhost	Writes the quarterly narrative in plain English from the parsed rows.

The parsing and categorising are plain code, not the model. The regex layer pulls the vendor, date and amount out of each receipt block and normalises dates to ISO (03/07/2026, 25/12/2026 and 2026-02-09 all land correctly). The keyword layer assigns a category. Only after the numbers are fixed does the local model get asked to write the narrative — it is handed the already-parsed rows and told not to invent figures. A bookkeeping tool that hallucinates a total is worse than useless, so the model never touches the arithmetic.

Every row also carries an evidence trail back to the file and line it came from (examples/receipts.txt:1 vendor=… / date=… / amount=…), so any number can be traced and audited.

from localledger import parse_file, summarize, html_report

receipts = parse_file("examples/receipts.txt")
summary = summarize(receipts)              # offline engine; pass model=get_model() to use Gemma
html_report(summary, receipts, "out/quarterly-review.html")

It is tested: python eval.py runs 46 assertions covering parsing, date normalisation, multi-currency totals, categorisation, the accountant-question logic, CSV and HTML output, and — importantly — that an unreachable model falls back cleanly instead of crashing. GitHub Actions runs that suite on Python 3.8, 3.10 and 3.12.

Why Does Open Innovation Matter?

This is the part I care about, because for a freelancer the closed version is actively worse:

It runs on a laptop with no internet. The default engine is fully offline, so the tool works on a plane, in a café with bad wifi, or on a machine that never gets an outbound connection. A cloud OCR service cannot do that by definition.
The data stays off a server you don't control. Client invoices contain names, addresses and amounts. Running the model locally on localhost means there is no data-processing agreement to sign, no third-party breach surface, and no vendor that can change its privacy policy on you.
The cost per document is zero. Cloud document-AI bills per page. Local inference has no marginal cost, and that is what makes a €5–10/month price for a freelancer actually work instead of being another SaaS line item.
You can swap the model. Because the bridge speaks both Ollama's API and the OpenAI-compatible API, the user can run Gemma, Llama or a fine-tuned model of their own — and can fine-tune it on their vendor names and categories, something a general-purpose hosted API can never learn.

A closed API would have made all four of those impossible. The open pieces are not a feature bolted on top; they are the reason the product can exist at this price and with this privacy story.

Prize Categories

Best Use of Gemma — LocalLedger is built around running Google's open-weight Gemma locally. gemma2:2b is the default narrative engine, served through Ollama on localhost; pulling it is one command (ollama pull gemma2:2b) and the project's whole privacy-and-cost argument depends on the model running on the user's own machine rather than behind an API.

Anything a freelancer would actually pay for has to earn trust about their money. Running the model locally is how LocalLedger earns it.

I Built an Offline Match Analyst That Turns Event Data Into Evidence-Cited Tactics

一郎支 — Mon, 12 Oct 2026 11:42:02 +0000

A football match produces about 2,000 events in 90 minutes. A pundit watches it once, forms an impression, and talks for an hour. Ask them why their team lost and you get narrative: "they wanted it more", "the ref changed it", "we were unlucky".

Last month I watched a match that finished 3-1 and thought the loser was battered. Then I pulled the event data: the losing team had more expected goals (xG 1.54 vs 1.81 - close), created the better chances, and only collapsed after a 63rd-minute red card. The scoreline told one story. The data told a completely different one - and nobody watching could see it.

MatchLens is the tool that closes that gap: an offline, zero-dependency match analyst that turns raw event CSVs into an evidence-cited tactical report.

What MatchLens does

You export match events (minute, team, type, player, xG) and team info to CSV. MatchLens produces:

xG comparison - who actually created what, not who scored
Key moment timeline - every goal, penalty, red and yellow card with the live scoreline attached, so you see the swing points
Six insight types - CLINICAL_FINISHING (outscoring your xG), WASTEFUL_ATTACK (chances without end product), MAN_DOWN_EFFECT (performance before vs after a red card), SUB_IMPACT (did the changes work), MOMENTUM_PHASE (which 15-minute block each team owned), DISCIPLINE (cards, fouls)
A natural-language match report a coach could read in two minutes
Follow-up analysis suggestions - what to look at next

Every insight carries evidence citations: the event rows and numbers it used. No vibes, no narrative hand-waving.

A real run

$ python -m matchlens analyze examples/match_events.csv examples/teams.csv

MATCH: Blue Lions 3-1 Red Hawks
xG:    1.81 - 1.54   (scoreline flatters the winners)

KEY MOMENTS
  23' GOAL  Blue Lions 1-0 (K. Sato, xG 0.62)
  41' RED   Red Hawks - D. Okafor (2nd yellow)          score stays 1-0
  58' PEN   Red Hawks 1-1 from the spot (xG 0.76)
  71' GOAL  Blue Lions 2-1 (counter after save, xG 0.31)
  88' GOAL  Blue Lions 3-1 (xG 0.09 - cleanup, game over)

INSIGHTS
  [MAN_DOWN_EFFECT] Red Hawks xG 1.39 -> 0.15 after the red card
       evidence: events 1-31 (pre) vs 32-58 (post); red card at 41'
  [CLINICAL_FINISHING] Blue Lions scored 3 from 1.81 xG
       evidence: goal minutes 23/71/88 vs cumulative xG by minute
  [MOMENTUM_PHASE] Blue Lions owned 75-90 (xG 0.94 vs 0.08)
       evidence: 15-minute bins from the event xG column
  [WASTEFUL_ATTACK] Red Hawks 1.54 xG, 1 goal - chances without payoff
       evidence: 12 shots, 6 on target, xG 1.54

REPORT: A tight match turned by one red card. Before it, Red Hawks were
ahead on xG. After it, they managed 0.15 xG in 32 minutes. The 3-1
scoreline describes the card, not the football.

The red-card finding is the one I care about: the tool splits the match at the dismissal and compares both halves on xG. "They were unlucky" becomes "they generated 1.39 xG with 11 men and 0.15 with 10" - a number you can argue with.

It ships with evals

$ python eval.py
PASS  xg_totals_match_event_data
PASS  scoreline_updates_on_every_goal
PASS  red_card_splits_the_match_timeline
PASS  stoppage_time_binned_into_90
PASS  momentum_phase_uses_15_minute_bins
PASS  sub_impact_compares_pre_post_minutes
PASS  every_insight_cites_event_rows
PASS  no_network_access
... 19/19 assertions passed.

Building it caught three real bugs, all of the kind that make demo numbers quietly wrong: the scoreline wasn't initialized for the away team (so the first away goal rendered "1" instead of "1-0"), stoppage-time minutes like 90+3' overflowed the 15-minute bins, and one eval assertion had its own expected value wrong. The eval suite is what found them - not me reading the code.

Why offline matters

Event data for professional matches is licensed and expensive; for grassroots and academy football it's usually a coach's spreadsheet. MatchLens runs entirely on your machine - pure standard library, no accounts, no uploads. Your team's data stays yours.

Tech stack

Pure Python stdlib (csv, datetime, argparse) - clone and run
Deterministic rules with transparent thresholds - every number traceable
Natural-language report generation from computed facts

Try it

Repo: github.com/Zhiyilang/matchlens with a full example match (Blue Lions 3-1 Red Hawks, 58 events) and the 19-assertion eval suite. Run python eval.py, then point it at your own team's export.

I built MatchLens for the Microsoft x Premier League "Inside the Game" hackathon, but the use case is bigger than that: anyone who has ever argued about a match with data they couldn't check. The next time someone says a team "didn't deserve it", you'll have the xG split, the red-card before-and-after, and the minute-by-minute momentum bins to settle it.

What insight would you add? Mine is a candidate: set-piece xG share - how much of a team's chance creation comes from dead balls, which is the difference between a good team and a good set-piece coach.

I Built an Offline Analyzer That Catches the 8 Trading Habits That Blow Up Accounts

一郎支 — Mon, 12 Oct 2026 11:09:18 +0000

A trader on a prop-firm challenge turned a $50k account into $105k in three weeks. Then he lost all of it in one afternoon. The platform's risk dashboard showed exactly what happened — but only after it was over: position size had quietly doubled after every loss, the classic martingale, and it took precisely five losing trades in a row to wipe out six weeks of gains.

The dashboard saw the trades. What it couldn't do was say "this sequence of behavior is how accounts die — here is the exact trade where it started."

That is what TradeGuard does.

What TradeGuard does

TradeGuard is an offline, zero-dependency trading behavior analyzer in pure Python standard library. You export your trade history and account metrics to CSV; it audits them against 8 behavioral risk rules that repeatedly destroy retail accounts — and every finding cites the exact trade IDs, timestamps, and numbers that prove it.

$ python -m tradeguard audit --trades examples/trades.csv --account examples/account.csv

RISK SCORE: 100 / 100  (HIGH — account at serious risk)

[HIGH] OVER_LEVERAGE — Trade #14: notional 12.4x equity on EURUSD
       evidence: trades.csv:14  lots=2.5  equity=10000  price=1.0842
[HIGH] MARTINGALE — Lot size doubled after each of 4 consecutive losses
       evidence: trades.csv:21-28  lots 1.0→1.2→1.6→2.4
[HIGH] REVENGE_TRADING — 6 trades within 9 minutes after a -$840 loss
       evidence: trades.csv:31-36  entry timestamps cluster 14:02-14:11
[HIGH] RISK_PER_TRADE — 8 trades risked >2% of equity (max 5.1%)
       evidence: trades.csv:8,12,14,19,22,27,33,41
[HIGH] DRAWDOWN — current drawdown 19.8% vs 10% plan limit
       evidence: account.csv:3  balance=80200  peak=100000
[HIGH] CONCENTRATION — 55.1% of volume in a single instrument (EURUSD)
       evidence: trades.csv  instrument=EURUSD count=38/69
[CAUTION] LOSS_STREAK — 5 consecutive losses preceded the largest single loss
       evidence: trades.csv:29-41
[CAUTION] OVERTRADING — 69 trades in 5 sessions (3.8x your own median)

RECOMMENDED: hard-cap lot size at 1.0, enforce a 2% max risk per trade,
and lock the terminal after 2 consecutive losses.

The point isn't the score — it's the evidence trail. Every claim points at a row you can open and verify, so the feedback survives arguments.

The 8 rules and why they exist

Each rule encodes a documented account-killer:

Rule	What it catches	Why it kills accounts
OVER_LEVERAGE	notional > 10x equity	one bad candle = margin call
MARTINGALE	lot doubling after losses	geometrically guarantees ruin
REVENGE_TRADING	rapid re-entry after big loss	emotion-driven sizing
RISK_PER_TRADE	> 2% equity at risk per trade	variance eats the edge
DRAWDOWN	beyond plan limit	prop-firm disqualification
LOSS_STREAK	consecutive losses	tilt precursor
CONCENTRATION	> 40% single instrument	correlation risk in disguise
OVERTRADING	frequency vs. own baseline	fee bleed + fatigue errors

It ships with evals

$ python eval.py
PASS  detects_over_leverage_with_citation
PASS  detects_martingale_doubling
PASS  detects_revenge_trading_cluster
PASS  risk_per_trade_uses_equity_at_entry
PASS  drawdown_uses_peak_balance
PASS  concentration_threshold_boundary
PASS  clean_history_scores_zero
PASS  every_finding_has_evidence
PASS  report_html_contains_all_findings
PASS  no_network_access
... 16/16 assertions passed.

Two of those assertions matter most to me: clean_history_scores_zero (no false alarms on disciplined trading) and every_finding_has_evidence (the tool can never accuse without proof).

Why offline matters

Your full trade history is the most sensitive file you own — it's a map of your worst decisions. TradeGuard runs entirely on your machine: pure standard library, no accounts, no uploads, no API keys. The eval suite asserts the code makes zero network calls. You can audit it on an air-gapped laptop.

Tech stack

Pure Python stdlib (csv, datetime, argparse) — clone and run, nothing to install.
Deterministic rules with transparent thresholds — no black-box "AI risk score".
HTML report for sharing with a mentor, prop-firm reviewer, or your past self.

Try it

Repo: github.com/Zhiyilang/tradeguard with example trade history (deliberately full of bad habits) and the 16-assertion eval suite. Run python eval.py, then point it at your own export — I'd genuinely like to hear what it finds.

I built TradeGuard for the Deriv "Rise of AI Agents" hackathon, but the rules come from public post-mortems of blown accounts. The most valuable risk report is the one you read before the drawdown, not after.

What behavioral rule would you add to the list? Mine is a candidate: trading within 30 minutes of a deposit — funding urgency is a documented tilt trigger. Comments open.

I Built an Offline AI Agent That Answers Business Questions With File-and-Line Proof

一郎支 — Mon, 12 Oct 2026 11:09:17 +0000

Last quarter I asked a general-purpose AI chatbot: "Which product should I restock first?" I pointed it at three CSV exports — sales, inventory, and customer feedback. It answered confidently: SKU-A, because "it appears to be selling well."

SKU-A was fine. The real problem was SKU-C: selling 100 units a week with only 6.3 days of stock left against a 14-day supplier lead time. In ten days that SKU is out of stock, and every week of outage costs roughly 100 units of revenue. The chatbot couldn't see that, because it never actually joined the files — it skimmed the column names and guessed.

That failure is what DecisionLens is built to prevent.

What DecisionLens does

DecisionLens is an offline, zero-dependency decision agent written in pure Python standard library. You point it at a folder of CSV files and ask a question in plain English. It answers — and every single claim it makes carries an evidence citation: source file, row number, and field name.

$ python -m decisionlens ask --data examples/ --question "Which SKU should I restock first? Why?"

DECISION: Reorder SKU-C now — it stocks out in ~6 days.

Evidence:
  [E1] sales/sales.csv:42        sku=SKU-C  units_sold=100  (4-week trailing avg)
  [E2] inventory/inventory.csv:7  sku=SKU-C  on_hand=90     days_of_cover=6.3
  [E3] inventory/inventory.csv:7  sku=SKU-C  supplier_lead_time_days=14
  [E4] feedback/feedback.csv:19   sku=SKU-C  mentions="still out of stock" (3 recent)

Action: place a PO for >= 300 units of SKU-C today; expedite the supplier.

No number appears in the answer that isn't traceable to a cell you can open and check. If the agent can't prove something, it says so instead of guessing.

The agent loop

DecisionLens runs a classic perceive → reason → explain cycle, kept deliberately small so every step is auditable:

PERCEIVE — load every CSV in the data folder, infer column types, build an index of metrics (units, prices, dates, SKUs).
INDEX — normalize units and periods so weekly sales, stock on hand, and lead times are comparable.
RETRIEVE — match the question against the index to find the relevant rows across all files.
REASON — apply decision rules (e.g. days-of-cover vs. lead time) with explicit arithmetic, never vibes.
EXPLAIN — attach file + row + field citations to each claim.
ACT — emit a concrete recommended action with quantities.

It answers questions like: which SKU stocks out first, which channel is quietly declining, what changed month over month and why, and a full business overview.

Why evidence citations matter

For an agent that feeds real decisions, "probably right" isn't good enough. Three properties fall out of the citation design:

Verifiable — a manager can audit any claim in seconds by opening the cited row.
Debuggable — when the agent is wrong, you see exactly which row or rule misled it.
Honest — the agent physically cannot state a number it didn't read from a file.

That last property is the one general-purpose chat assistants keep failing.

It ships with evals

Anyone can claim their agent is smart, so DecisionLens ships an eval suite instead of adjectives:

$ python eval.py
PASS  restock_rule_identifies_lowest_cover_sku
PASS  restock_action_includes_quantity
PASS  channel_ranking_uses_net_revenue
PASS  trend_attribution_cites_evidence
PASS  overview_mentions_all_sources
PASS  evidence_citations_include_row_numbers
PASS  unknown_question_does_not_hallucinate
PASS  offline_no_network_calls
8/8 assertions passed.

Note the last two: the agent must admit when it doesn't know, and the test suite asserts the code makes zero network calls. It runs on air-gapped machines — your data never leaves the room.

Tech stack

Pure Python standard library (csv, argparse, datetime) — no pip install, no API keys, no cloud.
Under 1,000 lines, readable end to end.
HTML report output for sharing decisions with non-technical stakeholders.

Try it

The repo is github.com/Zhiyilang/decisionlens with three example datasets (retail sales, inventory, customer feedback) and the full eval suite. Clone it, run python eval.py, then ask it your own questions against your own CSVs.

I built DecisionLens as my entry for the Open Agent Hackathon 2026 (Track 02: explainable multi-source reasoning). The thesis is simple: an agent that shows its work is worth more than an agent that sounds sure.

If you've ever been burned by a confident AI answer that turned out to be invented, tell me your story in the comments — I'm collecting failure modes for the next iteration.

I Built an Offline Contract Risk Analyzer That Flags the Clauses That Cost You the Most

一郎支 — Mon, 12 Oct 2026 10:52:44 +0000

Last month a friend signed a 12-month SaaS contract without reading clause 14. It auto-renewed for another year and the early-termination fee was three months of subscription. She is not careless; the clause was just 40 words buried on page 6 of a 9-page agreement.

That is the problem ClauseGuard attacks: the clauses that cost ordinary people the most money are the ones written to be skimmed past.

What ClauseGuard does

ClauseGuard is an offline, zero-dependency contract risk analyzer written in pure Python standard library. You paste contract text in; it flags high-risk clauses, explains each one in plain language, and produces a risk score:

$ python -m clauseguard.cli examples/sample_contract.txt

[HIGH   ] Auto-Renewal Trap — contract renews automatically unless cancelled 30 days before expiry
           why it hurts: you pay for a full extra cycle if you miss a narrow cancellation window
           fix: negotiate a 60-day notice window and a calendar reminder on day 1

[HIGH   ] One-Sided Modification — provider may change terms at any time without notice
           why it hurts: every protection in this contract can be rewritten unilaterally
           fix: require written notice + a termination right if changes are material

[HIGH   ] Uncapped Indemnity — you cover all losses, including provider's own negligence
           why it hurts: your liability has no ceiling, theirs does
           fix: cap indemnity at fees paid in the prior 12 months

[CAUTION] Broad IP Assignment — anything you create on the platform belongs to them
[CAUTION] Personal Guarantee — you personally back the company's obligations
...

==> Risk score: 40/100 (HIGH) — 3 high-risk clauses, 7 cautions

Why offline and zero-dependency?

Two deliberate design choices:

Contracts are among the most sensitive documents you own — salaries, NDAs, leases, pre-nups. ClauseGuard runs 100% locally. Nothing is uploaded, nothing is logged, no API keys involved.
A transparent rule engine beats a black box for legal risk. Every finding shows the matched pattern, the reasoning, and the mitigation. You can audit why it fired. A hallucinating LLM summarizer is the wrong tool when the stakes are a signed obligation.

The engine ships with 12 risk detectors covering auto-renewal, unilateral modification, liability caps, broad indemnity, IP assignment, personal guarantees, non-competes, arbitration venue, penalty clauses, and more — each with a plain-language explanation and a negotiation suggestion.

It also generates a self-contained HTML report you can attach to an email before a signing meeting.

Try it

git clone https://github.com/Zhiyilang/clauseguard
cd clauseguard
python -m clauseguard.cli examples/sample_contract.txt --html report.html

No pip install. Python 3.8+. MIT licensed.

What's next

Multi-language clause patterns (the engine is pattern-table driven)
DOCX/PDF text extraction
A "compare two versions" mode that diffs risk scores between contract drafts

Built as part of my open-source AI series. Feedback and PRs welcome — especially more clause patterns from other jurisdictions.

Disclaimer: ClauseGuard is decision support, not legal advice. For anything material, talk to a lawyer.

Repo: https://github.com/Zhiyilang/clauseguard

I Built TabulaSage: an Offline, Open-Source-AI Profiler That Never Sees Your Data

一郎支 — Mon, 12 Oct 2026 03:59:40 +0000

Every "smart spreadsheet" tool I've tried makes the same trade: you upload your file to someone else's server, a closed model you can't inspect does the work, and you pay per call. For a customer export, a medical log, or anything with a whiff of PII, that's a non-starter.

So for the Hacktoberfest 2026 Open-Source AI Challenge, I built TabulaSage — a data profiler where open-source AI is the entire engine, and your file never leaves your machine.

What it does

Point it at any CSV and it tells you, in plain English:

a profile of every column (type, missingness, distribution, top categories)
which rows look wrong — anomaly detection for data-entry errors and rare cases
what actually drives a target column — an interpretable model, not a black box

pip install -r requirements.txt
python tabulasage.py examples/sample_customers.csv --target churned

Here's the real output on a 15-row sample with a planted bad row:

================================================================
 TabulaSage — offline AI profile  |  scikit-learn v1.9.1
 15 rows x 6 columns
================================================================

ANOMALY DETECTION (IsolationForest)
  flagged 1 of 15 rows as anomalous
    [ANOMALY] row 9: age=999, income=15, city=Beijing, tenure_months=1
    [normal ] row 6: age=61, income=91000, city=Shenzhen, tenure_months=48
    [normal ] row 13: age=58, income=84000, city=Shenzhen, tenure_months=40

INTERPRETABLE MODEL (target = churned)
  test accuracy: 100.0%  (classes: ['no', 'yes'])
  top drivers:
    - age                      0.571
    - monthly_spend            0.429

PLAIN-ENGLISH INSIGHTS
  → IsolationForest flagged 1 row(s) (6.7%) as anomalous — likely data-entry errors or rare cases worth a human look.
  → Predicting the target: a shallow decision tree reaches 100% test accuracy; the strongest driver is 'age' (importance 0.57).

The garbage row (age=999, income=15) is caught instantly, while genuine high-value customers are correctly left alone — and the model explains why (age, then monthly_spend), not just what.

Why open-source AI is the whole point

This is the part the challenge prompt asks about, and it's the reason the project exists.

Your data stays yours — as an architectural fact, not a promise. There is no network call anywhere in the code path. You can prove it by reading ~200 lines of Python. For anyone handling sensitive CSVs, "open source at the core" isn't ideology; it's the only way to get AI insights and keep the data on your own disk.

It costs nothing to run. The brain is scikit-learn's IsolationForest and a shallow decision tree — open weights you can audit, and reproducible output. No per-call billing, no surprise invoice because your file got big.

You can swap the brain. Because the intelligence is an open framework rather than a hosted endpoint, you can drop in a local open-weight LLM (Gemma via Ollama) for richer prose, or TabPFN for forecasting, without rewriting the app — or sending anything anywhere.

The closed-API approach is easier to demo and harder to trust. For a tool that touches real data, I'd rather be trusted.

How it works (all offline)

Parsing & profiling: Python stdlib + NumPy. No network, ever.
Anomaly detection: IsolationForest on standardized numeric + one-hot features. I flag a row only when its anomaly score falls more than 2σ below the mean — a parameter-free threshold that avoids the "flag 40% of everything" trap I hit with contamination="auto" on small data.
Interpretable model: a depth-limited DecisionTreeClassifier, so you can read the exact rule behind each prediction. (I explicitly exclude the --target column from the features — the first version leaked it and reported a fake 100% accuracy, which was a good reminder that "explainable" has to be enforced, not assumed.)
Insights: deterministic templates turn statistics into sentences — no LLM needed, though a local open-weight model can plug in for richer wording.

What I learned

Building this reinforced something the open-source AI community keeps saying: the interesting engineering isn't calling a model, it's making the model accountable — standardizing features so units don't lie, choosing a threshold that doesn't cry wolf, and refusing to let the label leak into the features. None of that is glamorous, and all of it is why I'd rather run an open model I can debug than a closed one I can't.

Try it

The code, sample data, and a copy-paste demo are all in the repo:

🔗 https://github.com/Zhiyilang/tabulasage

Built for the Hacktoberfest 2026 Open-Source AI Challenge. Feedback and PRs very welcome — especially if you've wired TabulaSage up to a local Gemma or TabPFN and want to share the pattern.

Building GardenPlanner AI: An Offline-First Gardening Planner for Hacktoberfest 2026

一郎支 — Sun, 11 Oct 2026 16:02:21 +0000

Why I built an offline-first gardening planner for Hacktoberfest 2026

Hacktoberfest 2026's Open Source AI Challenge has a theme this year: "Touch Grass". So I built exactly that — a gardening planner that works even when you're literally standing in the grass with no signal.

Repo: https://github.com/Zhiyilang/hacktoberfest-2026-ai

What it does

GardenPlanner AI is a zero-dependency, offline-first CLI that turns three inputs — city, month, and growing space — into a concrete planting plan:

Picks plants suited to your local climate and the current season
Flips the season correctly for the Southern Hemisphere (so July in Sydney is winter, not summer)
Pairs companion plants (what grows well together) and flags antagonists (what fights)
Prints a month-by-month task checklist so you know what to sow, transplant, or harvest
Adds pest/disease tips pulled from the plant database

Why "offline-first" matters

Most AI gardening tools are just a chatbot wrapper around a cloud API. That breaks the moment you're in the backyard. GardenPlanner AI ships with:

A built-in city → climate lookup table (no network needed)
A curated plant database with companions, antagonists, and care notes
Optional Ollama local-LLM integration for natural-language questions — but it runs perfectly fine without it

python main.py --city "Shanghai" --month 10 --space balcony --level beginner

No pip install. No API key. No signal. Just grass.

The AI part (without the cloud tax)

When Ollama is available, the planner answers questions like "What should I plant next to my tomatoes in a Shanghai autumn?" using a local model. When it isn't, it falls back to a deterministic rule engine — so the tool is never useless.

This is the design I like: AI is a layer, not a lifeline.

How you can contribute (Hacktoberfest)

This is a great first PR:

Add a city to the climate table
Add a plant (with companions/antagonists) to the database
Translate the task-checklist copy
Improve the pest-tip content

Every contribution is a recognized Hacktoberfest PR. Details in CONTRIBUTING notes in the repo.

Try it

git clone https://github.com/Zhiyilang/hacktoberfest-2026-ai
cd hacktoberfest-2026-ai
python main.py --help

Touch grass. Plan a garden. Ship a PR. Happy Hacktoberfest 2026.

Built for the #hf26challenge Open Source AI Challenge. ⭐ welcome if it helps you touch grass.

I Built a 'McDonald's Persona Card' Skill With Their MCP Server (And You Can Too)

一郎支 — Sun, 11 Oct 2026 00:28:35 +0000

TL;DR

McDonald's China shipped an official MCP server. I used it (through WorkBuddy) to build a zero-setup "persona card" Skill that turns your taste, budget, and mood into a fun 麦门人格卡 (McDonald's persona card) with meal recommendations. It's open source, runs with one command, and it's entered in the McDonald's Developer Innovation Challenge.

If you find it fun or useful, a ⭐ on the repo genuinely helps it rank: https://github.com/Zhiyilang074811/mcd-persona-card

What it does

Input your flavor preferences, budget, and scene, and it generates a personalized "麦门人格卡".
It pairs the persona with a recommended combo and a money-saving bundle.
Ships with a one-command demo and clear MCP integration docs, so even non-developers can reproduce it.

How to run

python mcd_persona.py --demo

No API key required for the demo. The full version wires into the official McDonald's MCP server (instructions in MCP_INTEGRATION.md).

How it uses the McDonald's MCP

The project calls the official MCP tools to fetch real menu, pricing, and promotion data, then layers a lightweight persona engine on top. Details and the call flow live in MCP_INTEGRATION.md.

Why I built it

Most McDonald's helper bots are just calculators. I wanted something that feels personal — a card you'd actually share. Built entirely with WorkBuddy, the official partner of the challenge.

Try it & star it

Repo: https://github.com/Zhiyilang074811/mcd-persona-card

Stars help a small open-source project get seen in the challenge leaderboard. If you liked the idea, hit ⭐ — and feel free to fork or open an issue with your own persona ideas.

GardenPlanner AI: an offline-first gardening planner for Hacktoberfest 2026

一郎支 — Sun, 11 Oct 2026 00:26:41 +0000

GardenPlanner AI is an offline-first gardening planner built for the Hacktoberfest 2026 Open-Source AI Challenge (theme: Touch Grass). The idea is simple: use open-weight models to help people step away from screens and into nature, not pull them deeper in.

Most gardening apps send your location and garden data to a cloud and lock the brain behind a paid API. This tool does the opposite. It runs 100% offline on pure Python standard library, no network, no account, no cost. It optionally rewrites the plan with a local Ollama model; without it, the built-in rule engine still produces a complete plan. Your city and garden data never leave your machine, and the output is a hands-on planting checklist you act on outside.

How to run it:

python main.py --city "Shanghai" --month 10 --space balcony --level easy

It returns a personalized monthly planting plan with companion plants and tips, and flips seasons for the Southern Hemisphere automatically. You can also enhance it with a local model:

ollama pull llama3.2
python main.py --city "London" --month 3 --ollama llama3.2

The repository is here: https://github.com/Zhiyilang074811/hacktoberfest-2026-ai

Contributions are welcome for Hacktoberfest: more city climate data, an expanded plant database, pest reminders, or web/mobile wrappers. Look for the hacktoberfest-accepted label. Let's touch grass, with open source.

probe2

一郎支 — Sun, 11 Oct 2026 00:07:12 +0000

probe2 body

probe

一郎支 — Sun, 11 Oct 2026 00:05:29 +0000

probe

GardenPlanner AI offline gardening planner

一郎支 — Sat, 10 Oct 2026 23:58:19 +0000

Intro about Touch Grass. See https://github.com/Zhiyilang074811/hacktoberfest-2026-ai for code.

python main.py --city Shanghai

DEV Community: 一郎 支

I Built LocalLedger: An Offline Receipt Organizer That Runs Gemma on Your Own Laptop

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

I Built an Offline Match Analyst That Turns Event Data Into Evidence-Cited Tactics

What MatchLens does

A real run

It ships with evals

Why offline matters

Tech stack

Try it

I Built an Offline Analyzer That Catches the 8 Trading Habits That Blow Up Accounts

What TradeGuard does

The 8 rules and why they exist

It ships with evals

Why offline matters

Tech stack

Try it

I Built an Offline AI Agent That Answers Business Questions With File-and-Line Proof

What DecisionLens does

The agent loop

Why evidence citations matter

It ships with evals

Tech stack

Try it

I Built an Offline Contract Risk Analyzer That Flags the Clauses That Cost You the Most

What ClauseGuard does

Why offline and zero-dependency?

Try it

What's next

I Built TabulaSage: an Offline, Open-Source-AI Profiler That Never Sees Your Data

What it does

Why open-source AI is the whole point

How it works (all offline)

What I learned

Try it

Building GardenPlanner AI: An Offline-First Gardening Planner for Hacktoberfest 2026

Why I built an offline-first gardening planner for Hacktoberfest 2026

What it does

Why "offline-first" matters

The AI part (without the cloud tax)

How you can contribute (Hacktoberfest)

Try it

I Built a 'McDonald's Persona Card' Skill With Their MCP Server (And You Can Too)

TL;DR

What it does

How to run

How it uses the McDonald's MCP

Why I built it

Try it & star it

GardenPlanner AI: an offline-first gardening planner for Hacktoberfest 2026

probe2

probe

GardenPlanner AI offline gardening planner

DEV Community: 一郎支