UnrealClientProtocol

MCP开发工具

提供方 Italink · 包名 unrealclientprotocol

开发工具 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopCursorClineClaude Code
查看接入方式

Lightweight UE5 plugin that exposes Unreal Engine's reflection system over TCP+JSON — let AI agents call UFunctions, read/write UProperties, and inspe

一句话选型结论

按资料字段整理

UnrealClientProtocol 属于开发工具类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Cursor、Cline 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 98 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

unrealclientprotocol ai-agent automation blueprint cursor

支持客户端

适用场景

unrealclientprotocolai-agentautomation

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
git clone https://github.com/Italink/UnrealClientProtocol && cd unrealclientprotocol

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Cross-platform,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Cursor、Cline,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
UnrealClientProtocol当前 未标注 stdio · 本地进程 本地部署 有 2026-04-10
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方Italink上游标注的维护方 Italink
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时unrealclientprotocol · Cross-platform本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-04-10上游最后核验时间

详细介绍

20.0 KB
来自项目仓库与上游目录的原文,未做删改

UnrealClientProtocol

Give your AI Agent a pair of hands that reach into Unreal Engine.

UnrealClientProtocol (UCP) is an atomic client communication protocol designed for AI Agents. Its core design philosophy is:

  • Don't make decisions for the Agent — give it capability.

Traditional UE automation requires writing dedicated interfaces or scripts for every operation. UCP takes the opposite approach — it exposes only the engine's atomic capabilities (call any UFunction, read/write any UPROPERTY, find objects, introspect metadata), then trusts the AI Agent's own understanding of the Unreal Engine API to compose these primitives into arbitrarily complex tasks.

This means:

  • You don't need to predefine "what it can do." The Agent isn't limited to a fixed set of predefined commands — it has access to every function and property exposed by the engine's reflection system. If the engine can do it, the Agent can do it.
  • You can shape Agent behavior with Skills. By authoring custom Skill files, you can inject domain knowledge into specific workflows — level design conventions, asset naming rules, material authoring strategies — and the Agent will combine this knowledge with the UCP protocol to work the way you define.
  • Capabilities grow as models evolve. The UCP protocol layer is stable, while AI comprehension is continuously improving. Today the Agent might need describe to explore an unfamiliar class; tomorrow it may already know it by heart. You don't need to change a single line of code to benefit from AI progress.

Why AI Agent + Atomic Protocol + Domain Skills Changes Everything

LLMs Already Understand Unreal Engine

Ask any large language model — even one not specialized for coding — "How do you get all Actors in UE via Blueprint? What's the function signature?" Most LLMs can answer accurately: UGameplayStatics::GetAllActorsOfClass, parameters are WorldContextObject and ActorClass, returns TArray.

This demonstrates that LLMs already possess deep knowledge of Unreal Engine. They understand the reflection system, know the APIs of common modules, and can map Blueprint nodes to their underlying C++ functions. This knowledge isn't exclusive to any particular model — it's a consensus across the entire LLM ecosystem.

But knowledge alone isn't capability. The "balanced" nature of LLMs means they tend toward generic, conservative responses without guidance — they know how to do it, but won't proactively act. What UCP does is simple: give them hands (the protocol) plus a behavioral framework (Skills), turning existing knowledge into actual action.

From ShaderToy to Production Materials — Skill-Driven Continuous Evolution

Take material authoring as an example. UCP's current material Skill can read and write complete material node graphs, meaning the Agent is fully capable of translating ShaderToy code into corresponding UE materials — decomposing logic, building nodes, wiring pins, compiling and verifying, all in one seamless flow.

But the distance from a demo-level effect to a production-grade engineered material isn't about protocol capability — it's about domain experience:

  • Workflow experience: Repeated logic should be abstracted into Material Functions; prefer a single parent material covering more variants over creating separate materials for each effect.
  • Craft experience: Scene, character, VFX, and UI each have different material strategies; classic techniques (FlowMap, parallax mapping, distance field blending) have proven node composition patterns.
  • Self-feedback loops: The Agent should be able to validate its own output — compile the material, check instruction count, compare against expected results — then distill successful experiences into new Skill knowledge.

This is the evolutionary direction of Skills: not a one-time instruction manual, but a continuously accumulating, ever-refining experience base. Every successful material creation can feed back into more precise Skill descriptions, making the Agent better next time.

Skill Memory Layering — A Sustainably Evolving Architecture

The Agent community is adopting a memory layer strategy called "Skills" or "Memory" that dramatically improves AI performance in specific domains by structuring experience into retrievable knowledge fragments.

For Unreal Engine, this strategy has a natural fit. UE itself is highly modular — rendering, physics, animation, UI, networking, audio — each subsystem has independent API hierarchies and best practices. This means Skill layering can naturally align with UE's module structure:```
Skills/
├── unreal-client-protocol/ # Transport: protocol spec, invocation patterns
├── unreal-object-operation/ # Foundation: property R/W, object search, metadata
├── unreal-actor-editing/ # Scene: Actor lifecycle management
├── unreal-asset-operation/ # Assets: search, dependencies, CRUD
├── unreal-material-editing/ # Materials: node graphs, HLSL, material instances
├── unreal-blueprint-editing/ # Blueprints: node graph R/W, function/event/variable editing
├── unreal-large-blueprint-analysis/ # BP Analysis: systematic large Blueprint analysis & C++ translation
├── unreal-animation/ # (future) Animation layer
└── ...


As functionality grows, the Skill system will become increasingly extensive. But this isn't a problem — based on UE's own code structure and LLMs' understanding of UE modules, Skill memory layering can be systematically constructed. When executing tasks, the Agent only loads the relevant Skill subset rather than reading all knowledge at once.

More importantly, **this is an open, community-collaborative architecture.** Any developer can write Skills for their workflow — a Technical Artist can contribute material authoring experience, a Level Designer can contribute scene building conventions, a Tools Programmer can contribute engine extension patterns — and this knowledge ultimately flows into a shared Skill ecosystem that benefits everyone.

## Features

- **Zero Intrusion** — Pure plugin architecture; drop into `Plugins/` and go, no engine source changes required
- **Reflection-Driven** — Leverages UE's native reflection system to automatically discover all `UFunction` and `UPROPERTY` fields
- **Minimal Protocol** — Only `call` command, covering every reflectable operation in the engine
- **Editor Integration** — Property writes are automatically registered with the Undo/Redo system
- **WorldContext Auto-Injection** — No need to manually pass WorldContext parameters
- **Security Controls** — Loopback-only binding, class path allowlists, and function blocklists
- **Batteries-Included Python Client** — Lightweight CLI script to talk to the engine in one line
- **Domain Skill Ecosystem** — 7 specialized Skills covering objects, Actors, assets, materials, and Blueprints; Agent loads domain knowledge on demand
- **Multi-Tool Compatible** — Skill descriptors work with Cursor / Claude Code / OpenCode and other mainstream AI coding tools

## Skill Ecosystem

The UCP protocol layer provides "atomic capabilities" — calling functions, reading/writing properties. **Domain Skills** organize these atomic capabilities into domain-specific work patterns, letting the Agent load the right expertise for each task scenario.

Currently available Skills:

| Skill | Layer | Capabilities |
|-------|-------|-------------|
| `unreal-client-protocol` | Transport | TCP/JSON communication, `call` protocol, error handling & self-correction |
| `unreal-object-operation` | Foundation | Any UObject property R/W, metadata introspection, instance search, derived class discovery, Undo/Redo |
| `unreal-actor-editing` | Scene | Actor spawn / delete / duplicate / move / select, level queries, viewport control |
| `unreal-asset-operation` | Assets | AssetRegistry search, dependency & reference analysis, asset CRUD, editor operations |
| `unreal-material-editing` | Materials | Text-based material node graph R/W, Custom HLSL, material instance editing, compilation & stats |
| `unreal-blueprint-editing` | Blueprints | Text-based Blueprint node graph R/W, function / event / macro editing, variable creation, auto-compilation |

Each Skill is a standalone SKILL.md file that the Agent reads on demand when receiving a task. Skills naturally chain through the UCP protocol layer — for example, creating a material requires `unreal-asset-operation`'s asset creation + `unreal-material-editing`'s node graph editing + `unreal-object-operation`'s property setting; the Agent automatically combines multiple Skills to complete composite tasks.

## How It Works

### Architecture Overview```mermaid
flowchart TD
    User["User"]
    Agent["AI Agent"]

    subgraph skills ["Domain Skills"]
        Proto["unreal-client-protocol<br/>Transport"]
        Obj["unreal-object-operation<br/>Foundation"]
        ActorSkill["unreal-actor-editing<br/>Scene"]
        Asset["unreal-asset-operation<br/>Assets"]
        Mat["unreal-material-editing<br/>Materials"]
        BP["unreal-blueprint-editing<br/>Blueprints"]
        BPAnalysis["unreal-large-blueprint-analysis<br/>BP Analysis"]
    end

    subgraph engine ["Unreal Engine"]
        UCP_Py["UCP.py<br/>TCP/JSON"]
        Server["FUCPServer"]
        Reflect["UE Reflection System"]
    end

    User --> Agent
    Agent --> Proto
    Agent --> Obj
    Agent --> ActorSkill
    Agent --> Asset
    Agent --> Mat
    Agent --> BP
    Agent --> BPAnalysis
    Proto --> UCP_Py
    UCP_Py --> Server
    Server --> Reflect

Transport Layer Detail```mermaid

flowchart LR
Agent["AI Agent"]
Skill["SKILL.md<br/>Protocol Descriptor"]
Python["UCP.py<br/>Python Client"]
Server["FUCPServer<br/>TCP Listener"]
Handler["FUCPRequestHandler<br/>Command Dispatch"]
Invoker["FUCPFunctionInvoker"]
Converter["FUCPParamConverter"]

Agent -- &quot;reads&quot; --&gt; Skill
Agent -- &quot;shell call&quot; --&gt; Python
Python -- &quot;TCP / JSON&quot; --&gt; Server
Server --&gt; Handler
Handler --&gt; Invoker
Invoker --&gt; Converter

### NodeCode: Text-Based Intermediate Representation for Node Graphs

For visual node graphs like materials and Blueprints, creating nodes one by one via `call`, setting properties, and wiring pins is both tedious and error-prone.
UCP introduces a NodeCode syntax — a **text-based intermediate representation (IR)** that lets AI edit node graphs as naturally as editing code.

NodeCode encodes a node graph into three sections with this basic format:```
=== scope: BaseColor ===

=== nodes ===
N0 MaterialExpressionScalarParameter {ParameterName:&quot;Roughness&quot;, DefaultValue:0.5} #a1b2c3d4...
N1 MaterialExpressionMultiply #e5f6a7b8...

=== links ===
N0 -&gt; N1.A
N1 -&gt; [BaseColor]
  • Node line: N {properties} # — GUID ensures stable identity across read/write cycles
  • Link line: N.Output -&gt; N.Input or N -&gt; [GraphOutput]

AI Interaction Flow```mermaid

sequenceDiagram
participant Agent as AI Agent
participant UCP as UCP.py
participant NC as NodeCode
participant Graph as UE Node Graph

Agent-&gt;&gt;UCP: ReadGraph(AssetPath, Scope)
UCP-&gt;&gt;NC: BuildIR
NC-&gt;&gt;Graph: Traverse nodes &amp; links
Graph--&gt;&gt;NC: Node data
NC--&gt;&gt;UCP: IR → text
UCP--&gt;&gt;Agent: Return NodeCode text

Note over Agent: Understand graph structure, generate modified text

Agent-&gt;&gt;UCP: WriteGraph(AssetPath, Scope, NewText)
UCP-&gt;&gt;NC: ParseText → new IR
NC-&gt;&gt;NC: DiffAndApply (compare old &amp; new IR)
NC-&gt;&gt;Graph: Incrementally apply changes
Graph--&gt;&gt;NC: Done
NC--&gt;&gt;UCP: Return diff result
UCP--&gt;&gt;Agent: Change summary

#### On-Demand Reading Strategy

A complex material may have dozens of output pins and subgraphs; a Blueprint may contain multiple functions and event graphs.

Serializing everything at once wastes tokens and floods the context window.

NodeCode therefore introduces a **Scope** mechanism — the Agent first gets a table of contents, then reads on demand:```mermaid
flowchart LR
    List[&quot;ListScopes&lt;br/&gt;Get scope list&quot;]
    Decide{&quot;Agent decides&lt;br/&gt;which scopes needed&quot;}
    Read1[&quot;ReadGraph&lt;br/&gt;Scope A&quot;]
    Read2[&quot;ReadGraph&lt;br/&gt;Scope B&quot;]
    Skip[&quot;Skip irrelevant scopes&quot;]
    Write1[&quot;WriteGraph&lt;br/&gt;Scope A&quot;]

    List --&gt; Decide
    Decide --&gt; Read1
    Decide --&gt; Read2
    Decide --&gt; Skip
    Read1 --&gt; Write1

For materials, ListScopes returns all output pins (BaseColor, Roughness, Normal...) and Composite: subgraphs. The Agent reads only the relevant scopes based on the task — modifying roughness only requires ReadGraph(&quot;Roughness&quot;), no need to load the entire material graph. Writes are similarly scoped; the incremental diff only affects nodes within that scope, leaving everything else untouched.

Programmatic Processing: Diff & Apply

After the Agent modifies the text, NodeCode doesn't rebuild the entire graph — it precisely applies changes through incremental diffing:```mermaid
flowchart TD
NewText["Text submitted by Agent"]
ParseText["ParseText → new IR"]
BuildOldIR["BuildIR → old IR (read from current graph)"]
Match["Match nodes<br/>GUID → key properties → class name"]
Delete["Delete: remove unmatched nodes from old graph"]
Create["Create: instantiate unmatched nodes from new IR"]
Update["Update: apply property changes to matched nodes"]
DiffLinks["Link diff: disconnect extra links, establish new ones"]
PostApply["Post-process: recompile, relayout, refresh UI"]

NewText --&gt; ParseText
ParseText --&gt; Match
BuildOldIR --&gt; Match
Match --&gt; Delete
Delete --&gt; Create
Create --&gt; Update
Update --&gt; DiffLinks
DiffLinks --&gt; PostApply

Advantages of this incremental strategy:

- **Minimal changes**: Only modifies what actually changed, leaving other nodes and links untouched
- **External link safety**: Links outside the scope are never affected
- **Protected nodes**: Critical nodes like FunctionEntry / FunctionResult are never accidentally deleted
- **Automatic post-processing**: Materials auto-recompile; Blueprints are auto-marked as needing compilation

#### Supported Graph Types

| Graph Type | API | Scope Model |
|------------|-----|-------------|
| Materials | `UMaterialGraphEditingLibrary` | Material output pins (BaseColor, Roughness...) or `Composite:` subgraphs |
| Blueprints | `UBlueprintGraphEditingLibrary` | EventGraph, `Function:`, `Macro:` |

See the NodeCode Architecture Document for detailed format specifications and usage.

## Quick Start

### 1. Install the Plugin

Copy the `UnrealClientProtocol` folder into your project&#x27;s `Plugins/` directory and restart the editor to compile.

### 2. Verify the Connection

Once the editor starts, the plugin automatically listens on `127.0.0.1:9876`. Test it with the bundled Python client:```bash
echo &#x27;{&quot;object&quot;:&quot;/Script/UnrealClientProtocol.Default__ObjectOperationLibrary&quot;,&quot;function&quot;:&quot;FindObjectInstances&quot;,&quot;params&quot;:{&quot;ClassName&quot;:&quot;/Script/Engine.World&quot;}}&#x27; | python Plugins/UnrealClientProtocol/Skills/unreal-client-protocol/scripts/UCP.py

If you see a list of World objects, you're all set.

3. Install Agent Skills

The plugin ships with a complete Skill suite under Skills/. You can copy them manually, or simply ask the Agent to do it for you.

Option A: Let the Agent install (recommended)

Send this instruction to your Agent:

> "Copy all Skill folders from Plugins/UnrealClientProtocol/Skills/ to the project's .cursor/skills/ directory and make sure the scripts work"

The Agent will handle the file copying automatically.

Option B: Manual copy

Copy all folders from Skills/ into your AI tool's Skills directory:

Tool Target Path
Cursor .cursor/skills/
Claude Code .claude/skills/
OpenCode .opencode/skills/
Other Follow your tool's Agent Skills convention

The resulting directory structure:```
.cursor/skills/ # or .claude/skills/, etc.
├── unreal-client-protocol/
│ ├── SKILL.md # Transport layer protocol descriptor
│ └── scripts/
│ └── UCP.py # Python client
├── unreal-object-operation/
│ └── SKILL.md # Object operations
├── unreal-actor-editing/
│ └── SKILL.md # Actor operations
├── unreal-asset-operation/
│ └── SKILL.md # Asset operations
├── unreal-material-editing/
│ └── SKILL.md # Material operations
├── unreal-blueprint-editing/
│ └── SKILL.md # Blueprint editing
└── unreal-large-blueprint-analysis/
└── SKILL.md # Large Blueprint analysis


**Resolving Script Execution Policy Issues (Windows)**

On Windows, PowerShell&#x27;s default execution policy may prevent the Agent from running Python scripts. If you encounter a &quot;cannot be loaded because running scripts is disabled on this system&quot; error, open PowerShell as **Administrator** and run:```powershell
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Or simply ask the Agent to run this command for you.

Once configured, when the Agent receives Unreal Engine-related instructions, it will automatically read the relevant SKILL.md and communicate with the editor via scripts/UCP.py.

> Workflow: User gives an instruction → Agent identifies and reads SKILL.md → Builds JSON commands per the protocol → Sends via UCP.py → Returns results```mermaid
sequenceDiagram
participant User
participant Agent as AI Agent
participant Skill as SKILL.md
participant UCP as UCP.py
participant UE as Unreal Editor

User-&gt;&gt;Agent: &quot;Scale all cubes in the scene by 2x&quot;
Agent-&gt;&gt;Skill: Read protocol spec
Skill--&gt;&gt;Agent: Command format &amp; object path conventions
Agent-&gt;&gt;UCP: call FindObjectInstances
UCP-&gt;&gt;UE: TCP JSON request
UE--&gt;&gt;UCP: Object list
UCP--&gt;&gt;Agent: Results
Agent-&gt;&gt;UCP: call SetObjectProperty (Scale3D × 2)
UCP-&gt;&gt;UE: TCP JSON request
UE--&gt;&gt;UCP: Success
UCP--&gt;&gt;Agent: Done
Agent-&gt;&gt;User: &quot;Scaled N cubes by 2x&quot;

```

4. Verify Agent Functionality

Send the following test prompts to your Agent to confirm the Skills are configured correctly:

  • Query the scene: "Show me what's in the current scene"
  • Read a property: "What real-world time does the current sunlight correspond to?"
  • Modify a property: "Change the time to 6 PM"
  • Call a function: "Call GetPlatformUserName to check the current username"
  • ...

If the Agent automatically constructs the correct JSON commands, invokes UCP.py, and returns results, the setup is complete.

Configuration

Configure via Editor → Project Settings → Plugins → UCP:

Setting Type Default Description
bEnabled bool true Enable or disable the plugin
Port int32 9876 TCP listen port (1024–65535)
bLoopbackOnly bool true Bind to 127.0.0.1 only
AllowedClassPrefixes TArray\ empty Class path allowlist prefixes; empty = no restriction
BlockedFunctions TArray\ empty Function blocklist; supports ClassName::FunctionName format

Known Limitations

  • Latent functions (those with FLatentActionInfo parameters) are not supported
  • Delegates cannot be passed as parameters

Roadmap

  • [x] Atomic protocol (call / reflection-driven)
  • [x] Object operations (property R/W, metadata introspection, instance search, Undo/Redo)
  • [x] Material text serialization (node graph R/W, Custom HLSL, material instance editing)
  • [x] Actor operations (spawn, delete, duplicate, select, transform)
  • [x] Asset management (AssetRegistry search, dependency analysis, CRUD, editor operations)
  • [ ] Widget text serialization
  • [ ] Niagara text serialization
  • [ ] Visual perception (screenshots / preview feedback so the Agent can "see" its own results)
  • [ ] Skill memory layering & self-feedback (experience accumulation, output self-validation, continuous knowledge growth)

License

MIT License — Copyright (c) 2025 Italink

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
UnrealClientProtocol 怎么安装?

在客户端按下面的安装命令接入:git clone https://github.com/Italink/UnrealClientProtocol && cd unrealclientprotocol。对应的包名是 unrealclientprotocol。装完在客户端配置里引用同一个包或端点。

UnrealClientProtocol 怎么在 Claude Desktop、Cursor、Cline 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

UnrealClientProtocol 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

UnrealClientProtocol 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

UnrealClientProtocol 支持哪些客户端?

资料标注支持 Claude Desktop、Cursor、Cline、Claude Code;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

UnrealClientProtocol 能提供哪些能力?

资料显示能力标签包括 unrealclientprotocol、ai-agent、automation、blueprint、cursor。具体工具清单以官方文档为准。

UnrealClientProtocol 需要什么运行环境?

运行时为 Cross-platform;属于本地进程,需要在本机装好运行环境。

UnrealClientProtocol 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-04-10。