Project archive

Showing 24 of 24 projects
  • 2026

    E2B Usage Billing Service — Production-Grade Billing Engine + PostgreSQL Observability

    kotlinbackendbillingpostgresqlobservabilityprometheusgrafana

    An event-driven usage billing engine (Kotlin 2.1, Ktor, JetBrains Exposed, PostgreSQL 16) that ingests idempotent compute telemetry (cpu_seconds), applies temporal per-customer/default pricing tiers, enforces reactive spend caps, and issues immutable monthly invoices with bit-exact database-reconstructible audit proofs. Includes a Prometheus + Grafana observability stack for live through put & bottleneck analysis.

    E2B Usage Billing Service is a production-grade billing engine for E2B's microVM AI-sandbox platform (~50,000 customers, 16.7k+ records/sec average).Live one-click demo — the service runs permanently on this VPS against PostgreSQL 16. Watch the live dashboard while the load tester streams: open Grafana (live) and the interactive Swagger docs. Scripted demo: DEMO_RUNBOOK.md — seed 1k customers, 10+ temporal price changes and ~30% per-customer overrides, then run the end-to-end load test; the assignment's worked example (ACME-0001 $20.00 / CYBERDYNE-0001 $18.17 past the $15 spend cap / late-usage rollover into ACME-0002) is one command: ./gradlew run --args="--simulate-only".Core billing correctness — streams consumption via idempotent HTTP ingestion, applying the price in force at each telemetry timestamp (customer override > default), with exact integer micro-cent arithmetic and per-bucket HALF_UP rounding. Credits apply strictly to usage (never add-ons); spend caps evaluate the current UTC month only; and every invoice is immutable once issued, with the precise math reconstructible directly from the DB for dispute resolution. A batch-ingestion differential test and independent billing oracle guarantee bit-exact results over 1,000+ invoices.PostgreSQL load validation on a constrained VPS (2 vCPU, slow disk) — reproduced the original laptop benchmark on real PostgreSQL 16: monthly concurrent billrun sustains ~224 customers/sec (1,000 customers in 4.5s, bit-exact), and ingestion holds ~11k–17k events/sec at only ~10% CPU with raw↔rollup unit-sum reconciliation bit-exact. JFR server-side profiling showed the bottleneck is PostgreSQL commit/fsync + JDBC round-trip latency on the slow disk, not CPU, JSON, or application locks.Live observability (Prometheus + Grafana) — the app exposes Micrometer metrics at /metrics (ingest counters + latency histogram, HTTP rate, HikariCP pool saturation, JVM/GC). A docker-compose stack (Prometheus, Grafana, node-exporter) runs on the VPS and a pre-provisioned Grafana dashboard visualizes through put (events/sec), ingest latency p50/p95/p99, DB pool saturation (the key bottleneck signal), GC, and the host CPU<75% memory guardrail live while the app runs.Design philosophy — Hexagonal (ports & adapters) Kotlin with on-the-go rollup pre-aggregation (O(active price tiers) per billing query), strict API planes (platform / customer / admin), fail-fast config, and Flyway versioned migrations. CLI simulator + 72 automated tests (0 failures).
  • Robot Test Wizard — Grounded AI-Driven Test Automation Framework

    pythonaitoolfullstackbackend

    A cloud-ready, data-driven test automation framework built on Robot Framework 7.x and Playwright, where AI coding agents generate modern, hallucination-free test code grounded in dynamically reflected, version-locked library documentation (LEGO Architecture: code, YAML test data, env config, and masked secrets strictly separated).

    Robot Test Wizard rethinks test automation for the agent era: instead of letting LLMs hallucinate deprecated Robot Framework 3/4 syntax, the framework grounds AI coding agents in their exact installed environment.Grounded AI generation (`tools/dump_libdocs.py`) — runs Robot Framework's native robot.libdoc introspection against the precise library binaries in the active virtualenv (RF 7.x VAR/RETURN/TRY EXCEPT/Secret, Playwright Browser Library, RequestsLibrary, plus custom libraries) and compiles them into human-readable docs/robot-libraries/*.md, a KEYWORDS_QUICKREF.md index, and a .agents/skills/robotframework-architect skill (SKILL.md + reference mirrors) that coding agents like Antigravity/GitHub Copilot read before generating a single keyword — auditable via conversation transcripts.LEGO Architecture — .robot files are pure workflow orchestration with zero hardcoded data. All scenarios live in resources/config/testdata/*.yaml (e.g. single product, multi-product bundle, quantity duplication, negative catalog tests), environment parameters in environments/<env>/env.yaml, and user personas in users.yaml. A DataLoader pre-run SuiteVisitor AST modifier dynamically clones test cases per YAML scenario and injects environment config.Zero-cleartext secrets — credentials are never committed: users.yaml stores pointers (secret_env) to git-ignored .env, and DataLoader wraps them in robot.api.types.Secret so execution reports log strictly <secret>.Structured PDF verification — receipts downloaded during checkout are parsed from binary PDF streams into semantic XML via pypdf, then asserted with Robot Framework's XML library and XPath on line items and grand totals.Fast-fail & graceful negative handling — catalog existence is validated with Browser.Get Element Count (fails in 0s with a clean business error), while TRY ... EXCEPT-wrapped keywords validate expected YAML-defined error messages and conclude with Pass Execution.Closed-loop `--dryrun` sandbox — a zero-side-effect Robot Framework --dryrun acts as a ~3s semantic compiler for any agent-generated suite (keywords exist, argument types match, IF/TRY/FOR/WHILE block boundaries valid, YAML binds correctly), enabling an automated self-healing loop that only ships compilable tests.Playwright vs. Selenium evaluation — documented engineering comparison (in-process CDP WebSocket vs. HTTP JSON Wire, zero driver hell, native auto-waiting, strict-mode locators, network mocking, multi-engine Chromium/Firefox/WebKit coverage on Windows). Packaged with a Streamlit install-wizard and PowerShell/Batch quick runners.
  • Music Note Reader — Precision Neural OMR & Audio Player

    pythonfullstackaimusictool

    A 100% local, zero-API-key Optical Music Recognition system and interactive web player: upload a scanned sheet or PDF and get editable MusicXML, playable multi-instrument WAV / MIDI — every note, key signature and rhythm transcribed by a hybrid SegNet + Transformer neural pipeline.

    Music Note Reader converts scanned sheet music and PDF documents into editable MusicXML, playable multi-instrument polyphonic audio (WAV), and Standard MIDI — with zero cloud dependencies and no API keys.Precision Neural OMR (TrOMR + SegNet) — powered by homr's hybrid SegNet staff/symbol segmentation and Transformer-based end-to-end sequence recognition, resolving key signatures, time signatures, clefs, notes, accidentals, ties, rests, and measures with pitch & rhythm accuracy.Original sheet layout preservation — the engine keeps the printed system breaks and measure-per-row layout (<print new-system="yes"/>), so the rendered score mirrors the source page exactly.Multi-instrument audio synthesis — a built-in additive synthesizer with instrument-specific ADSR envelope modeling: 🎹 acoustic grand piano (hammer-strike percussive decay), ⛪ pipe/church organ (multi-rank harmonic plenum), 🎻 string ensemble (vibrato sawtooth), 🪈 concert flute (breathy woodwind), ⚡ electric piano (Rhodes bell-tine), ✨ music box/celesta (inharmonic chimes), and 👾 8-bit chiptune square waves.Multi-format input & async pipeline — PDFs rendered to crisp 300-DPI via pypdfium2 (no external Poppler), plus PNG/JPG/WEBP uploads, with real-time 0–100% progress reporting across segmentation, dewarping, transformer inference, and synthesis stages.Interactive vector engraving — OpenSheetMusicDisplay renders the MusicXML as interactive zoomable SVG with one-click downloads of WAV, MIDI, and MusicXML. FastAPI backend + async job worker, deployed as a Dockerized Cloud Run service.
  • Testing New Models — Frontier AI Spatial Reasoning Benchmark

    aifrontendtool

    A comparative benchmark suite evaluating Gemini 4, DeepSeek-V4, Qwen 3.8 Max and Kimi 3 on hard spatial-reasoning tasks: programmatic vector generation (SVG), animation mechanics, and an interactive 3D Jenga physics tower.

    Frontier AI Model Benchmark Suite independently probes the latest frontier LLMs with three escalating spatial challenges.The pelican-on-a-bicycle benchmark — popularised by Simon Willison — exposes a model's internal world model: it must compose a rigid mechanical bicycle (matched wheel radii, closed diamond frame, handlebars, pedals) with organic pelican anatomy (webbed feet on pedals, wings on the bars) in a coherent Cartesian coordinate system it cannot see.The toad & fly test — spatial-temporal coordination: the fly buzzes a dynamic path while the toad's eyes track it, and the tongue strike projects to exact coordinates with contact adhesion and retraction.Gemini 4's Jenga Tower — the standout artifact under gemini-4/: a true WebGL/Three.js 3D scene with OrbitControls, directional lighting, and wooden-block texturing; rigid-body physics via Cannon.js (collision bounds, friction, mass distribution, collapse dynamics); and real-time structural load analysis telling which blocks are safe to extract.Models are ranked chronologically by release: Gemini 4 (Sep 30 — Oct 13, 2026), DeepSeek-V4 (Jul 31 — Oct 17), Qwen 3.8 Max (Jul 19 — Aug 3), Kimi 3 (Jul 16 — 27).Try the live demo — the Jenga tower simulator runs fully in the browser.
  • GrantLoom — AI Grant Intelligence & Compliance Appliance

    pythonfullstackaibackendtool

    A self-hosted RAG appliance for academic research labs: cross-references grant solicitations against institutional documents and answers with citations that resolve to file, page, line, sheet and row coordinates. Four LLM-judged guardrail gates (G1–G4), a bounded rewrite loop with explicit unverified warnings, compliance matrix with Satisfied/Partial/Gap evidence, and a golden-set evaluation harness that reports its own measurement caveats.

    GrantLoom weaves funding solicitations and lab documents into verifiable answers. Ingestion runs through an async SQLite outbox (extract → chunk → two-tier injection scan → embed → index into ChromaDB vectors, FTS5 keywords, spreadsheet tables and a KùzuDB knowledge graph), with content-hash dedup, versioning, quarantine and a deletion saga that purges every store.Questions flow through a single agent pipeline — Planner → Retriever → Writer → Validator — streamed as SSE. The writer only emits [chunk_id] markers; the backend resolves them to physical coordinates and an independent judge model (different family, NFR-6) verifies every claim against its cited evidence, driving a bounded rewrite loop. Retrieval fuses dense + BM25 (RRF) with two extra tools: LLM-written SQL over spreadsheet schemas (AST-guarded, results become citable chunks) and graph traversal over extracted entities.The decision layer is a typed DecisionBackendPort: a prompt-based LLM judge primary with a labelled, metered heuristic fallback — degradation is never silent. Deployment is a multi-stage Docker image (non-root, ~230 MB RSS) behind nginx with TLS, unbuffered SSE and per-IP rate limiting, running in public BYOK mode: zero server-side secrets — every visitor's inference runs on their own live-probed OpenRouter key (deepseek-v4-flash writer, gpt-4o-mini judge). Prometheus scrapes custom gate/tool/ingestion metrics.
  • Latch — Zero-Trust Neural PII Pre-Commit Guardrail

    pythonaitoolsecurityobservability

    A 100% local, CPU-native git pre-commit hook running the ultra-compact Julia-1 (144M) decision model to block leaked PII and credentials before they ever leave the laptop — 0% FNR on real secrets, single-digit-ms warm daemon latency, and a live Prometheus + Grafana observability stack.

    Latch (pii-guardrail) is an ultra-fast, 100% local git pre-commit guardrail powered by Julia-1 — a 144.3M-parameter non-autoregressive decision model built on mmBERT-small — that blocks PII (names+phones, addresses, government IDs) and leaked credentials (API keys, tokens, DB passwords) before code leaves the developer's machine.Why it's different: Classic tools rely on rigid regex rules that miss natural-language semantic leaks, while cloud LLMs violate privacy and add multi-second commit latency. Latch runs entirely on the local CPU: zero cloud calls, zero telemetry, zero data exfiltration.Architecture highlights:
    - Warm daemon + client — a loopback HTTP daemon keeps Julia-1 warm (~50ms probe), with seamless in-process cold-start fallback; token-authenticated telemetry endpoints (/metrics Prometheus, /v1/stats JSON, protected web dashboard)
    - Fail-closed invariant — missing weights, corrupt tensors, diff-parse failures, or crashes always abort the commit with actionable diagnostics (test suite: test_fail_closed.py)
    - Dissection pinpointing — flags the exact lines and classifications in a diff, not just 'this file is bad'
    - Adversarial hardening — prompt-injection resistance at 100% injection resilience, per-file batching partition, sliding-window chunk overlap against boundary PII
    - 91-test suite — unit tests + live Julia-1 integration, benchmark gates FNR at 0.0%
    Benchmark (CPU): FNR 0.0% (zero missed leaks), FPR 14.3%, injection resilience 100%, mean warm-daemon latency ~1.2s/sample forward pass (forward_ms = 99.5%+ of phase time).Observability: a running Prometheus → Grafana stack visualizes throughput, token counts, phase-by-phase latency percentiles (p50/p90/p99), cache hit/miss, and CPU/RSS saturation — dashboards live while the test suite runs.🎬 Hackathon demo video (silent, 3:00): portfolio.taskmind-ai.com/pii-guardrail-demo.mp4 — opens with the README (problem → solution), then shows Latch blocking a commit containing real PII (Jane Doe + sk-live token), the remediated env-var version being accepted (✓ Latch: Clean (daemon)), and closes on the live Grafana dashboard while tests run — throughput, token counts, and phase-latency percentiles from the Prometheus stack.🎙️ Narration: The 3-minute walkthrough is now produced by Frame Talk — the multimodal screen-to-podcast studio engine. Hosts Alex (Lead Systems Architect) and Sarah (Dev Advocate) deliver a synchronized two-host technical podcast anchored to the actual video frames (Gemini 3.7 Flash vision + Chronos timeline holds). ▶ Watch the narrated version (click Play on the card — the in-page player opens; the file also downloads 7.7MB MP4, H.264+AAC 24kHz)🏆 Hackathon: Submitted to the Devpost AI Hackathon — Latch.
  • Aethelgard Infra-GraphRAG — Tri-Modal Supply Chain Intelligence

    pythonfullstackaiinfrasecurity

    An autonomous Agentic GraphRAG engine for sovereign AI data-center supply chains: unifies a 332-node NetworkX knowledge graph, ChromaDB sovereign-contract vectors, and a SQLite BOM/PO SSOT behind a 6-pattern adaptive intent router, prompt-injection guardrails, ABAC persona clearance, and zero-hallucination citations.

    Aethelgard Infra-GraphRAG (rag6-supply-chain) is a tri-modal sovereign infrastructure & supply-chain intelligence engine that answers operational, legal, and financial questions about AI data-center hardware supply chains — from a Streamlit showcase with 4 workspaces:
    • AI Decision Console — 6 adaptive GraphRAG reasoning patterns (P1 text-to-cypher audits, P2 parallel hybrid, P3 graph-first cascade, P4 table-first comparisons, P5 vector-primary compliance, P6 agentic multi-step crisis loops) with a reflection loop and confidence-scored, footnoted citations
    • Disruption Simulator — 1-click scenario mutation (e.g., Taiwan embargo, vendor restructuring) that re-projects the graph dynamically under CQRS and surfaces procurement backorders from dock_receipts triangulation
    • Knowledge Base Analytics — live PyVis graph visualization + ChromaDB collection metrics
    • Ingestion & Lifecycle — document upload, hashing, version deprecation, and vector re-indexing
    Security & sovereignty: 4 ABAC persona viewpoints (CTO / Procurement / General Counsel / SRE — SRE is blocked from legal clauses), prompt-injection pre/post retrieval guardrails, EU data-residency provider routing, and a deterministic offline fallback mode that keeps the whole demo functional with zero API keys.Stack: Python 3.11, Streamlit, ChromaDB (BGE small embeddings), NetworkX, SQLite SSOT, PyMuPDF, OpenRouter adapter, hexagonal ports & DI registry.Validation: 27/27 pytest suite + 10/10 benchmark RAG queries (faithfulness 0.94, correctness 1.00, citation accuracy 1.00). Hosted on Streamlit Cloud; fully containerized with Docker for self-hosting.
  • JobAgent — Autonomous Career CRM & Statutory Compliance Engine

    pythonfullstackaitoollocal-first

    A local-first, autonomous career dashboard that turns chaotic job hunting into a single intelligent cockpit: 1-click posting archive with Markdown + PDF snapshots, multi-protocol email triage with genuine interview detection (even in German), and automatic Agentur für Arbeit proof reports. Built on the AWS Strands Agents SDK — zero PII leaves your machine.

    JobAgent is an autonomous background agent for job seekers, submitted to the Agents for Humans hackathon (AWS Strands Agents SDK). It turns the chaos of job hunting — expiring postings, scattered emails, hidden interview invites — into a single intelligent cockpit with zero PII leaving the machine.What it does:
    - Dual-asset archiving — 1-click browser extension captures a clean Markdown brief and a pixel-perfect PDF snapshot before the posting disappears
    - 3-tier email triage — deterministic rules → offline ML classifier → Gemini semantic reasoning detects genuine interview invitations (including German 'Einladung zum Vorstellungsgespräch'), filters recruiter spam/webinars, tracks Applied → Interview → Rejected lifecycles
    - Statutory compliance — automatically compiles the official German Agentur für Arbeit proof table (Eigenbemühungsnachweis, §138 SGB III) as print-ready PDF
    - Agent-to-Agent (A2A) & MCP server — Telegram, Claude Desktop, Cursor and other parent agents query and control JobAgent via standard A2A/SSE endpoints
    - 100% local-first — SQLite CRM + local archive; optional Ollama for true zero-cloud inference
    Architecture: Strands Agent Coordinator (Gemini) orchestrating EmailIngestTool → JobArchiveTool → ReportRenderTool over a local SQLite CRM, exposed via FastAPI A2A gateway + MCP and a Chrome Manifest V3 Copilot extension.Quality: 49-test suite (PII/secret scans clean across full git history), adversarial QA pass, DNS-rebinding-guarded loopback gateway.Demo video (2:02, narrated): screencast replayed with Frame Talk's synchronized two-host walkthrough. Code: https://github.com/tdk67/jobagent
  • Frame Talk — Multimodal Screen-to-Podcast Studio Engine

    pythonfullstackaimultimodaltool

    Transforms silent developer screencasts and README docs into synchronized two-host technical podcast walkthroughs — Gemini 3.7 Flash vision reads video pixels, Chronos Sync Engine matches dialogue to UI actions with millisecond precision.

    Frame Talk is the Multimodal Screen-to-Podcast Studio Engine, built for the Agentic Cinema Hackathon. It ingests a raw silent .mp4 screencast plus project README.md, and uses Gemini 3.7 Flash native multimodal comprehension to extract granular visual scenes (UI actions, clicks, terminal logs, state transitions) directly from video pixels — no external transcripts.Pipeline: Ingestion & Alignment Agent → Scriptwriter Persona Agent → QA & Pacing Audit Agent → Chronos Sync Engine (TTS + duration meter + freeze calculator) → Compiler Agent (FFmpeg 1080p stitching with permanent holds).Highlights:
    - Scriptwriter persona agents generate organic two-host dialogue between Mark (Lead Systems Architect) and Sarah (Dev Advocate) with natural turn-taking pauses (180-240ms) and zero synthetic timestamps.
    - Chronos Sync Engine synthesizes every line via gemini-3.1-flash-tts-preview at 24kHz PCM, measuring audio duration to the millisecond (duration_ms = pcm_bytes / 48) and computing required_freeze_ms to hold the video timeline at the focal action — audio and screen never desync.
    - Observability via ClickHouse time-series DB + Grafana dashboard tracking turn_index, audio_ms, freeze_ms, and drift.
    - BYOK — no server-side credentials required.
  • Idea Lint — Adversarial Multi-Agent Venture Validation Engine (FlyRank Capstone)

    pythonaibackendtool

    An impartial AI courtroom for startup ideas — researches with live Google Search grounding, debates across adversarial agents, and outputs an audit-proof, scored PRD. Privacy-first with zero cloud storage and BYOK free-tier support. Google hackathon submission: devpost.com/software/idea-lint

    Idea Lint (formerly VentureBot) is an adversarial, multi-agent venture validation engine built on Google ADK. It takes a raw startup concept and runs it through a panel of specialized agents with deliberately asymmetric information access:
    • Researcher — mines competitor signals and market metrics via live Google Search grounding
    • Creative Ideator — proposes lateral pivot angles
    • Advocate — argues the strongest bull case
    • Critic — red-teams feasibility, moats, and unit economics traps
    • Judge — synthesizes everything into structured 1-10 scores (Novelty, Feasibility, Market Fit) with a PROCEED / PARK / PRUNE verdict
    • PRD Writer + Security Auditor — produce a rigorous, machine-actionable PRD
    V1 was submitted to the Google Gemini Hackathon on Devpost: https://devpost.com/software/idea-lint. For the FlyRank Backend Track Capstone it was re-architected into a production-grade, zero-retention backend: decoupled asynchronous job engine, hardened REST gateway with rate limiting, adversarial agent guardrails, a 161-test deterministic test suite, and browser-local IndexedDB persistence (BYOK). Live demo: https://idea-lint.taskmind-ai.com
Page 1 of 3