DEV Community: Ashraf Ahmed

Lumbre: a Día de los Muertos altar that only remembers what you tell it

Ashraf Ahmed — Sun, 01 Nov 2026 06:25:56 +0000

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

What I Built

Lumbre is a small altar for Día de los Muertos. You write the name of someone you want to remember, how you knew them, the years if you know them, one memory, and any food, song, or object that belongs with them.

An open-weight model writes the line that sits on the altar and a short remembrance. The memory you typed is kept word for word, under "As told." The food, the song, and the object come from the form. A field you leave blank stays blank. The model is told not to invent a date, a relative, or a favorite thing you did not give it.

I read the week as remembrance rather than a jump scare. Día de los Muertos is the thin place between someone who is gone and the people who still set a place for them. The altar is that place: paper, a candle, marigolds, and only the facts you actually brought.

You can save the card as a JSON file.

Demo

https://ashraf01k-lumbre.static.hf.space

A card comes back in a few seconds. Use "Try a fictional altar" if you want to see the page before you write a real name. The host allows about two cards a minute.

Code

https://github.com/AshrafGalaxy/lumbre

AshrafGalaxy / lumbre

Lumbre

Lumbre letters a Día de los Muertos altar card. You write a name, a memory, and only the foods, songs, and objects you actually know. Llama 3.3 70B, an open-weight model, writes the lines on the card. Anything you leave blank stays blank.

The memory you typed is kept word for word. The offering list is built in code from those fields, so the model cannot add a favorite food you never named.

Why open weights

Llama 3.3's weights are public. The altar calls that model on a host, so a card comes back in a few seconds and the page does not download hundreds of megabytes. The model id is one constant, so it can be swapped for another open instruct model. A closed API would lock the wording to one vendor.

Architecture

flowchart TD
    visitor[Visitor] --> page[Altar page]
    page --> facts[Altar facts]
    facts --> scribe[Scribe]
    scribe -->

…

View on GitHub

How I Built It

The public page is static HTML. Pressing "Light the altar" sends the note once to Llama 3.3 70B Instruct, an open-weight model from Meta, through OVHcloud's OpenAI-compatible endpoint. The browser does not download the weights, and the page does not contain an API key.

The scribe is small on purpose. lumbre/prompts.py asks for two labeled parts, an inscription and a remembrance. lumbre/altar.py builds the offering list and the list of gaps from the fields you filled in. The model is not trusted to decide what was brought to the altar.

Gemma is open-weight too, and the weights are on Hugging Face. I did not use it for the live card. The Hugging Face router can serve Gemma, but this account has no Inference Providers credits, and a free account cannot run a Docker Space to load the weights. The host that answers with no key does not offer a Gemma chat model. Llama 3.3 70B is the open chat model that host does serve, so that is what letters the card. The model id is one constant.

Why Does Open Innovation Matter?

A remembrance should not depend on a closed chat product that can change its model or shut the endpoint down. Llama's weights are public. Lumbre calls that model by name, and the same scribe can point at another open instruct model. The offering list is ordinary code, so a model update cannot quietly add a favorite food. The note is sent for one reply. Lumbre does not keep a database of it.

The Spirit of It

The part that matters is the empty space. A remembrance gets worse if the model invents a song, a Sunday, or a cause of death. Lumbre writes down what you actually said, and leaves the rest quiet.

ClientRadar: Autonomous Freelance Contract Discovery & AI Proposal Engine

Ashraf Ahmed — Mon, 19 Oct 2026 06:06:33 +0000

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

What I Built

Freelance engineers and boutique consultants spend 10 to 15 hours every week manually scanning fragmented job boards, dodging low-rate listings, and writing custom proposals.

ClientRadar AI is an autonomous contract arbitrage and AI proposal engine that turns this unpaid grind into a 30-second workflow:

Live Multi-Platform Contract Discovery: Harnesses real-time contract listings across LinkedIn, ZipRecruiter, Indeed, and direct company boards with dynamic portal deep-links.
Dynamic Compensation & Recency Parsing: Intelligently extracts true hourly rates (e.g., $75 – $150 / hr, $170 – $200 / hr) or computes role-based market estimates instead of showing generic placeholders.
Multi-Factor Viability & Risk Audit: Evaluates contract viability (68–97/100) based on compensation transparency, 1099 vs. W2 terms, scope detail, and flags potential risks (such as unlisted budgets or roles posted over two weeks ago).
AI-Powered Pitch Synthesis: Leverages open-weight Google Gemma to draft structured, bespoke technical outreach proposals across three selectable strategies (Direct Technical, Fast 48h Turnaround, Strategic Retainer).
Personalized Freelancer Profiles: Injects consultant credentials (target rate, portfolio, specialties, name) directly into generated pitches with 1-click Markdown export.

Who Would Pay For It?

Independent software engineers, technical consultants, and boutique agency founders who currently pay $50–$150/month for lead scraping tools. ClientRadar delivers a private, open-source alternative that finds high-intent remote contracts and drafts winning proposals instantly.

Demo

Live Deployed App: https://clientradar.streamlit.app/
Repository: https://github.com/AshrafGalaxy/ClientRadar

How to Run Locally

git clone https://github.com/AshrafGalaxy/ClientRadar.git
cd ClientRadar
python -m venv .venv
.\.venv\Scripts\activate   # On Windows (or source .venv/bin/activate on Linux/Mac)
pip install -r requirements.txt
streamlit run app.py

Open http://localhost:8501 in your browser. Configure your API keys (SERPAPI_API_KEY and HUGGINGFACE_TOKEN) in a .env file or use the built-in demo engine.

Code

AshrafGalaxy / ClientRadar

Autonomous freelance lead-arbitrage engine

🎯 ClientRadar AI

Autonomous freelance lead-arbitrage engine powered by SerpApi and Google Gemma 2.
Built for the Hacktoberfest open source AI challenge.

💡 Overview

Freelancers and boutique technical consultants spend 10-15 hours every week scanning job boards, filtering low-budget listings, and drafting custom outreach pitches.

ClientRadar AI turns this manual grind into an autonomous, 30-second pipeline:

Live Discovery & Deep-Linking: Leverages SerpApi's google_jobs engine to harvest fresh, high-ticket tech contracts across LinkedIn, Indeed, ZipRecruiter, and company portals in real time with direct application deep-links.
Multi-Tier Viability & Risk Scoring: Google's open-weight Gemma 2 (google/gemma-2-2b-it) parses the job description, evaluates Scope Clarity (35 pts), Budget Alignment (35 pts), and Timeline Realism (30 pts), while auditing for scope-creep or equity-only red flags.
Custom Outreach Pitch Studio: Gemma 2 crafts tailored proposals with selectable pitch strategies (Direct Technical, Fast 48h Turnaround, or Strategic Retainer…

View on GitHub

Repository: https://github.com/AshrafGalaxy/ClientRadar

How I Built It

Core Framework & UI: Built with Python 3.11 and Streamlit, featuring a bespoke responsive interface with SVG icon systems, dark/light theme switching, and segmented preview controls.
Open-Source AI Model: Powered by Google's open-weight model Gemma (google/gemma-3-4b-it / google/gemma-2-2b-it) via the Hugging Face Serverless Router for structured viability audits and technical proposal generation.
Real-Time Job Harvesting: Integrated with the SerpApi Google Jobs Engine to harvest real-time job listings, parsing direct apply portals (e.g., generating direct Apply on LinkedIn ↗ and Apply on ZipRecruiter ↗ buttons).
Heuristic Viability Engine: Custom Python parsing pipeline extracting hourly compensation brackets, work-from-home eligibility, and risk signals before synthesizing client outreach.

Why Does Open Innovation Matter?

Open-source and open-weight models like Google Gemma democratize high-grade AI for independent developers:

Eliminating Vendor Lock-in & Unpredictable API Costs: Proprietary closed APIs enforce restrictive usage caps and unpredictable meter billing. Open-weights allow developers to run inference locally or via serverless endpoints without recurring commercial tolls.
Data Privacy for Client Communications: Client pitches, client names, hourly terms, and confidential project proposals never have to be stored or trained on by closed third-party providers.
True Customizability: Developers have full transparency into model prompts, system architectures, and fine-tuning pipelines.

My Agent Session

ClientRadar was built and optimized using Google Antigravity, leveraging agentic pair programming to:

Implement resilient IPv4 network adapters overcoming Windows IPv6 connection resets on external cloud APIs.
Design dynamic SerpApi data parsers for compensation brackets and multi-platform action buttons.
Build the dual-view proposal studio (Rendered Pitch vs. Editable Markdown) with 1-click export.

My First User

During initial testing with independent backend contractors:

The tool scanned live remote listings and surfaced a $170 – $200 / hr Python contract on Turing via LinkedIn/ZipRecruiter.
In less than 15 seconds, ClientRadar evaluated the scope viability at 97/100, verified clear tech alignment (Python, Async, Distributed Systems), and generated a tailored 3-paragraph outreach pitch ready to submit.
The tester praised the direct platform action buttons (Apply on LinkedIn ↗) and the ability to personalize commercial rates and GitHub portfolio links in the sidebar.