Skip to main content
Glama

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_status

  • loremotion_generate_video

  • loremotion_list_history

  • loremotion_download_video

  • loremotion_probe_ui

The selector-override system and soak-test harness are retained.

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 session

Never 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_status logic 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 install

  • Network 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:

  1. LOREMOTION_EXECUTABLE_PATH=/absolute/path/to/headless_shell, or

  2. the existing PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH environment 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 .env

For the interactive desktop login, set:

LOREMOTION_SESSION_MODE=persistent
LOREMOTION_PROFILE_DIR=.loremotion-profile
LOREMOTION_HEADLESS=false
LOREMOTION_EXECUTABLE_PATH=
LOREMOTION_BROWSER_CHANNEL=chrome

Then run:

npm run login

Complete 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-profile

Transfer 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 .env

A 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-process

If 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_shell

When LOREMOTION_EXECUTABLE_PATH is blank, the code automatically uses PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH when present.

Install dependencies:

npm install

You 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-profile

Zip archive

npm run import-profile -- /secure/path/loremotion-profile.zip

Tar archive

npm run import-profile -- /secure/path/loremotion-profile.tgz

Supported archive forms are .zip, .tar, .tar.gz, and .tgz.

The importer:

  1. locates the Chromium user-data root;

  2. checks for Local State, a Default/Profile N directory, Preferences, and browser session state;

  3. removes stale Chromium lock files during the copy;

  4. stages the import beside LOREMOTION_PROFILE_DIR;

  5. preserves the current server profile as a temporary backup;

  6. installs the staged profile;

  7. launches the configured headless browser;

  8. verifies LoreMotion with the existing auth-status logic;

  9. keeps the new profile only when signedIn:true is confirmed; otherwise it restores the previous profile.

Scripted import

Instead of a CLI argument, set:

LOREMOTION_PROFILE_IMPORT_PATH=/secure/path/loremotion-profile.tgz

Then either run:

npm run import-profile

or 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.js

The 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 MCP

If 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.tgz

or:

export LOREMOTION_PROFILE_IMPORT_PATH=/secure/path/loremotion-profile.tgz
./setup-google-login.sh

In 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-gpu

These 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:

  1. finds the most likely duration range input;

  2. reads its current min and max;

  3. rejects a requested duration above the live maximum with a clear error;

  4. writes the value using HTMLInputElement.prototype.value's native setter;

  5. dispatches bubbling input and change events so React observes the update;

  6. 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_ui

The 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 required

This prevents Hermes from wasting the full generation timeout on a blocked datacenter session.

Verify the imported login

npm run verify-login

Expected 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.js

MCP tool check

After dependencies are installed:

npm run check-tools

This 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_ui

Probe the live UI

npm run probe

probe 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 true

Use 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 true

Reports are written under reports/soak-<timestamp>/.

Environment variables

Variable

Purpose

LOREMOTION_BASE_URL

LoreMotion base URL.

LOREMOTION_SESSION_MODE

persistent for signed-in operation; anonymous remains available for diagnostics.

LOREMOTION_PROFILE_DIR

Persistent Chromium user-data directory. Treat it as a credential.

LOREMOTION_PROFILE_IMPORT_PATH

Optional directory/archive used by scripted import and Hermes bootstrap. Never a cookie/password/token.

LOREMOTION_DOWNLOAD_DIR

Downloads, screenshots, and error artifacts.

LOREMOTION_HEADLESS

true on the VPS; false for interactive desktop login.

LOREMOTION_EXECUTABLE_PATH

Bare browser executable path; takes precedence over channel. Falls back to PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH.

LOREMOTION_BROWSER_CHANNEL

Optional named Playwright browser channel such as chrome; leave empty for headless shell.

LOREMOTION_LAUNCH_ARGS

Comma-separated launch args. Defaults to --no-sandbox,--disable-dev-shm-usage,--disable-gpu,--single-process.

LOREMOTION_TIMEOUT_MS

Normal Playwright action timeout.

LOREMOTION_GENERATION_TIMEOUT_MS

Video generation wait timeout.

LOREMOTION_SLOW_MO_MS

Optional Playwright slow motion.

LOREMOTION_LTX_DEFAULT_DURATION

Default requested LTX duration; live slider max remains authoritative.

LOREMOTION_H3_DEFAULT_DURATION

Default requested H3 duration; live slider max remains authoritative.

LOREMOTION_SELECTORS_JSON

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 tools
loremotion_auth_statusA

Check whether the current LoreMotion browser session appears signed in and report whether it is persistent or anonymous.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
filenameNo
shareUrlNo
videoUrlNo

TDQS

B3.3/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
waitNo
modelNoltx-2.5
promptYes
imagePathNoOptional local image path on the MCP server machine for image-to-video.
timeoutMsNo
aspectRatioNo16:9
durationSecondsNo

TDQS

B3.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters1/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNo

TDQS

B3.1/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters2/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
pathnameNo/generate/

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters2/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 5 tool updatesv1.0.0
    • First observedloremotion_auth_status
    • First observedloremotion_download_video
    • First observedloremotion_generate_video
    • First observedloremotion_list_history
    • First observedloremotion_probe_ui

TDQS

A3.7/5.0

Scored across 5 tools

Disambiguation5/5

Each tool addresses a distinct concern: history listing, video download, UI probing, auth status, and video generation. No overlap or ambiguity between purposes.

Naming Consistency5/5

All tools follow the consistent 'loremotion_verb_noun' pattern, making the set predictable and easy to navigate.

Tool Count5/5

Five tools is well-scoped for the server's purpose: covering authentication, generation, retrieval, and maintenance without unnecessary bloat.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers