AdobePremiereProMCP
🎬 AI-powered MCP server for Adobe Premiere Pro — 1,027 tools for timeline editing, color grading, audio mixing, effects, export & more. Control video editing with natural language via Claude, GPT, or any AI assistant. The most comprehensive MCP server for any NLE.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/ayushozha--adobepremierepromcp)HTML
<a href="/listings/ayushozha--adobepremierepromcp"><img src="/api/listings/ayushozha--adobepremierepromcp/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
# Clone the repository git clone https://github.com/ayushozha/AdobePremiereProMCP.git cd AdobePremiereProMCP # Copy env template cp .env.example .env # Install dependencies just install # Generate protobuf stubs just proto # Build all components just build # Run tests just test # Install the CEP panel into Premiere Pro just install-panel
Those commands use a POSIX shell. Native Windows users should follow the platform-specific build/start commands in [`docs/USER_MANUAL.md`](docs/USER_MANUAL.md#windows-native-setup); the current `PremierPro.bat` is a fail-fast CLI launcher, not a service supervisor.
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
README.md · README · 350 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- # PremierPro MCP Server -- AI-Powered Video Editing for Adobe Premiere Pro
- [](https://opensource.org/licenses/MIT)
- [](https://github.com/ayushozha/AdobePremiereProMCP/pulls)
- [](https://www.adobe.com/products/premiere.html)
- [](https://modelcontextprotocol.io)
- [](https://github.com/ayushozha/AdobePremiereProMCP/stargazers)
- **An open-source MCP server for Adobe Premiere Pro.** Automate supported timeline, media, audio, effect, caption, graphics-template, and export workflows through Claude, GPT, or another [Model Context Protocol](https://modelcontextprotocol.io) client.
- > Give it a script and your footage, review the proposed edit, then let it assemble a recoverable rough cut on a duplicated sequence.
- ```
- "Edit this 5-minute video using script.pdf with the footage in /media/"
- ```
- The server can parse a script, scan media, generate an edit decision list, and assemble a Premiere Pro timeline. Mutations are checked with timeline/DOM readback where the host API exposes it.
- ---
- ## Why This Exists
- Video editors spend hours on repetitive tasks: syncing clips, rough cuts, color matching, audio leveling, exporting variants. This MCP server turns Adobe Premiere Pro into an AI-controllable tool, so you can describe edits in plain English and let your AI assistant execute them.
- **No separate MCP subscription. Local CEP bridge. Fully open source.**
- ## Capabilities and Verification Boundary
- The source registry contains **1,066 MCP tool schemas** backed by **935 literal host command names**. The default `standard` profile exposes **74 curated, readback-first tools**, which fits common model function limits and covers normal editing work. The full registry remains available for compatibility and specialist use; schema or symbol presence is not proof that a command works in every Premiere version.
- The curated surface includes:
- - Project/timeline inspection, sequence versioning, import, placement, trim, ripple, markers, and export.
- - Rust-backed media probe, thumbnail, waveform, silence, scene, and asset-scan operations.
- - Script parsing, asset matching, EDL generation, and pacing analysis.
- - Caption-track creation from validated SRT with count readback.
- - Installed-effect and transition discovery, application, and public-DOM readback.
- - [12 native transition recipes](docs/native-transition-recipes.md), with dry-run checks, sequence copies, and exact cut/duration readback.
- - MOGRT-based titles, social derivatives, proxy workflows, and batch-delivery recipes.
- The audited caption, transition, effect, and graphics-template routes return
- explicit `unsupported` errors when Premiere cannot perform and read back the
- requested mutation. The broader compatibility catalog still contains legacy
- and experimental handlers that have not completed the same audit, so it must
- not be treated as a certified surface. Arbitrary script, shell, URL, clipboard,
- external-editor, and file-I/O tools are hidden unless `unsafe` is selected. A
- real Premiere session is still required to certify host mutations on a
- particular OS/Premiere build.
- ## Supported Premiere Pro Versions
- | Version | Year | Support |
- |---|---|---|
- | 14.x | 2020 | Manifest target; live matrix pending |
- | 15.x | 2021 | Manifest target; live matrix pending |
- | 22.x | 2022 | Manifest target; live matrix pending |
- | 23.x | 2023 | Manifest target; live matrix pending |
- | 24.x | 2024 | Manifest target; live matrix pending |
- | 25.x | 2025 | Primary development target; live matrix pending |
- | 26.x | 2026 | 26.5.2: 8 core CEP workflows tested on macOS arm64; broader matrix pending |
- The CEP bridge targets **macOS** and **Windows** and declares Premiere Pro 14.0+ in its extension manifest.
- The manifest range is not a live compatibility certification. Run the host smoke workflow against your exact Premiere build before trusting project mutations.
- Help us expand compatibility -- [report your setup](https://github.com/ayushozha/AdobePremiereProMCP/issues/4).
- ## Architecture
- Four languages, each playing to their strengths:
- ```
- CLI / MCP Client (Claude, GPT, any AI)
- | stdio / JSON-RPC
- v
- +-------------------------------------+
- | Go -- MCP Server & Orchestrator |
- | Protocol handling . Concurrency |
- | Service mesh . Health & recovery |
- +------+------------+------------+-----+
- | gRPC | gRPC | gRPC
- v v v
- +------------+ +----------+ +----------------+
- | Rust | | Python | | TypeScript |
- | Media | | Intel | | Premiere Pro |
- | Engine | | Layer | | Bridge |
- +------------+ +----------+ +-------+--------+
- | CEP / ExtendScript
- v
- Adobe Premiere Pro
- ```
- | Language | Role | Why |
- |---|---|---|
- | **Go** | MCP server, orchestration | Goroutines for concurrency, fast startup, low memory |
- | **Rust** | Media processing | Raw performance for scanning, indexing, waveform analysis |
- | **Python** | Edit intelligence | Deterministic script parsing, asset matching, EDL generation, pacing analysis |
- | **TypeScript** | Premiere Pro bridge | Native access to Adobe's ExtendScript/CEP DOM |
- Full architecture diagram: [`docs/architecture.md`](docs/architecture.md)
- ## Project Structure
- ```
- AdobePremiereProMCP/
- +-- go-orchestrator/ # Go -- MCP server & task orchestrator
- | +-- cmd/server/ # Entry point
- | +-- internal/ # Core packages
- | | +-- mcp/ # MCP protocol handler (1,066 registered schemas)
- | | +-- orchestrator/ # Task orchestration
- | | +-- health/ # Health checks
- | | +-- grpc/ # gRPC client/server
- | +-- configs/ # Configuration files
- |
- +-- rust-engine/ # Rust -- Media processing engine
- | +-- src/
- | +-- media/ # Media probe & metadata
- | +-- assets/ # Asset indexing & fingerprinting
- | +-- waveform/ # Waveform & silence detection
- | +-- thumbnails/ # Thumbnail generation
- |
- +-- python-intelligence/ # Python -- AI intelligence layer
- | +-- src/
- | | +-- parser/ # Script parsing & NLP
- | | +-- edl/ # Edit Decision List generation
- | | +-- matching/ # Shot-to-asset matching
- | | +-- analysis/ # Pacing & timing analysis
- | +-- tests/
- | +-- models/ # ML model configs
- |
- +-- ts-bridge/ # TypeScript -- Premiere Pro bridge
- | +-- src/
- | +-- extendscript/ # ExtendScript API layer
- | +-- cep/ # CEP Panel bridge (primary)
- | +-- standalone/ # Node.js fallback bridge
- | +-- timeline/ # Timeline operations
- |
- +-- cep-panel/ # CEP Panel -- Premiere Pro extension
- | +-- src/
- | +-- assets/
- | +-- CSXS/ # Adobe extension manifest
- |
- +-- proto/ # Shared protobuf definitions
- +-- docs/ # Documentation
- +-- scripts/ # Build & setup scripts
- +-- Justfile # Unified build system
- +-- .env.example # Environment template
- ```
- ## Prerequisites
- - [Go](https://go.dev/) 1.26.1+
- - [Rust](https://rustup.rs/) 1.85+
- - [Python](https://python.org/) 3.12+
- - [Node.js](https://nodejs.org/) 20+
- - [just](https://github.com/casey/just) (command runner)
- - [buf](https://buf.build/) (protobuf toolchain)
- - `rsync` (generated-client synchronization on macOS/Linux)
- - [FFmpeg](https://ffmpeg.org/) (media processing)
- - Adobe Premiere Pro (2020 or later)
- ## Quick Start
- ```bash
- # Clone the repository
- git clone https://github.com/ayushozha/AdobePremiereProMCP.git
- cd AdobePremiereProMCP
- # Copy env template
- cp .env.example .env
- # Install dependencies
- just install
- # Generate protobuf stubs
- just proto
- # Build all components
- just build
- # Run tests
- just test
- # Install the CEP panel into Premiere Pro
- just install-panel
- ```
- Those commands use a POSIX shell. Native Windows users should follow the
- platform-specific build/start commands in
- [`docs/USER_MANUAL.md`](docs/USER_MANUAL.md#windows-native-setup); the current
- `PremierPro.bat` is a fail-fast CLI launcher, not a service supervisor.
- ## Usage
- ### As an MCP Server (Claude Code, Claude Desktop, Cursor, etc.)
- Add to your MCP client configuration:
- ```json
- {
- "mcpServers": {
- "premiere-pro": {
- "command": "./go-orchestrator/bin/premierpro-mcp",
- "args": ["--transport", "stdio"]
- }
- }
- }
- ```
- The complete tool catalog is returned in cursor-paginated pages of 100 by
- default. MCP clients should continue requesting `tools/list` with the returned
- cursor until `nextCursor` is absent. Set `MCP_PAGE_SIZE` to tune the page size.
- The default `standard` profile keeps the normal editing surface small enough
- for model tool limits. Set `MCP_TOOL_PROFILE` to `core`, `dialogue`, `captions`,
- `social`, `transitions`, `effects`, `proxies`, `delivery`, `standard`, or a
- comma-separated combination. Specialized profiles always include core
- inspection and duplicate-sequence recovery tools. `all` exposes the safe full catalog; arbitrary
- script, shell, URL, and file-I/O tools additionally require `unsafe` (for
- example `MCP_TOOL_PROFILE=all,unsafe`) and should only be used with trusted
- prompts and explicit human review.
- ### Workflow Skills
- Seven reusable Agent Skills live in [`skills/`](skills/): dialogue cutting,
- captions, social reframing, transition recipes, look/effect chains, proxy
- conform, and batch delivery. Mutation skills preserve an untouched duplicate
- sequence (or a tool-created derivative) as the recovery boundary and require
- readback verification. Timeline snapshots and saved sequence versions are
- audit/comparison records, not whole-sequence rollback points. The same catalog is available to MCP clients through
- the `config://workflow-skills` resource.
- The sources evaluated, patterns adopted, and integrations intentionally left
- out are recorded in [`docs/workflow-research.md`](docs/workflow-research.md).
- The exact test matrix and remaining host boundaries are recorded in
- [`docs/repository-audit-2026-08-05.md`](docs/repository-audit-2026-08-05.md).
- ### Via CLI
- ```bash
- # Start the server
- just go-run
- # Or run directly
- ./go-orchestrator/bin/premierpro-mcp --transport stdio
- ```
- ### Platform Launchers
- Platform-specific CLI launchers are included:
- - **macOS:** `./PremierPro.command` starts the three backends, installs the CEP
- panel if needed, waits for readiness, and launches the CLI.
- - **Linux/Unix:** `./PremierPro.sh` starts the three backends, waits for
- readiness, and launches the CLI. Premiere/CEP itself must run on macOS or
- Windows.
- - **Windows:** `PremierPro.bat` prepares the Node/Go CLI and launches it. Start
- the Rust, Python, and TypeScript services separately and install the panel
- with `scripts\install-cep-panel-win.bat`; full Windows supervision is not yet
- implemented by the batch launcher.
- ### CEP Bridge Security and Docker
- The CEP panel accepts authenticated WebSocket connections only on loopback.
- On first start, the Go orchestrator, TypeScript bridge, or panel creates a
- shared token at `~/.premierpro-mcp/cep-token`. It authenticates both the
- Go-to-TypeScript gRPC hop and the TypeScript-to-CEP WebSocket hop. To override
- it, set `BRIDGE_CEP_TOKEN` or `MCP_CEP_TOKEN` consistently, or point all three
- processes at the same file with `PREMIERE_MCP_TOKEN_FILE`.
- Because Premiere Pro and its CEP panel run on the host, do not run the
- TypeScript bridge solely inside Docker: a container cannot reach the panel's
- loopback-only WebSocket. The supported live-editing layout keeps the Go
- orchestrator and TypeScript bridge on the host; Docker Compose runs only the
- Rust and Python analysis backends.
- Before `docker compose up`, set `PREMIERE_MEDIA_ROOT` to the narrowest absolute
- directory containing the input media and `PREMIERE_OUTPUT_ROOT` to an absolute
- writable output directory. Compose mounts each directory at the identical
- container path, so file paths sent over gRPC remain meaningful on both sides.
- The input mount is read-only. Service-specific Docker targets avoid building a
- duplicate all-language runtime for each analysis backend.
- The SSE transport also binds to `127.0.0.1` by default. It has no application-
- level authentication, so do not set `MCP_SSE_HOST` (or `--host`) to a public or
- LAN interface unless an authenticated TLS reverse proxy protects it.
- ## How It Works
- 1. **You send a prompt** -- "Edit this video using the script with footage from /media/"
- 2. **Go orchestrator** receives the MCP tool call and fans out:
- - **Rust engine** scans `/media/`, indexes all assets (codec, duration, resolution, waveforms)
- - **Python intelligence** parses the script, generates an Edit Decision List, matches shots to assets
- 3. **Go merges results** and sends the EDL to the TypeScript bridge
- 4. **TypeScript bridge** executes in Premiere Pro -- creates the sequence,
- places clips, and applies supported transitions and graphics templates
- 5. **Premiere Pro renders** the final output
- ## Build Commands
- | Command | Description |
- |---|---|
- | `just build` | Build all components |
- | `just test` | Run all test suites |
- | `just lint` | Lint all code |
- | `just ci` | Full CI pipeline (lint + build + test) |
- | `just proto` | Generate protobuf stubs |
- | `just clean` | Remove all build artifacts |
- | `just go-build` | Build Go orchestrator only |
- | `just rust-build` | Build Rust engine only |
- | `just py-test` | Run Python tests only |
- | `just ts-build` | Build TypeScript bridge only |
- | `just cep-build` | Build CEP panel only |
- | `just install-panel` | Install CEP panel into Premiere Pro |
- | `just start` | Start all backend services |
- | `just stop` | Stop all backend services |
- | `just status` | Check service status |
- ## Use Cases
- - **Automated rough cuts** -- Parse a script and assemble a timeline from raw footage
- - **Batch color grading** -- Apply Lumetri Color adjustments across clips via natural language
- - **Audio post-production** -- Set levels, apply effects, and mix tracks through AI prompts
- - **Template-based editing** -- Generate videos from MOGRTs and data using AI
- - **Multi-format export** -- Queue multiple export presets from a single command
- - **Review workflows** -- Add markers, comments, and metadata programmatically
- - **AI-assisted editing** -- Let Claude or GPT analyze your footage and suggest edits
- ## Community
- We are actively looking for testers and contributors!
- - **Test the server** with your Premiere Pro setup and [report results](https://github.com/ayushozha/AdobePremiereProMCP/issues/1)
- - **Request features** you need for your workflow using [a separate feature request](https://github.com/ayushozha/AdobePremiereProMCP/issues/new?template=feature_request.md)
- - **Report bugs** with reproduction steps using [a separate bug report](https://github.com/ayushozha/AdobePremiereProMCP/issues/new?template=bug_report.md)
- - **Confirm your Premiere Pro version** works in [the compatibility tracker](https://github.com/ayushozha/AdobePremiereProMCP/issues/4)
- - **Start or join a discussion** in [GitHub Discussions](https://github.com/ayushozha/AdobePremiereProMCP/discussions)
- - **Read the [Contributing Guide](CONTRIBUTING.md)** to get started with development
- If this project is useful to you, please **star the repository** to help others find it.
- ## Related
- - [Model Context Protocol](https://modelcontextprotocol.io) -- The open protocol for AI tool use
- - [Adobe Premiere Pro Scripting Guide](https://ppro-scripting.docsforadobe.dev/) -- ExtendScript API reference
- - [Adobe CEP Resources](https://github.com/nicmangroup/CEP-Resources) -- CEP panel development
- ## License
- MIT
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.