MCP video generation: AI agents that create videos

Ask Claude to write a launch announcement and it writes one. Ask it to make a launch video and, until recently, it apologized. That gap closed when Ozor shipped its MCP server: any AI assistant that speaks the Model Context Protocol — Claude Desktop, Claude Code, Cursor, or a custom agent — can now generate, edit, and export real animated videos as part of a conversation. You describe the video; the agent calls the tools, waits on the render, and hands you a link. This guide covers what MCP is, what the Ozor server's fifteen tools actually do, the three-step setup, and the agent workflows worth building first — all running on the same engine behind Ozor's document to video AI.

What is MCP, and why does it matter for video?

The Model Context Protocol is an open standard for connecting AI assistants to external tools and data. Instead of every AI product building bespoke integrations with every service, a service publishes one MCP server describing its capabilities as typed tools, and every MCP-compatible client — Claude Desktop, Claude.ai, Claude Code, Cursor, VS Code, custom agents — can discover and call those tools from natural language. It is the reason your coding assistant can query your database or file a ticket without you writing glue code.

Video is an unusually good fit for this model, because video creation is not one API call — it is a pipeline. A video gets generated, previewed, revised, revised again, exported, and shared, with judgment calls at each step. That shape is awkward for a single REST request but natural for an agent holding a conversation: it can generate a draft, show you the result, take your feedback in plain English, apply it, and only export when you say the word. The protocol handles the plumbing; the agent handles the back-and-forth.

The Ozor MCP server is a thin, typed wrapper around the same engine that powers the Ozor app: prompts and documents become animated motion-graphics videos with AI voiceover, music, and your brand styling, in 16:9 or 9:16. The server is stateless — every call authenticates as you, and everything it creates lands in your regular Ozor account. It is one of three integration surfaces, alongside the official n8n node for workflow automation and a keyed REST API for code — all sharing one credit balance and documented in Ozor's developer docs.

What the Ozor MCP server can do

The server exposes fifteen tools. You never call them by name — the agent picks them based on what you ask — but knowing what exists tells you what you can ask for. They group into five capabilities:

• →Create and iterate. generate_video turns a short creative brief (up to 2,000 characters) into a new video, with optional reference images and clips and a choice of 16:9 or 9:16. send_messagesends a natural-language edit instruction — "add our logo to scene 2", "make the outro shorter" — to an existing video, which is what makes the workflow conversational rather than one-shot. list_videos and get_video let the agent find and inspect what it has made.
• →Monitor long-running work. Generation and editing are asynchronous jobs. get_job is a one-shot status check; wait_for_job blocks until the job completes and returns the editor URL — the gate before the agent shows you anything. Your assistant handles the polling; you just see the finished result.
• →Deliver. export_video renders an MP4 at 720p, 1080p, or 4K; wait_for_export blocks until the render finishes and returns a permanent public watch page, the raw MP4 file, and a download link. get_embed_code produces a ready-to-paste responsive iframe for your site. Identical exports are content-addressed, so re-exporting an unchanged video returns the cached result instantly.
• →Work from documents. analyze_document converts a PDF, PPTX, DOCX, or web URL into a draft video plan — scenes, voiceover script, credit cost. prepare_document_upload issues a one-time signed upload URL for large local files. get_plan and update_plan let the agent revise the plan with you before spending anything, and generate_from_plan renders the approved plan into a real project.
• →Voices. list_voices returns the catalog of TTS narration voices — name, language, gender — so the agent can offer you a choice and lock one in via update_plan before generating.

The server is also opinionated about behavior, not just capability. It instructs agents to present the editor link and stop after generation — asking before spending render time on an export — and to pass URLs through verbatim rather than constructing them. The practical effect: an agent using Ozor behaves like a careful colleague, not a runaway script.

Set it up in three steps

Setup is deliberately small: there is nothing to deploy and no SDK to install. Local clients run the server via npx with an API key; hosted clients connect to the managed server over OAuth. Either way you are generating within ten minutes.

The config block for step 2 — the same shape works in Claude Desktop, Cursor, and VS Code's mcp.json:

{
  "mcpServers": {
    "ozor": {
      "command": "npx",
      "args": ["-y", "@ozor/mcp"],
      "env": {
        "OZOR_API_KEY": "sk_live_a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6"
      }
    }
  }
}

A note on credits: a generation costs 1 credit, an edit message costs 1 credit, and document analysis costs 1 credit; exports and all read operations are free. Failed generations are not charged. Credits are shared across MCP, n8n, the REST API, and the app — plans and current allowances are on the pricing page.

Example agent workflows

The interesting uses are not "a chatbot that makes videos" — they are agents that produce a video as one step inside a larger job. Three patterns worth building:

A PRD becomes a demo video. You hand Claude Code a product requirements doc and ask for a demo video for the sprint review. The agent calls analyze_document on the file, presents the scene plan — titles, voiceover lines, credit cost — in plain language, and waits. You cut two scenes and ask for a more direct tone; it applies the changes via update_plan, generates on your approval, and returns the editor link. Ten minutes later the review has a narrated, brand-styled walkthrough that would otherwise have been a screen share and an apology.

A personalized video inside a support conversation. A support agent (human or AI) escalates a question that keeps recurring: how a specific feature handles a specific edge case. Instead of writing another paragraph nobody reads, the assistant calls generate_videowith a prompt built from the ticket's actual context, waits for the job, exports, and drops the watch link into the reply. The customer gets a 60-second animated answer to their exact question, and the video joins a library that deflects the next identical ticket.

A scheduled agent produces the weekly recap. An agent runs every Friday, pulls the week's shipped work from your project tracker, condenses it into a brief, and calls generate_video — then export_video and wait_for_export — and posts the watch link to the team channel. Nobody scripts, records, or edits anything, and the update actually gets watched. The full build, including what belongs in the prompt, is in the automated weekly report video guide.

MCP vs REST API vs the Ozor app

MCP is one of three ways to drive the same engine. The right choice depends on who — or what — is steering:

These are not competing products — they are the same account, credits, and engine with different steering wheels. An agent-generated video opens in the same editor as an app-made one, and a project started over MCP can be exported later by a script hitting the video generation API. A sensible progression: start in the app to learn what the engine produces, wire up MCP so your assistant can do the routine work, and reach for the REST API only when video generation becomes a feature of your own product.

Frequently asked questions