DEV Community: Creta

PhishGuard Inbox: private, local-first email triage for freelancers

Creta — Thu, 15 Oct 2026 12:46:14 +0000

The problem

Freelancers and small teams regularly receive invoices, document shares, account notices, and payment requests without having a security team to review them. A suspicious email can be hard to judge quickly, especially when it creates urgency or uses a lookalike sender or link.

What I built

PhishGuard Inbox is a local-first email triage app. Paste an email or upload an .eml file, and it extracts links, domains, selected sender details, and attachment metadata. Deterministic Python checks flag common warning signs and show their evidence. A locally hosted Gemma model, served through Ollama, adds an explanation and a cautious next step. The app can also create a JSON report that omits the full email body and attachment contents.

The project includes 22 fictional sample emails spanning phishing attempts and routine messages, so people can try the workflow without using real inbox data.

Who it is for

The first intended users are freelancers and small teams who want a quick second look at an unexpected payment request, login warning, document share, or other message. This is an early product hypothesis; I have not yet validated willingness to pay with users.

Demo

Demo video or walkthrough:https://phishguard-zctfym5bmf6mklsmpvur2a.streamlit.app/
Source code: https://github.com/Mstr-Creta/PhishGuard

The current app runs locally with Python, Streamlit, and Ollama. A public Streamlit Cloud link is not available for this local-only version: the app is configured to use a loopback Ollama service on the same computer. A recorded walkthrough is the most accurate demo unless the app is later adapted for a hosted inference setup.

For a short recording, load sample email, run the analysis, show the extracted link and evidence, then download the JSON report. Explain that the model and rules provide triage assistance, not a verdict users should trust without checking.

Why open innovation matters here

Running an open-weight model locally makes the inference path inspectable and avoids sending email text to a hosted LLM provider. It also avoids a per-request cloud model fee for the local workflow. That matters for a small tool aimed at independent professionals, where recurring inference costs and handling client email data are both practical concerns.

Local processing is not a guarantee of security, and this prototype has not been independently audited. The model can misunderstand a message, and rules can miss attacks or flag legitimate email. Users should verify sensitive requests through a contact method they already trust.

How it works

Streamlit accepts pasted text or an .eml upload.
The parser extracts message text, headers, links, domains, and attachment metadata in memory.
Deterministic checks score visible signals and keep their evidence available.
Ollama runs the selected local model to explain the findings and suggest a safe next step.
The downloadable report excludes the full email body and attachment contents.

Built with

Python, Streamlit, Ollama, and Gemma 3 1B. The default model is gemma3:1b; qwen2.5:1.5b-instruct is an optional alternative.

Try it locally

See the setup instructions in the GitHub README below. The sample messages are synthetic and use reserved .test domains.

Current limitations

This is a prototype, not an antivirus product or proof that a message is safe or malicious.
The heuristics and model have not been calibrated against a representative, labeled email dataset.
The sample emails are illustrative and do not establish accuracy.
The current local-only Ollama configuration does not provide a public hosted demo.
No user testing or willingness-to-pay validation has been completed yet.

Challenge fit

PhishGuard Inbox explores the Side Hustle prompt by applying an open-weight model to a specific workflow for freelancers and small teams. Whether people would pay for it remains to be tested with actual users.

#hf26challenge #python #ai #security

# PhishGuard Inbox

Local-first email triage for freelancers and small teams. Paste an email or upload an `.eml` file to inspect links, sender signals, attachments, and common social-engineering patterns. A local Ollama model explains the evidence and suggests a cautious next step.

> PhishGuard is triage assistance. It cannot prove that a message is safe or malicious. Verify sensitive requests through a contact method you already trust.

## Features

- Parse pasted email text and `.eml` files in memory
- Extract URLs, domains, selected header fields, and attachment metadata
- Flag common signals such as urgency, payment or credential requests, URL mismatches, shorteners, and risky attachments
- Show deterministic findings and their evidence alongside a local model explanation
- Download a JSON report without the full email body or attachment contents
- Browse 22 fictional sample emails across phishing and routine message categories

## How it works

The app parses the message, applies transparent Python checks, and sends selected email content to the local Ollama service for an explanation. The app is configured for loopback Ollama addresses; it does not use a cloud LLM API or perform DNS lookups. Uploaded `.eml` files are read in memory, and attachment contents are not opened or saved.

## Requirements

- Python 3.11 or newer
- [Ollama](https://ollama.com/download)
- About 16 GB system RAM is recommended for the target setup; model performance depends on the computer

## Run locally on Windows

Open PowerShell in the project folder:

powershell
py -3 -m venv .venv
..venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install -r requirements.txt
Copy-Item .env.example .env
ollama pull gemma3:1b
streamlit run app.py


Ollama's Windows app normally runs in the background. If the app reports that Ollama is unavailable, open Ollama and retry. The optional alternative model is `qwen2.5:1.5b-instruct`:

powershell
ollama pull qwen2.5:1.5b-instruct


For macOS or Linux, create and activate a Python virtual environment with your platform's commands, install `requirements.txt`, pull `gemma3:1b` with Ollama, and run `streamlit run app.py`.

## Sample walkthrough

1. Open **Sample Emails**.
2. Select a fictional phishing message and choose **Load sample in Analyze Email**.
3. Open **Analyze Email** and select **Analyze locally**.
4. Review the evidence, extracted links, model explanation, and JSON report.

The examples are synthetic and use reserved `.test` domains.

## Privacy notes

The default Streamlit address is `127.0.0.1`. Email text is sent to the local Ollama process for analysis, not to a cloud LLM service. The model request contains selected headers, a body excerpt capped at 6,000 characters, URLs, domains, attachment metadata, and deterministic findings. Reports do not include the full email body or attachment contents.

## Limitations

PhishGuard is an experimental triage tool. Rules can miss attacks or flag legitimate messages, and a small local model can misunderstand an email. The included examples are not a benchmark and do not demonstrate real-world accuracy. Do not use the output as the sole basis for payments, account changes, or sharing sensitive information.

The current Ollama setup is local-only. Deploying this app to Streamlit Community Cloud will not connect it to Ollama running on your personal computer. A hosted deployment requires a separately designed inference setup and corresponding privacy/security review.

## Project status

Early MVP. Accuracy evaluation, user research, accessibility review, and a public hosted demo are future work.

## License

[Add your chosen license and include its `LICENSE` file before describing this project as open source.]

Outside, Today: Weather-aware ideas to help us touch grass

Creta — Tue, 06 Oct 2026 12:26:33 +0000

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

What I Built

Outside, Today is a small weather-based activity suggester for anyone who wants a nudge to spend less time deciding what to do and more time outdoors. Enter a city and it checks current conditions, the forecast, and nearby parks, gardens, and walking trails. It then gives three practical activity cards with a suggested time window, duration, and a note about why each idea fits the weather.

Each nearby place can include an interactive map preview. The cozy interface also has Moss, a little cat who follows the cursor, settles back at the edge when things get quiet, and gives weather-aware messages when tapped.

Demo

Live demo: https://weather-activity-mvp.onrender.com/

Code

GitHub repository: https://github.com/Mstr-Creta/weather_activity_mvp.git

How I Built It

The app uses FastAPI and Python for its backend, with a single HTML page built using vanilla JavaScript, CSS, and inline SVGs. SerpApi supplies live weather and local outdoor-place results. When GEMINI_API is configured, Google's hosted Gemma open-weight model uses the city, current conditions, forecast, and nearby places to generate three tailored activity ideas. If the model key is missing or the model request fails, local weather-based rules provide fallback ideas.

I chose Gemma because its open weights give builders more choice in how they inspect, adapt, and serve a model. This MVP calls Gemma through Google's hosted API; it does not run offline or self-host the model. That trade-off keeps setup light for a first build, while the model choice leaves room for a future self-hosted or alternative-provider version.

Why Does Open Innovation Matter?

The activity ideas depend on timely local context, but the language model that turns that context into a useful plan does not have to be locked to one proprietary model. An open-weight option gives future maintainers a path to change the serving setup, experiment with different Gemma variants, or move inference to infrastructure they control. The current hosted API is still an external service, so this version does not yet deliver local inference or keep all request data on the user's device.

The app sends the entered city to SerpApi for weather and nearby places. When Gemma is enabled, the city and related weather and place context are sent to Google's API. The app does not create an account or store a user profile.

Prize Categories

Best Use of Gemma: Gemma generates the weather-aware activity cards from current conditions and local search context.
Best Use of SerpApi: SerpApi provides fresh weather and nearby-place results that are passed into the Gemma prompt to ground its suggestions.

🚀 Building “Neon Dash” with Amazon Q CLI

Creta — Mon, 26 May 2025 17:10:50 +0000

When I first heard about the Build Games with Amazon Q CLI campaign, I was curious but a little skeptical — how could an AI coding assistant really help speed up the game development process?

I decided to test it out with a fun idea:
✨ Neon Dash — a reflex-based racing game built with Python and Pygame, where players dodge glowing obstacles and collect neon orbs in an endless, fast-paced challenge.

Check project repository: https://github.com/Mstr-Creta/Neon_dash_game

In this blog, I’ll Walk you through how I used Amazon Q CLI, what the workflow looked like, and why it made my dev process surprisingly smooth, creative, and efficient.

🛠️ What is Amazon Q CLI?
Amazon Q CLI is a command-line interface tool powered by Amazon’s generative AI. It can help developers:
✅ Generate code from detailed prompts
✅ Create modular, readable project structures
✅ Suggest fixes, optimizations, or improvements
✅ Iterate on projects quickly, even for creative or experimental builds

*Read the blog here to get started with Q on your machine: *

docs.aws.amazon.com

For this campaign, I wanted to test if Q CLI could handle an interactive GUI-based game — not just backend or scripts, but something visual and real-time.

🎮 My Game Idea: Neon Dash

Here’s the concept I fed into Q CLI:
I want to build a Pygame-based GUI game called "Neon Dash."

Game concept:

A fast-paced reflex racing game where the player controls a glowing neon vehicle racing down an endless track filled with moving obstacles.
The goal is to survive as long as possible, dodging obstacles and collecting neon orbs for points.
The game gets progressively faster and harder over time.

Key features I want the code to include:

Game Window & Setup:

Pygame window with dimensions (e.g., 800x600).

Neon color palette: black background with bright glowing colors (cyan, magenta, yellow, lime).

FPS set for smooth gameplay (e.g., 60 FPS).

Player Vehicle:

Represent the player’s vehicle as a glowing rectangle or triangle.

Control with left/right arrow keys (or A/D) to shift between lanes or smoothly move left/right.

Add a subtle trail effect behind the vehicle for a glowing streak.

Track & Obstacles:

Generate a series of incoming neon obstacles (blocks, walls, or barriers) that the player must dodge.

Randomize obstacle positions and sizes.

Gradually increase obstacle speed as the player survives longer.

Pickups & Scoring:

Generate collectible neon orbs or pickups that increase the player’s score.

Track and display current score on-screen.

Optional: Add combo multipliers for streaks or near-misses.

Visual Effects:

Add glow/shadow effects to obstacles, player, and pickups.

Background animations (moving neon grid, flashing patterns, or starfield effect).

Smooth screen shake or pulse effect when the player narrowly dodges or collects pickups.

Game Over & Restart:

Detect collisions with obstacles — triggers game over.

Show game over screen with final score.

Add a “press R to restart” or “press Q to quit” option.

Sound & Music:

Looping synthwave/neon-style background track.

Sound effects for dodging, collisions, and collecting pickups.

Difficulty Scaling:

Gradually increase the speed of obstacles and frequency as time progresses.

Optional: Introduce new types of obstacles or lane patterns at certain score thresholds.

Optional Bonus Features:

Add leaderboard system to track top scores.

Add custom color themes players can unlock.

Add a turbo/boost mode the player can activate when a meter fills up. Please generate:

Main game loop with proper event handling.

Code for rendering the player vehicle, obstacles, pickups, and score display.

Collision detection between player, obstacles, and pickups.

Functions to spawn obstacles and pickups with random properties.

Code for scaling difficulty and updating speed.

Code for the game-over screen and restart handling. Bonus if possible:

Code for simple particle effects when the player collects pickups or crashes.

Code for a neon-style animated background (moving grid or pulse). Make sure the code is modular, readable, and split into functions or classes where appropriate to make future expansion easy.

I prepared a detailed prompt that included:
✅ Game window setup (size, colors, FPS)
✅ Player controls (left/right, smooth movement)
✅ Obstacle generation and scaling difficulty
✅ Score system and pickups
✅ Visual effects like glowing trails
✅ Game over and restart functionality

⚡ Using Q CLI: Workflow Breakdown

Here’s how the workflow went:
1️⃣ Crafting the Prompt
Instead of jumping straight into code, I focused on describing what I wanted in as much detail as possible.

With Q CLI, the more structured and specific your prompt, the better the results.

2️⃣ Generating Core Code
I ran the prompt through Q CLI, and in seconds, it generated:
✅ A Pygame window setup
✅ Player object and movement
✅ Obstacle spawning system
✅ Basic collision detection
✅ Score tracking

What impressed me was that the generated code wasn’t just functional — it was well-structured and modular, with clear functions and comments. I could easily tweak or expand parts without breaking things.

3️⃣ Iterating & Improving
I used Q CLI iteratively:

Asked it to add sound effects.
Asked for visual glow effects on the player and obstacles.
Asked to introduce difficulty scaling — increasing obstacle speed over time.

Instead of spending hours debugging, I could refine features and try new ideas quickly, letting Q CLI handle the repetitive or boilerplate parts.

4️⃣ Testing & Polishing
Once the base game worked:
✅ I added custom neon color themes.
✅ Polished the background with moving grids and flashes (with Q CLI suggestions).
✅ Implemented a simple leaderboard (again, assisted by Q CLI).

By the end, I had a playable, visually appealing game ready for submission — in much less time than if I’d coded it all solo.

💡 Why Q CLI Was a Game-Changer

Here’s what stood out to me:
✅ Speed — Q CLI helped generate usable code in seconds, giving me a playable foundation fast.
✅ Creativity — I could experiment freely because the AI handled the heavy lifting.
✅ Structure — The output was modular and clean, making it easy to expand.
✅ Focus — I spent more time on design and gameplay decisions, less on boilerplate setup.

For devs used to grinding through long setup phases or struggling with game loops, Q CLI acts like an intelligent coding partner — boosting your flow and creativity.

📦 Final Thoughts

Participating in the Build Games with Amazon Q campaign showed me that AI tools like Q CLI aren’t just productivity boosters — they’re creative enablers.

If you’re a developer curious about:

Building interactive games quickly
Exploring AI-assisted workflows
Experimenting with creative coding

I highly recommend giving Q CLI a try. It helped me turn Neon Dash from an idea to a playable project faster and smoother than I expected.

✨ Thanks, Amazon Q CLI team, for making this campaign fun and empowering! I’m excited to explore even more projects with this tool.

AmazonQCLI

My First Submission for Frontend Challenge - December Edition

Creta — Fri, 27 Dec 2024 07:37:50 +0000

🧑🏻‍💻What I Built
I created an interactive and visually stunning landing page dedicated to exploring the science and culture surrounding the Winter Solstice. The project focuses on engaging users with animations, dynamic content, and a rich user experience inspired by the solstice theme.

🧑🏻‍🚒Demo
You can view the live demo here: https://winter-wonderland-journey.vercel.app/
Or check out the project repository on GitHub: https://github.com/Mstr-Creta/winter-wonderland-journey

✍🏻Journey
Throughout this challenge, I focused on re-creating a design that captures the essence of the Winter Solstice. Key features include:

Snowfall animations
Use of Gradient hero section
Multiple style for each section
Use of better colors and depth effect with icons suitable to theme

🤖Use of Ai

for planning the framwork and workflow
bugs fixing
better code visibility

😄Lessons Learned
I gained insights into advanced CSS animations and JavaScript event handling, especially for SVG-based interactive elements. The project also challenged me to think creatively about balancing aesthetics and usability.