Levea Mcp Server

Levea MCP Server

An autonomous agentic video editor. Send a sentence. Get a finished video. No timelines, no keyframes, no plugin chains. Open-source MCP client connecting local AI agents (Claude, Cursor, Cline) to our cloud GPU video production harness.

[npm] [MCP Registry]

Beta. The agent can make mistakes. Preview every output before publishing or sharing. For high-stakes or irreversible edits, pass requirePlanApproval: true so the agent stops after planning and waits for your approval before anything runs.

Contents

1. Quickstart — running in 60 seconds
2. What it does — say it, get it
3. Capability surface — the full toolset
4. Goals & briefs — from one line to a full creative brief
5. API reference — endpoints, request/response, streaming, async
6. Who it's for · vs. legacy editors · Safety · Media
7. Links & channels

Quickstart

The portable interface is the levea-mcp-server MCP server — one server, every MCP client (Claude Desktop, Claude Code, Cursor, Cline, OpenClaw, Hermes), one tool surface, one backend contract, so nothing drifts per platform.

1. Get an API key — sign up at livecore.ai and generate a Levea API key.

2. Add the MCP server — the same npx line works for every MCP client:

{  "mcpServers": {    "levea": {      "command": "npx",      "args": ["-y", "levea-mcp-server"],      "env": {        "LEVEA_API_URL": "https://api.livecore.ai",        "LEVEA_API_KEY": "your-key-from-livecore.ai"      }    }  }}

3. Use it — say to your AI: "Use the levea tool to generate 5 viral clips from this video, add captions, reframe vertical." The agent picks the tool, fills the prompt; the editor plans → executes → exports. A full edit takes minutes, not seconds; see Safety & limits for long edits.

Per-client setup

This package on npm: npx -y levea-mcp-server — no global install needed.

Hosted endpoint — no install

Clients that connect to a remote MCP server by URL (Smithery, Claude / ChatGPT connectors, Cursor remote servers) can skip npx entirely:

URL:    https://api.livecore.ai/api/v1/misc/mcp      (Streamable HTTP, stateless)Auth:   OAuth 2.1 sign-in (clients that support it open your Levea account in the browser)        or Header: Authorization: Bearer your-key-from-livecore.ai

Same tools, same backend. Clients that can't set headers may pass ?apiKey=... instead. Every request is authenticated, including the tool list; an unauthenticated call gets 401 with a WWW-Authenticate challenge that points OAuth clients at the sign-in flow.

Every client calls the same backend: this MCP server, the hosted endpoint, the OpenClaw and Hermes plugins, and the ChatGPT action share one tool contract.

Two hosts — don't confuse them

Env vars are LEVEA_API_URL / LEVEA_API_KEY.

Tools the AI sees

One editing entry point. Everything else is typed state-management and polling — so integrators can build full editing experiences through one API key instead of mixing JWT and MCP.

No edit shims (add_captions, generate_viral_clips, …) and no editor_execute escape hatch. The backend's planner is the specialist — fragmenting the editing surface encourages calling LLMs to second-guess the planner and lose multi-step intent. State-management tools (brand / project / asset / caption-template CRUD) aren't editing, so they don't fragment intent — they just give integrators typed access.

→ For agent-integration details (schemas, async semantics, error handling, plan approval), see AGENTS.md.

What it does

Say it in plain language; the agent plans and finishes the edit.

Capability surface

The full toolset behind the prompt. Everything below is reachable from natural language — mix and match in a single sentence.

🔍 Read & inspect

• Scene state — timeline / layer / scene structure, schema introspection
• Search — asset gallery (type, duration, name); transcript (keyword, semantic, timestamp)
• Vision — CV frame analysis (object, face, scene); on-screen text-region detection (locates chyrons / lower-thirds / burned-in captions so reframing avoids covering them)
• Intelligence — narrative peaks, speaker diarization, sentiment, pacing
• Jobs — async job status polling

✂️ Structural editing

• Layers — insert / update / replace / delete (video, audio, image, text, shape, solid, adjustment, group, light, vfx, visualizer, lottie)
• Timing — trim, split, retime (slow-mo 0.5×, fast-forward 2×, freeze-frame), reverse, stabilize
• Arrange — reposition, sequence, snap to transcript word boundaries
• Assemble — multi-cam sync + automatic angle switching, montage assembly (shot discovery + sequencing from source footage), slideshow generation, chapter markers, SRT import
• Safety — gap healing, audio normalize, duration reconcile (pre-export pass), multi-step undo / redo

🎬 Visual editing

• Color grade — brightness, contrast, saturation, hue, lift/gamma/gain, RGB curves, LUT / film-look presets (including your own .cube files), auto color, shot-to-shot color matching, vignette, chromatic aberration
• VFX — ~100 GPU effect presets: lens flares, film burn, bloom, rain, dust, smoke, fire, explosion, lightning, snow, glitch, scanlines, grain, lens blur, slit-scan, glassmorphism, bokeh, portal, …
• Transitions — 160+ named transitions (wipes, whips, light-band reveals, glitches, CRT power-off, …)
• Editing techniques — speed ramps and time remap, J/L, match, and smash cuts, AI outpainting to a new aspect ratio, eye-contact correction, face retouch
• Composite — chroma key, AI background removal (alpha matte), masking (luma / alpha / depth, with boolean multi-mask)
• Blend & opacity — 29 blend modes (multiply, screen, overlay, color dodge / burn, difference, hue / saturation / color / luminosity, additive) + per-layer & group opacity
• Shape & transform — clip shapes (circle, dome, star, hexagon, polygon), crop, 3D rotation / perspective, glow, shadow, gradient fills
• Lighting — up to 8 scene lights illuminating 3D-transformed layers
• Reframe & layout — caption-safe vertical reframe (9:16) + vertical montage, split screen (top/bottom, L/R, PiP, grid)
• Track — motion / face tracking with zoom-follow, branding overlays
• Camera — keyframed 3D camera moves (push-in, orbit, drift) with depth-based parallax

📊 Motion graphics & data viz

Every graphic is placed clear of faces and reviewed by an AI critic before it reaches the timeline:

• Data — transcript-driven charts (bar, line, pie), stat callouts, animated counters
• Lower-thirds & cards — lower-thirds, title / chapter cards, checklists, keyword pills
• Diagrams — flowcharts, timelines, geo callouts
• Layouts — collage layouts, text behind the subject, sticker cut-outs
• Films — standalone motion-graphic films from one sentence: 2D motion design and 3D character films with camera moves, lighting, music, and sound design
• CTAs — animated subscribe / call-to-action buttons

💬 Captions & text

• Generate — auto-captions from the transcript
• Style — 60+ built-in templates (Hormozi, Spotlight, Karaoke, phrase lockups, two-line podcast looks, …), or an AI director that picks/generates one at runtime
• Scripts — Latin, Indic, Arabic, Cyrillic, and Greek text
• Animate — per-word animations (typewriter, slide, fade, scale, rotate, bounce, flip, swing, elastic, blur, glitch, wave — each with a matching exit)
• Typography — crisp scalable glyphs (MSDF), stroke / outline, drop shadow, gradient fill, background pill / box, per-word karaoke fill + underline
• Shape — curved text paths (circle, wave, custom SVG), Lottie playback control

🎵 Audio

• Clean up — remove silences, breaths, filler words; word-level mute/cut
• Mix — auto-duck (sidechain music vs voice), loudness (LUFS) normalize + true-peak limiting, denoise, crossfade, EQ presets (bass-boost, vocal-clarity, warm, bright), vocal / instrumental separation
• Library — a reviewed, licensed music and sound-effects library; music fitted to the video length; sound design (effects on cuts and beats, room tone)
• Generate — SFX, music (mood/genre/BPM), voiceover (TTS or cloned voice), voice conversion
• Sync — external master audio alignment (timecode / explicit offset)
• Visualize — waveforms (bars, wave, circular)

🔒 Privacy & cleanup

• Faces — blur all faces or background-only
• Regions — privacy redaction (blur / cover)
• Language — profanity cleanup (mute / bleep)
• Layout — safe-zone repair

✨ Async generation

• Video — AI video / B-roll (duration + aspect)
• Images — AI images (single or batch at timestamps), generative image edit, auto-thumbnail extraction
• Audio — AI music (prompt + duration + mood + genre + BPM), AI voiceover (TTS or cloned voice library)

🚀 High-level presets

• Viral — vertical + captions + silence removal + tracking + word emphasis
• Cinematic director — dynamic zooms + cinematic grade + mood camera moves
• Emphasis system — keyword detection + coordinated scaling / glow / pulse
• Pacing optimizer — filler + silence + low-energy removal for retention

📦 Export

• MP4 — single file (resolution / codec / quality tier)
• Viral-clip batch — auto-segmented short-form, packaged as a ZIP
• Multi-platform pack — TikTok + Reels + Shorts + YouTube + Instagram in one pass

✅ Also shipped

• On-screen text, logo, and watermark removal
• On-screen text recognition (OCR), enabling find-and-replace on burned-in text

Goals & briefs

autonomous_edit accepts anything from a five-word command to a five-hundred-word creative brief.

1. Direct commands — a single edit, single result. The What it does examples above are all direct commands.

2. Open-ended goals — hand the agent a goal instead of a command; it inspects the asset, then proposes a plan:

"Watch this and tell me how to make it more engaging for TikTok""Look at the first 30 seconds and suggest 3 ways to hook the viewer""Review this footage and propose edits to tighten the pacing"

Pair these with requirePlanApproval: true for propose-only mode — the agent stops after planning and waits for your approval (see Plan approval).

3. Full creative briefs — multi-step orchestrations executed end-to-end. The agent decomposes the brief into a DAG of canonical actions, plans the order, executes through safety gates, verifies each step, and exports every requested format. Use SSE to watch each step land in real time.

No timeline UI, no per-step API calls, no glue code on your side.

API reference

Base URL: {LEVEA_API_URL} (production: https://api.livecore.ai). Auth on every request:

Authorization: Bearer {LEVEA_API_KEY}

All paths are under /api/v1/misc/openclaw.

Each management group above is also exposed as a typed MCP tool (see Tools the AI sees).

LEVEA_API_URL is the bare host https://api.livecore.ai — not a full path, not livecore.ai, and not the in-product /api/v1/misc/editor/ route.

Request

Every edit goes through one tool — autonomous_edit. Pass a natural-language description; the agent plans, executes, verifies, and exports. No tool list to memorize, no structured params to learn.

curl -sS -X POST "$LEVEA_API_URL/api/v1/misc/openclaw/v1/execute" \  -H "Authorization: Bearer $LEVEA_API_KEY" \  -H "Content-Type: application/json" \  -d '{    "tool": "autonomous_edit",    "params": {      "prompt": "Make this a TikTok-ready viral clip: vertical reframe, bold captions, remove silences, motion-track the speaker, and export."    },    "project_id": "my-project"  }'

prompt is the only required field. Everything else is optional:

Response

{  "type": "success | partial_success",  "tool": "autonomous_edit",  "success": true,  "partial": false,  "status": "completed | failed | awaiting_approval",  "scene": { },  "reply": "Human-readable summary of what changed",  "message": "Short status message",  "videoUrl": "https://.../output.mp4",  "jobId": "12345",  "viral_clips": [ ],  "zip_url": "https://.../clips.zip",  "activeTasks": [ ],  "pendingAsyncJobs": [ ],  "verificationPassed": true,  "verificationIssues": [],  "verificationReport": { "status": "verified", "repairs": [], "counts": { "failedVerification": 0, "repairsAttempted": 0 } },  "qualityNotes": [],  "quality": {    "score": 0.94,    "stepsTotal": 7,    "stepsFailed": 0,    "hasExportedMedia": true,    "mediaReachable": true  },  "processingTime": 12.3,  "workingMemory": { }}

jobId is the numeric task_id (a string of digits), not a task_-prefixed value. quality is a calibrated post-run score block; partial is the top-level partial-success flag (mirrors type: "partial_success").

SSE streaming

Set Accept: text/event-stream or ?stream=true. Notable event types:

Async job lifecycle

Generation actions return immediately with a jobId. Poll until terminal:

JOB_ID=$(jq -r '.jobId // .activeTasks[0].intent.job_id' /tmp/result.json)while true; do  STATUS=$(curl -sS "$LEVEA_API_URL/api/v1/misc/openclaw/v1/jobs/$JOB_ID" \    -H "Authorization: Bearer $LEVEA_API_KEY" | jq -r '.status')  echo "Status: $STATUS"  case "$STATUS" in completed|succeeded|failed|error|cancelled) break;; esac  sleep 5done
curl -sS "$LEVEA_API_URL/api/v1/misc/openclaw/v1/jobs/$JOB_ID" \  -H "Authorization: Bearer $LEVEA_API_KEY" | jq '.result'

Auto-export

After any mutating tool call that changed the scene (including partial successes), if no export is already queued the route auto-fires one synchronously — so the response carries a real videoUrl. Read-only and conversational autonomous_edit calls do not trigger auto-export.

Plan approval

Pass requirePlanApproval: true to make the agent stop after planning. It returns status: "awaiting_approval" + populated workingMemory. Resume by sending the same workingMemory with planDecision: "approve" (or an approval prompt such as yes, approve, go), optionally with an editedPlan. To change the plan instead, send a new prompt with the same workingMemory.

Verification report

Every edit result carries verificationReport: status is verified (approved on the rendered frames), rejected, unverified (no verdict could be reached; the edit is kept but never reported as verified), or not_applicable, plus every task that failed its check, what the repair loop tried, and whether it was repaired. qualityNotes lists advisory notes, and modelsUsed names the models the edit called.

Who it's for

vs. legacy editors

This isn't an editor with AI features bolted on — it's an autonomous agent that finishes the edit for you.

Safety & limits

• Beta — outputs can be wrong. Preview every result before sharing. For irreversible workflows, pass requirePlanApproval: true to inspect and approve the plan first.
• OAuth or API-key authentication on every request.
• Destructive actions (mass deletes, clears) require explicit confirmation params.
• Output is verified after execution; auto-repairs on failure.
• Concurrent identical requests are deduplicated server-side.
• Rate-limited per account. Read-only questions take seconds; a simple edit with export takes a few minutes; a full edit with motion graphics, music, and export can take 10–20 minutes.
• Long edits outlive a single MCP request: autonomous_edit waits up to 5 minutes (LEVEA_REQUEST_TIMEOUT_MS) and autonomous_edit_streaming up to 30 (LEVEA_STREAM_TIMEOUT_MS), then return status: "running" with the project_id; the edit keeps running, and get_active_task follows it. For full edits, queue_edit + check_task_status is the most robust path.

Supported media

Links & channels

Versions aren't pinned here — npx -y levea-mcp-server and the ClawHub listing always pull the latest, and the linked npm / ClawHub pages show the current version. You never need a specific number.

Support — setup help, integration questions, or issue reports: [email protected] or GitHub issues.

Privacy & telemetry — edits send your prompt, source URLs, and project ids to the Levea API. The client also sends a tiny anonymous usage ping (event name, client version, whether a key is set; never prompts, media, or keys). Turn it off with LEVEA_TELEMETRY=off. See the privacy policy.

License — MIT