Distill: AI Video-to-Knowledge Engine

AI that turns long videos into summaries, structured notes, and mind maps — so students can review a 3-hour lecture in 10 minutes. Live in production at wd-ai.cloud.

Comment

Inspiration

Exam-prep students in China routinely face 3-hour lecture videos on Bilibili and Douyin. Tools like NotebookLM serve YouTube and English content — China's 200M+ exam-prep learners have nothing equivalent. Watching at 2x speed still wastes time, and nothing gets retained as reviewable notes. I built Distill to turn passive video watching into structured, reusable knowledge assets — transcripts, summaries, documents, and mind maps.

What it does

Paste a Bilibili video link, or just paste raw text directly, and Distill:

  1. Downloads and transcribes the video audio automatically (Bilibili ingestion built this hackathon)
  2. Generates an adaptive-structure summary and a structured study document via LLM
  3. Renders a Mermaid mind map for visual review
  4. Compares multiple LLMs side by side — two models generate in parallel; an independent judge model evaluates both and picks the better output, with scores shown to the user

A 7-minute Bilibili lecture — from URL to summary, study notes, and mind map — in under 60 seconds.

The product is live at https://wd-ai.cloud.

How we built it

Built entirely solo — full-stack development, DevOps, prompt engineering, and product design by one person over the hackathon period.

  • A multi-model LLM orchestration layer: DeepSeek and Kimi generate in parallel on the same transcript, with Doubao acting as an independent judge that scores both outputs on coverage, structure, and factuality before picking a winner
  • End-to-end Bilibili ingestion pipeline: paste a video URL, and the system downloads the audio (yt-dlp), transcribes it via a cloud ASR API (SiliconFlow, running the SenseVoiceSmall model), and feeds the transcript straight into the LLM router — no manual transcript copy-pasting required
  • A Next.js 15 (App Router) frontend with TypeScript, covering both direct-text input and URL-based ingestion in a single interface
  • All three models run through a single unified gateway (Volcano Ark), differentiated only by model parameter — simplifying key management for a solo-maintained project
  • Deployed on a dedicated server via Docker Compose

Challenges we ran into

  • Silent data corruption from an unstable CDN edge: our video-to-audio pipeline would occasionally report a successful download — correct exit code, plausible file size — while the actual audio was a truncated 5-second stub instead of the full lecture. The failure mode wasn't a crash; it was confidently wrong data. We added a post-download duration check (via ffprobe) with an automatic retry that deliberately switches download strategy on each attempt, plus explicit cache invalidation so retries don't just re-serve the same bad file. The bigger lesson: "the process exited 0" is not the same guarantee as "the data is correct," and any pipeline ingesting third-party media needs a validation step that's independent of the tool's own success signal.
  • Mermaid rendering reliability: LLMs love generating invalid graph syntax. Constraining output to a strict tree structure dramatically reduced render failures.
  • Prompt structure vs. content diversity: forcing a fixed What/Why/How template degraded quality on general-purpose videos; we switched to adaptive structuring based on content type.

What we learned

Shipping an AI product solo means the bottleneck is rarely the model — it's orchestration, output reliability, and the unglamorous edges of third-party integrations. The hardest bugs weren't in our own logic; they were in trusting that an external system (a CDN, a download tool's caching behavior) did what it claimed. Building defensively — validating outputs instead of just trusting exit codes — turned out to matter more than getting the LLM prompts exactly right on the first try. Prompt engineering is empirical: measure, don't assume.

What's next

  • Asynchronous processing with progress streaming (the current pipeline is synchronous HTTP, which works for short clips but won't scale to hour-long lectures without queuing)
  • Two-tier LLM caching (exact-match + semantic cache) to cut inference costs
  • Observability stack: structured logs → metrics → distributed tracing
  • WeChat Mini Program login for the Chinese market
  • Migrating the LLM orchestration logic into a visual workflow engine (n8n) for easier extensibility

Built With

Share this project:

Updates

Submission history