AutoClip: Generate highlight clips and short-video compilations from subtitles
A tool that turns interview, podcast, and course subtitles into highlight clips, with local Ollama analysis and CLI/MCP automation.
GitHub zhouxiaoka/autoclip Updated 2026-09-22 Branch main Stars 8.2K Forks 1.6K
Python TypeScript FFmpeg Whisper Ollama Docker CLI/MCP Video editing

🧭 Decision Guide

Try it if you

  • You need to turn interviews, podcasts, courses, or livestream replays into clips in batches
    The README lists interviews, podcasts, courses, and livestream replays, and documents CLI batch orchestration
  • You want to use Ollama and qwen2.5:7b without a cloud API key
    The README states that the Ollama local preset needs no cloud key and uses qwen2.5:7b by default
  • You need a Docker Web interface or an MCP-compatible client to access the processing pipeline
    The README documents localhost:3000, API docs, and autoclip mcp under Docker / Web and CLI / MCP

Skip it if you

  • Your material mainly consists of purely visual action or music videos
    The README FAQ explicitly says current analysis is mainly subtitle-based and may be limited for these videos
  • You cannot accept subtitle text being sent to a cloud model provider
    The README FAQ states that subtitle text is sent to the provider when cloud models are used
  • You require instant customer support or one-to-one deployment assistance
    The README says the project is maintained part-time and provides neither instant support nor one-to-one deployment service

Requirements

  • The CLI requires Python 3.10+ (3.11 recommended) and FFmpeg available in PATH
  • Docker deployment requires Docker and Docker Compose v2
  • Videos without subtitles require faster-whisper and a speech model; Ollama must be started and its model downloaded
  • The desktop release supports Windows 10/11 x64 and provides a macOS Apple Silicon package

First step (verbatim from README)

docker compose up -d --build

Watch out

  • If Docker bind mounts fail with permissions, use root to fix /app/data, /app/logs, and /app/uploads
    The README Docker / Web section provides a docker compose run --rm --no-deps --user root command
  • When generation fails, check subtitles, model connectivity, the score threshold, FFmpeg, and disk space
    The README FAQ lists these checks and mentions lowering the score threshold from 0.7 to 0.5
  • localhost inside Docker is not the host machine; Ollama requires a reachable host address
    The README model configuration section explicitly states that localhost points to the container itself
  • Cloud models analyze subtitles, but downloading videos and models still requires network access
    The README model configuration section says cloud processing sends subtitle text, while video and model downloads still need network access

Not stated in the README

  • The README does not specify supported video codecs, container formats, or maximum video duration
  • The README does not state the minimum CPU, GPU, memory, or disk requirements for Ollama or faster-whisper
  • The README provides no processing-time or output-quality data across models, video lengths, and hardware configurations
  • The README does not specify the fields, default settings, or retention period for analytics and error reports
  • The README does not quantify failure rates or recognition accuracy for YouTube, Bilibili, local videos, or SRT subtitles

💡 Deep Analysis

6
Yes I use Python 3.11 and FFmpeg to batch-process livestream replays and cannot depend on a desktop UI. Can I use the AutoClip CLI to output JSON and then let an MCP client orchestrate Shorts export?
For: A developer processing long livestream replays in batches with Python 3.11 and FFmpeg, who wants to integrate CLI/MCP into an automation pipeline

It is suitable because the README provides a CLI for Python 3.10+ and explicitly supports JSON results, batch orchestration, and a stdio MCP server.

  • The CLI requires Python 3.10+, recommends 3.11, and requires FFmpeg on PATH; local CLI processing does not need Redis.
  • autoclip run ... --json outputs processing results, after which autoclip export PROJECT_ID --preset shorts can export using the project ID.
  • autoclip mcp starts a stdio MCP service, allowing MCP-capable clients to call the same processing pipeline.
  • The README presents the CLI as a batch-orchestration entry point for analysis, clip generation, and platform-preset export.

This meets the constraints of avoiding the desktop UI, retaining machine-readable results, and integrating with an agent. However, the README does not define batch queues, retry behavior, idempotency rules, or resource limits for long videos, so those parts must be designed separately.

  • CLI / MCP: requires Python 3.10+ (3.11 recommended) and FFmpeg on PATH; local CLI processing does not require Redis
  • Quick Start: autoclip run talk.mp4 --provider ollama --json
  • Quick Start: autoclip export PROJECT_ID --preset shorts
  • Quick Start: autoclip mcp; batch orchestration through CLI or invocation of the same pipeline by MCP-capable clients
python -m pip install -e .
Not stated in the README:The README does not state whether the CLI supports native concurrency, job queues, resume, or retries.;It does not specify maximum video duration, maximum file size, or the stability of the JSON schema.
Yes My existing model services use an OpenAI-compatible API and Gemini, and podcast clips must be adapted for Douyin, Xiaohongshu, YouTube Shorts, and Bilibili. Can AutoClip cover both model integration and platform-format export?
For: A podcast producer using OpenAI-compatible APIs and Gemini who needs exports for Douyin, Xiaohongshu, YouTube Shorts, and Bilibili

It is suitable because the project supports OpenAI-compatible APIs, Gemini, and export presets for all four target platforms, including burned-in subtitles and title cards.

  • Model configuration supports Qwen, OpenAI-compatible APIs, Gemini, and SiliconFlow; the OpenAI-compatible option allows a custom Base URL.
  • Export presets explicitly include Douyin, Xiaohongshu, YouTube Shorts, and Bilibili, so platform formatting does not have to be handled by a separate editor.
  • The project derives topic timelines, highlight scores, and clip titles from subtitles, then generates clips and recommended compilations, matching a spoken podcast workflow.
  • The output remains an editable first draft; the README says to review clip boundaries, context, subtitles, title cards, aspect ratio, and platform requirements.

It therefore covers the main path from model invocation to multi-platform draft export, but the README does not establish support for platform publishing APIs, account management, or automatic uploading.

  • Model Configuration: supports Qwen, OpenAI-compatible APIs, Gemini, and SiliconFlow; compatible APIs can configure a Base URL
  • What You Can Do: export presets for Douyin, Xiaohongshu, YouTube Shorts, and Bilibili, with burned-in subtitles and title cards
  • What You Can Do: extracts outlines, topic timelines, highlight scores, and clip titles from subtitles
  • Best Practices: review clip boundaries, context, subtitles, title cards, aspect ratio, and platform requirements before publishing
cp env.example .env
Not stated in the README:The README does not specify the exact resolution, bitrate, frame rate, or duration rules for the four platform presets.;It does not state whether official platform APIs, account authorization, or publication-status callbacks are supported.
Yes I maintain macOS Intel and Linux workstations, already have Docker in the team, and mainly process interviews and podcast recordings. Can AutoClip avoid desktop installers and provide a Web interface and API inside our network?
For: A content producer maintaining macOS Intel and Linux workstations with Docker, who wants to process interview and podcast recordings

It is suitable because the README explicitly positions Docker/Web as the path for Intel Macs and Linux, while exposing both a Web interface and a backend API.

  • The desktop packages are listed only for macOS Apple Silicon and Windows x64; Intel Mac and Linux should use Docker or the CLI.
  • Docker requires Docker Compose v2. After startup, the Web interface is at http://localhost:3000, and API documentation is at http://localhost:8000/docs.
  • The project accepts local videos, YouTube, and Bilibili links, and generates highlights, clips, and compilations for interviews, podcasts, courses, and livestream replays.
  • Video editing runs locally, but subtitle text is sent to the selected provider when a cloud model is used.

It therefore fits an internal browser-based deployment. However, the README does not specify reverse-proxy support, authentication, concurrency limits, or multi-user permissions, so it cannot establish that this is ready to operate as a multi-tenant production platform.

  • Quick Start: Intel Mac / Linux should use Docker or the CLI
  • Quick Start: Web interface at http://localhost:3000; API docs at http://localhost:8000/docs
  • What You Can Do: suitable for interviews, podcasts, courses, and livestream replays
  • Model Configuration: video editing is local; cloud-model analysis sends subtitle text to the selected service
git clone https://github.com/zhouxiaoka/autoclip.git
Not stated in the README:The README does not state whether the Web service includes authentication, authorization, or multi-user isolation.;It does not specify Docker concurrency capacity, reverse-proxy configuration, or the intended network security boundary.
It depends I only have livestream replays without subtitles, use a Windows 10/11 x64 laptop, and do not want to buy cloud API keys. Can AutoClip start with local transcription and perform highlight extraction?
For: A video operator with subtitle-free livestream replays, using a Windows 10/11 x64 laptop, who does not want to purchase cloud API keys

It depends: Windows x64, Ollama/LM Studio, and local Whisper paths are available, but subtitle-free processing adds installation, model-download, and hardware burdens.

  • The README provides a Windows 10/11 x64 installer, with Python and FFmpeg bundled in the desktop application.
  • Without subtitles, faster-whisper and a speech model must be installed; this happens locally, but first transcription can take a long time and is affected by language, accent, and audio quality.
  • Ollama and LM Studio presets do not require a cloud key, but they still require a model and suitable hardware; the README gives no minimum specification for Windows laptops.
  • Analysis is primarily subtitle-based and is intended for spoken interviews, podcasts, courses, and livestream replays; game footage, music, or visually driven streams may be limited.

Thus, it fits the “no cloud key” deployment direction, but suitability for this laptop and stream type depends on local hardware, speech clarity, and the stream’s language structure.

  • Quick Start: Windows 10 / 11 x64; the desktop installer bundles Python and FFmpeg
  • FAQ: without subtitles, prepare the local Whisper component and speech model first
  • FAQ: Ollama / LM Studio local presets do not require a cloud key, but require a model and suitable hardware
  • FAQ: analysis is primarily subtitle-based and suits interviews, podcasts, courses, and spoken content; visually driven or musical videos may be limited
python -m pip install faster-whisper
Not stated in the README:The README does not specify the minimum CPU/GPU configuration or actual transcription speed of faster-whisper on Windows x64 laptops.;It does not specify the combined disk usage or VRAM requirements of the local speech model and local LLM.
It depends I use Ollama with qwen2.5:7b to process course videos containing client information and cannot send subtitles to the cloud. Can AutoClip perform analysis, editing, and Shorts export locally?
For: A knowledge creator using Ollama and qwen2.5:7b who cannot send course subtitles to cloud services

It depends: local models and local video processing are supported, but acceptable analysis quality depends on qwen2.5:7b, subtitle quality, and the machine’s hardware.

  • The README provides an Ollama preset with default address http://localhost:11434/v1, default model qwen2.5:7b, and no cloud API key requirement.
  • Video editing is performed locally; with local Ollama, the README does not require subtitles to be sent to a cloud provider.
  • Videos without subtitles require faster-whisper and a downloaded speech model, adding local compute, download, and storage requirements.
  • The CLI can produce JSON results with --json, followed by export using the Shorts preset; however, local-model hardware requirements, speed, and quality floor are not quantified.

Thus, it fits the “data stays on the machine” architecture constraint, but that does not guarantee stable course-content understanding or cloud-level semantic quality.

  • Model Configuration: Ollama defaults to http://localhost:11434/v1 and qwen2.5:7b, with no API key required
  • FAQ: local editing is performed on your device
  • Quick Start: videos without subtitles require faster-whisper and the speech model is downloaded on first transcription
  • Quick Start: autoclip run talk.mp4 --provider ollama --json; autoclip export PROJECT_ID --preset shorts
ollama pull qwen2.5:7b
Not stated in the README:The README does not report qwen2.5:7b accuracy or throughput across subtitle lengths, languages, and hardware.;It does not state whether the local model handles course-specific terminology, speaker separation, or complex context.
It depends I need to integrate a tool into an MIT-licensed open-source workflow for client interviews and courses. The UI must support Chinese, English, Japanese, and Korean, and sensitive subtitles should preferably stay local. Does AutoClip meet these constraints?
For: An integrator maintaining an open-source toolset for client interviews and courses, requiring an MIT license, multilingual UI, and data-compliance controls

It depends: the license and multilingual UI meet the stated requirements, and local editing plus local models can reduce data transfer, but subtitles leave the machine when a cloud model is selected.

  • Project data identifies the license as MIT, and the README explicitly describes AutoClip as free and open source under MIT, making it suitable as part of an open-source workflow.
  • Since v1.3.1, the interface, website, and README support Chinese, English, Japanese, Korean, Spanish, Portuguese, Russian, and French; user materials and generated content retain their original language.
  • Local video editing runs on the device, and Ollama and LM Studio are available as local-model options, enabling a lower-transfer workflow.
  • However, cloud-model use sends subtitle text to the provider, and active publishing sends video to the target platform.

Thus, it meets the product constraints of “MIT + multilingual + locally deployable processing,” but cannot guarantee that sensitive data stays local when cloud models or platform uploads are used. The README also warns that translated README languages do not define transcription-model or material-language support.

  • Project data: license is MIT License
  • README: since v1.3.1, the product UI, website, and README support Chinese, English, Japanese, Korean, Spanish, Portuguese, Russian, and French
  • FAQ: local editing is performed on the device; cloud-model use sends subtitle text to the provider
  • Documentation: README translation languages do not represent application UI or transcription-model language support
Not stated in the README:The README does not describe the license combination of third-party model, FFmpeg, Whisper, and frontend dependencies beyond the project’s MIT license.;It does not provide the actual language list for each transcription model, data-retention periods, or compliance certifications of cloud providers.

✨ Highlights

  • Supports local videos, YouTube, Bilibili, and SRT subtitle import
  • Can run the qwen2.5:7b model locally through Ollama
  • Provides desktop, Docker Web, and CLI/MCP interfaces
  • Supports export presets for Douyin, Xiaohongshu, and YouTube Shorts

🔧 Engineering

  • AI extracts outlines, topic timelines, highlight scores, and clip titles from subtitles
  • FFmpeg automatically creates clips and compilations with subtitles and title cards
  • Use autoclip run and autoclip mcp for batch workflows and MCP clients

⚠️ Risks

  • Analysis is mainly subtitle-based, so purely visual or music videos may perform poorly
  • Cloud models send subtitle text to the selected provider and may incur charges
  • Videos without subtitles require faster-whisper and a speech model download on first transcription
  • When Docker accesses a host model service, localhost points to the container itself
  • The project is maintained part-time, with no fixed response time or instant support

👥 For who?

  • Content teams processing interviews, podcasts, courses, or livestream replays
  • Developers using Python 3.10+, FFmpeg, and local Ollama models
  • Engineers needing Docker Web, CLI batch processing, or MCP automation