Projects

Overview

Plantr is an offline-first iOS utility application that helps houseplant owners track and optimize their gardening schedules. Users can lookup pre-configured guides or input custom plants to generate comprehensive care instructions dynamically.

AI & Structural Integrations

The app features advanced mobile LLM capabilities:

• Structured JSON Parsing: Queries the Google Gemini 2.5 Flash API with strict response schemas (using responseMimeType: "application/json") to map raw LLM outputs directly into type-safe Swift structures.
• Offline Heuristics: If internet connectivity is lost or an API key is absent, the app falls back to a smart, keyword-based local generator to synthesize care sheets for specific plant families (e.g. succulents, ferns, tropicals).
• Local Storage: Persists user configurations, favorited plants, and custom caretakers directly into Document directory JSON files.

Technical Stack

UI & UX Design Patterns

Strictly compliant with Apple's Human Interface Guidelines (HIG). Includes semantic system color palettes, dynamic type support, custom difficulty rating badges (Easy, Medium, Hard), and elegant detail animations.

Overview

This project is a dedicated physical desktop device showing real-time personal finance and market trend data. To prevent memory exhaustion on an Arduino Uno (2KB SRAM), all computation is offloaded to a host daemon, turning the microcontroller into a serial-driven drawing terminal.

System Design & Data Pipeline

The pipeline separates hardware display rendering from API orchestration:

• Data Retrieval: A Python background daemon makes scheduled API calls to YNAB for category balance values and Yahoo Finance for S&P 500 weekly trends.
• Data Normalization: S&P 500 closing values are normalized in Python to fit a 0-63 coordinate plane.
• Serial Communication: The daemon routes commands via serial at 9600 baud using custom headers: S1|CategoryName|Balance (for Screen 1) and S2|%Change|HeightsString (for Screen 2).
• Raspberry Pi Deployment: Can run persistently as a systemd service, using a 3-key USB Macropad bound via the Linux evdev input event framework to manually page categories or trigger API syncs.

Technical Stack

Hardware Optimization

Uses a "power hack" to drive GND and VCC directly from Arduino digital output pins to simplify wiring. Dual screens are managed in Software I2C page-buffered mode to fit inside the strict 2KB SRAM ceiling of the Uno.

Overview

CRUNGCP is a deployment of the Model Context Protocol (MCP). Traditional MCP servers use local stdio-based transport, limiting them to local developer terminals. CRUNGCP uses Server-Sent Events (SSE) to host tools on public, secure HTTPS endpoints, giving cloud-hosted LLMs like the Claude Web UI direct, programmatic access to private services.

Architecture & Protocols

The server operates on Google Cloud infrastructure:

• SSE Transport: Hosts Starlette-based endpoints for /sse (establishing client-bound event channels) and /messages (receiving client-to-server tool call requests).
• Authentication Middleware: Integrates a custom ASGI gateway checking for the presence of a secure API key, blocking unauthenticated traffic.
• Secrets Security: Sensitive developer credentials for the YNAB API are stored in Google Cloud Secret Manager and dynamically mapped as environment variables in Cloud Run containers at runtime.

Technical Stack

Available MCP Tools

Exposes tools to the LLM context: get_ynab_budget (currency, accounts, balances), get_ynab_transactions (history queries), and add_ynab_transaction (automated ledger entry creation).

Overview

The Model Armor Tester is a specialized web interface designed to audit, verify, and demonstrate enterprise LLM protection mechanisms. It integrates Google Cloud Platform's Model Armor safety templates with the modern Google GenAI Client SDK.

The Three-Phase Safety Pipeline

Every model prompt and response cycles through three key phases:

• Phase 1: Input Sanitization: Intercepts raw user text and validates it against active GCP Model Armor policy templates. If a filter violation is found (e.g. injection, hate speech, PII), the call is blocked, and the threat metrics are displayed.
• Phase 2: Generation Request: Passes verified, safe prompts to the selected Gemini model. The client queries active models dynamically based on credentials.
• Phase 3: Output Sanitization: Runs the model's generated text back through Model Armor templates. If the LLM generates sensitive leaks or policy violations, the output is redacted before it reaches the UI.

Technical Stack

Security Controls

Supports simulated security testing via a "Force Send" configuration, letting developers bypass prompt blocks to test how subsequent model generations respond to jailbreaks, and monitoring detailed API logs.

Overview

Previously titled MiniAiBeast, this project is an Edge-to-Cloud routing proxy that runs locally on macOS. It optimizes corporate prompt security, protects sensitive internal data from being exfiltrated to the public cloud, and reduces API consumption costs by resolving trivial queries locally.

The Multi-Stage Routing Pipeline

Incoming API requests are processed through three local stages before a response is returned:

• Stage 1: Local Security Guard: A local LLM (running via Ollama) evaluates the prompt for adversarial injections or safety threats. Malicious prompts are rejected with a 403 Forbidden header instantly.
• Stage 2: Complexity Router: Safe prompts are analyzed locally to determine if they are SIMPLE (factual, small, template-based) or COMPLEX (coding tasks, logic systems, multi-step planning).
• Stage 3: Generation Execution: Simple prompts are generated locally using the local Ollama instance on Apple Silicon. Complex prompts are escalated to the Google Gemini cloud API (using the google-genai SDK).

Technical Stack

Key Advantages

Retains local data privacy for simple internal operations, cuts public API transaction counts in half, and establishes local prompt sanitization guards before sending text across the network.

Overview

WalBeast is an AI agent that automates grocery planning and cart injection. By parsing natural language goals (e.g., *"I want to make a Mississippi Pot Roast"*), the system generates a smart, cost-effective shopping list and automatically drives a web browser to locate and add items to a Walmart cart.

System Architecture

The application runs on a three-tier decoupled architecture:

• Frontend Dashboard: A React + Vite dashboard displaying the current shopping checklist, real-time agent action logs, and headed browser state indicators.
• Backend API: A FastAPI server streaming logs and updates via Server-Sent Events (SSE).
• Agent Engine: Built on Playwright and the browser-use LLM agent framework, which executes a browser context, solves selectors, and logs in.

Technical Stack

Safeguards & Edge Cases

The automation loop handles cart injection only; the final order placement is strictly left for manual execution. It includes dynamic banner alerts for manual CAPTCHA solving, and session persistence via a dedicated browser profile to avoid SMS multi-factor challenges.