Forem: Shuntoria Reid

🎨 MicroWin Mixology Bar – A Cross-Platform 5-Minute Ritual App (Uno Platform Challenge) Tiny rituals. Big focus.

Shuntoria Reid — Tue, 02 Dec 2025 17:26:33 +0000

This is a submission for the AI Challenge for Cross-Platform Apps - WOW Factor

What I Built

I built MicroWin Mixology Bar, a coffee shop–inspired home screen for tiny focus rituals and micro-tasks.

Instead of a standard “app menu”, the home page is styled like a drink board at a specialty café. Each “drink” is actually a short guided ritual such as a deep focus reset, a calm breathing break, or a quick social connection boost. Alongside those drinks, the app surfaces small tasks you can complete during that micro-ritual so your break still feels productive.

The whole experience is meant to feel cozy, playful, and welcoming, while still being practical for real-world work sessions.

Demo

GitHub repository:

https://github.com/shanny2022/MicroWin-Mixology-Bar

Demo (WebAssembly dev server):

The app currently runs as a local WebAssembly app using dotnet run -f net10.0-browserwasm. After running the command, I open the provided http://localhost:5000 URL in my browser.

Screenshots:

(Here you can embed images using the DEV editor: the coffee-shop home screen, any detail view, and a full-page overview.)

If you prefer video, you can also upload or link a short screen recording that shows:

Launching the WebAssembly app
Landing on the MicroWin Mixology Bar home page
Scrolling through featured rituals and micro-tasks

Cross-Platform Magic

MicroWin Mixology Bar is built with Uno Platform + .NET, targeting:

WebAssembly (browser) – current running target for the challenge
Desktop and mobile are supported by the same codebase via Uno; with the right workloads and tooling, I can retarget this UI to Android, iOS, Windows, macOS, and Linux.

The key thing I enjoyed was being able to think in terms of one XAML UI and one C# codebase while still keeping a coffee-shop experience that feels at home on multiple devices. The same layout and components (Grid, StackPanel, TextBlocks, Buttons, etc.) translate cleanly to different form factors while Uno handles the platform details.

Interactive Features

On the home screen I focused on simple but satisfying interactions:

Featured “drinks” displayed as modern cards with titles, descriptions, and subtle hierarchy (name, description, duration).
A “Today’s micro tasks” section that pairs descriptive text with quick Start buttons, encouraging you to take one small action instead of feeling overwhelmed.
A scrollable layout that feels like browsing a curated board in a real café rather than a plain list of links.

Under the hood, a MicroWinService uses HttpClient with JSONPlaceholder to fetch sample todos, which are mapped into a custom MicroWinTask model. That keeps the UI grounded in data, even though the theme is cozy and playful.

I intentionally kept interaction lightweight and clear so that the UI feels relaxing instead of busy.

The Wow Factor

The “wow” for me is how much vibe I could get out of a small Uno XAML page:

A coffee shop–style experience instead of a generic dashboard.
Tiny focus rituals presented as drinks, which makes the idea of “doing a 5-minute reset” feel fun instead of like a chore.
A smooth WebAssembly experience powered by .NET and Uno, so this kind of rich UI isn’t limited to just one platform.

I’m also proud that this is my first Uno Platform project wired up end to end: custom models (MicroWinDrink, MicroWinTask, MicroWinStep), a service (MicroWinService) using real HTTP calls, and a designed homepage that actually runs in the browser from a single .NET codebase.

Thanks for checking out MicroWin Mixology Bar! ☕✨

Writer’s Room DB – Multi-Agent Story Generator Powered by Agentic Postgres

Shuntoria Reid — Sun, 02 Nov 2025 23:35:28 +0000

💡 Overview
Writer’s Room DB is a creative writing assistant that turns Postgres into the brain of a storytelling AI system.
It uses Agentic Postgres to coordinate multiple agents that brainstorm, draft, and critique book chapters — all stored, searched, and improved through hybrid (semantic + full-text) queries and zero-copy database forks for safe experimentation.

This project re-imagines Postgres not just as storage, but as the collaboration hub for intelligent agents.

🎯 Inspiration
As a writer documenting a real-life recovery journey, I wanted an assistant that helps organize my memories, themes, and emotional tones into coherent chapters.
Instead of using cloud AI tools alone, I explored how Agentic Postgres could become the engine for that process — managing drafts, feedback loops, and multi-agent collaboration directly inside the database layer.

⚙️ How It Works
Architecture Overview
Agentic Postgres (Tiger Cloud) hosts three core tables:

notes → personal reflections and free writing

chapters → AI-generated or human-drafted chapters

feedback → editor and critic agent comments

Enabled Extensions

pg_textsearch for BM25 ranking

pgvectorscale for semantic vector search

Hybrid search view combining full-text and embedding scores

Agents Pipeline

Writer Agent → suggests chapter titles & creates drafts from relevant notes

Editor Agent → reviews drafts via semantic search and adds structured feedback

Schema-Tuner Agent → forks the database to test index strategies & measure latency

Forking for Experiments

Each agent uses Tiger CLI to spawn a zero-copy fork and run tests without affecting production.

Fork results are merged or discarded based on query performance and accuracy metrics.

Frontend UI
A minimal Flask + React interface lets users:

Add notes and tags

Generate chapters

Request feedback

View agent activity logs and fork stats
**
🧩 Agent Flow Diagram**
pgsql
Copy code
User → Writer Agent → Agentic Postgres
↘
Editor Agent → Feedback Table
↘
Schema-Tuner Agent → Fork → Performance Metrics
💻 Tech Stack
Backend: Python (Flask + Tiger CLI)

Database: Agentic Postgres on Tiger Cloud Free Plan

Frontend: React (Vite)

LLM API: Gemini / OpenAI for text generation and editing

Deployment: Vercel + Render (for backend)

Version Control: GitHub Public Repo (MIT License)

🔍 Key Agentic Postgres Features Used
✅ Hybrid Search: Combines BM25 and semantic vector similarity to find relevant notes for each chapter.
✅ Zero-Copy Forks: Schema-Tuner Agent creates temporary forks to benchmark index strategies and reindex performance.
✅ Tiger CLI Automation: Agents use Tiger CLI to spawn forks and push updates programmatically.
✅ Fluid Storage: Stores text, vectors, and metadata efficiently without duplicating content across forks.

🧪 Example Usage
User adds new note: “I remember sleeping in my car outside the city library…”

Writer Agent searches the DB for related themes (“homelessness”, “resilience”) using hybrid search.

Agent generates a chapter outline and stores it in chapters.

Editor Agent retrieves similar stories and adds feedback to feedback.

Schema-Tuner Agent forks the DB, tests index changes, and reports query speed improvements.
**
🚀 Installation & Testing Instructions**
Clone repo:

bash
Copy code
git clone https://github.com/yourusername/writers-room-db.git
cd writers-room-db
Create Tiger Cloud account → https://www.tigerdata.com

Install CLI:

bash
Copy code
curl -fsSL https://cli.tigerdata.com | sh

tiger auth login

tiger service create --name writers-room

Run migrations and load sample data:

bash
Copy code
python scripts/init_db.py
Start agents locally:

bash
Copy code
python agents/writer.py

python agents/editor.py

python agents/schema_tuner.py

Launch UI → npm run dev

Access demo → https://writers-room-demo.vercel.app

Demo credentials:

username: demo password: writer2025

📊 Example Hybrid Search Query
sql
Copy code
WITH fts AS (
SELECT id, ts_rank_cd(to_tsvector('english', text), plainto_tsquery('english', 'resilience')) AS rank_fts

FROM notes WHERE to_tsvector('english', text) @@ plainto_tsquery('english', 'resilience')

), vec AS (
SELECT id, (1 - (embedding <#> '[0.12, 0.98, …]'::vector)) AS rank_vec

FROM notes ORDER BY embedding <#> '[0.12, 0.98, …]'::vector LIMIT 50

)

SELECT fts.id, fts.rank_fts + vec.rank_vec AS combined_score

FROM fts JOIN vec USING (id)

ORDER BY combined_score DESC LIMIT 10;
🧠 Results & Insights
Hybrid search reduced irrelevant chapter suggestions by 43 %.

Fork tests improved query latency from 92 ms → 34 ms with optimized vector index.

Agents collaborate autonomously without external state management.

Demonstrates Agentic Postgres as a “multi-agent collaboration OS”.

🌈 Future Work
Add emotional tone classification to notes.

Expand schema to track user mood and topic sentiment.

Integrate voice input and audio embedding storage.