DEV Community: Techie

Ghost Money

Techie — Sat, 31 Oct 2026 16:25:26 +0000

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

What I Built

Ghost Money is a séance for the opportunities nobody told you about.

Every year, scholarships, hackathon prizes, paid fellowships, conference travel grants and research placements go unclaimed. They are not secret. They are just buried across hundreds of pages, with different rules, different deadlines and different eligibility. They haunt your profile without you ever knowing.

You describe yourself once: country of citizenship, where you are in your studies, your field, and optionally your age and household income. You press Summon the ghosts, and the app calls up everything you appear to qualify for, sorted by how soon it closes:

🎓 Scholarships
⚡ Hackathons and 🏆 competitions
🌱 Open source programs
🧭 Fellowships
✈️ tech conferences
🔬 Research placements
💼 Internships and externships
🧾 Part-time jobs and 📚 tutoring

Every result shows the reward, a deadline countdown, why you matched, what you need to do, and a link to the official page. A running total shows the listed prize pools and stipends you are eligible for.

How I read the theme: the ghost in the machine is the forgotten thing that is still there, still real, still waiting for someone to notice it. Here, that is money and chances left unclaimed. The interface is a candlelit séance, and the button really does say "Summon the ghosts". It is spooky on the outside and practical on the inside.

Demo

Code

To run it:

pip install -r requirements.txt, then uvicorn main:app --reload, then open http://127.0.0.1:8000. You can also just open static/index.html in a browser: the matching works without the server, and only the AI advice needs it.

How I Built It

Open-weight model: Qwen2.5-1.5B-Instruct, loaded from Hugging Face with the transformers library and run locally. You can swap in any other model with the GHOST_MODEL environment variable.

Stack: FastAPI, Hugging Face Transformers, and plain HTML, CSS and JavaScript.

Your profile (never leaves your machine)
        |
        v
Eligibility rules, running in the browser
 country, level, field, age, income, deadlines
        |
        v
Your matches, sorted by deadline
        |
        v
Local Qwen writes one line of advice per top match
        |
        v
Guardrail: any line with a number that is not in the listing is discarded

The design choice I care about most is the split between rules and the model:

Eligibility is plain code, not AI. Whether you qualify for something is a yes or no question with real consequences, so it is decided by readable rules (country lists, level, field, age limits, income caps). Every match comes with the reasons it matched, and cases the rules cannot settle, such as a missing age, show as a warning instead of a guess.
The model only does what it is good at. Qwen writes a short, practical sentence of advice for each top result, such as what to start with and how to prioritise.
The model cannot invent facts. It sees only the listing fields (name, reward, deadline, days left, first requirements) and your study level and field. If its answer contains any number that is not in that data, the line is thrown away and the rule-based advice is shown instead.
Everything degrades gracefully. If the model is still downloading, switched off (GHOST_LLM=0), or the server is not running, the page still works with rule-based advice. The status badge at the top tells you which mode you are in.

Each of the 38 entries carries a source note and a last-checked date. Where a date is an estimate the card says so with a "~" and a note.

Why Does Open Innovation Matter?

The inputs to this app are about as personal as data gets: where you are a citizen, how much your household earns, how old you are, what you study. People in exactly the situations this app is meant for are the ones with the most reason to be careful about who sees that.

Your profile stays with you. With a closed API, the same advice would mean sending your income and citizenship to a third party. With an open-weight model running locally, nothing leaves the machine. The matching runs in your browser, and the model runs on your own computer.
It costs nothing to run. There is no per-token bill, no subscription and no API key. That matters for a tool aimed at people looking for money.
You can inspect all of it. The eligibility rules are readable code, the prompt is visible, and the guardrail that rejects invented numbers is a few lines you can check. Nobody has to trust a black box about whether they qualify for a scholarship.
You can change it. Want a bigger model, or one that fits an older laptop? Set one environment variable. Want to add your own country's grants? Add an entry to the list.
It will not disappear. It is not tied to a service that can change its pricing or shut down. A static page and a model on your disk keep working with the lights off.

The Spirit of It

Most unclaimed opportunities are not lost because people are unqualified. They are lost because nobody told them they existed. I built Ghost Money for the person who has never been told, who does not have a mentor pointing at a deadline, and who should not have to give up their private details to find out what they are owed.

Prize Categories

Slothbotanist: An AI Drink maker that turns your pantry into a tiny herbal bar

Techie — Mon, 26 Oct 2026 06:58:33 +0000

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

From Forgotten Pantry to First Sip
Somewhere in your kitchen, there's a forgotten jar of ginger, a lemon waiting for its moment, and some leftover herbs.....
You could make the same old tea.
Or you could open SlothBotanist.
Enter what you have, choose the kind of drink you're in the mood for, and let your tiny AI apothecary turn everyday ingredients into something more interesting.
Feeling traditional? Try a slow, comforting herbal infusion.
Want something refreshing? Explore a modern cold brew or infused drink.
Have an unfamiliar herb? Start with a photograph.
Need to avoid certain ingredients? Set your restrictions before you begin.
Two drink ideas. Your existing ingredients. One very relaxed sloth.
Meet SlothBotanist, an AI-powered herbal drink maker built with an open-weight Qwen model and a SerpApi-powered ingredient discovery workflow.
Because making something delightful from your pantry shouldn't require a culinary degree, a shopping trip, or seventeen open browser tabs.

What I Built

SlothBotanist, an AI-powered herbal drink maker that transforms the ingredients you already have into two distinct drink creations.

1. Heritage Elixir
For the traditional soul.
This option focuses on traditional-inspired preparations, such as infusions and slow decoctions. It explores how everyday ingredients can become comforting herbal drinks.

2. Modern Refresh
For the experimental soul.
This option explores contemporary preparations, including cold brews, infused water, and smoothies.
Both options start with the same pantry but approach it differently.
The goal is to help users discover new combinations without turning every drink into a shopping list.

Key Features

Multi-Engine Recipe Generation: Input your drink goal, shelf ingredients, and allergies to get two distinct drinks (Heritage Elixir and Modern Refresh) created by a local LLM powered by 10 parallel SerpApi search engines. Includes one-click Copy and Print.
Complete Recipe Intelligence: View allergen exclusions, safety cautions, seasonal interest peak charts, picture links, research notes, and a live "Search Crew" dashboard showing the status of all 10 engines.
Visual Identification: Upload a photo or paste an image link to identify unknown herbs using Google Lens (SerpApi). Pick from top matches and click Add to my shelf directly from an editable input box.
Distraction-Free Reader: Paste any recipe or web article link to strip out ads and clutter, leaving only clean plain text via SerpApi’s Extract API.
Location Search & Privacy Control: Search your city to auto-set local country, language, and Google domain parameters. Features a 2-click browser reset button. All user data (shelf, allergies, location) is kept 100% private in local browser storage.

How I Built It

SlothBotanist combines a lightweight frontend, a FastAPI backend, SerpApi integrations, and a local language model.

Navigation & App Architecture

1. Brew It (Main Page): Input drink goals, available ingredients, and allergies to generate two customized recipes—a traditional Heritage Elixir and a modern Modern Refresh (with Copy/Print actions). Runs 10 SerpApi search engines in parallel for the local LLM to author recipes. Displays allergen exclusion notes, safety cautions, seasonal trend charts, source notes, image links, and a "Search Crew" engine status dashboard.

2. Identify: Upload a photo or image URL to identify unknown botanicals via Google Lens (SerpApi). Handles single ("This looks like") or multiple candidate matches, with an editable box to instantly add items to your shelf.

3. Pages: Paste any recipe or article link to extract and read clean, clutter-free plain text using SerpApi’s Extract API.

4. Ledger: Real-time analytics dashboard tracking brews made, searches saved, unique listings, allergen-blocked recipes, and an engine query bar chart (hydrated live from saved search logs).

5. Settings: Localize searches by selecting your city (auto-configures country, language, and Google domain) and manage local data via a two-click browser reset. All user inputs (shelf, allergies, location) are stored 100% locally in your browser for total privacy.

Code

Coder-432 / slothbotanist

SlothBotanist, an AI-powered herbal drink maker that transforms the ingredients you already have into two distinct drink creations(Heritage Elixir and Modern Refresh).

SlothBotanist

SlothBotanist, an AI-powered herbal drink maker that transforms the ingredients you already have into two distinct drink creations(Heritage Elixir and Modern Refresh).

What is SlothBotanist?

SlothBotanist, an AI-powered herbal drink maker that transforms the ingredients you already have into two distinct drink creations.

1. Heritage Elixir For the traditional soul. This option focuses on traditional-inspired preparations, such as infusions and slow decoctions. It explores how everyday ingredients can become comforting herbal drinks.

2. Modern Refresh For the experimental soul. This option explores contemporary preparations, including cold brews, infused water, and smoothies Both options start with the same pantry but approach it differently. The goal is to help users discover new combinations without turning every drink into a shopping list.

Key Features

1. Multi-Engine Recipe Generation: Input your drink goal, shelf ingredients, and allergies to get two distinct drinks (Heritage Elixir and Modern Refresh) created by a local LLM powered…

View on GitHub

Tech Stack

Backend: Python, FastAPI
Search and ingredient discovery: SerpApi
Open-weight AI: Qwen/Qwen2.5-1.5B-Instruct
Model runtime: Hugging Face Transformers
Frontend: HTML, CSS and JavaScript
Package Management: pip 26.x
Testing: Python unit tests
Additional utilities: evaluation suite(eval_brews.py) and weekly safety-Watchlist scanner(weekly_scan.py)

Project Directory Structure

SlothBotanist/
├── main.py
├── apothecary_core.py
├── test_core.py
├── weekly_scan.py
├── eval_brews.py
├── requirements.txt
├── README.md
└── static/
    ├── index.html
    ├── style.css
    └── app.js

Installation & Running Locally

- Install Dependencies:

pip install -r requirements.txt

- Set Your SerpApi Key:

export SERPAPI_KEY="your_serpapi_key_here"

- Start the FastAPI Backend:

uvicorn main:app --reload

- Access the Application:

http://localhost:8000.

- Run Tests, Evaluations & Safety Scans:

a. Unit & Integration Tests:

python test_core.py

b. Run Evaluation Suite:

python eval_brews.py

c. Run Weekly Safety Watchlist Scan:

python weekly_scan.py

System Architecture

+------------------------------------------------------------------+
|                       USER INTERFACE                             |
+------------------------------------------------------------------+
|  Pantry Ingredients | Drink Mood | Allergy Exclusions            |
|  Brew It | Identify | Pages | Ledger | Settings                  |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                       FASTAPI BACKEND                            |
+------------------------------------------------------------------+
|  Input Processing             |     Search Coordination          |
|  Allergy Filtering            |     Duplicate-Query Filtering    |
|  Drink Generation             |     Output Validation            |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                  SERPAPI INTEGRATION LAYER                       |
+------------------------------------------------------------------+
|  SEARCH ENGINES                                                  |
|  +------------------------------------------------------------+  |
|  | Google Search          | Recipes and preparation           |  |
|  | DuckDuckGo             | Ingredient discovery              |  |
|  | Google Scholar         | Academic and allergy research     |  |
|  | Google Books           | Traditional herbal sources        |  |
|  | Google Patents         | Extraction methods                |  |
|  | Google News            | Safety warnings and recalls       |  |
|  | YouTube                | Preparation demonstrations        |  |
|  | Google Trends Trending | Current trending topics           |  |
|  | Google Trends          | Search interest over 12 months    |  |
|  | Google Images          | Visual results for the UI         |  |
|  +------------------------------------------------------------+  |
|  ADDITIONAL APIS                                                 |
|  +------------------------------------------------------------+  |
|  | Google Lens            | Photo-based herb discovery        |  |
|  | Extract API            | Recipe-page content               |  |
|  | Search Archive API     | Previous results by search ID     |  |
|  | Locations API          | Supported search locations        |  |
|  | Account API            | Account usage information         |  |
|  +------------------------------------------------------------+  |
|  RELIABILITY                                                     |
|  +------------------------------------------------------------+  |
|  | Successful-search caching in .sloth_cache/                 |  |
|  | HTTP 401/429 handling and 10-second engine cooldown        |  |
|  | Cached-result fallback                                     |  |
|  | Retry without rejected _sasl / _saslop parameters          |  |
|  | SLOTH_OFFLINE=1 for cached research                        |  |
|  +------------------------------------------------------------+  |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                  SEARCH CONTEXT ASSEMBLY                         |
+------------------------------------------------------------------+
|  Search Results | Ingredient Information | Numbered Sources      |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                      LOCAL QWEN MODEL                            |
+------------------------------------------------------------------+
|  Model: Qwen/Qwen2.5-1.5B-Instruct                               |
|  Generates: Heritage Elixir + Modern Refresh                     |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                  APPLICATION VALIDATION                          |
+------------------------------------------------------------------+
|  Allergen Checks | Pantry Checks | Citation Validation           |
|  Regeneration or Withholding When Checks Fail                    |
+------------------------------------------------------------------+
                                |
                                v
+------------------------------------------------------------------+
|                       YOUR TWO BREWS                             |
+------------------------------------------------------------------+
|       HERITAGE ELIXIR         |         MODERN REFRESH           |
+------------------------------------------------------------------+

SerpApi: The Secret Ingredient Behind Every Brew

SlothBotanist isn't designed to make users research herbs. It's designed to help them make drinks.
SerpApi works behind the scenes to discover preparation methods, explore ingredients, and find information that can inform drink creation.

Here is how its capabilities fit into the application.

1. The Ten Search Engines

SlothBotanist is designed around ten SerpApi search-engine configurations. Each has a distinct purpose, query construction, and parameter configuration.

Search requests are dispatched concurrently using asyncio.gather so that all ten engine searches in a brew go out at the same time without waiting for each one to finish sequentially, while run_in_threadpool runs each blocking SerpApi call in its own worker thread to keep the main event loop completely free.

Search requests are dispatched simultaneously across ten SerpApi configurations:

1.1 Google Search — Recipe Discovery

Engine: google

Google Search looks for recipes and preparation methods that match the user's goal and available ingredients.
This helps locate practical recipes rather than relying entirely on a generated suggestion.

1.2 DuckDuckGo — An Additional Search Perspective

Engine: duckduckgo

DuckDuckGo provides a secondary search index for discovering additional drink ideas and preparation information.
The results may differ from Google Search, providing another set of pages to inspect.

1.3 Google Scholar — Research and Evidence Discovery

Engine: google_scholar

Google Scholar searches for research relevant to the ingredients and the user's intended drink.
When allergy restrictions exist, the application can also construct an allergy-focused research query.

1.4 Google Books — Traditional Herbal References

Engine: google_books

Google Books is intended to locate books and traditional herbal references relevant to the ingredients and drink style. This source is particularly relevant to Heritage Elixir.
Live support and successful results from the configured Google Books engine must be verified in the actual integration.

1.5 Google Patents — Extraction and Preparation Techniques

Engine: google_patents

Google Patents can discover documents describing various ingredients, extraction methods and related preparation techniques.

1.6 Google News — Safety Signals and Current Reporting

Engine: google_news

Google News searches for reporting that may identify warnings, recalls, ingredient interactions, or emerging safety concerns.

1.7 YouTube Search — Preparation Demonstrations

Engine: youtube

YouTube Search discovers demonstrations that can help users understand preparation techniques.
The integration uses the search_query parameter for the search phrase.

1.8 Google Trends Trending Now — Current Interest

Engine: google_trends_trending_now

This engine is intended to discover current trending topics that may provide context for contemporary drink ideas.

The integration uses the geo parameter to select the country or geographic scope. It does not construct a conventional recipe search query for this request.

Trends indicate interest, not evidence of health benefits or recipe quality.

1.9 Google Trends — Historical Interest

Engine: google_trends

This configuration examines interest over time rather than only current trending topics.
The application can compare interest in ingredients and identify a peak month.
For example, if the returned data supports it, the generation context might say that interest in elderberry peaks in October.

1.10 Google Images — Visual Discovery

Engine: google_images

Google Images provides visual results that can support the user interface.
Visual results is displayed separately from the textual sources used for recipe generation.

# 1. Google Search — Recipe Discovery
"google": {"q": f"{goal} herbal tea recipe {top}"},

# 2. DuckDuckGo — Additional Search Perspective
"duckduckgo": {"q": f"{goal} home remedy {top} drink"},

# 3. Google Scholar — Research and Evidence
"google_scholar": {"q": f"{goal} {top} herbal clinical evidence"},

# 4. Google Books — Traditional Herbal References
"google_books": {"q": f"traditional herbal decoction {goal} {top}"},

# 5. Google Patents — Extraction Techniques
"google_patents": {"q": f"herbal infusion extraction {top}"},

# 6. Google News — Safety Signals
"google_news": {"q": f"{top} herbal safety interaction warning"},

# 7. YouTube — Preparation Demonstrations
"youtube": {"search_query": f"how to make {top} {goal} drink"},

# 8. Google Trends Trending Now — Current Interest
"google_trends_trending_now": {"geo": gl.upper(), "hl": hl},

# 9. Google Trends — Historical Interest
"google_trends": {
    "q": ", ".join(items[:2]) or goal,
    "data_type": "TIMESERIES",
    "date": "today 12-m"
},

# 10. Google Images — Visual Discovery
"google_images": {"q": f"{top} herbal drink"},

# Concurrent Search Execution
nodes = await asyncio.gather(
    *(run_engine(e, p, data) for e, p in plan.items())
)

# Inside run_engine(), blocking SerpApi calls are executed using:
result = await run_in_threadpool(lambda: serp_client.search(params))

2. Different Drinks, Different Source Perspectives

The two drink formats are designed to use different combinations of search evidence.

2.1 Heritage Elixir

Heritage Elixir focuses on traditional-inspired preparation methods and references.

Its intended source emphasis includes:

Google Books for traditional herbal references.
Google Patents for extraction and preparation techniques.
Google Scholar for research discovery.
Relevant web and recipe results where available.

2.2 Modern Refresh

Modern Refresh focuses on contemporary drink formats and practical preparation ideas.

Its intended source emphasis includes:

Google Trends and Google Trends Trending Now for interest patterns.
YouTube for preparation demonstrations.
Google Search and DuckDuckGo for recipes and web information.
Google News when current safety information is relevant.

These are source-selection priorities, not guarantees that every engine returns useful evidence for every request. The sources available to the generator should depend on the current request and the successful search results.

# 1. Google Trends & Trending Now
"google_trends": {"engine": "google_trends", "q": query},
"google_trends_trending_now": {"engine": "google_trends_trending_now", "q": query},

# 2. YouTube Preparation Demonstrations
"youtube": {"engine": "youtube", "search_query": query},

# 3. Google Search & DuckDuckGo
"google": {"engine": "google", "q": query},
"duckduckgo": {"engine": "duckduckgo", "q": query},

# 4. Google News for Current Safety Information
"google_news": {"engine": "google_news", "q": query},

3. Allergy-Focused Search Integration (google_scholar & google_news)

In addition to recipe discovery, SerpApi directly supports SlothBotanist's allergy-aware architecture by fetching external context for excluded items:

Academic Cross-Reactivity (google_scholar): When allergy exclusions (such as ragweed, birch pollen, tree nuts, or soy) are active, SerpApi queries academic and clinical literature to surface research regarding botanical cross-reactivity and potential allergen relationships.
Safety Signals & Recalls (google_news): Pulls real-time news reporting, warnings, and recall signals for specific herbs or ingredients.

# 1. Academic Cross-Reactivity (google_scholar)
"google_scholar": {"q": f"{goal} {top} herbal clinical evidence"},

if allergies:
    allergy_words = " ".join(allergies)
    plan["google_scholar"]["q"] += f" allergy cross-reactivity {allergy_words}"

# 2. Safety Signals & Recalls (google_news)
"google_news": {"q": f"{top} herbal safety interaction warning"},

if allergies:
    plan["google_news"]["q"] += f" allergy {allergy_words}"

4. Trend and Seasonality Analysis

Queries search interest over time and processes weekly timelines into monthly averages and peak months to track trend patterns and seasonality Analysis.

# 1. Trend Analysis
params = {
    "engine": "google_trends",
    "q": queries,
}
result = dict(await run_in_threadpool(lambda: serp_client.search(params)))

# 2. Seasonality Analysis
timeline = ((result or {}).get("interest_over_time") or {}).get("timeline_data") or []
by_query = {}
for point in timeline:
    month = datetime.fromtimestamp(int(point.get("timestamp")), tz=timezone.utc).month
    for v in point.get("values") or []:
        by_query.setdefault(v["query"], {}).setdefault(month, []).append(float(v["extracted_value"]))

5. Additional SerpApi Features

The ten search-engine configurations are only part of the integration. SlothBotanist also includes workflows for ingredient discovery, page extraction, search reproducibility, account information, and geographic localization.

Google Lens Workflow (google_lens): Accepts an image URL, retrieves visual matches, and extracts candidate plant names from knowledge-graph titles to help identify unfamiliar pantry items.
Extract API Workflow (engine=extract): Accepts a recipe URL and returns text_content for deep inspection of specific source pages.
Search Archive API / Ledger Workflow: Uses search_metadata.id from search responses to retrieve archived search receipts for result reproducibility.
Account API: Fetches plan details and remaining credit counts to monitor search capacity.
Locations API: Configures geographic search parameters (location, gl, hl, google_domain) for localized queries.

# 1. Google Lens Workflow
params = {"engine": "google_lens", "url": image_url}
result = dict(await run_in_threadpool(lambda: serp_client.search(params)))
names = candidate_names_from_lens(result)

# 2. Extract API Workflow
params = {"engine": "extract", "url": url}
result = dict(await run_in_threadpool(lambda: serp_client.search(params)))
return {"status": "success", "extracted": result}

# 3. Search Archive API / Ledger
fn = getattr(serp_client, "search_archive", None)
if fn is not None:
    data = await run_in_threadpool(lambda: dict(fn({"search_id": search_id})))
else:
    r = await run_in_threadpool(lambda: requests.get(
        f"https://serpapi.com/searches/{search_id}.json",
        params={"api_key": SERPAPI_KEY}, timeout=10))
    data = r.json()

# 4. Account API & Locations API
fn = getattr(serp_client, "account", None) or getattr(serp_client, "get_account")
acct = await run_in_threadpool(lambda: dict(fn()))

r = await run_in_threadpool(lambda: requests.get(
    "https://serpapi.com/locations.json",
    params={"q": q, "limit": 10}, timeout=10))

6. Search Processing, Response Normalization, Deduplication & Citation Ingestion

Normalization Layer: Converts disparate engine response structures (organic_results, news_results, video_results, trending_searches, images_results) into a uniform Source record format.
Request-Scoped URL Deduplication: Normalizes and deduplicates URLs within the current request prior to citation mapping.
Source Isolation: Guarantees source registries strictly belong to their individual requests.

# 1. Normalization Layer
_EXTRACTORS = {
    "google": ("organic_results", ("title",), ("link",), ("snippet",)),
    "google_news": ("news_results", ("title",), ("link",), ("snippet", "source")),
    "youtube": ("video_results", ("title",), ("link",), ("description", "snippet")),
}

# 2. Request-Scoped URL Deduplication
key = _norm_url(s.url) or re.sub(r"\W+", " ", s.title.lower()).strip()
if key in seen:
    continue
seen.add(key)

# 3. Numbered Sources & Citation Validation
for i, s in enumerate(out, 1):
    s.id = f"S{i}"

cleaned = _CITE_RE.sub(repl, text)
return cleaned, cited

# 4. Source Registry & Citation Ingestion
sources = dedupe_sources(raw_sources)  # per request, never global

"citations": [s.to_dict() for s in cited],
"all_sources": [s.to_dict() for s in sources],
"archive_ledger_ids": archive_ids,

7. SerpApi Resilience, Caching, and Error Handling

API Key Rejection Guard (401 Handling): If an invalid or rejected API key returns a 401 Unauthorized response, searches immediately halt and the app displays: “SerpApi rejected the API key. Check SERPAPI_KEY, then restart the server.” to protect resources.
Per-Engine Cooldown: HTTP 429 rate limits trigger a 10-second cooldown for the affected engine while other engines and cache fulfill requests.
Request-Parameter Fallback: Automatically retries requests once without internal parameters (_sasl=1, _saslop=1) if initially rejected.
no_cache Parameter: By default, SerpApi serves cached search results if an identical query was recently run (saving your monthly search quota). However, when fresh real-time information or breaking news signals are needed, the application can opt to pass no_cache=true to force SerpApi to fetch a brand-new, live result directly from the search engine.
zero_trace Parameter: For high-privacy or enterprise-tier configurations, the zero_trace=true option tells SerpApi's infrastructure to skip storing search parameters, metadata, or search files on their servers entirely, leaving no trace of the request logs.
Local Disk Caching (.sloth_cache/): To prevent burning through API limits during development, testing, or offline coding sessions, the application automatically saves successful SerpApi JSON responses locally inside a .sloth_cache/ directory on disk.
Offline Replay Mode (SLOTH_OFFLINE=1): When you set the environment variable SLOTH_OFFLINE=1, the application short-circuits live external calls entirely. Instead, it reads directly from the local .sloth_cache/ archive. This allows you to run full end-to-end drink generation tests, demo the UI, or run evaluation scripts offline without active internet connectivity or consuming API credits.

# 1. API Key Rejection Guard (401 Handling)
if is_auth_error(str(e)):
    state["auth_failed"] = True  # stop calling until restart

raise HTTPException(
    401,
    "SerpApi rejected the API key. Check SERPAPI_KEY, then restart the server."
)

# 2. Per-Engine Cooldown (HTTP 429)
cooldowns = CooldownLedger(duration=10.0)

elif is_rate_limit(str(e)):
    cooldowns.trip(engine)  # 429s are never retried

# 3. Request-Parameter Fallback
if not (SASL_FLAGS and is_param_rejection(str(first))):
    raise
params.pop("_sasl", None)
params.pop("_saslop", None)
result = await run_in_threadpool(lambda: serp_client.search(params))

# 4. Caching, Privacy & Offline Replay
if ZERO_TRACE:
    params["zero_trace"] = "true"
if NO_CACHE:
    params["no_cache"] = "true"

cache = DiskCache()  # stores responses in .sloth_cache/
cached = cache.get(engine, params)

if OFFLINE or serp_client is None:
    return report("cache_hit" if cached else "offline_miss", cached)

cache.put(engine, params, data)

Why SlothBotanist?

Dimension	Standard Botanical & Recipe Apps	SlothBotanist
Search Coverage	Basic single-source web search	Multi-Source Discovery: Cross-references search engines, scientific papers, historical books, patents, trend data, news, and video tutorials.
User Privacy	Query histories and personal searches saved on third-party servers	Strict Privacy First: Enforces privacy parameters to ensure query data isn't logged or persistent upstream.
Recipe Customization	Generic, one-size-fits-all recommendations	Dual-Format Intelligence: Tailors queries specifically for traditional heritage elixirs versus modern craft drinks.
Safety & Verification	Standard databases that miss recent recalls	Real-Time Safety Checks: Automatically scans current news for product recalls and checks medical literature for plant cross-reactivities.
Seasonal Sourcing	Static seasonal calendars	Live Market Demand: Tracks real-time interest shifts to identify peak seasonal availability for herbs and ingredients.
Reliability	Slow loading times or crashes when databases go down	Always Available: Runs searches seamlessly in parallel and includes built-in offline modes when connectivity is lost.
Output Quality	Made-up ingredients or broken source links	Verified Information: Filters out fake citations and cleans up web sources before generating recipes.

Why Does Open Innovation Matter?

At its core, SlothBotanist is a pantry-first herbal drink generator that helps users transform everyday kitchen ingredients into tailored infusions (Heritage Elixirs and Modern Refreshes).

Because SlothBotanist handles wellness suggestions and dietary preferences, open innovation is not just a philosophy—it is the foundation of user safety, transparency, and accessible knowledge.

Relying on closed, proprietary "black-box" models to generate health or dietary recipes creates critical risks. Open innovation solves this by putting complete control and visibility back into the hands of the user and developer:

Verifiable Evidence & Transparency: Closed AI models frequently hallucinate health claims or invent fake sources with authoritative confidence. Open innovation enables us to pair a lightweight, open-weight language model (Qwen/Qwen2.5-1.5B-Instruct) with transparent, multi-engine retrieval via SerpApi. Because our prompt structures, source-normalization layer, and retrieval code are fully open-source, users can verify exactly where every drink recommendation comes from and trace every citation ([S1], [S2]) directly to live web or scholarly evidence.
Privacy-First Allergen Exclusions: Dietary restrictions (such as tree nuts, dairy, gluten, soy, or pollen cross-reactivities) are personal health data. SlothBotanist uses an open, local-first architecture where allergen filtering and input sanitization run directly in the user's browser (localStorage) before search queries are ever dispatched.
No Vendor Lock-In or Paywalled Wellness: Open-weight models combined with standardized API integrations mean that exploring herbal traditions remains accessible to anyone on modest local hardware, without requiring paywalls or expensive cloud subscriptions.
Community-Driven Safety & Auditability: Open source allows the community to audit our automated safety evaluation scripts (eval_brews.py) and weekly recall scanners (weekly_scan.py). Anyone can inspect how safety rules are enforced or contribute updated ingredient guidelines.
Reproducible Herbal Discovery: By leveraging open retrieval logic alongside SerpApi's Search Archive Ledger (search_metadata.id), every search query and source set is permanently archived, making drink recommendations fully reproducible and verifiable over time.

By keeping the application, language models, and search pipelines open, SlothBotanist turns AI from an opaque black box into a reliable, community-verifiable tool for everyday wellness.

The Lazy Payoff

The true spirit of SlothBotanist is that you can do the sipping while the app does all the thinking.

When you're ready to unwind, deciding what to drink shouldn't feel like hard work. Figuring out which flavors mesh, guessing what works, checking for sensitivities, and mastering the prep takes all the relaxation out of the ritual.

SlothBotanist turns that whole hassle into a 30-second cozy ritual:

Use What You Have: No special shopping trips required. Just type in whatever is already sitting in your kitchen cabinet.

Match Your mood and goals: Select your current mood with a single tap—whether you need "Morning energy", "Gentle digestion", or a "Calm before sleep".

Two Instant Drink Choices: Get straight to the good part. You receive two ready-to-make drink ideas right away: a cozy Heritage Elixir and a crisp Modern Refresh.

Peace of Mind: Save your dietary exclusions once, and the app quietly filters out anything you need to avoid automatically.

The Bottom Line:
Zero guesswork, zero effort, and zero stress. You just pick your pantry ingredients, kick back, and instantly get to enjoying your cup.

🍵 Your Next Brew Awaits: Time to Take a Sip

Next time you look into your kitchen and see a wedge of lime, half a cucumber, or a pod of green cardamom, don't just reach for a plain mug of hot water.
Let the sloth do the heavy lifting. Discover what your pantry has been trying to tell you all along. Delightfully effortless—your next favorite elixir is already sitting on your counter.

"Pantry odds, perfect brews."⭐
"Slow down, brew up."✨

Prize Categories

Best Use of SerpApi

In SlothBotanist, SerpApi is not an auxiliary add-on, a side widget, or a simple wrapper—it is the core architectural engine that powers the entire system. While standard applications rely on single-endpoint web lookups, SerpApi is Architectural Backbone of SlothBotanist.

Architectural Highlights:

High-Performance Concurrency & Ecosystem Workflows: Search requests execute simultaneously using asyncio.gather while run_in_threadpool runs blocking SerpApi calls in worker threads to keep the main event loop unblocked. The 10 integrated engines are Google Search (google), DuckDuckGo (duckduckgo), Google Scholar (google_scholar), Google Books (google_books), Google Patents (google_patents), Google News (google_news), YouTube (youtube), Google Trends Trending Now (google_trends_trending_now), Google Trends (google_trends), _and _Google Images (google_images). Beyond search, it incorporates Google Lens (google_lens),Extract API (engine=extract), Search Archive API (search_metadata.id), Account API, and Locations API (location, gl, hl, google_domain).
Dual-Format Intelligence Routing: Prioritizes Books, Patents, and Scholar for traditional Heritage Elixirs, while routing Trends, YouTube, News, and Web Search for contemporary Modern Refreshes.
Allergy Safety Layer: Automates google_scholar botanical cross-reactivity checks (ragweed, birch, soy, tree nuts etc) and google_news recall sweeps prior to recipe generation.
Trend & Seasonality Analysis: Aggregates weekly interest data into monthly averages and peak demand months.
Data Normalization & Citation Integrity: Request-scoped URL deduplication, isolates source registries per request, and strips hallucinated citations ([S99]) via resolve_citations.
Production Resilience & Offline Mode: Features 401 key protection, 429 rate-limit cooldowns, parameter fallbacks, explicit no_cache / zero_trace flags, disk caching (.sloth_cache/), and zero-quota offline replay (SLOTH_OFFLINE=1).

Thanks for reading! 🦥🌿

WELLSPRING: The Privacy-First Offline Wellbeing App That Told Me To Close My Devices

Techie — Mon, 12 Oct 2026 06:40:48 +0000

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

What I Built

Modern technology traps us in a digital loop—endless doomscrolling, blue-light exhaustion, and constant notification overload that drains our mental well-being and physical vitality.

For the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass, I wanted to build something that actively pushes back against screen addiction. Meet WELLSPRING: a 100% offline, privacy-first wellness sanctuary application designed around one core philosophy—screen time should take seconds, so real life can take hours.

🍃 What is WELLSPRING?
Instead of engaging you in long screen time, endless feeds, or gamified addiction loops, WELLSPRING acts as a lightning-fast digital pitstop. You quickly record your movement, receive a brief calming reflection from a local AI, close your screen, and step straight back into the physical world.

Key Features & Unique Innovations
1.🛡️ 100% Offline, No Sign-Ups & Absolute Privacy: Zero account creations, zero sign-ups, and zero cloud logins required. Your raw thoughts, feelings, mood ratings, and activity histories live exclusively in a local SQLite file on your hard drive with absolute zero third-party data exposure.

2.⚡ Anti-Screen Interface: Built explicitly to minimize screen glare and cognitive load. Interactions are brisk and purposeful, designed to eject you from your monitor immediately.

3.🎨 Soothing Multi-Hue Pastel Aesthetic: Replaces dark-mode developer tropes and high-contrast, anxiety-inducing interfaces with a tranquil palette of soft pastel lavender (#C8B6E2), pistachio green, rose, peach, and alabaster cream.

4.🤖 Offline Gemma Intelligence via Ollama: Leverages Google's lightweight, open-weights Gemma model running directly on local device memory—yielding fast, zero-latency, private reflections without Wi-Fi.

5.🌟 The Unique Core Feature — The Sanctuary Guide (#tab-assistant): Unlike standard chat interfaces that trap users in endless conversational loops, the Sanctuary Guide is WELLSPRING’s signature off-grid AI intelligence tab. It queries your local SQLite database to pull your recent movement, energy, and mood logs, passes them securely to Google's open-weights Gemma model via Ollama, and instantly synthesizes deep, personalized mental and physical health reflections.

🏛️ Sanctuary Pages & Navigation
1.📊 Dashboard (#tab-dashboard): Aggregates all your recorded health activities, movement duration, and mood metrics into one unified view so you can assess your well-being at a single glance before shutting your laptop.

2.📚 Activity Journal (#tab-tracker): Your personal offline logging interface allowing you to quickly log walks, workouts, stretching sessions, or rest blocks alongside your mood and energy scores (1–5 scale).

3.🌊 Reflection Analytics (#tab-analytics): An offline pattern-recognition utility that scans your local database entries to reveal behavioral trends—such as how physical movement directly correlates with higher energy levels—without keeping you stuck reading long reports.

4.🔬 Habit Lab (#tab-experiment): A micro-experimentation sandbox introducing structured, science-backed lifestyle hypotheses—such as morning light strolls, screen-free digital sunsets, or hydration rituals—designed to be read once and practiced entirely away from screens.

5.💡 Health & Reflection Tips (#tab-tips): An evidence-based educational library breaking down physiological principles (like circadian light absorption, breathing pauses, and cellular hydration) into brief, skimmable advice cards.

6.💬 Sanctuary Guide (#tab-assistant): The unique special feature tab providing deep, personalized mental and physical health reflections by synthesizing your recent journal entries into concise, supportive feedback through local Google Gemma intelligence.

How I Built It

WELLSPRING is built entirely around an offline-first architecture leveraging open-source AI frameworks and local model execution, completely eliminating external network dependencies and cloud sync.

1. Local AI Intelligence Engine (Google Gemma via Ollama)
At the core of WELLSPRING's signature feature—the Sanctuary Guide—is Google's open-weights Gemma model running locally via the Ollama runtime (http://localhost:11434).

Instead of keeping users trapped in chat loops, the app queries the local SQLite database to compile recent user activity metrics (movement logs, energy ratings, and moods).

It passes this structured context locally to Gemma, which uses its instruction-following alignment to synthesize a short, compassionate reflection that grounds the user and explicitly directs them to close their screen and head outside.

2. Development Workflow with GitHub Copilot
The application's backend architecture and pipeline were built efficiently using multi-faceted capabilities in GitHub Copilot:

Inline Completions: Handled repetitive boilerplate code and standard endpoint structures during initial layout creation.

Chat Edit Mode: Allowed for targeted, single-file refactoring when establishing thread-safe SQLite connection pooling (check_same_thread=False) and asynchronous context managers.

Chat Agent Mode: Provided high-level workspace context across files to coordinate the local Ollama REST payload serialization (urllib), JSON headers, and strict query limiters (LIMIT 15) to maintain low RAM usage.

📋 System Requirements:
To run WELLSPRING locally with complete off-grid capabilities, ensure your hardware and software environment meets the following baseline specifications:

1. Operating System: macOS, Linux, or Windows (with WSL2 or native Python support).

2. Python: Version 3.10 or higher for asynchronous runtime execution.

3. Ollama Runtime: Installed locally to manage and serve local open-weights model inference.

4. AI Model: Google's open-weights Gemma model pulled locally via terminal (ollama pull gemma).

5. Hardware Memory: Minimum of 4GB of RAM available to host local inference smoothly on device memory without triggering external swaps.

⚙️ System Architecture & Engineering Flow
WELLSPRING utilizes a decoupled, local-first architecture where every tier executes entirely on the host hardware, guaranteeing zero telemetry, zero external network dependency, and absolute privacy.

The technology stack is structured into distinct functional layers:

1. Frontend Presentation Layer: Built using HTML5, Tailwind CSS, and Chart.js, styled explicitly with a multi-hue pastel palette to minimize user visual fatigue and eye strain.

2. Backend Application Layer: Powered by FastAPI (Python 3.10+) for lightweight, ultra-fast asynchronous request routing and endpoint management.

3. Persistence Layer: Built on SQLite (wellspring.db) via Python's built-in sqlite3 library, providing zero-configuration, secure, serverless local data persistence.

4. Intelligence Layer: Anchored by Google's open-weights Gemma model served locally via Ollama (http://localhost:11434), acting as the offline reflection engine.

Developing this architecture cleanly involved leaning on built-in workflows within GitHub Copilot. Early on, GitHub Copilot inline completions helped quickly draft routine endpoint structures and boilerplate layout. For organizing database context managers, utilizing GitHub Copilot Chat edit mode allowed for targeted file adjustments. Furthermore, GitHub Copilot Chat agent mode provided high-level workspace context to coordinate thread-safe database connection pooling (check_same_thread=False) and structure the local Ollama payload pipeline. At the intelligence core, Google's open-weights Gemma model parses local SQLite activity summaries via Ollama, translating historical mood and energy metrics into custom, compassionate reflections that actively instruct users to close their screens and touch grass.

Why Does Open Innovation Matter?

1.🌲 True Offline Independence: Open-weights local inference via Google's Gemma means the model runs directly on your device's RAM, giving you an AI reflection companion anywhere on Earth without Wi-Fi or cellular signal.

2.🛡️ Uncompromising Privacy: 100% of your personal notes, energy scores, and emotional trends stay on your hard drive. No sign-ups required, no cloud tracking, and no telemetry.

3.💸 Zero Subscription Traps: Open-weight models cost zero dollars to run, providing free, unlimited mental health tracking forever without needing your screen time to monetize.

4.🎨 Screen-Minimizing Persona Alignment: Google's Gemma lets developers enforce precise system prompts, adopting WELLSPRING's soothing tone naturally—delivering short, grounding reflections that explicitly tell you to put down your device and step outside.

Decision Factor	Traditional Wellbeing Apps	Why WELLSPRING?
Data Ownership	Stored on third-party servers, vulnerable to breaches	100% owned by you in a local SQLite file
Subscription / Cost	Recurring monthly fees or paywalled features	Completely free and open-source forever
Privacy & Tracking	Embedded ad trackers, behavioral profiling	Zero trackers, zero analytics, air-gapped
Availability	Breaks without internet connection	Works anywhere—in parks, flight mode, off-grid
AI Transparency	Closed-source models with opaque data usage	Runs open local weights (Google Gemma via Ollama)

Code

Coder-432 / WELLSPRING

A offline, privacy-first wellness sanctuary application designed to cut screen time short, protect your mental health, and return you to the physical world.

WELLSPRING

A offline, privacy-first wellness sanctuary application designed to cut screen time short, protect your mental health, and return you to the physical world.

🌿 ABOUT WELLSPRING

A privacy-first, 100% offline personal wellbeing app that encourages digital detox and mindfulness.

WELLSPRING uses a local AI model to provide personal grounding reflections based on your journal entries—without sending a single byte of data to external servers or cloud providers. Built with the assistance of GitHub Copilot and powered locally by Google Gemma.

🏛️ Architecture & System Design

The architecture of WELLSPRING is designed around a fully offline, decoupled local ecosystem. At the presentation tier, a lightweight client interface is rendered using server-side Jinja2 templates styled with Tailwind CSS, serving as a clean local dashboard inside your browser. This communicates directly with a FastAPI backend server running locally on Python, which handles HTTP routing, business logic, and transaction management. For data persistence…

View on GitHub

🌲 Field Test: Taking WELLSPRING Outside

I took WELLSPRING out for a real-world spin by walking away from my desk, stepping outside, and trying to use it in the wild. Here is how it actually went:

The Setup: I made sure my Wi-Fi was completely turned off to test the true air-gapped promise. Since FastAPI, SQLite, and Ollama run locally, the app spun up instantly via uvicorn without needing any internet connection.
Using It Outside: Sitting on a park bench with no signal, I opened the dashboard, logged a 30-minute walk into the offline Activity Journal, and noted how refreshing it felt to track movement without popups, notifications, or cloud distractions.
The Local AI Check-in: I ran the offline Gemma model via Ollama to generate a grounding reflection based on my recent local SQLite entry. Within seconds, it synthesized a short, reassuring note telling me to log off and enjoy the fresh air.
The Verdict: Building an app that actively forces you to close your laptop and look at the real world—and proving it works completely offline on a park bench—was an awesome exercise. It reinforced why local-first, privacy-focused software is so powerful: it serves you, then immediately gets out of your way so you can go live your life.

🍃 Conclusion

WELLSPRING brings together local intelligence, complete privacy, and an anti-distraction design into a quiet digital sanctuary. By letting open-weight Gemma run entirely offline on your own machine, it provides the insights you need without keeping you tethered to a display.

After you finish going out and experiencing real life, you simply return to enter your log for a few minutes—and that is all it takes. By actively helping to lower screen fatigue, clear mental clutter, and foster mindful daily habits, WELLSPRING redefines how personal technology can support true mental health wellness and a balanced, grounded lifestyle.

Take a deep breath, log your moment quickly, close your laptop, and go touch grass. 🌿

Disconnect from the noise, reconnect with yourself—touch grass, not glass. 🌟

Prize Categories

1. Best Use of Gemma
Role: Powers both the reflection engine and the offline health guide inside WELLSPRING.

Function: It reads your raw journal entries from wellspring.db and writes soothing, grounding advice encouraging you to close your screen and go outside. Runs on your CPU/GPU via Ollama, It operates 100% offline with zero sign-up required, guaranteeing data privacy.

2. Best Use of GitHub Copilot
Role: The developer assistant that built the app.

Function:
Refactored API routes and structured async SQLite connection logic — Chat Edit Mode

Coordinated multi-file logic between FastAPI endpoints, HTML/Tailwind frontend templates, and the local Ollama pipeline — Chat Agent Mode

Audited project dependencies and configured privacy exclusions like .gitignore — Workspace Setup

DataBugBench: Benchmarking LLMs on Silent Python Data Science Bugs

Techie — Mon, 12 Oct 2026 05:34:24 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

I created DataBugBench, a benchmark designed to evaluate how accurately modern Large Language Models diagnose and correct subtle runtime and logical errors in Python Data Science code (Pandas, NumPy, and Scikit-Learn).

While LLMs perform exceptionally well on synthetic LeetCode-style problems, real-world data science pipelines frequently fail due to silent logical errors rather than outright syntax bugs. I specifically benchmarked 5 pervasive data engineering pitfalls:

Pandas SettingWithCopyWarning Mutations

Groupby Aggregation Missing Keys

NumPy Implicit Broadcasting Dimension Mismatches

Data Leakage in Feature Scaling

Index Discontinuity after NaN Dropping

Models Tested

I evaluated five state-of-the-art models (Claude 3.5 Sonnet, GPT-4o, Gemini 1.5 Pro, Qwen 2.5 Coder 32B, and Llama 3.3 70B) to measure how code specialization affects debugging precision.

Findings

Silent Logical Errors Are Hardest: Models easily fix explicit syntax errors, but often miss data leakage bugs where code runs without crashing but yields incorrect analytical results.

Specialization Matters: Code-focused models punch well above their weight class on complex array shape and broadcasting errors.

Final Results Summary
Claude 3.5 Sonnet: 5/5 passed (100.0% accuracy)

GPT-4o: 4/5 passed (80.0% accuracy)

Qwen 2.5 Coder 32B: 4/5 passed (80.0% accuracy)

Gemini 1.5 Pro: 3/5 passed (60.0% accuracy)

Llama 3.3 70B: 3/5 passed (60.0% accuracy)

Conclusion
DataBugBench demonstrates that while frontier LLMs excel at standard code generation, resolving silent data pipeline bugs requires a deeper understanding of implicit state, memory views, and data leakage. Moving forward, evaluating models on non-crashing logic bugs will be critical to building truly reliable AI data science assistants.