Tiny Tool Development

// AI Plugins / Available on Fab

Unified MCP Server

One local MCP host for Unreal features that should stay independent, with UCM route aggregation for shared editor job visibility.

Editor-only loopback MCP host with provider registry, bearer-token auth, and modular tool aggregation.

Give local agents one loopback MCP host for Unreal, while individual plugins keep owning their own tool behavior.

Show on Fab Read GitHub documentation Back to catalogue
product slidesCommitted walkthrough media; documentation carries the detailed operating context.

// PRODUCT WALKTHROUGH

Visual orientation backed by the product facts below.

Use the gallery as quick orientation, then inspect mechanics, actions, outputs, integrations, and boundaries.

Overview Local loopback MCP host for Unreal

Editor-managed endpoint, token authentication, and runtime tool registry.

// THE PAIN

Before the plugin enters the chat.

Tool plugins each ship their own transport setup, and agent clients end up learning multiple patterns.

PAIN

Teams quickly grow multiple entry points, inconsistent security defaults, and fragmented logs when each feature brings its own MCP surface.

Unified MCP Server centralizes the local transport, so providers expose tools through a shared runtime contract instead of each product owning its own server semantics.

What that feels like

  • Agent wiring changes per plugin instead of a stable local entry point.
  • Tool availability depends on local boot order and duplicated runtime glue.
  • Debugging request flow is difficult when every module has separate connection setup.
// WHAT YOU GET

After — in the editor, not in a slide deck.

One loopback endpoint, many providers, clear ownership boundaries.

GAIN

UMCP keeps transport, token handling, and lifecycle in one editor module while providers register tool contracts through `IUmcpToolProvider`.

  • Loopback HTTP host on localhost with generated bearer token and port.
  • Shared provider registry with stable tool discovery for local MCP clients.
  • Request logging and explicit lifecycle controls for start, stop, and token rotation.

// HOW IT WORKS

The product architecture, inspected from the plugin surface.

These are the moving parts I would place on the page so buyers can understand what they are actually getting beyond the slide narrative.

01 / Host

The server owns lifecycle, endpoint, and token.

Editor functions start and stop the local endpoint, rotate bearer tokens, write the handshake file, and report endpoint JSON.

02 / Providers

Tool providers register contracts independently.

The IUmcpToolProvider modular feature lets other plugins publish descriptors and invocation handlers without bundling their own server.

03 / Observe

Access and runtime blocks are visible.

The editor surface exposes provider count, tool count, access journal, and explicit block/unblock controls for runtime behavior.

// FIT

Who actually reaches for this.

Projects that want Cursor/Claude/other local agents to connect to Unreal through one predictable gateway.

Unified MCP Server (UMCP) is available on Fab. It hosts local MCP transport, discovers provider tools, and aggregates editor job status through UCM routes when Unreal Capability Mesh is enabled.

// SURFACE

Where it lives in Unreal.

Project Settings, editor menu actions, provider registration, endpoint file output, and request log.

// CAPABILITY MAP

Feature groups with the value of each part made explicit.

Grouped from plugin modules, public APIs, automation hooks, and documented workflow surfaces.

One local endpoint

Agent clients get one predictable connection file instead of learning a different transport shape for every plugin.

  • Start and stop the loopback host from the editor.
  • Generate endpoint JSON and handshake files for local clients.
  • Rotate bearer tokens without rewriting provider code.
  • Expose server status for debugging setup issues.

Provider independence

UMCP is valuable because it centralizes transport while keeping domain logic outside the server.

  • Register tool descriptors through IUmcpToolProvider.
  • Keep provider plugins separately shippable.
  • Show provider and tool counts in the host surface.
  • Aggregate UCM-backed editor job visibility without forcing direct links.

Runtime control

Local automation still needs explicit controls when a tool is unavailable or should be blocked.

  • Inspect the access journal for request flow.
  • Block, unblock, and clear runtime blocks.
  • Keep localhost and bearer-token defaults front and center.
  • Surface status for client setup, not hidden logs only.

// OPERATOR TOOLS

Concrete actions, expected result, and mutation boundary.

This is the part that keeps product marketing honest: buyers can see which buttons, APIs, or MCP tools matter and what they change.

// ACTION

Start server

Why it matters
Opens the loopback MCP host for local client use.
Operator result
A client can discover Unreal tools through one endpoint.
Change surface
Changes local server runtime state.
// ACTION

Rotate token

Why it matters
Refreshes bearer authorization for the endpoint.
Operator result
Old client credentials can be invalidated.
Change surface
Updates endpoint security material.
// ACTION

Read endpoint JSON

Why it matters
Shows the client-ready connection payload.
Operator result
Setup becomes copyable and inspectable.
Change surface
Read-only.
// ACTION

Block runtime

Why it matters
Prevents a provider or runtime behavior from being used.
Operator result
Operators can pause risky surfaces without uninstalling plugins.
Change surface
Updates runtime block state.
// ACTION

Read handshake file path

Why it matters
Shows where the generated client handoff file lives.
Operator result
Local MCP setup becomes inspectable instead of tribal knowledge.
Change surface
Read-only endpoint discovery.
// ACTION

Read access journal

Why it matters
Surfaces recent requests and host activity.
Operator result
Operators can debug client/provider flow without attaching a debugger first.
Change surface
Read-only diagnostics.
// ACTION

Count providers and tools

Why it matters
Confirms what the host discovered from installed provider plugins.
Operator result
A missing integration is visible as a registry problem, not a mystery client problem.
Change surface
Read-only registry status.

// TYPICAL FLOW

From inspection to use without losing the product boundary.

01

Enable Unified MCP Server and configure host settings.

02

Enable providers/bridges that expose tools with compatible MCP contracts.

03

Start the endpoint and point your local client to the generated `mcp_endpoint.json` connection file.

// PROOF AND BOUNDARIES

Signals that make the product specific, plus the limits worth saying out loud.

Each card turns implementation facts into buyer-facing proof without pretending the tool solves the wrong problem.

Transport Local loopback MCP host
Auth Generated bearer token and rotation
Extension IUmcpToolProvider modular feature
Diagnostics Access journal, counts, blocks, endpoint JSON
Host API Start, stop, status, endpoint JSON, token rotation, handshake path
Provider API Descriptors and invocation handlers registered by provider plugins
No bundled executables The plugin hosts local transport inside the Unreal/editor environment

Outputs

What the plugin leaves behind when the workflow is doing useful work.

  • mcp_endpoint.json

    Client connection information for local MCP tools.

  • Access journal

    A readable trace of server use and request flow.

  • Tool registry

    Descriptors from installed provider plugins.

  • Runtime block state

    Operator-controlled pause points for provider or host behavior.

  • Endpoint status

    Current host, port, token, provider count, and tool count signals.

Inspection basis

The concrete code, API, and tool surfaces used to shape this product page.

  • Blueprint library

    UUmcpEditorBlueprintLibrary exposes lifecycle, endpoint, token, provider/tool counts, handshake path, and block controls.

  • Provider interface

    IUmcpToolProvider defines the registration boundary for descriptors and invocation.

  • Runtime behavior

    The host centralizes local loopback transport while domain plugins own tool semantics.

  • Aggregation path

    UCM-backed editor job visibility avoids forcing every provider to link directly against UMCP internals.

Integrations

Where the product connects without losing ownership of its own domain.

  • Provider plugins

    Any plugin can own tools and publish them through the provider interface.

  • Unreal Capability Mesh

    Mesh routes can supply shared editor job visibility.

  • Local MCP clients

    Cursor, Claude, and similar clients can use a single Unreal connection target.

  • AI plugins

    IIS and LLM Store can expose useful local operations without each shipping a separate transport story.

  • Editor tools

    Small utility plugins can become local tools when they implement provider descriptors.

Safety model

The boundaries that make the tool understandable before automation enters.

  • Loopback default

    The server is designed for local machine workflows.

  • Token auth

    Bearer token generation and rotation are first-class host actions.

  • Provider boundary

    The server does not silently invent tool behavior; providers own invocation semantics.

  • Runtime blocks

    Operators can block or clear provider/runtime availability without removing plugins.

  • Journal visibility

    Access logs make local automation observable during setup and review.

Not for

The cases where the product promise would be the wrong expectation.

  • Teams looking for a hosted remote collaboration server.

  • Plugins that need to bypass a shared local transport for policy reasons.

  • Workflows that should never expose editor actions to a local agent client.

// PRODUCT MEDIA

Tutorial and platform embeds stay attached to product context.

YouTube, Discord, LinkedIn, and Fab widgets are reserved for product presentation, explanation, support context, or tutorials. No third-party widget loads automatically.

Tutorial video

YouTube

Product walkthroughs, setup explanations, and tutorial material.

Embed source pending. No third-party widget is loaded here.

Open platform
Primary support context

Discord

Discord-first product support, quick questions, setup discussion, and community context.

Embed source pending. No third-party widget is loaded here.

Open platform
Professional context

LinkedIn

Company background, provider identity, project credibility, and listing context.

Embed source pending. No third-party widget is loaded here.

Open platform
Marketplace context

Fab

Product listing context, license details, purchase route, and marketplace availability.

Embed source pending. No third-party widget is loaded here.

Open platform

// INFORMATION

All essential product signals in one place.

Status Available on Fab
Category AI Plugins
Unreal Engine 5.4; current descriptor/build line UE 5.8
Source state UnifiedMcpServer.uplugin VersionName 1.0.10 / Version 9
Primary surface Project Settings, editor menu actions, provider registration, endpoint file output, and request log.
Marketplace Fab listing available
Direct sales None on this website
Support route Discord first; product context lives on this page
Listing context Fab for marketplace, LinkedIn for public provider identity
Fact surface 4 functions / 3 settings / 4 failure modes / 1 bridge
Boundary Editor-local loopback MCP host with provider registry, scoped bearer tokens, access policy, and redacted diagnostics.
Primary workflow Start the local MCP server, read the handshake file, configure a local client with a scoped bearer token, list tools, and call provider tools through the shared endpoint.

// NOTES

Practical boundaries.

Unified MCP Server (UMCP) is available on Fab. The implementation surface (loopback transport, token auth, lifecycle, provider registry, and UCM-backed job aggregation) is represented here.

License, checkout, and download context are handled through the Fab listing.

Works well with modular providers and bridge plugins; the server does not dictate project-specific tool logic.

UMCP publishes the transport, lifecycle, and aggregation layer. Tool behavior remains owned by provider plugins or by UCM route setup.

// LEGAL / PRIVACY

Static information page.

Purchases, downloads, marketplace accounts, and platform-specific license details are handled outside this website. Product or tutorial widgets are loaded only after activation, where configured.

Provider details are listed in the legal notice. The current site template does not set first-party cookies and does not load analytics scripts.

Legal Notice Privacy Policy

// RESOURCES

Open the channel that matches the next question.

Fab listing

Listing, license, purchase, account, and download context are handled by Fab.

Open

GitHub documentation

Manuals, quickstarts, settings references, troubleshooting, technical notes, and release material live in GitHub.

Open

Discord support (primary)

Start quick questions, setup help, support context, and product-fit discussion on Discord.

Open

Plugin support email

Formal plugin support requests can be sent to the dedicated support mailbox.

Open

LinkedIn company context

Company background, public provider identity, and listing context are available on LinkedIn; support still starts on Discord.

Open

// RELATED

Nearby tools in the catalogue.

AI Plugins

Internal Index Service

Local indexes, retrieval, context packs, embedding jobs, and agent-facing search.

View page
AI Plugins

LLM Store

Central management for AI providers, models, routes, policies, costs, and secrets.

View page
AI Plugins

Tiny Tool Execution Runtime

Owns tool, invocation, resource, and artifact lifecycle without owning transport or UCM policy.

View page

// TOOL NAVIGATION

Continue through the catalogue.

Each tool page keeps the product overview here and routes deep technical material to GitHub.

Previous: LLM Store Next: Tiny Tool Execution Runtime