Skip to content
Back to search

AdobePremiereProMCP

SkillWorks with Claude CodeGitHub

🎬 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.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ayushozha--adobepremierepromcp/badge.svg)](/listings/ayushozha--adobepremierepromcp)

HTML

<a href="/listings/ayushozha--adobepremierepromcp"><img src="/api/listings/ayushozha--adobepremierepromcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

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)

  1. # PremierPro MCP Server -- AI-Powered Video Editing for Adobe Premiere Pro
  2. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  3. [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/ayushozha/AdobePremiereProMCP/pulls)
  4. [![Premiere Pro 2020-2026](https://img.shields.io/badge/Premiere%20Pro-2020--2026-9999FF.svg)](https://www.adobe.com/products/premiere.html)
  5. [![MCP Protocol](https://img.shields.io/badge/MCP-Model%20Context%20Protocol-blue.svg)](https://modelcontextprotocol.io)
  6. [![GitHub stars](https://img.shields.io/github/stars/ayushozha/AdobePremiereProMCP?style=social)](https://github.com/ayushozha/AdobePremiereProMCP/stargazers)
  7. **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.
  8. > Give it a script and your footage, review the proposed edit, then let it assemble a recoverable rough cut on a duplicated sequence.
  9. ```
  10. "Edit this 5-minute video using script.pdf with the footage in /media/"
  11. ```
  12. 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.
  13. ---
  14. ## Why This Exists
  15. 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.
  16. **No separate MCP subscription. Local CEP bridge. Fully open source.**
  17. ## Capabilities and Verification Boundary
  18. 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.
  19. The curated surface includes:
  20. - Project/timeline inspection, sequence versioning, import, placement, trim, ripple, markers, and export.
  21. - Rust-backed media probe, thumbnail, waveform, silence, scene, and asset-scan operations.
  22. - Script parsing, asset matching, EDL generation, and pacing analysis.
  23. - Caption-track creation from validated SRT with count readback.
  24. - Installed-effect and transition discovery, application, and public-DOM readback.
  25. - [12 native transition recipes](docs/native-transition-recipes.md), with dry-run checks, sequence copies, and exact cut/duration readback.
  26. - MOGRT-based titles, social derivatives, proxy workflows, and batch-delivery recipes.
  27. The audited caption, transition, effect, and graphics-template routes return
  28. explicit `unsupported` errors when Premiere cannot perform and read back the
  29. requested mutation. The broader compatibility catalog still contains legacy
  30. and experimental handlers that have not completed the same audit, so it must
  31. not be treated as a certified surface. Arbitrary script, shell, URL, clipboard,
  32. external-editor, and file-I/O tools are hidden unless `unsafe` is selected. A
  33. real Premiere session is still required to certify host mutations on a
  34. particular OS/Premiere build.
  35. ## Supported Premiere Pro Versions
  36. | Version | Year | Support |
  37. |---|---|---|
  38. | 14.x | 2020 | Manifest target; live matrix pending |
  39. | 15.x | 2021 | Manifest target; live matrix pending |
  40. | 22.x | 2022 | Manifest target; live matrix pending |
  41. | 23.x | 2023 | Manifest target; live matrix pending |
  42. | 24.x | 2024 | Manifest target; live matrix pending |
  43. | 25.x | 2025 | Primary development target; live matrix pending |
  44. | 26.x | 2026 | 26.5.2: 8 core CEP workflows tested on macOS arm64; broader matrix pending |
  45. The CEP bridge targets **macOS** and **Windows** and declares Premiere Pro 14.0+ in its extension manifest.
  46. The manifest range is not a live compatibility certification. Run the host smoke workflow against your exact Premiere build before trusting project mutations.
  47. Help us expand compatibility -- [report your setup](https://github.com/ayushozha/AdobePremiereProMCP/issues/4).
  48. ## Architecture
  49. Four languages, each playing to their strengths:
  50. ```
  51. CLI / MCP Client (Claude, GPT, any AI)
  52. | stdio / JSON-RPC
  53. v
  54. +-------------------------------------+
  55. | Go -- MCP Server & Orchestrator |
  56. | Protocol handling . Concurrency |
  57. | Service mesh . Health & recovery |
  58. +------+------------+------------+-----+
  59. | gRPC | gRPC | gRPC
  60. v v v
  61. +------------+ +----------+ +----------------+
  62. | Rust | | Python | | TypeScript |
  63. | Media | | Intel | | Premiere Pro |
  64. | Engine | | Layer | | Bridge |
  65. +------------+ +----------+ +-------+--------+
  66. | CEP / ExtendScript
  67. v
  68. Adobe Premiere Pro
  69. ```
  70. | Language | Role | Why |
  71. |---|---|---|
  72. | **Go** | MCP server, orchestration | Goroutines for concurrency, fast startup, low memory |
  73. | **Rust** | Media processing | Raw performance for scanning, indexing, waveform analysis |
  74. | **Python** | Edit intelligence | Deterministic script parsing, asset matching, EDL generation, pacing analysis |
  75. | **TypeScript** | Premiere Pro bridge | Native access to Adobe's ExtendScript/CEP DOM |
  76. Full architecture diagram: [`docs/architecture.md`](docs/architecture.md)
  77. ## Project Structure
  78. ```
  79. AdobePremiereProMCP/
  80. +-- go-orchestrator/ # Go -- MCP server & task orchestrator
  81. | +-- cmd/server/ # Entry point
  82. | +-- internal/ # Core packages
  83. | | +-- mcp/ # MCP protocol handler (1,066 registered schemas)
  84. | | +-- orchestrator/ # Task orchestration
  85. | | +-- health/ # Health checks
  86. | | +-- grpc/ # gRPC client/server
  87. | +-- configs/ # Configuration files
  88. |
  89. +-- rust-engine/ # Rust -- Media processing engine
  90. | +-- src/
  91. | +-- media/ # Media probe & metadata
  92. | +-- assets/ # Asset indexing & fingerprinting
  93. | +-- waveform/ # Waveform & silence detection
  94. | +-- thumbnails/ # Thumbnail generation
  95. |
  96. +-- python-intelligence/ # Python -- AI intelligence layer
  97. | +-- src/
  98. | | +-- parser/ # Script parsing & NLP
  99. | | +-- edl/ # Edit Decision List generation
  100. | | +-- matching/ # Shot-to-asset matching
  101. | | +-- analysis/ # Pacing & timing analysis
  102. | +-- tests/
  103. | +-- models/ # ML model configs
  104. |
  105. +-- ts-bridge/ # TypeScript -- Premiere Pro bridge
  106. | +-- src/
  107. | +-- extendscript/ # ExtendScript API layer
  108. | +-- cep/ # CEP Panel bridge (primary)
  109. | +-- standalone/ # Node.js fallback bridge
  110. | +-- timeline/ # Timeline operations
  111. |
  112. +-- cep-panel/ # CEP Panel -- Premiere Pro extension
  113. | +-- src/
  114. | +-- assets/
  115. | +-- CSXS/ # Adobe extension manifest
  116. |
  117. +-- proto/ # Shared protobuf definitions
  118. +-- docs/ # Documentation
  119. +-- scripts/ # Build & setup scripts
  120. +-- Justfile # Unified build system
  121. +-- .env.example # Environment template
  122. ```
  123. ## Prerequisites
  124. - [Go](https://go.dev/) 1.26.1+
  125. - [Rust](https://rustup.rs/) 1.85+
  126. - [Python](https://python.org/) 3.12+
  127. - [Node.js](https://nodejs.org/) 20+
  128. - [just](https://github.com/casey/just) (command runner)
  129. - [buf](https://buf.build/) (protobuf toolchain)
  130. - `rsync` (generated-client synchronization on macOS/Linux)
  131. - [FFmpeg](https://ffmpeg.org/) (media processing)
  132. - Adobe Premiere Pro (2020 or later)
  133. ## Quick Start
  134. ```bash
  135. # Clone the repository
  136. git clone https://github.com/ayushozha/AdobePremiereProMCP.git
  137. cd AdobePremiereProMCP
  138. # Copy env template
  139. cp .env.example .env
  140. # Install dependencies
  141. just install
  142. # Generate protobuf stubs
  143. just proto
  144. # Build all components
  145. just build
  146. # Run tests
  147. just test
  148. # Install the CEP panel into Premiere Pro
  149. just install-panel
  150. ```
  151. Those commands use a POSIX shell. Native Windows users should follow the
  152. platform-specific build/start commands in
  153. [`docs/USER_MANUAL.md`](docs/USER_MANUAL.md#windows-native-setup); the current
  154. `PremierPro.bat` is a fail-fast CLI launcher, not a service supervisor.
  155. ## Usage
  156. ### As an MCP Server (Claude Code, Claude Desktop, Cursor, etc.)
  157. Add to your MCP client configuration:
  158. ```json
  159. {
  160. "mcpServers": {
  161. "premiere-pro": {
  162. "command": "./go-orchestrator/bin/premierpro-mcp",
  163. "args": ["--transport", "stdio"]
  164. }
  165. }
  166. }
  167. ```
  168. The complete tool catalog is returned in cursor-paginated pages of 100 by
  169. default. MCP clients should continue requesting `tools/list` with the returned
  170. cursor until `nextCursor` is absent. Set `MCP_PAGE_SIZE` to tune the page size.
  171. The default `standard` profile keeps the normal editing surface small enough
  172. for model tool limits. Set `MCP_TOOL_PROFILE` to `core`, `dialogue`, `captions`,
  173. `social`, `transitions`, `effects`, `proxies`, `delivery`, `standard`, or a
  174. comma-separated combination. Specialized profiles always include core
  175. inspection and duplicate-sequence recovery tools. `all` exposes the safe full catalog; arbitrary
  176. script, shell, URL, and file-I/O tools additionally require `unsafe` (for
  177. example `MCP_TOOL_PROFILE=all,unsafe`) and should only be used with trusted
  178. prompts and explicit human review.
  179. ### Workflow Skills
  180. Seven reusable Agent Skills live in [`skills/`](skills/): dialogue cutting,
  181. captions, social reframing, transition recipes, look/effect chains, proxy
  182. conform, and batch delivery. Mutation skills preserve an untouched duplicate
  183. sequence (or a tool-created derivative) as the recovery boundary and require
  184. readback verification. Timeline snapshots and saved sequence versions are
  185. audit/comparison records, not whole-sequence rollback points. The same catalog is available to MCP clients through
  186. the `config://workflow-skills` resource.
  187. The sources evaluated, patterns adopted, and integrations intentionally left
  188. out are recorded in [`docs/workflow-research.md`](docs/workflow-research.md).
  189. The exact test matrix and remaining host boundaries are recorded in
  190. [`docs/repository-audit-2026-08-05.md`](docs/repository-audit-2026-08-05.md).
  191. ### Via CLI
  192. ```bash
  193. # Start the server
  194. just go-run
  195. # Or run directly
  196. ./go-orchestrator/bin/premierpro-mcp --transport stdio
  197. ```
  198. ### Platform Launchers
  199. Platform-specific CLI launchers are included:
  200. - **macOS:** `./PremierPro.command` starts the three backends, installs the CEP
  201. panel if needed, waits for readiness, and launches the CLI.
  202. - **Linux/Unix:** `./PremierPro.sh` starts the three backends, waits for
  203. readiness, and launches the CLI. Premiere/CEP itself must run on macOS or
  204. Windows.
  205. - **Windows:** `PremierPro.bat` prepares the Node/Go CLI and launches it. Start
  206. the Rust, Python, and TypeScript services separately and install the panel
  207. with `scripts\install-cep-panel-win.bat`; full Windows supervision is not yet
  208. implemented by the batch launcher.
  209. ### CEP Bridge Security and Docker
  210. The CEP panel accepts authenticated WebSocket connections only on loopback.
  211. On first start, the Go orchestrator, TypeScript bridge, or panel creates a
  212. shared token at `~/.premierpro-mcp/cep-token`. It authenticates both the
  213. Go-to-TypeScript gRPC hop and the TypeScript-to-CEP WebSocket hop. To override
  214. it, set `BRIDGE_CEP_TOKEN` or `MCP_CEP_TOKEN` consistently, or point all three
  215. processes at the same file with `PREMIERE_MCP_TOKEN_FILE`.
  216. Because Premiere Pro and its CEP panel run on the host, do not run the
  217. TypeScript bridge solely inside Docker: a container cannot reach the panel's
  218. loopback-only WebSocket. The supported live-editing layout keeps the Go
  219. orchestrator and TypeScript bridge on the host; Docker Compose runs only the
  220. Rust and Python analysis backends.
  221. Before `docker compose up`, set `PREMIERE_MEDIA_ROOT` to the narrowest absolute
  222. directory containing the input media and `PREMIERE_OUTPUT_ROOT` to an absolute
  223. writable output directory. Compose mounts each directory at the identical
  224. container path, so file paths sent over gRPC remain meaningful on both sides.
  225. The input mount is read-only. Service-specific Docker targets avoid building a
  226. duplicate all-language runtime for each analysis backend.
  227. The SSE transport also binds to `127.0.0.1` by default. It has no application-
  228. level authentication, so do not set `MCP_SSE_HOST` (or `--host`) to a public or
  229. LAN interface unless an authenticated TLS reverse proxy protects it.
  230. ## How It Works
  231. 1. **You send a prompt** -- "Edit this video using the script with footage from /media/"
  232. 2. **Go orchestrator** receives the MCP tool call and fans out:
  233. - **Rust engine** scans `/media/`, indexes all assets (codec, duration, resolution, waveforms)
  234. - **Python intelligence** parses the script, generates an Edit Decision List, matches shots to assets
  235. 3. **Go merges results** and sends the EDL to the TypeScript bridge
  236. 4. **TypeScript bridge** executes in Premiere Pro -- creates the sequence,
  237. places clips, and applies supported transitions and graphics templates
  238. 5. **Premiere Pro renders** the final output
  239. ## Build Commands
  240. | Command | Description |
  241. |---|---|
  242. | `just build` | Build all components |
  243. | `just test` | Run all test suites |
  244. | `just lint` | Lint all code |
  245. | `just ci` | Full CI pipeline (lint + build + test) |
  246. | `just proto` | Generate protobuf stubs |
  247. | `just clean` | Remove all build artifacts |
  248. | `just go-build` | Build Go orchestrator only |
  249. | `just rust-build` | Build Rust engine only |
  250. | `just py-test` | Run Python tests only |
  251. | `just ts-build` | Build TypeScript bridge only |
  252. | `just cep-build` | Build CEP panel only |
  253. | `just install-panel` | Install CEP panel into Premiere Pro |
  254. | `just start` | Start all backend services |
  255. | `just stop` | Stop all backend services |
  256. | `just status` | Check service status |
  257. ## Use Cases
  258. - **Automated rough cuts** -- Parse a script and assemble a timeline from raw footage
  259. - **Batch color grading** -- Apply Lumetri Color adjustments across clips via natural language
  260. - **Audio post-production** -- Set levels, apply effects, and mix tracks through AI prompts
  261. - **Template-based editing** -- Generate videos from MOGRTs and data using AI
  262. - **Multi-format export** -- Queue multiple export presets from a single command
  263. - **Review workflows** -- Add markers, comments, and metadata programmatically
  264. - **AI-assisted editing** -- Let Claude or GPT analyze your footage and suggest edits
  265. ## Community
  266. We are actively looking for testers and contributors!
  267. - **Test the server** with your Premiere Pro setup and [report results](https://github.com/ayushozha/AdobePremiereProMCP/issues/1)
  268. - **Request features** you need for your workflow using [a separate feature request](https://github.com/ayushozha/AdobePremiereProMCP/issues/new?template=feature_request.md)
  269. - **Report bugs** with reproduction steps using [a separate bug report](https://github.com/ayushozha/AdobePremiereProMCP/issues/new?template=bug_report.md)
  270. - **Confirm your Premiere Pro version** works in [the compatibility tracker](https://github.com/ayushozha/AdobePremiereProMCP/issues/4)
  271. - **Start or join a discussion** in [GitHub Discussions](https://github.com/ayushozha/AdobePremiereProMCP/discussions)
  272. - **Read the [Contributing Guide](CONTRIBUTING.md)** to get started with development
  273. If this project is useful to you, please **star the repository** to help others find it.
  274. ## Related
  275. - [Model Context Protocol](https://modelcontextprotocol.io) -- The open protocol for AI tool use
  276. - [Adobe Premiere Pro Scripting Guide](https://ppro-scripting.docsforadobe.dev/) -- ExtendScript API reference
  277. - [Adobe CEP Resources](https://github.com/nicmangroup/CEP-Resources) -- CEP panel development
  278. ## License
  279. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.