Erfan Salehi.

Editors making video-heavy content — tutorials, documentaries, product explainers — burn hours hunting stock sites for B-roll: searching, downloading, renaming files, and hand-building text-overlay graphics. For recurring topics the same clips get found and re-downloaded across projects, wasting time and API quota. B-Roll Finder automates the entire search-and-select loop, and gets faster with every project by remembering the footage you've already used.

• Transcribe — Whisper (via Groq) turns the voiceover into a timestamped transcript, chunked at sentence boundaries to respect API limits.
• Direct — an LLM "director" reads the script and produces a structured shot list: timing, visual intent, shot type, and 2–3 search queries per shot. A context-aware pre-pass anchors queries to the subject in play at each timestamp, so "the transmission is jerky" searches for that car's gearbox, not a generic one.
• Fetch — queries fan out in parallel across Pexels, Pixabay, YouTube, and your own clip library.
• Rank — an LLM-as-Judge scores every candidate against the narration and hides off-topic clips, batched and rate-limit-aware so large projects don't trigger 429 storms.
• Auto-select — optionally binds the best clips to each shot, scaled to its length, with a variety guard so visuals never repeat back-to-back.
• QA — an AI "executive producer" reviews the whole selected timeline in one reasoning pass and flags pacing problems, repeated visuals, or clips that don't match the script.
• Export — generates animated on-screen text overlays with matched sound effects, then writes an FCP7 XML that drops straight into Premiere Pro, plus the shot list and an SRT.

• Custom AI orchestration — the whole pipeline runs on a hand-built orchestration layer: a typed state object flows through each stage, validation gates enforce a coherent timeline at every boundary, and a human-in-the-loop review gate persists across sessions. It's the same agent state-machine pattern that frameworks like LangGraph provide — built from scratch for full control over retries, multi-provider fallback, and exactly where a human steps in.
• AI evaluation, end to end — model output is never trusted blindly. An LLM-as-Judge scores and filters every footage candidate against the narration, and a separate "executive producer" pass evaluates the whole assembled timeline for coherence and pacing — automated evaluation and quality gating baked directly into the pipeline.

• Self-improving clip library — every confirmed clip is embedded into a local SQLite + vector store. On the next project a semantic (RAG) search surfaces your own footage first — no quota, no network, no re-downloading. Teams on separate machines can pool libraries by exporting and merging small metadata bundles; the videos never travel.
• Learns your cuts — re-import a finished Premiere XML and it records how you actually trimmed each clip, then suggests that proven trim the next time the clip is reused.
• Run it from your phone — the same pipeline runs headless behind a Telegram bot. Send a voice note from anywhere and by the time you reach your desk the project is downloaded, graded, and waiting in Premiere.
• Resilient & cost-aware by design — runs on free LLMs by default with an optional paid tier, a multi-provider fallback chain (DeepSeek → Groq → OpenRouter), and per-video API cost tracking.
• Fully automatic mode — one click drives transcribe → shot list → fetch → rank → auto-select → QA, then stops for review — or downloads too, hands-off.

This is my favorite thing I've built — a genuinely agentic product, not a demo. It orchestrates transcription, multiple reasoning LLMs, parallel web search, retrieval, and AI-driven evaluation into one tool that exports a real Premiere project — collapsing hours of tedious editing into a single click, and compounding in value the more you use it. It's the project where product thinking and hands-on engineering meet: every feature exists because it removes a real, repeated pain from a real workflow.

Cardiovascular diseases are the leading cause of death globally. Early diagnosis via ECG is critical but requires specialized expertise. I built an end-to-end deep learning pipeline to classify ECG signals into 5 diagnostic superclasses: Normal, Myocardial Infarction, ST/T Change, Conduction Disturbance, and Hypertrophy.

• SE-ResNet architecture with Squeeze-and-Excitation blocks for lead-wise attention across all 12 ECG leads
• Custom data pipeline with bandpass filtering, Z-score normalization, and stratified splitting on PTB-XL (21,799 records)
• Mixup augmentation to generate synthetic training samples and Focal Loss to address heavy class imbalance
• Ensemble of baseline + Focal Loss variants for state-of-the-art multi-label performance
• External validation on Chapman-Shaoxing dataset (10,646 records) to test generalization

This project sits at the intersection of AI and real clinical impact. The ensemble approach achieved 0.932 Macro-AUC on the PTB-XL test set, with strong external generalization (0.844 AUROC). It demonstrates how thoughtful architecture choices and training techniques can meaningfully close the gap between AI models and clinical-grade tools.

Manual review of cervical cytology images is time-consuming and subjective. Automating the classification of cells into normal, dysplastic, and malignant categories can significantly improve the efficiency and consistency of pap smear screenings.

• End-to-end data pipeline for the SIPaKMeD dataset including preprocessing and augmentation.
• Deep learning classification model using ResNet/EfficientNet backbones for 8-class categorization.
• Explainable AI (XAI) integration utilizing Grad-CAM to highlight regions of interest for clinical transparency.
• Production-ready REST API built with FastAPI, supporting batch processing and real-time inference.
• Dockerized deployment setup with GPU acceleration support for scalable production use.

Localizing video for a new market means re-voicing it in another language, getting captions to match the new audio and script correctly — including right-to-left languages — and often cutting the result down into shorts for distribution. That chain normally runs across separate tools with no shared pipeline. I built Tovo to run dub, caption, and clip as one paste-and-go desktop app.

• Voiceover — AI dubbing & voice cloning — batch-routes clips to the right trained RVC voice by filename, auto-shortens unnatural pauses so the dub reads naturally, and runs a local GPU-accelerated Mangio-RVC pipeline to convert clips into a target voice — the core re-voicing step of the pipeline.
• Transcription, Sync SRT & Auto-Caption — a single Groq cloud Whisper engine transcribes source audio, re-times existing subtitles against the new dub track, or generates fresh captions from scratch, with styled `.ttml` export for editorial delivery.
• RTL-correct captions — burned-in captions render as custom overlays rather than standard subtitle rendering, specifically so Persian/Arabic text shapes and reorders correctly on screen — a detail most caption tooling gets wrong.
• Shorts — AI highlight detection — an OpenRouter LLM reads a timed transcript and picks the most compelling clip ranges for distribution, then renders vertical 9:16 or lossless 16:9 cuts automatically.
• Batch downloads & Premiere-ready output — paste alternating title/link lines to queue a whole source batch, merging best video + audio into a single H.264/AAC MP4 ready for the editing timeline.
• Zero-config bootstrap & bot-detection bypass — auto-installs yt-dlp, FFmpeg, and Deno on first run; optional cookies, proxy routing, and alternate player clients keep sourcing reliable at volume.

• RVC voice conversion — a local Mangio-RVC-v23.7.0 install clones a target voice onto source clips entirely on-device, GPU-accelerated with automatic CPU fallback.
• Groq cloud Whisper (whisper-large-v3) — the single transcription engine behind Transcription, Sync SRT, Auto-Caption, Shorts, and Voiceover title extraction; one fast, consistent engine, no offline fallback to maintain.
• OpenRouter LLM — reads a plain-text timed transcript (never audio or video) and returns the best Shorts clip ranges and titles as JSON, keeping highlight selection fast and cheap.

Tovo is the tool I actually use — a polished native GUI wrapped around powerful CLI and AI engines so re-voicing, captioning, and clipping a video for a new market doesn't mean touching a terminal or juggling five disconnected tools. It's a hands-on study in productizing an AI dubbing pipeline: voice cloning, cloud transcription, and LLM-driven clipping orchestrated into one resilient, human-in-the-loop workflow that handles the real edge cases — RTL captions, format merging, bot walls, missing binaries — so the person doing the dub doesn't have to.

Internal support teams drown in repetitive IT and HR tickets — VPN password resets, PTO policy questions, holiday calendars — that are already answered somewhere in company documentation. Each one still costs a human a context-switch. The hard part isn't answering the easy questions; it's knowing which questions an AI shouldn't answer, and getting those to the right person fast.

• Ingest — internal policy docs are chunked and embedded into a Chroma vector store with a local sentence-transformer model, so nothing leaves the machine.
• Retrieve — each employee question runs a semantic search over the policy base, pulling the top-k most relevant passages as grounding context.
• Guardrail — a relevance threshold on the retrieval score decides whether the copilot is confident enough to answer. Below the bar, it skips the LLM entirely and escalates — the core product decision of the whole system.
• Resolve or route — in-domain questions get exact, doc-grounded steps from a local LLM under a strict no-hallucination prompt; everything else is handed to the correct human queue (e.g. the IT Security Jira queue).

This started as a PRD, not a notebook. The defining product call was the confidence guardrail: an enterprise support bot that confidently invents a VPN procedure is worse than no bot at all. By measuring retrieval relevance and routing low-confidence queries to humans, the copilot is trustworthy by construction — it only speaks when the docs back it up, and gracefully hands off when they don't. That "know when to defer" behavior is what makes it deployable inside a real org.

Aortic stenosis is a life-threatening narrowing of the aortic valve. Accurately predicting blood flow in stenosed arteries is critical for non-invasive diagnosis — but only if the turbulence model captures the complex post-stenotic flow separation and pressure recovery. This study benchmarked five turbulence models against PC-MRI data to find the most accurate approach.

• Simulated blood flow through an 87% stenosed aorta in ANSYS Fluent 2019, using PC-MRI–derived boundary conditions (flow rate 130 mL/s, Re ≈ 1570)
• Compared k–ε (Standard, Realizable) and k–ω (Standard, SST, GEKO) turbulence models against velocity and pressure profiles reconstructed from PC-MRI imaging
• Calibrated the GEKO separation parameter C_sep = 0.82 to minimize post-stenotic pressure deviation — a novel application of this parameter to hemodynamic simulation
• Analyzed wall shear stress distributions and recirculation zones across all models to assess clinical risk indicators for plaque rupture and secondary lesion formation

• Calibrated GEKO achieved <11% velocity error — significantly lower than comparable CFD–PC-MRI studies in the literature (errors up to 61% reported elsewhere)
• k–ε models predict higher WSS at the throat (rupture risk), while k–ω models predict larger recirculation zones (secondary lesion risk) — clinically distinct risk profiles
• Post-stenotic pressure deviation reached zero at exactly one vessel diameter downstream with C_sep = 0.82

Yaghoubi S., Salehi E., Kermani S., Jahangiri M. “Computational Analysis of Turbulent Blood Flow in Stenosed Aorta Using Modified k–ω Geko Model.” Submitted to Journal of Engineering, June 2026.

Keeping a steady cadence of SEO/GEO-optimized blog content live is a standing content-ops job: researching topics that won't cannibalize existing coverage, drafting and fact-checking articles, sourcing images, getting confident work onto the storefront — and, the part most pipelines skip, going back to fix posts that are actually losing traffic. I built this pipeline to run that whole loop using its own published performance data (Search Console, GA4) to decide what to write next and what to rewrite, with a human still in the loop via Linear for anything the QA stage isn't confident about.

• Calendar graph (weekly) — imports the store's existing posts so dedup can see them, researches new topics against a niche and (optionally auto-derived) seed keywords, dedupes with exact and semantic matching, assigns publish dates per cadence, and opens a Linear issue per new topic.
• Article graph (per due entry) — outlines, drafts, SEO/GEO-optimizes, generates or placeholders images, and QA-checks each article. Confident, QA-clean articles publish straight to Shopify and their Linear issue moves to Done; everything else — low confidence, a review/block verdict, or no Shopify configured — syncs to Linear instead for a human to review and publish by hand.
• Refresh graph (weekly) — ranks live posts by absolute search impressions lost, rewrites the worst-decaying one, and writes it back to Shopify in place, snapshotting the previous body first and refusing to publish if the rewrite drops an image or link.
• Checkpointed & resumable — every run is checkpointed to Postgres in production (SQLite locally), so a draft sitting in Linear can be reviewed days later without re-running anything.
• CLI-first & cron-driven — a full CLI (run-calendar, run-daily, run-refresh, import-existing, sync-performance, status, report) drives all three graphs, with GitHub Actions crons for the weekly calendar, daily publish, and weekly refresh — plus an optional WhatsApp trigger for on-demand runs.

• LangGraph orchestration — three graphs (Calendar, Article, Refresh) with Postgres/SQLite checkpointing, so a long-running pipeline with a human-review step survives restarts and resumes exactly where it left off.
• Per-stage model routing via Google AI Studio — each stage is pinned to a different Gemini model on purpose: AI Studio's free tier rate-limits per model, so spreading research, outline, drafting, SEO, and QA across separate models multiplies the effective daily budget instead of every stage fighting over one model's cap; images route through OpenRouter to a separate provider. LangSmith traces every call.
• Evidence-driven, not just rubric-driven — a GEO-focused SEO rubric (chunking, statistics, pull-quotes, named sources, per Aggarwal et al.'s Generative Engine Optimization study) drives new drafts, while real Search Console/GA4 data — not a static rubric — decides which live posts have actually decayed and need a rewrite.

This is a real production content-ops pipeline, not a demo — three-graph LangGraph orchestration, per-stage model routing that spreads free-tier quota instead of fighting over one model's cap, and a confidence-gated publish path that keeps a human in control via Linear for anything the pipeline isn't sure about. It also closes a loop most content pipelines never build: it measures its own articles' real search performance and rewrites the ones actually losing traffic, instead of only ever producing new content. Both Shopify and Linear degrade gracefully — the whole thing runs Linear-only with no Shopify credentials at all — the kind of platform thinking that scales past a single store.