"Information on Unreal Engine" matching MCP tools:

• proximens_geo_compare_urlsA

  Proximens OracleA

  Pro-tier. Fetch two web pages (your URL and a competitor's) and audit both against the Proximens GEO Engine principles using the same audit engine as audit_url, then compute the delta. INPUT: self_url and competitor_url (both required, http/https). RETURNS: JSON with a 0-100 score per URL (same scoring as audit_url), the principles each page satisfies, the principles each page VIOLATES that the other satisfies (delta_principles), and strategic insights on where to close the gap. USE WHEN you want a competitive GEO gap analysis between your page and a rival's.

  ConnectorNo auth

• get_keyword_rank_historyA

  rankparse-mcpA

  Get the stored day-by-day ranking history for one keyword on one search engine over a date range. Reads RankParse snapshots synced on a schedule; it is not a live SERP check. History is inherently single-engine, so engine is required (use get_keyword_rankings first to compare across engines). Days with no synced data are simply absent from rows rather than filled with a zero or placeholder value -- do not treat a missing date as "not ranking". Bing and Yandex are opt-in and lower-frequency than Google; their responses may report availability as provider_limited, meaning that provider did not return enough data for that day rather than the keyword ranking nowhere.

  ConnectorNo auth

• update_template_draftA

  FaldaroA

  Save a template’s draft. Both kinds take structured `content` — see create_document_template for the node format; notifications use its EMAIL profile (no image, no pageBreak) — or, for a template still on the legacy HTML engine (check get_template_draft’s `engine`), a `body`; a structured draft refuses body-only writes. Notifications also take subject and recipients; documents also take `settings`. Editing a live template’s draft does not change what sends until publish_template. A document on the SVG facsimile engine (engine "SVG") is edited with edit_svg_template, never here. Requires notification:write or document:write.

  Connector

  Destructive

  API key

• tm_import_rvtA

  Twinmotion MCPA

  Import a Revit/BIM model into the Twinmotion visualization pipeline: downloads the source file from a public URL, uploads it to an APS OSS transient bucket, and kicks off an SVF2 + thumbnail translation job. Returns the base64 URN (project_id) used by every other tm_* tool. When to use: when a user wants to prepare a Revit (.rvt), IFC (.ifc), or other BIM/CAD model for real-time visualization in Unreal Engine / Twinmotion — typically the first step before rendering stills, defining scenes, or exporting FBX/glTF/OBJ geometry for a UE import. Also use when you need thumbnails or view metadata from a source file that has not yet been translated by APS. When NOT to use: not for MEP clash review (use navisworks-mcp), not for quantity takeoff or cost estimation (use qto-mcp), not for Twinmotion presets editing — Twinmotion itself has no public REST API, so scene/material authoring must happen manually in the UE editor after FBX/USD export. APS scopes required: data:read data:write data:create bucket:read bucket:create viewables:read. Uses Model Derivative API (translation) + OSS (upload). Twinmotion has no public REST API; all automation is APS Model Derivative + manual Unreal Engine export. Rate limits: APS default ~50 req/min per app per endpoint; Model Derivative translation jobs ~60 req/min; large .rvt/.nwd/.ifc files are often multi-GB and translation can take 5–60 min — poll the manifest with exponential backoff (start 5s, cap 60s) rather than retrying this tool. Worker request ceiling is ~100MB body; extremely large files may need signed-URL upload instead. Errors: 401 = APS token failed (check APS_CLIENT_ID/APS_CLIENT_SECRET, re-auth); 403 = scope missing (bucket:create/data:write not granted — have user re-consent); 404 = file_url unreachable; 409 = bucket key collision (rare — retry, tool uses timestamp); 413/507 = file too large for worker memory (advise signed-URL upload); 422 = unsupported source format (only Autodesk-accepted types: rvt, ifc, nwd, dwg, dgn, 3dm, stp, etc.); 429 = back off 60s before retrying; 5xx = APS upstream outage, retry with backoff. Side effects: CREATES a new transient OSS bucket (scanbim-viz-<timestamp>, auto-expires in 24h), CREATES an object in OSS, STARTS a translation job consuming APS cloud credits. NOT idempotent — each call creates a new bucket + URN. Writes a row to usage_log D1 table.

  ConnectorNo auth

• engine_infoA

  Backtest360A

  Engine version, API contract number, and health. Free (not quota-counted). Call once at the start of a session to confirm the engine is reachable and which contract it serves.

  ConnectorNo auth

• run_backtestA

  Backtest360A

  Run a historical backtest against the engine. Quota-counted and compute-bound. Validate the strategy first (validate_strategy is far cheaper). On a 504 compute timeout, do NOT retry the same request — reduce the date range, use a coarser frequency, or simplify the strategy. On 429/503, wait for the advertised Retry-After before retrying. Args: data_source: Either inline OHLCV ({"ohlcv": {dates, open, high, low, close, volume?}} as parallel arrays, ISO-8601 dates) or a server-side fetch ({"symbol", "start", "end", "frequency"} — requires a paid plan). strategy: Strategy document (indicators[] + condition_tree). Mutually exclusive with signals. signals: Precomputed signal series ({"dates": [...], "values": [-1|0|1, ...]}). Mutually exclusive with strategy. execution: Execution/cost/risk/sizing settings. Use values from get_catalog('execution-modes'/'stop-types'/'sizing-methods'); omit for engine defaults. benchmark: Optional benchmark data source (same shape as data_source) — when given, the result also carries benchmark-relative metrics (beta, alpha, information ratio, tracking error, up/down capture) and bar-alignment info. data_inputs: Optional custom time-series the strategy references (name -> {dates, values}). response_detail: 'summary' (default — headline metrics, smallest), 'stats' (every metric), 'full' (plus trades and series downsampled to a fixed, server-controlled number of points). include: Optional add-on blocks at any detail level: 'trades', 'equity_curve', 'monthly_returns', 'yearly_returns', 'signal_diagnostics' (which per-bar entry/exit conditions fired, as capped fire-date lists — {"available": false, ...} if the run has none, e.g. precomputed signals). trades_limit: Max trades returned when trades are included. Returns: The shaped result at the requested detail (including ``benchmark_relative``/``alignment`` when a benchmark was given); an oversized result is thinned and marked ``truncated_by_mcp``. If the engine rejects the request as invalid (400/422), returns {"accepted": false, "error": ...} so you can fix the named field(s) and retry. Capacity, timeout, and permission failures (e.g. 429/503/504/401/403) raise a tool error carrying explicit recovery guidance.

  ConnectorNo auth

• create_guidesA

  serpmanticsA

  Create new guides Create one or more new guides based on provided queries. Each guide targets exactly ONE engine and ONE analysis mode, chosen with the optional `source` field (default `google`). How to request each guide type: 1. Google SERP guide (1 credit per guide): omit `source`, or pass `source: "google"`. Example payload: {"queries": ["best crm"], "lang": "en-us"} 1bis. Google AI Overview guide (1 credit per guide). Two modes, like AI engines: `source: "google_ai_overview"` builds the guide from the TEXT of Google's AI answers (AI Overview, completed with AI Mode answers) ; `source: "google_ai_overview_citations"` builds it from the content of the web SOURCES those answers cite (recommended for GEO). Same language/country parameters as a Google SERP guide, 1 credit per guide in both modes. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "google_ai_overview_citations"} 2. LLM ANSWER guide (4 credits per guide): pass the engine name alone, e.g. `source: "chatgpt"`. The guide is built from the answer text the AI generates for the query. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "chatgpt"} 3. LLM CITATIONS guide (4 credits per guide) [RECOMMENDED AI mode]: pass the engine name with the `_citations` suffix, e.g. `source: "chatgpt_citations"`. The guide is built from the content of the web pages the AI cites in its answer. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "chatgpt_citations"} Which AI mode to pick? For GEO (getting a page visible in AI answers), prefer `<engine>_citations`: AI engines send traffic by CITING pages as sources, so the winning move is to look like the pages they cite. The answer-text mode (`<engine>` alone) is mostly useful to analyze how the AI phrases its own answer. When in doubt, pick `<engine>_citations`. The same two modes exist for every AI engine (chatgpt, perplexity, claude, gemini, grok, mistral, deepseek). To optimize the same page for several engines or modes (e.g. Google AND ChatGPT answers AND ChatGPT sources), create one guide per source value on the same query. IMPORTANT, HOW TO READ THE RESPONSE OF THIS ENDPOINT, WHICH SPENDS CREDITS. Queries listed in `guidesFailed` are PROVEN not to have produced a guide and their credit was given back (unless the account has unlimited credits, where nothing was reserved): re-sending them is free and correct. Queries listed in `guidesUnknown` have an UNDECIDABLE outcome and their credit is deliberately KEPT, because the guide was most likely written: DO NOT re-send them, you would pay for the same guide twice. Look them up in `GET /api/v1/guides` after a few minutes instead, and contact support if nothing shows up. Finally, a `200` is NOT a promise that every query produced a guide: compare `guides.length` with the number of queries you sent, never read `success` alone, and never re-send a query just because it is missing from `guides`.

  ConnectorNo auth

• verify_repayment_historyA

  droplinkedA

  Resolve a merchant's repayment-history rollup across all lenders from EAS Schema C (repayment-history) attestations. Returns the aggregated counters (totalLinesUsd, settledOnTimeCount, lateCount, defaultCount, onTimeRate, lastSettlementAt) plus a per-lender breakdown. Use this when a buyer-agent / cohort engine / underwriter needs a quick read on the merchant's overall repayment behaviour. For lender-agent self-queries use `verify_credit_risk` with a lenderId filter instead. Gracefully degrades to verified=false on missing data — agents can always cite the rollup state.

  ConnectorNo auth

• list_rankingsA

  Game Dev Outsourcing DirectoryA

  List every ranked list the directory publishes — "Overall", "3D Art in Poland", "Unreal Engine" and so on — with each list's size, URL and slug, plus the "method" string describing exactly what the order measures. Use to find the right list before calling get_ranking. Always pass the method on: these lists are ordered by size, years in business and how completely a listing is filled in, not by studio quality, and are not an endorsement.

  ConnectorNo auth

• list_content_spacesA

  ProductClankA

  List the ProductClank content spaces you can draft into — spaces the user owns, delegates for, or manages that have their content engine turned on. Returns { space_id, name }. Call this first to resolve the space_id for write_content_candidates, and confirm the target space with the user.

  ConnectorNo auth

• console_list_propertiesA

  Manifold MCPA

  The Search Console and Bing Webmaster properties the workspace's connected accounts can read. The first console call; every other console tool takes a property from here. Use when: "what sites are in my Search Console", before any console_get_* call, or to check which engine is connected. Not for: third-party sites the user does not own, use seo_get_domain_overview. Live rankings, use seo_get_serp. Returns: List. rows[]: engine (google | bing), property (the id to pass on: sc-domain:example.com, https://example.com/ or a Bing site URL), permission (Google: siteOwner, siteFullUser, siteRestrictedUser, siteUnverifiedUser; Bing: null), verified. NotConnected when no account of that engine is connected; its connect_url is where the user connects one. Cost: 0 credits. The user's own data is free; 60 console calls per minute per workspace. Cached 1 hour. Example: {"engine": "all"}

  ConnectorAPI key

• get_panchangA

  Kundlit Vedic AstrologyA

  Returns the Hindu panchang (daily Vedic almanac) for one date at one place: the five angas (tithi with paksha, nakshatra, yoga, karana, vara with its weekday lord) each with its end time, the lunar month in AMANTA reckoning with its adhika-masa flag (omitted entirely, never substituted, if the engine cannot supply the amanta month; plus the purnimanta month where the engine supplies it), sunrise/sunset/moonrise/moonset, abhijit muhurta, the auspicious choghadiya windows, and the inauspicious periods (rahu kaal, yamaganda, gulika kala). Use this for 'what is today's panchang / tithi / nakshatra' questions. If the user wants the FULL timing surface (all 16 choghadiya, the 24 horas, varjyam, bhadra, panchak, brahma muhurta) to choose a moment for an activity, call get_muhurta_timings instead. Nakshatra here is the DAY's nakshatra, not a person's birth star -- for that use get_birth_details. Read-only deterministic computation (Swiss Ephemeris, Lahiri ayanamsa); no writes, no auth, at least 30 requests/min/IP per server instance, plus a shared engine budget of at least 60/min/IP across all engine-backed tools. Any city worldwide; window times derive from that location's actual sunrise and sunset, so they differ city to city on the same date.

  ConnectorNo auth

• get_verifier_infoA

  scrapecheckA

  Free. Returns the public key, engine version, benchmark summary with sample-size labels, and scope, so you can verify any verdict offline. Call this first if your selection policy requires evidence before trusting a verification provider: every verdict this service issues verifies offline against the returned key, so you do not have to trust the service at runtime to rely on its output.

  ConnectorNo auth

• check_geoA

  GetCitedA

  Queues a run of every tracked GEO prompt against each configured AI answer engine and returns status, jobId and the prompt count. The work runs asynchronously in the worker and takes minutes; this returns as soon as it is queued. Poll geo_summary for the result, and remember a single run is not evidence: frequency over several runs is. Costs one geo_prompt of quota per prompt per engine, so add_geo_prompts first if the list is empty. Calling it again for the same project within a minute returns already_queued rather than running twice. If the last run is under 20 hours old it returns fresh and bills nothing: runs on different days are the independent samples geo_summary needs, so read it instead, or pass force: true.

  ConnectorNo auth

• engine_getA

  AeviaA

  Detail for one engine-catalog object by ref: `p<N>`, `e<N>`, `f<N>` or `m<N>`. Refs come from `engine_search` and name objects in the connected engine database. Polymorphic on the prefix: `p<N>` → process, `e<N>` → engine product system, `f<N>` → flow, `m<N>` → LCIA method. A workspace `s<N>` is a different object, read with `lca_get(ref='s<N>')`; this tool rejects it. Process detail defaults to a summary of both sides (top 20 each: product flows first, then elementary, grouped by unit, largest amount first); `section='inputs'|'outputs'` with `offset` pages one side, and `limit` (max 100) sizes the page. Every heading states the true total; a follow-up hint appears whenever rows remain. `include_providers=true` on a flow ref lists the processes that produce it. An `m<N>` returns the method's categories; `section='factors'` adds their characterization factors (rarely needed). A process's exchange rows and reference product carry `f<N>` refs, which the compose and edit tools accept directly.

  ConnectorAPI key

• view_invoice_demoA

  Factur-X: Generate & Validate E-InvoicesA

  Demonstrate the engine on bundled synthetic samples only; never checks a user's invoice. Use for product evaluation without a key. To check a supplied document, choose validate_invoice. Choose sample=valid to inspect a passing CII invoice or sample=invalid to see the missing-buyer-name finding. Both use the production XSD and EN 16931 engine; results may be cached for 24 hours for the same engine version and input. Inspect validated_at and cached; a cache hit is not a fresh run. Call with {} to validate the passing sample, or sample=downloads for PDF/CII/UBL files and the published report. Accepts no document data, URLs or extra arguments. No PDF or business-register checks in live mode. Shared rate limits return a retryable tool error; unavailable checks never become a passing result. Use explain_finding for a returned rule id. Your own invoices require validate_invoice with a verified-account trial, prepaid or monthly-plan key. Nothing is stored except reports for these public fixtures.

  ConnectorAPI key

• check_brand_citationA

  AuditAE SEO MCPA

  Ask one question of AI answer engines now; per engine: brand URL cited?, brand named and where, competitors named, cited sources, sentiment. Saved as a citation audit. Billing: 5–12¢ per engine check — Perplexity 5¢, ChatGPT 7¢, AI Overviews 9¢, Gemini 12¢ (33¢ a prompt on the four defaults), AI Mode 10¢ if asked; only answered checks bill (a repeat within an hour is cached but billed). Then the fix-it playbook get_fix_plan plans from (playbook: false skips it): at most 12¢ per answered check that didn't cite the brand, plus about 45¢ for a rollup when 2+ questions were lost. Default engines: 33¢ + at most 48¢ playbook. dry_run: true quotes it free. When to call: ask the engines now about one question, or re-check one after a fix. An audit that already ran: get_audit (free); many questions: get_share_of_voice. Returns { audit_id, report_url (public; give it to the user), results: [{engine, status, brand_mentioned, brand_url_cited, position, competitors, sources, sentiment, was_cache_hit, error_message, answer_excerpt}], citation_rate, completed, total, partial, out_of_credits, charged_cents, charged_breakdown_cents }. Past ~45 s: { audit_id, status: "running", next_step }; it finishes in the background (read with get_audit).

  ConnectorOAuth

• get_auditA

  AuditAE SEO MCPA

  Read a citation audit that already ran: per prompt and engine, brand cited or named, competitors cited or named, cited URLs; summary rates, the playbook's top actions, a report_url. Asks no engine. (The technical Site Audit is crawl_site.) Billing: free, at any balance. When to call: before paying for new checks, to see where competitors are cited instead (list_sites' latest_audit.audit_id); then get_fix_plan. Across all the site's audits: mine_competitor_prompts. Returns { audit_id, brand, domain, status, engines, prompt_count, competitor_domains, visibility_score, failure_reason, report_url, charged_cents (0), audit_charged_cents (what the run billed), summary: {answered, total, cited, mentioned, citation_rate, mention_rate, branded, non_branded, prompts_lost, by_engine, competitors: [{domain, cited_cells, cited_where_brand_not}], top_cited_domains, top_competitors_mentioned, suggested_competitor_domains, suggested_sources}, do_this_first?: [{priority, title, description, closes_lost_cells, target_hosts, verified, already_done?, evidence?}], results: [{prompt, engines: [{engine, status, cited, mentioned, competitors_cited, competitors_mentioned, urls, answer_excerpt?}]}] }. summary covers every cell; filters narrow only results. branded / non_branded: rates over questions naming / not naming the brand. do_this_first: the playbook's top 3 open actions, re-checked now on the live site (already_done: skip). suggested_competitor_domains: untracked hosts cited instead (confirm before add_site).

  ConnectorOAuth

• get_recheckA

  AuditAE SEO MCPA

  Read a recheck from schedule_recheck. Before it runs: status and run_at. After: per prompt and engine, baseline vs recheck — citations (brand URL in sources) and mentions gained or lost. Billing: free — reads stored results only; asks no engine and works at a zero balance. When to call: when asked whether fixes worked, or once run_at has passed. recheck_id reads one; site_id/domain lists the site's; nothing lists the workspace's. Status: scheduled | queued | running | complete | failed | paused (site archived; it won't run). Returns { recheck_id, status, headline (relay it), site_id, domain, run_at, ran_at, prompts, engines, baseline, audit_id, report_url, failure_reason, out_of_credits, answered, total, charged_cents, summary: {compared_cells, cited_before, cited_after, mentioned_before, mentioned_after, citation_gained: [{prompt, engine}], citation_lost, mention_gained, mention_lost, no_baseline}, results: [{prompt, engines: [{engine, before, after, after_error, citation, mention}]}] }. citation / mention: gained | lost | kept | still_missing, null if a side has no answer. A list: { rechecks: [{recheck_id, status, domain, run_at, ran_at, prompt_count, audit_id}] }.

  ConnectorOAuth

• search_toolsA

  ZeroMind (OrigoZero game engine)A

  Search the Zero tool registry. Tools are named, typed operations grouped into toolboxes (entityOps, scene, appearance, lighting, …). With no arguments, returns the toolbox overview — one row per toolbox with its purpose and tool count. `toolbox` returns all of that toolbox's tools; `query` on its own searches every tool and toolbox this world can reach — its own, the builtin library, installed libraries and imports — by meaning (`mode: "semantic"`) or by words (`mode: "keyword"`), and answers the top 25 compact rows: the callable identity, whether the hit is a tool or a toolbox (drill into a toolbox with `toolbox`), and a one-line purpose. The answer names the mode and slot that ran, the worlds it covered, and its status. A `query` given with a `toolbox` searches inside that toolbox's registered tools instead. Pass `schema: true` on a `toolbox` drill-in for full signatures, args, and examples inline, or call describe_tool for one tool's full schema. Run a result with tool_exec. Answered by the attached engine, so it needs one: world.open attaches one. `guides` answers without an engine.

  ConnectorAPI key

• world.openA

  ZeroMind (OrigoZero game engine)A

  Open a world in the editor. With an engine to open it in — one this conversation is already driving, or one you name with `session` from session.list — this MOVES that engine to the world and answers {switched, session_id, world, branch}; engine tools then act on it with nothing else to call. Otherwise it records that you want the world open and answers where it opens: the browser URL and the `zero://` URL an installed desktop engine answers to. Nothing opens from the server — the opening happens on the user's machine, and `next` says who does it (a harness with a shell runs `zeromind open <guid>`; anyone else shows the user the link). The engine that comes up binds to this conversation on its own, so engine tools work with no connect call; world.connect waits for it explicitly. An engine you did not name is never taken: when you have engines running, the answer lists them under `engines` so you can ask the user which to reuse, and any engine another conversation is driving (`claimed_by_another`) is refused — the one you are driving included, if somebody else has taken it since. Requires edit access (use world.create for a new world). A world you have deleted is refused here — world.trash lists it and world.restore brings it back. The editor binds the world's live working copy: naming a `branch` checks the name against the world's branches but does not yet choose what the editor loads — branch selection is coming. The result lists the world's branches.

  ConnectorAPI key