Bobi Facts MCP Server

A Model Context Protocol server (official C# SDK, ModelContextProtocol 2.0.0-preview.1) that stores facts about Bobi the cat. It runs as a Streamable HTTP server and persists to Postgres (Supabase) via EF Core.

Tools

Tool	Arguments	Description
get_facts	–	Return all facts about Bobi.
insert_fact	content: string	Add a new fact; returns the created fact.
delete_fact	id: int	Delete a fact by id; returns if it hit.

Layout

src/BobMcp.Server/
  Models/Fact.cs            EF Core entity
  Dtos/                     Wire DTOs (FactDto, DeleteResultDto)
  Data/BobiDbContext.cs     EF Core DbContext
  Data/DesignTimeDbContextFactory.cs   For `dotnet ef`
  Migrations/               EF Core migrations (Npgsql)
  Services/IFactService.cs  Injectable service abstraction
  Services/FactService.cs   EF Core implementation (IDbContextFactory)
  Tools/FactTools.cs        [McpServerToolType] — thin handlers, delegate to service
  Program.cs                Host + DI + HTTP MCP wiring
src/BobMcp.Client/          A real MCP client (HTTP) used to test the server

The tool layer holds no logic — every tool maps arguments to an injected IFactService call, which is the only place that touches the database.

Configuration

Env var	Required	Default
BOBI_DB_CONNECTION	yes	–
BOBI_HTTP_URL	no	http://localhost:5111
AUTH_ISSUER	yes	–
MCP_RESOURCE	yes	–
ALLOWED_EMAILS	yes	–

Authentication is mandatory (see Authentication): if AUTH_ISSUER, MCP_RESOURCE, or ALLOWED_EMAILS is missing the server throws on startup and will not run — there is no unauthenticated mode.

BOBI_DB_CONNECTION is an Npgsql key/value string (not a postgresql:// URI). For Supabase use the Session pooler with channel binding disabled:

Host=aws-1-eu-central-1.pooler.supabase.com;Port=5432;Username=postgres.<project-ref>;Password=<pw>;Database=postgres;SSL Mode=Require;Trust Server Certificate=true;Channel Binding=Disable

Channel Binding=Disable is required — Supavisor rejects Npgsql's default SCRAM channel binding and otherwise returns a misleading 28P01 password authentication failed.

Build & run

dotnet build BobMcp.slnx -c Release

BOBI_DB_CONNECTION="Host=...;Channel Binding=Disable" \
AUTH_ISSUER="https://your-app.authkit.app" \
MCP_RESOURCE="http://localhost:5111/mcp" \
ALLOWED_EMAILS="you@gmail.com" \
  dotnet src/BobMcp.Server/bin/Release/net10.0/BobMcp.Server.dll

The auth vars are required — the server throws on startup without them. See Authentication.

The MCP endpoint is http://localhost:5111/mcp. The server applies EF Core migrations on startup.

Test it (acts as an MCP client)

dotnet src/BobMcp.Client/bin/Release/net10.0/BobMcp.Client.dll          # localhost:5111
dotnet src/BobMcp.Client/bin/Release/net10.0/BobMcp.Client.dll https://host/mcp

Or with curl:

curl -i -X POST http://localhost:5111/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

Migrations

dotnet ef migrations add <Name> --project src/BobMcp.Server

Authentication

The server is an OAuth 2.1 resource server, and auth is required — it refuses to start unless AUTH_ISSUER, MCP_RESOURCE, and ALLOWED_EMAILS are all set. It never shows a login page itself — it validates a JWT access token on every /mcp call and only lets through tokens whose email claim is in ALLOWED_EMAILS. The actual "sign in with Google" flow is run by WorkOS AuthKit, which acts as the OAuth authorization server. claude.ai (the MCP client) drives the whole flow: it discovers AuthKit from /.well-known/oauth-protected-resource, registers itself (DCR), sends you to Google to log in, then retries with Authorization: Bearer <token>.

claude.ai ──initialize──▶ /mcp ──401 + WWW-Authenticate──▶ claude.ai
claude.ai ──discovers──▶ WorkOS AuthKit ──Google login──▶ access token (aud = MCP_RESOURCE)
claude.ai ──Bearer token──▶ /mcp ──validate JWT + email allowlist──▶ tools

Why AuthKit and not Google directly: Google's OAuth doesn't support Dynamic Client Registration and won't scope tokens to this server, both of which MCP clients need.

The wiring lives in Auth/AuthenticationExtensions.cs: AddJwtBearer validates the token, .AddMcp(...) serves the resource metadata, and an authorization policy enforces the email allowlist.

One-time WorkOS AuthKit setup

1. Create a WorkOS account and an AuthKit application (free tier is enough).
2. Enable Google login: WorkOS Dashboard → Authentication → add Google OAuth as a sign-in method.
3. Surface the email claim: Authentication → Sessions → Configure JWT Template, add "email": "{{ user.email }}" so the access token carries the email claim the allowlist checks.
4. Enable Dynamic Client Registration: Applications / OAuth → turn on DCR (lets claude.ai register itself).
5. Add a Resource Indicator equal to your public MCP URL, e.g. https://<host>/mcp. This becomes the token's aud. (Without it AuthKit uses a default environment-scoped aud, which won't match MCP_RESOURCE.)
6. Copy your AuthKit domain (e.g. https://your-app.authkit.app) — that's AUTH_ISSUER.

Env vars

AUTH_ISSUER=https://your-app.authkit.app   # AuthKit domain (the OAuth issuer)
MCP_RESOURCE=https://<host>/mcp            # must match the AuthKit Resource Indicator + the URL you add in claude.ai
ALLOWED_EMAILS=you@gmail.com               # comma-separated allowlist

Hosting for claude.ai

claude.ai connects to remote MCP servers over Streamable HTTP. To expose this one:

1. Run it pointed at your Postgres/Supabase DB, with the Authentication env vars set.
2. Put it behind public HTTPS (reverse proxy or a tunnel such as Cloudflare Tunnel / ngrok) — claude.ai requires https://. Make MCP_RESOURCE match this public /mcp URL.
3. In claude.ai → Settings → Connectors, add https://<host>/mcp. claude.ai will walk you through the Google sign-in on first connect.

RAG (Retrieval-Augmented Generation) - C# Implementation

A C# implementation of a Retrieval-Augmented Generation (RAG) system that processes PDF documents and enables intelligent question-answering using local AI models.

Overview

This RAG implementation allows you to ask questions about PDF documents by combining semantic search with large language models. The system extracts text from PDFs, converts it into semantic vectors, stores them in a vector database, and retrieves relevant context to generate accurate answers.

Architecture

The system uses the following components:

• Qdrant: Vector database for storing and searching semantic embeddings
• Ollama with Phi3 model: Local LLM for generating embeddings and completions
• PdfPig: PDF text extraction library
• .NET 9.0: Runtime environment

How It Works

1. PDF Processing: Extract text content from PDF documents
2. Text Chunking: Split the text into manageable chunks
3. Overlay Chunking: Create overlapping chunks to maintain context continuity
4. Semantic Vectorization: Convert each chunk into semantic vectors using Ollama's Phi3 model
5. Vector Storage: Store all vectors in Qdrant vector database
6. Query Processing: Convert user queries into semantic vectors
7. Similarity Search: Use Qdrant to find the most relevant chunks via semantic search
8. Context Augmentation: Compose a final prompt with retrieved context
9. Answer Generation: Generate accurate answers using the LLM with relevant context

Prerequisites

• Docker with GPU passthrough support enabled
• NVIDIA GPU (required for Ollama to run efficiently)
• .NET 9.0 SDK or later

Docker GPU Setup

Ensure Docker has access to your GPU. You need:

• NVIDIA Container Toolkit installed
• Docker configured with --gpus=all flag support

DjOrm

A lightweight ORM for .NET that maps C# classes to PostgreSQL tables using custom attributes and a generic DbContext<T>.

Features

• Auto-generates CREATE TABLE SQL from annotated C# entities
• Junction table generation for entity relationships
• Full CRUD operations via a single generic context
• Translates simple LINQ expressions into SQL WHERE clauses
• Recursive fetching of related objects via junction tables
• Async throughout

Usage

1. Annotate your entities

[TableAttribute]
public class CarEntity
{
    [PrimaryKeyAttribute]
    public int Id { get; set; }
    public string Name { get; set; }
    public string Make { get; set; }

    [SecondaryKeyAttribute]
    public DriverEntity? Driver { get; set; }
}

2. Create tables and run queries

var db = new DatabaseConnector(connString);

// Auto-create tables from entity definitions
var entities = new TableEntitiesMaker(new TypeTranslator()).CreateObjectEntities();
await db.ExecuteCommands(new SqlCreateTablesTranslator(entities).TranslateEntitiesToCreateTables());

// CRUD
IDbContext<CarEntity> ctx = new DbContext<CarEntity>(db);

await ctx.InsertData(new CarEntity("Civic", "Honda", driver));
var all    = await ctx.GetData();
var hondas = await ctx.GetDataBy(x => x.Make == "Honda" && x.Name != "Accord");
await ctx.UpdateData(car);
await ctx.DeleteData(car);

LINQ expression support — GetDataBy walks the expression tree and translates binary expressions (==, !=, <, <=, >, >=, &&, ||) directly into parameterized SQL conditions.

3. Recursive fetching of related objects

Pass recursive: true (or isRecursive: true on DbContext) to automatically load related entities via their junction tables:

// Fetch all articles and populate their related TagEntity objects
var articles = await ctx.GetData(isRecursive: true);

// Same with a filter
var articles = await ctx.GetDataBy(x => x.Title == "Hello", isRecursive: true);

For each fetched object, DjOrm:

1. Queries the junction table ({ParentType}{RelatedType}) using the parent's primary key.
2. Looks up the related entity by its primary key.
3. Assigns the result to the [SecondaryKey]-annotated property.

This works recursively — related objects that themselves have [SecondaryKey] properties are also populated.

Configuration

Connection string is loaded from a .env file:

HOST=localhost
PORT=5432
USERNAME=postgres
PASSWORD=postgres
DATABASE=testdb

RSTracker

RSTracker helps coaching staff make data-driven decisions about player load management. By tracking daily RPE (Rating of Perceived Exertion) and wellness scores across a squad, the application calculates key performance indicators such as training load volume, intensity, and the Acute:Chronic Workload Ratio (ACWR) -- a widely recognized metric for assessing injury risk.

The platform is designed around the concept of league weeks (7-day windows), allowing staff to review and compare data on a week-by-week basis aligned with the competitive schedule.

---

Key Features

Player Management

• Maintain a full squad roster with player profiles (name, age, position, weight, height)
• Add and remove players with cascading data cleanup

RPE Tracking

• Record daily session RPE values and training duration per player
• Automatic calculation of session training load (RPE x duration)
• Daily team averages, volume percentages, and intensity metrics
• Comparison against built-in reference norms for each day of the week

Wellness Monitoring

• Track four daily wellness dimensions per player: Muscle Status, Recovery Status, Stress, and Sleep
• Each dimension scored on a 1-7 scale (total wellness score out of 28)
• Mid-week recovery assessment via Wednesday-Thursday-Friday averages

ACWR Analysis

• Acute:Chronic Workload Ratio calculation over configurable time windows
• Multi-week trend visualization to identify periods of elevated injury risk
• Combined volume and intensity breakdown per week

Data Visualization

• Bar charts for daily wellness and RPE summaries
• Combo charts comparing actual RPE loads against daily reference norms
• Stacked bar charts for weekly RPE breakdowns across the ACWR period
• ACWR ratio trend charts spanning multiple weeks

Weekly Data Views

• Day-by-day tables showing individual player values alongside team averages
• Week summary tables with aggregated statistics
• Date picker navigation to browse historical data by league week

---

Screenshots

RPE Bar Chart -- daily training load visualization

RPE Norm Chart -- actual loads compared against daily reference norms

Wellness Chart -- daily wellness score overview

ACWR Analysis -- workload ratio trends across multiple weeks

Player Management -- squad roster administration

Player Data, RPE, Wellness and Management -- combined data entry view

---

Sports Science Background

RPE (Rating of Perceived Exertion)

RPE is a subjective measure of how hard a player perceives a training session to be. When combined with session duration, it produces the session RPE or total training load:

$\text{Session RPE} = \text{RPE Value} \times \text{Duration (minutes)}$

Volume and Intensity

• Volume is expressed as a percentage of the maximum expected daily load (baseline of 760):

$\text{Volume} = \frac{\text{Total RPE}}{760} \times 100$

• Intensity normalizes volume by time to account for differences in session length:

$\text{Intensity} = \frac{\text{Volume}}{\text{Common Time} / 95}$

Wellness Scoring

Players self-report four metrics daily, each on a 1-7 scale:

Metric	Description
Muscle Status	Perceived muscle soreness and readiness
Recovery Status	General sense of physical recovery
Stress	Mental and emotional stress levels
Sleep	Sleep quality and duration

The total wellness score ranges from 4 to 28. The platform also calculates a Wednesday-Thursday-Friday average, commonly used to assess recovery state heading into match day.

ACWR (Acute:Chronic Workload Ratio)

The ACWR compares the current week's training load against the rolling average of the previous four weeks:

$ACWR = \frac{\text{Current Week Load}}{\text{Average of Previous 4 Weeks}}$

ACWR Range	Interpretation
Below 0.8	Undertraining -- potential detraining risk
0.8 - 1.3	Safe zone -- optimal load management
1.3 - 1.5	Caution -- elevated injury risk
Above 1.5	Danger zone -- high injury risk

Daily Reference Norms

The system includes built-in daily RPE norms for a typical training week to compare against actual loads:

Day	Mon	Tue	Wed	Thu	Fri	Sat	Sun
Reference RPE	300	600	580	110	220	760	0

---

Technology Stack

Frontend

Technology	Purpose
React 19	UI framework
Vite	Build tool and dev server
React Router DOM	Client-side routing
React Bootstrap / Bootstrap 5	UI component library and styling
Chart.js + react-chartjs-2	Data visualization and charting
chartjs-plugin-datalabels	Chart label overlays
MSAL React + MSAL Browser	Microsoft Entra ID authentication
date-fns	Date manipulation and formatting
react-datepicker	Date selection component
react-select	Enhanced dropdown selects
react-toastify	Toast notifications
react-spinners	Loading indicators

Backend

Technology	Purpose
.NET 9 / ASP.NET Core	Web API framework
Entity Framework Core 9	ORM and database migrations
PostgreSQL (via Npgsql)	Relational database
JWT Bearer Authentication	API security
Swashbuckle / Swagger	API documentation
Newtonsoft.Json	JSON serialization
Azure Key Vault	Secrets management
Azure Blob Storage	Structured operation logging
In-Memory Cache	Response caching with TTL-based invalidation

Infrastructure

Technology	Purpose
Docker	Containerization with multi-stage builds
Nginx	Frontend reverse proxy and SPA routing
Azure Container Apps	Cloud hosting
Azure Key Vault	Centralized secrets management
Azure Blob Storage	Append-style daily log files

Testing

Technology	Purpose
xUnit	Test framework
Testcontainers	Integration testing with real PostgreSQL instances

---

CI/CD

The project uses GitHub Actions for continuous integration and deployment. A workflow is triggered on every push to the main branch and performs the following steps:

1. Test -- restores .NET dependencies, pulls a PostgreSQL image, and runs the full xUnit test suite (including Testcontainers-based integration tests)
2. Build -- builds Docker images for both the backend (ASP.NET Core API) and frontend (React SPA served by Nginx), tagged with the short commit hash
3. Push -- pushes both images to Docker Hub
4. Deploy -- authenticates with Azure and updates both Azure Container Apps (backend and frontend) to use the newly built images

This ensures that every merge to main is automatically tested, containerized, and deployed to production.

---

Authentication

RSTracker uses Microsoft Entra ID (formerly Azure Active Directory) for authentication.

• Users log in through a browser redirect flow via the Microsoft identity platform
• The frontend acquires an access token using MSAL (Microsoft Authentication Library) with the configured API scope
• Every API request includes the token in the Authorization: Bearer {token} header
• The backend validates the JWT against the configured Azure AD tenant and audience
• All API endpoints are protected -- unauthenticated requests receive a 401 response

---

Testing

The test suite uses xUnit with Testcontainers to spin up real PostgreSQL instances during integration tests, ensuring database operations are tested against actual database behavior rather than mocks.

Test coverage includes:

Test File	Coverage
PlayerHelperTests	Player CRUD operations and data retrieval
RPEManagerTests	RPE calculations, weekly aggregation, volume, and intensity
WelnessManagerTests	Wellness scoring, weekly summaries, and mid-week averages

Azure Blob Storage logging is mocked during tests to isolate database-focused assertions.

---

License

All rights reserved.

Intermezzo Staff

A staff management and time-tracking web app for small businesses — built to track daily work inputs, cash flow, and shift schedules. Built for a small cafe in my home city.

---

Tech Stack

Layer	Technology
Framework	Next.js 16 (App Router) + React 19 + TypeScript
Auth	NextAuth v5 — Google OAuth
Database	MongoDB (Atlas)
UI	React Bootstrap 5 + Custom CSS Modules
Calendar	FullCalendar (day/week/month views)
Utilities	date-fns, react-spinners
Hosting	Vercel-ready (Next.js server actions)

---

Role-Based Access

Access is controlled via environment-level email whitelists:

• Standard users — can view and edit their own data only; edit window limited to current month + last 2 days
• Admin users — elevated privileges: view all employees' data, filter by employee, access full wallet history

Authentication is handled through Google OAuth — only whitelisted emails can log in.

---

Pages

Wallet /wallet

Tracks the business cash balance. Users can submit balance updates with a timestamp. Admins see the full history of all updates (shown in the História accordion); standard users see the current balance only.

---

My Inputs /myinputs

Daily work log table. Each entry records hours worked, start/end times (auto-calculates hours), cash and terminal turnover, day expenses, and start/end float amounts. Filterable by month. Admins can view entries for all staff. Older entries outside the edit window are masked with ****.

---

Timetable /timetable

A color-coded shift calendar showing staff schedules. Powered by FullCalendar with day, week, and month views. Each employee is assigned a distinct color.

---

ChoreMaster

A Simple Household Task Management System
Transform your chaotic chore routine into an organized experience!

---

Technologies Used

• Frontend: React 18 + TypeScript
• Styling: Bootstrap
• Backend: .NET 9
• Database: PostgreSQL with Entity Framework ORM
• Authentication: JWT + OAuth2 (Google)
• Deployment: Azure + Terraform
• Testing: xUnit + .NET Testcontainers
• CI/CD Automation: GitHub Actions

---

Core Features

• Create, edit, and delete chores
• Manage users (create/edit/delete)
• Delegate chores to specific users
• Mark tasks as completed and reassign them to a user
• View full task history
• Configure custom task time thresholds
• Display relations and time left for each task

---

Overview of the App

---

Setting It Up Locally

Backend

Prerequisites

• .NET 9 SDK
• Entity Framework CLI tools
• Docker and Docker Compose

Setup Steps

1. Start PostgreSQL database:

   docker-compose up -d
   

2. Create environment file: Create a .env file in the backend directory with your connection string:

   DATABASE_CONNECTION_STRING=your_connection_string_here
   

3. Run Entity Framework migrations:

   dotnet ef database update
   

4. Start the backend:

   dotnet build
   dotnet run
   

---

Frontend

Prerequisites

• Node.js (npm version 10.8.2 or higher)

Setup Steps

1. Install dependencies:

   npm install
   

2. Start the development server:

   npm run dev
   

   The app automatically uses http://localhost:5272/api for the backend in development.

---

Production Deployment

Prerequisites

• Azure CLI installed and configured
• Terraform installed
• Docker Hub account
• Azure subscription

GitHub Secrets Configuration

Before deploying to production, configure the following secrets in your GitHub repository (Settings → Secrets and variables → Actions):

Secret Name	Description
DOCKERHUB_USERNAME	Your Docker Hub username
DOCKERHUB_TOKEN	Your Docker Hub access token
AZURE_CREDENTIALS	Azure service principal credentials (JSON format)
PRODUCTION_API_URL	Your production API URL (e.g., https://api.yourapp.com)

Deployment Steps

1. Login to Azure:

   az login
   

2. Navigate to the infrastructure directory:

   cd infrastructure
   

3. Initialize Terraform:

   terraform init
   

4. Review the deployment plan:

   terraform plan
   

5. Apply the infrastructure:

   terraform apply
   

6. Push to main branch:

   Once the infrastructure is set up, pushing to the main branch will trigger the CI/CD pipeline that:

   • Runs backend tests
   • Builds Docker images for frontend and backend
   • Pushes images to Docker Hub
   • Updates Azure Container Apps with the new images

---

Life Organizer

A personal productivity application built with Next.js 14, featuring task management, work reports, and workout tracking. The app uses Google OAuth for authentication and MongoDB for data persistence.

Tech Stack

• Framework: Next.js 14 (App Router)
• Authentication: NextAuth.js with Google OAuth
• Database: MongoDB
• UI: React Bootstrap
• Language: TypeScript
• Deployment: Vercel free tier + Atlas

Home (/)

• Landing page showing welcome message for authenticated users
• Displays access denied message for unauthenticated users

Tasks (/tasks)

• Daily task management system
• Date-based task organization
• Create, update, and toggle task completion
• Tasks persist per date in MongoDB

Work Reports (/workreports)

• Daily work report editor
• Rich text editor with formatting options
• Date-based report management
• Integrated Pomodoro timer for time management
• Create and update reports for specific dates

Workouts (/workouts)

• Workout tracking and management
• Built-in stopwatch timer
• Rich text editor for workout details
• Add, edit, and delete workout entries
• View workout history

Notes (/notes)

• Note tracking and management
• Rich text editor for note details
• Add, edit, and delete note entries

AES Implementation in C#

A simple, educational implementation of the Advanced Encryption Standard (AES) algorithm in C#. This project demonstrates the core AES encryption and decryption processes with a focus on clarity and learning.

Educational Purpose Only: This implementation is intended for learning and educational purposes. Do NOT use this in production environments or for securing sensitive data.

Quick Start

Prerequisites

• .NET 9.0 SDK or later

Supported Features

• ✅ AES-128 encryption and decryption
• ✅ Single block operations (16 bytes)
• ✅ Row-based state representation
• ✅ NIST SP 800-38A test vector compliance

Limitations

• ❌ Only supports 128-bit keys
• ❌ Single block only (no chaining modes like ECB, CBC)
• ❌ No initialization vectors (IV)
• ❌ Not optimized for production use

Performance Benchmarks

Latest benchmark results on Ubuntu 24.04.3 LTS with Intel Core i5-12450H:

Method	Mean	Error	StdDev	Ratio
Custom AES Encrypt	4,048.8 ns	74.34 ns	62.07 ns	~4.9x
Custom AES Decrypt	7,394.6 ns	31.49 ns	29.46 ns	~8.7x
.NET AES Encrypt	832.0 ns	3.82 ns	3.58 ns	1.0x
.NET AES Decrypt	847.2 ns	5.56 ns	4.64 ns	1.0x

Testing

The implementation is thoroughly tested against NIST Special Publication 800-38A and FIPS 197 test vectors:

dotnet test --verbosity normal

All tests validate:

• Correct encryption of known plaintext/key pairs
• Proper decryption back to original plaintext
• Compliance with NIST standards

Learning Resources

• NIST SP 800-38A - AES Test Vectors
• FIPS 197 - AES Standard

License

This project is for educational purposes only. Please refer to the license file for details.

Contributing

This is an educational project. Feel free to fork and experiment, but remember this is not intended for production use.

Mandelbrot Set Visualizer

A desktop application for rendering and exploring the Mandelbrot set, built with C# and Avalonia UI targeting .NET 9.

About

The Mandelbrot set is one of the most famous fractals in mathematics. A point $c$ in the complex plane belongs to the set if the sequence defined by:

$z_{n+1} = z_n^2 + c, \quad z_0 = 0$

remains bounded (does not diverge to infinity). This application renders the set on a 1000×1000 pixel canvas, coloring points that belong to the set in red.

Features

• Real-time rendering of the Mandelbrot set
• Pan navigation using arrow keys to explore different regions
• Zoom in by pressing Space to increase magnification
• Adaptive iteration count — the maximum number of iterations automatically increases as you zoom deeper, improving detail at higher magnifications

Controls

Key	Action
Arrow Up	Pan up
Arrow Down	Pan down
Arrow Left	Pan left
Arrow Right	Pan right
Space	Zoom in

Performance Note

You can scroll (zoom) into the set to explore its infinitely complex boundary, but be aware that performance degrades significantly after a few zoom levels. The rendering is not heavily optimized — each zoom step requires recalculating every pixel on the canvas, and as the iteration count increases with deeper zoom levels, the computation becomes substantially more expensive. This is a known limitation of the current implementation and would require significant optimization (e.g., multithreading, GPU acceleration, or perturbation theory) to handle deep zooms smoothly.

Getting Started

Prerequisites

• .NET 9 SDK

Run

cd MandelBrot/MandelbrotApp
dotnet run

Tech Stack

• C# / .NET 9
• Avalonia UI 11.3 — cross-platform UI framework
• WriteableBitmap — pixel-level rendering

PriceChecker

A .NET tool that monitors product prices on the web and notifies you by email when your target price is hit.

How It Works

1. Define items to track in InputConfig.xml — each entry has a URL, a target price, and a regex to extract the current price.
2. The tool fetches each page, parses the price, and compares it to your goal.
3. Every 30 minutes, it sends an email summary via Mailjet SMTP showing actual vs. target prices and whether each goal was reached.

Configuration

<root>
    <Recipient>you@example.com</Recipient>
    <ItemWebResource>
        <url>https://example.com/product</url>
        <priceGoal>49.99</priceGoal>
        <regexPricePattern>price-regex</regexPricePattern>
    </ItemWebResource>
</root>

Setup

Set your Mailjet SMTP keys as environment variables:

PUBLIC_KEY_PARSERTOOL=<your-public-key>
PRIVATE_KEY_PARSERTOOL=<your-private-key>

Then run:

dotnet run --project PriceChecker