loremotion-mcp
This server lets an agent automate LoreMotion video generation and account management through MCP.
Check whether the LoreMotion browser session is signed in or anonymous.
Generate LoreMotion videos from a text prompt with model, aspect ratio, duration, and optional image-to-video settings.
Use a persistent signed-in profile or an explicit anonymous session; it does not bypass ads or site limits.
List recent signed-in history/dashboard items.
Download generated MP4s from a video URL or share URL and get a local file path.
Probe the live LoreMotion UI to inspect fields, sliders, Turnstile state, and save screenshots for selector maintenance.
Support headless Linux/VPS deployments with persistent Chromium profile import and verification.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@loremotion-mcpCreate a 10-second cinematic drone shot of a modern tower at sunrise using ltx-2.5."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
LoreMotion MCP — Hermes / Headless Linux
A GitHub-ready MCP server that drives LoreMotion.com with Playwright and a persistent LoreMotion browser profile. This version is designed for an automated agent such as Hermes running on a headless Linux VPS, including arm64 systems where the only available browser is Playwright's Chromium headless shell.
The five MCP tool names and schemas are unchanged:
loremotion_auth_statusloremotion_generate_videoloremotion_list_historyloremotion_download_videoloremotion_probe_ui
The selector-override system and soak-test harness are retained.
Recommended headless authentication workflow
Google OAuth/MFA should not be automated on the VPS. The recommended headless flow is:
Authenticate once on an interactive desktop
↓
Dedicated Chromium user-data/profile directory
↓
Securely copy/archive that profile to the VPS
↓
npm run import-profile -- <profile-dir-or-archive>
↓
Importer validates structure + verifies LoreMotion auth
↓
Hermes starts scripts/hermes-mcp.js
↓
Persistent headless LoreMotion MCP sessionNever put a Google password, OAuth token, MFA secret, recovery code, or raw cookie string in .env, source code, Git, an MCP configuration, or an agent prompt. The persistent profile directory is the credential.
Chromium profile portability can vary across operating systems/browser builds because some browser state may be OS-protected. The importer therefore never assumes that a copied profile is usable: it launches the configured headless browser and verifies the copied profile with the same
loremotion_auth_statuslogic used by the MCP server. If the imported profile does not authenticate on the server, the import fails and the previous server profile is restored.
Related MCP server: google-flow-mcp
Requirements
Node.js 20+
npm dependencies installed with
npm installNetwork access to LoreMotion
A Playwright-compatible Chromium executable
For the target headless VPS: no X server, Xvfb, Chrome channel, or desktop GUI is required
The server supports either:
LOREMOTION_EXECUTABLE_PATH=/absolute/path/to/headless_shell, orthe existing
PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATHenvironment variable.
LOREMOTION_EXECUTABLE_PATH takes precedence over LOREMOTION_BROWSER_CHANNEL.
1. Create an authenticated profile on a desktop
On a desktop machine with a normal GUI browser available:
npm install
cp .env.example .envFor the interactive desktop login, set:
LOREMOTION_SESSION_MODE=persistent
LOREMOTION_PROFILE_DIR=.loremotion-profile
LOREMOTION_HEADLESS=false
LOREMOTION_EXECUTABLE_PATH=
LOREMOTION_BROWSER_CHANNEL=chromeThen run:
npm run loginComplete LoreMotion's normal Sign in with Google flow and MFA in the visible browser. The script verifies that LoreMotion is signed in before accepting the profile.
npm run login is intentionally interactive. If stdin/stdout is not a TTY, it exits non-zero immediately and points to the profile-import workflow instead of blocking forever.
Archive the profile for transfer
After the login script closes the browser, copy the entire dedicated profile directory. For example:
tar -czf loremotion-profile.tgz .loremotion-profileTransfer the profile/archive to the VPS using your normal secure file-transfer mechanism. Do not place it in Git.
2. Configure the headless VPS
Create .env:
cp .env.example .envA typical headless configuration is:
LOREMOTION_SESSION_MODE=persistent
LOREMOTION_PROFILE_DIR=/opt/loremotion-mcp/.loremotion-profile
LOREMOTION_DOWNLOAD_DIR=/opt/loremotion-mcp/downloads
LOREMOTION_HEADLESS=true
LOREMOTION_BROWSER_CHANNEL=
LOREMOTION_EXECUTABLE_PATH=/opt/ms-playwright/chromium_headless_shell/chrome-linux/headless_shell
LOREMOTION_LAUNCH_ARGS=--no-sandbox,--disable-dev-shm-usage,--disable-gpu,--single-processIf your VPS already exports Playwright variables, this also works:
export PLAYWRIGHT_BROWSERS_PATH=/opt/ms-playwright
export PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/opt/ms-playwright/chromium_headless_shell/chrome-linux/headless_shellWhen LOREMOTION_EXECUTABLE_PATH is blank, the code automatically uses PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH when present.
Install dependencies:
npm installYou do not need npm run install-browser if the headless-shell binary already exists and LOREMOTION_EXECUTABLE_PATH or PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH points to it.
3. Import the authenticated profile
Directory
npm run import-profile -- /secure/path/.loremotion-profileZip archive
npm run import-profile -- /secure/path/loremotion-profile.zipTar archive
npm run import-profile -- /secure/path/loremotion-profile.tgzSupported archive forms are .zip, .tar, .tar.gz, and .tgz.
The importer:
locates the Chromium user-data root;
checks for
Local State, aDefault/Profile Ndirectory,Preferences, and browser session state;removes stale Chromium lock files during the copy;
stages the import beside
LOREMOTION_PROFILE_DIR;preserves the current server profile as a temporary backup;
installs the staged profile;
launches the configured headless browser;
verifies LoreMotion with the existing auth-status logic;
keeps the new profile only when
signedIn:trueis confirmed; otherwise it restores the previous profile.
Scripted import
Instead of a CLI argument, set:
LOREMOTION_PROFILE_IMPORT_PATH=/secure/path/loremotion-profile.tgzThen either run:
npm run import-profileor let the Hermes bootstrap import it automatically when no valid session exists.
After a successful one-time import, you may clear LOREMOTION_PROFILE_IMPORT_PATH if you do not want Hermes to reuse that source automatically.
4. Hermes MCP entrypoint
For Hermes, use this as the MCP command:
node /opt/loremotion-mcp/scripts/hermes-mcp.jsThe bootstrap performs this sequence:
check existing persistent profile
↓
if signed in → start MCP
↓
if signed out and LOREMOTION_PROFILE_IMPORT_PATH exists
↓
import profile → verify signedIn:true
↓
start MCPIf no valid authenticated profile is available, it exits non-zero with an actionable message. It does not attempt Google password entry or MFA automation.
All pre-MCP bootstrap messages are written to stderr. Stdout remains clean for MCP stdio framing.
Example configuration is in examples/mcp-config.json.
Headless setup helper
setup-google-login.sh now supports both modes.
On the VPS:
./setup-google-login.sh /secure/path/loremotion-profile.tgzor:
export LOREMOTION_PROFILE_IMPORT_PATH=/secure/path/loremotion-profile.tgz
./setup-google-login.shIn a non-TTY environment with no profile import path, the script exits immediately instead of invoking interactive login.
On an interactive desktop, with no import path, it retains the existing browser-install + npm run login flow.
Browser launch configuration
LOREMOTION_EXECUTABLE_PATH
Optional absolute path to a Chromium/Chrome executable. When set, it wins over LOREMOTION_BROWSER_CHANNEL.
If unset, PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH is used automatically when available.
LOREMOTION_BROWSER_CHANNEL
Desktop fallback such as chrome. Leave it empty on a VPS that only has a bare Playwright headless-shell binary.
LOREMOTION_LAUNCH_ARGS
Comma-separated arguments passed to both chromium.launch() and chromium.launchPersistentContext().
Default:
--no-sandbox,--disable-dev-shm-usage,--disable-gpuThese defaults are intended for common headless/container/VPS deployments. Override them only when your environment requires different Chromium flags.
Duration slider handling
The live LoreMotion generator exposes duration as input[type=range] rather than a select.
The server now:
finds the most likely duration range input;
reads its current
minandmax;rejects a requested duration above the live maximum with a clear error;
writes the value using
HTMLInputElement.prototype.value's native setter;dispatches bubbling
inputandchangeevents so React observes the update;re-reads
inputValue()and verifies the requested value stuck.
Legacy select/text fallbacks remain in place for future UI variations.
Before generating, Hermes can call:
loremotion_probe_uiThe response includes durationSliders and durationSliderMax, allowing the agent to choose a legal duration for the selected model/account tier.
Prompt field handling
The live prompt textarea has a placeholder but no reliable accessible name. fillPrompt therefore prefers placeholder-based textarea matching first and only then uses generic/configured fallbacks.
Cloudflare Turnstile behavior
The generator includes cf-turnstile-response. The automation does not solve or bypass Cloudflare.
If an unsolved visible Turnstile/challenge is detected before generation, after clicking Generate, or while waiting for the result, generation fails quickly with:
Cloudflare challenge present; a signed-in profile or different egress is requiredThis prevents Hermes from wasting the full generation timeout on a blocked datacenter session.
Verify the imported login
npm run verify-loginExpected shape:
{
"signedIn": true,
"sessionMode": "persistent",
"profileDir": "/opt/loremotion-mcp/.loremotion-profile"
}Start without Hermes bootstrap
If the profile is already verified, the original server entrypoint remains valid:
node src/server.jsMCP tool check
After dependencies are installed:
npm run check-toolsThis boots the server over stdio, calls tools/list, and asserts that exactly these five tools are present:
loremotion_auth_status
loremotion_generate_video
loremotion_list_history
loremotion_download_video
loremotion_probe_uiProbe the live UI
npm run probeprobe now respects the configured headless mode instead of forcing a visible browser. It reports inputs, duration range metadata, Turnstile presence/state, links, buttons, and a screenshot path.
Selector overrides remain available:
LOREMOTION_SELECTORS_JSON={"prompt":["textarea[name=prompt]"],"generate":["button[data-testid=generate]"]}Soak test
The existing harness is retained:
npm run soak-test -- --ltx-runs 10 --ltx-duration 5 --h3-runs 10 --h3-duration 5 --aspect 16:9 --timeout-ms 600000 --verify-history trueUse loremotion_probe_ui first and set durations no higher than the live durationSliderMax. The soak harness no longer forces headed mode into its child MCP process, so .env/VPS headless settings are respected.
To download successful outputs as part of the test:
npm run soak-test -- --ltx-runs 10 --h3-runs 10 --download trueReports are written under reports/soak-<timestamp>/.
Environment variables
Variable | Purpose |
| LoreMotion base URL. |
|
|
| Persistent Chromium user-data directory. Treat it as a credential. |
| Optional directory/archive used by scripted import and Hermes bootstrap. Never a cookie/password/token. |
| Downloads, screenshots, and error artifacts. |
|
|
| Bare browser executable path; takes precedence over channel. Falls back to |
| Optional named Playwright browser channel such as |
| Comma-separated launch args. Defaults to |
| Normal Playwright action timeout. |
| Video generation wait timeout. |
| Optional Playwright slow motion. |
| Default requested LTX duration; live slider max remains authoritative. |
| Default requested H3 duration; live slider max remains authoritative. |
| Optional selector override JSON. |
PLAYWRIGHT_BROWSERS_PATH and PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH may also be provided externally by your VPS deployment.
Security
Never commit or share:
.env
.loremotion-profile/Do not expose this stdio MCP server directly to the public internet. See SECURITY.md for profile-handling guidance.
License
MIT. Independent integration; not affiliated with LoreMotion.
Available Tools
5 toolsloremotion_auth_statusA
Check whether the current LoreMotion browser session appears signed in and report whether it is persistent or anonymous.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It honestly discloses the heuristic nature of the check ('appears') and the two reportable states, implying a read-only status probe. However, it doesn't disclose edge behaviors such as what happens when no session exists, whether any network/auth call is made, or error modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single 18-word sentence with zero filler. The action verb is front-loaded, the subject and scope are precise, and the expected binary outcome is stated. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool of this simplicity — no parameters, no annotations, no output schema — the description is largely sufficient: it names what is checked and what the report will contain ('persistent or anonymous'). It could add what to do when anonymous or what the exact return shape is, but those are minor for a status probe.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so there is nothing for the description to explain beyond the baseline. The empty schema covers 100% of parameters trivially, and per the rubric 0 params earns a baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Uses a specific verb+resource pair ('Check whether the current LoreMotion browser session appears signed in') and specifies the exact output ('persistent or anonymous'). The purpose is unambiguous and clearly distinct from siblings like loremotion_generate_video and loremotion_download_video, which are about content operations, not session state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is given. The intended context is inferable — verifying session state before auth-requiring operations — and the sibling tools have no overlap, so exclusions aren't strictly needed, but the description never states when an agent should reach for this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loremotion_download_videoB
Download a generated MP4 using a video URL or LoreMotion share URL and return the local file path.
| Name | Required | Description | Default |
|---|---|---|---|
| filename | No | ||
| shareUrl | No | ||
| videoUrl | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavior. It does state that the tool downloads and returns a local file path, but it omits important behavioral details like whether authentication is required, how the file is saved or overwritten, and whether any persistent side effects occur. Given the sibling tool loremotion_auth_status, auth status seems relevant but is not mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence that front-loads the core action and key information. Every phrase adds value, with no repetition, filler, or buried detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three parameters, zero required parameters, no annotations, and no output schema, the description is too thin. It does not explain which parameter combination is valid, what filename means, what auth requirements exist, or what error conditions might arise. Agents would need to guess or probe to call this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the schema's silence. It does add useful meaning by explaining that videoUrl and shareUrl are alternative sources, but it leaves filename undefined and does not clarify whether one of the URL parameters is required, which one takes precedence, or how filename is used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action ('Download'), the resource ('generated MP4'), the input forms ('video URL or LoreMotion share URL'), and the output ('local file path'). This distinguishes it from siblings like loremotion_generate_video, which creates the video rather than downloading it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used after a video has been generated and when a videoUrl or shareUrl is available. However, it does not explicitly state when not to use it, mention prerequisites such as prior generation or authentication, or compare it to alternative sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loremotion_generate_videoB
Generate a LoreMotion video through the website. Supports a persistent signed-in session or an explicit anonymous ephemeral session. The free ad-supported flow is allowed to run normally; this tool does not bypass ads or site limits.
| Name | Required | Description | Default |
|---|---|---|---|
| wait | No | ||
| model | No | ltx-2.5 | |
| prompt | Yes | ||
| imagePath | No | Optional local image path on the MCP server machine for image-to-video. | |
| timeoutMs | No | ||
| aspectRatio | No | 16:9 | |
| durationSeconds | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it does add real behavioral context: it discloses two session modes (persistent signed-in vs anonymous ephemeral) and explicitly states that ads and site limits are not bypassed. This helps an agent anticipate auth and compliance behavior, though it still omits response shape, wait semantics, and failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler, tautology, or repetition. The primary action is front-loaded, and the second sentence adds relevant session and ad-related constraints without bloating the text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 7 parameters, no annotations, and no output schema, yet the description omits central operational details: what the call returns, what wait=false means, how timeoutMs interacts with generation, and what a successful response looks like. The session/ads context is useful but does not make the description complete enough for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 14% (only imagePath has a description), and the tool description adds no parameter-specific meaning. For 7 parameters including model, aspectRatio, durationSeconds, and timeoutMs, the agent must infer semantics from names and enums alone; the description does nothing to compensate for the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Generate a LoreMotion video through the website.' It is clearly distinct from the sibling tools (list_history, download_video, probe_ui, auth_status) because it is the creation operation, but it does not explicitly name or contrast those siblings, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The purpose itself implies when to use the tool, and the session/ads notes add context about how it may be used. However, it does not explicitly say when to prefer this over alternatives, does not state prerequisites for each session mode, and gives no negative usage guidance, so guidance remains implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loremotion_list_historyB
List recent signed-in LoreMotion history/dashboard items, which are normally retained for 48 hours on the free account.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It usefully adds that history is 'signed-in' and 'normally retained for 48 hours on the free account,' but it does not mention authentication requirements, output behavior, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence communicates the core action immediately and includes one valuable retention detail. There is no redundancy or wasted wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one optional parameter, so the description is close to adequate. However, it lacks parameter guidance, output expectations, and explicit auth context beyond the word 'signed-in,' leaving some gaps for an agent to infer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description does not mention the 'limit' parameter at all. The schema constraints (default, maximum, minimum) provide some meaning, but the description fails to compensate for the missing parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('recent signed-in LoreMotion history/dashboard items'), making the tool's purpose immediately clear. It is implicitly distinct from siblings like download_video or generate_video, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to prefer this tool over siblings such as loremotion_auth_status or loremotion_generate_video. The description states what the tool does but offers no context for selection or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
loremotion_probe_uiA
Inspect the current LoreMotion UI labels/fields and save a screenshot. Useful when the website changes and selectors need adjustment.
| Name | Required | Description | Default |
|---|---|---|---|
| pathname | No | /generate/ |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the primary action as inspection and discloses the screenshot side effect, which is important since no annotations exist. However, it doesn't specify where the screenshot is saved, whether any state is modified, or whether authentication is required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and immediate purpose, with no redundant detail. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Low-complexity tool with one optional parameter and no output schema. The description covers the intent and triggering condition, but omits what pathname does and what the screenshot/output looks like, so it is not fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never mentions the pathname parameter or its default. With only one optional parameter, this is a clear gap; the agent must infer meaning from the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a clear verb ('Inspect') and resource ('LoreMotion UI labels/fields') plus the side effect of saving a screenshot. This differentiates it from siblings like generate_video, download_video, list_history, and auth_status, which perform entirely different actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when it is useful: when the website changes and selectors need adjustment. It does not offer exclusions or name alternatives, but the use case is specific enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.0.0- First observed
loremotion_auth_status - First observed
loremotion_download_video - First observed
loremotion_generate_video - First observed
loremotion_list_history - First observed
loremotion_probe_ui
TDQS
Scored across 5 tools
Each tool addresses a distinct concern: history listing, video download, UI probing, auth status, and video generation. No overlap or ambiguity between purposes.
All tools follow the consistent 'loremotion_verb_noun' pattern, making the set predictable and easy to navigate.
Five tools is well-scoped for the server's purpose: covering authentication, generation, retrieval, and maintenance without unnecessary bloat.
Core workflow (generate, download, list history) is covered, plus auth and UI probing for robustness. Minor gaps like video deletion or status polling are not essential for the stated purpose.
Maintenance
Related MCP Connectors
Transcode, host and caption video from a prompt. Fifteen tools, nine read-only, nothing deletes.
LLM chat, text tools, image generation, editing, batch image jobs, and asynchronous video generation
Generate AI images, video, voiceovers and music from Claude, ChatGPT or Cursor through 50+ models (Veo 3.1, Kling 3, Seedance, Nano Banana, GPT Image, ElevenLabs). Also image editing, upscaling, background removal, face swap, transcription, voice cloning and UGC-style video ads. Sign in with OAuth — no API key to paste. Tools are annotated (read-only vs. credit-spending); failed generations are refunded.
Generate AI videos from a prompt or document (PDF/PPTX/DOCX/URL) and export shareable MP4s.
Related MCP Servers
- AlicenseAqualityDmaintenanceControls Google Flow for image and video generation from an AI agent. Enables generating images with models like Imagen 4, creating videos, managing characters and scenes via browser automation.1765 npm74MIT
- AlicenseAqualityBmaintenanceEnables video generation using Google AI tools (Veo, Nano Banana) via the Model Context Protocol, with browser automation powered by Playwright.24MIT
- AlicenseAqualityAmaintenanceEnables AI agents to programmatically generate images and videos through the authenticated Google Flow web interface via a direct Chrome DevTools Protocol connection, exposing tools for media generation, project management, status checks, and asset downloads without requiring official API keys.271MIT
- AlicenseAqualityAmaintenanceEnables AI agents to generate Google Flow videos and images and automate Scene Builder clip extensions through a user's own Chrome session.1165 npm1MIT