企业官网建设流程全解析

1. 项目概述：当Unity3D遇见MCP，AI角色开发的新范式

最近在游戏开发圈里，一个词被频繁提及：MCP。如果你关注AI Agent或者Claude、Cursor这类智能编程工具，那你可能已经和它打过照面了。MCP，全称Model Context Protocol，你可以把它理解为一个标准化的“翻译官”和“接线员”。它的核心使命，是让大语言模型（LLM）能够安全、规范地调用外部工具、数据和功能。简单来说，以前你想让AI帮你查数据库，得写一堆复杂的提示词和接口描述，现在有了MCP，你只需要告诉AI“用那个数据库工具”，它自己就知道该怎么用了。

那么，把MCP引入Unity3D游戏开发，特别是智能角色构建，意味着什么？意味着开发流程的范式转移。传统游戏AI，无论是有限状态机（FSM）还是行为树（BT），其“智能”的上限在编写之初就被固定了。一个NPC巡逻、战斗、对话的逻辑，需要开发者事无巨细地预设好。而基于MCP的AI角色，其“大脑”是一个随时可以学习、可以推理、可以调用外部知识的大模型。它的行为不再完全由代码逻辑链决定，而是由对当前游戏情境（上下文）的理解和决策驱动。我们可以构建一个能真正“读懂”任务简报、动态规划行动路径、甚至与其他AI角色进行复杂协作的游戏伙伴或对手。

这个项目的目标，就是带你从零开始，在Unity3D中搭建一套基于MCP协议的AI智能角色系统。这不是一个简单的“调用API”的教程，而是一个完整的工程实践：从理解MCP Server/Client架构，到在Unity中集成MCP客户端，再到设计一套能让AI模型理解游戏世界、并安全执行动作的“工具集”，最后实现一个具有上下文感知、自主决策能力的游戏角色Demo。无论你是想为你的游戏注入真正的“灵魂”，还是探索AI与游戏结合的前沿，这篇实战指南都将提供一条清晰的路径。

2. 核心架构设计：拆解MCP在Unity中的工作流

在动手写代码之前，我们必须把整个系统的骨架搭清楚。基于MCP构建AI角色，核心在于建立一条从“游戏世界”到“AI模型”再到“游戏世界”的闭环数据流。这个架构可以清晰地分为三层：游戏环境层、MCP中介层和AI模型层。

2.1 三层架构解析：环境、协议与模型

第一层是游戏环境层，也就是你的Unity项目本身。这一层包含了游戏的所有状态：场景物件、角色位置、生命值、任务目标、玩家输入等。它是AI需要感知和作用的终极对象。

第二层是MCP中介层，这是本次实战的核心。它在Unity内部以一个“MCP客户端”的形式存在。这个客户端主要做两件事：

1. 收集与格式化上下文：它需要从游戏环境层实时抓取关键信息（例如：“玩家位于（10，0，5），生命值80%；前方10米处有一个敌人，生命值100%；任务目标是击败所有敌人”），并将这些信息按照MCP协议要求的格式（通常是结构化的JSON）进行封装，形成“游戏上下文”。
2. 暴露与调用工具：它需要向AI模型提供一系列安全的“工具”（Tools）。这些工具本质上是封装好的函数，AI可以通过MCP协议调用它们来影响游戏世界。例如，“移动工具”接收一个目标坐标，“攻击工具”指定一个目标对象，“使用道具工具”指定道具ID。MCP客户端负责验证这些调用，并将其转换为对Unity游戏对象的具体操作。

第三层是AI模型层。这通常是一个运行在远端服务器（或本地）的大语言模型服务，例如通过OpenAI API访问的GPT-4，或是本地部署的Llama 3。Unity中的MCP客户端通过WebSocket或HTTP，将封装好的上下文和可用的工具列表发送给AI模型。AI模型基于上下文进行推理，决定下一步该做什么，并选择调用一个工具，将调用指令和参数返回给MCP客户端。

整个工作流就像一场对话：

• Unity (MCP Client): “当前游戏状态是XXX，你可以使用的工具有：移动、攻击、对话。你接下来想做什么？”
• AI Model: “我分析了一下，应该先移动到（15，0，5）那个掩体后面。请调用移动工具，参数为 {“destination”: [15， 0， 5]}。”
• Unity (MCP Client): “收到，开始执行移动。” （随后驱动游戏角色对象移动）
• 移动完成后，Unity再次收集最新状态，发起新一轮“对话”。

这个架构的优势在于解耦。AI模型不需要知道Unity的GameObject、Transform是什么，它只处理结构化的上下文和工具调用。游戏逻辑也无需关心AI内部是如何思考的，它只需要提供状态和响应工具调用。MCP协议则成为了两者之间通用、安全的通信语言。

2.2 工具（Tools）设计：定义AI与游戏的交互边界

工具集的设计是整个系统的重中之重，它直接决定了AI能力的范围和安全性。设计不当，要么AI“英雄无用武之地”，要么可能让AI执行破坏游戏平衡或导致崩溃的危险操作。

设计原则：

1. 原子性：每个工具应只完成一件具体、明确的事情。比如，“移动到某点”是一个工具，“攻击某个目标”是另一个工具。避免设计“移动到某点然后攻击”这种复合工具，把决策链留给AI。
2. 安全性：工具内部必须包含参数校验和逻辑保护。例如，“移动工具”需要检查目标点是否在可行走区域（通过NavMesh采样），是否距离过远。“攻击工具”需要检查目标是否在攻击范围内，是否还存活。
3. 信息丰富性：工具的“描述”（description）字段至关重要。你需要用自然语言清晰、无歧义地向AI说明这个工具是干什么的、接受什么参数、每个参数的意义和格式。这是AI能否正确使用工具的关键。
4. 状态反馈：工具执行后，应返回明确的成功/失败结果和原因。例如，移动成功返回“已到达目的地”，失败则返回“路径被阻挡”或“目标点不可达”。这为AI的后续决策提供了重要反馈。

一个基础工具集示例：

• get_environment_state：获取当前游戏世界摘要。这是一个“只读”工具，AI可以随时调用它来刷新自己的认知。
• move_to_position：参数destination(Vector3)。驱动角色通过导航系统移动到指定坐标。
• attack_target：参数target_id(string)。命令角色攻击场景中指定ID的敌人。
• use_item：参数item_id(string)。使用背包中的指定物品。
• interact_with_object：参数object_id(string)。与场景中的可交互物件（如门、NPC）进行交互。

注意：在工具实现中，务必避免直接暴露Unity的底层API或允许执行任意代码。所有工具都应该是经过高度封装、业务逻辑明确的函数。例如，不要提供一个execute_script工具，这无异于给AI开了后门。

2.3 上下文（Context）构建：让AI“看见”游戏世界

AI模型不是神仙，它看不到你的游戏画面。它依赖你提供的“上下文”来理解当前状况。因此，如何从纷繁复杂的游戏数据中，提炼出对决策最关键的信息，并以AI易于理解的方式组织起来，是一项关键设计。

上下文信息通常包括：

1. 角色自身状态：生命值、魔法值/能量、位置、装备、技能冷却状态、当前 buff/debuff。
2. 环境状态：时间（游戏内）、天气、地图区域信息。
3. 目标信息：当前激活的任务目标、完成条件。
4. 实体信息：视野内或感知范围内的其他关键实体列表。对于每个实体，提供其ID、类型（玩家、敌人、中立NPC）、位置、生命值、阵营等。这里尤其需要注意信息过滤，不需要把场景里每一个石头、每一棵草都告诉AI，那会产生大量无关噪音，干扰判断并增加token消耗。
5. 行动历史：最近几次成功的行动和结果。这有助于AI进行连贯的序列决策。

上下文的格式推荐使用清晰的层级化JSON结构。例如：

{ “self”: { “health”: 85, “position”: [10， 0， 5], “weapon”: “assault_rifle” }, “mission”: { “current”: “eliminate_enemies”, “remaining_enemies”: 3 }, “perceived_entities”: [ {“id”: “enemy_1”， “type”: “enemy”， “position”: [15， 0， 10]， “health”: 100}， {“id”: “medkit_1”， “type”: “item”， “position”: [5， 0， 8]} ], “last_action”: “moved_to_cover” }

构建上下文的代码需要高效运行，因为它可能每帧或每个决策周期都被调用。可以考虑使用对象池来减少GC（垃圾回收）压力，并对信息进行增量更新（只有变化了的信息才重新序列化）。

3. 实战搭建：在Unity中创建MCP客户端

理论清晰后，我们进入实战环节。首先，我们需要在Unity项目中建立MCP通信能力。

3.1 环境准备与依赖集成

Unity版本建议使用2021 LTS或更新版本，以获得稳定的.NET环境。我们的核心工作是实现一个MCP客户端，这需要处理WebSocket通信和JSON序列化。

1. 创建Unity项目：新建一个3D项目，命名为“UnityMCPAI”。
2. 导入WebSocket库：Unity本身不支持WebSocket，我们需要第三方库。在Package Manager中，选择“Add package from git URL”，输入com.neuecc.unity.websockets或使用com.endel.nativewebsocket。这两个都是社区评价较高、维护活跃的WebSocket实现。这里我们以NativeWebSocket为例。
3. 导入JSON库：Newtonsoft.Json（Json.NET）是.NET生态的事实标准，功能强大。可以通过Unity的Package Manager搜索“Newtonsoft Json”并安装，或者从Asset Store获取。我们将用它来序列化上下文和解析AI返回的指令。

安装完成后，你的项目依赖就准备好了。接下来，我们创建核心的管理器。

3.2 核心管理器：MCPClientManager

我们将创建一个单例模式的MCPClientManagerMonoBehaviour，负责整个MCP生命周期的管理。

using UnityEngine; using NativeWebSocket; using Newtonsoft.Json; using System; using System.Collections.Generic; using System.Threading.Tasks; public class MCPClientManager : MonoBehaviour { public static MCPClientManager Instance { get; private set; } [Header(“MCP Server Configuration”)] [SerializeField] private string serverUrl = “ws://localhost:8080”; // MCP Server地址 [SerializeField] private float heartbeatInterval = 30f; // 心跳间隔 private WebSocket websocket; private bool isConnected = false; private float lastHeartbeatTime; // 已注册的工具字典 private Dictionary<string， Func<object， Task<object>>> tools = new Dictionary<string， Func<object， Task<object>>>(); // 当前会话的上下文 private string currentSessionContext; private void Awake() { if (Instance != null && Instance != this) { Destroy(this.gameObject); } else { Instance = this; DontDestroyOnLoad(this.gameObject); } } private async void Start() { await ConnectToServer(); } private async Task ConnectToServer() { try { websocket = new WebSocket(serverUrl); // 注册事件回调 websocket.OnOpen += OnWebSocketOpen; websocket.OnMessage += OnWebSocketMessage; websocket.OnError += OnWebSocketError; websocket.OnClose += OnWebSocketClose; await websocket.Connect(); } catch (Exception e) { Debug.LogError($“连接MCP服务器失败: {e.Message}”); } } // ... 其他方法见下文 }

这个管理器是连接的中枢。serverUrl指向你的MCP服务器（后面会讲如何搭建）。tools字典用于存储我们向AI注册的所有工具方法。

3.3 实现MCP协议核心通信

MCP协议通信基于JSON-RPC。我们需要处理连接、工具注册、调用和心跳。

1. 连接与初始化连接建立后，我们需要向服务器发送initialize请求，告知客户端信息，并获取服务器能力。

private void OnWebSocketOpen() { Debug.Log(“已连接到MCP服务器”); isConnected = true; SendInitializeRequest(); StartHeartbeat(); } private void SendInitializeRequest() { var initRequest = new { jsonrpc = “2.0”， id = 1， method = “initialize”， @params = new { protocolVersion = “0.1.0”， clientInfo = new { name = “Unity3D MCP Client”， version = “1.0.0” } } }; string message = JsonConvert.SerializeObject(initRequest); websocket.SendText(message); }

2. 工具注册在初始化成功后，服务器会返回initialized通知。随后，我们需要将定义好的工具列表发送给服务器进行注册。

// 在MCPClientManager中添加 public void RegisterTool(string toolName， Func<object， Task<object>> toolMethod， string description， JsonSchema parametersSchema = null) { if (tools.ContainsKey(toolName)) { Debug.LogWarning($“工具 ‘{toolName}’ 已注册，将被覆盖。”); } tools[toolName] = toolMethod; // 在实际项目中，这里应缓存工具的元信息（名称、描述、参数模式），用于后续的 tools/list 调用。 } // 当收到服务器就绪信号后，发送工具列表 private void SendToolsList() { // 构建工具描述列表 var toolDescriptions = new List<object>(); // 这里需要根据实际注册的工具来构建 // 示例： toolDescriptions.Add(new { name = “move_to”， description = “Move the character to a specified position”， parameters = {...} }); var listRequest = new { jsonrpc = “2.0”， id = 2， method = “tools/list”， @params = new { } }; // ... 发送请求 }

3. 处理AI的调用请求当AI决定采取行动时，它会通过MCP服务器发送一个tools/call请求。我们的客户端需要接收这个请求，找到对应的本地方法执行，并返回结果。

private async void OnWebSocketMessage(byte[] bytes) { string message = System.Text.Encoding.UTF8.GetString(bytes); Debug.Log($“收到消息: {message}”); try { dynamic jsonRpc = JsonConvert.DeserializeObject(message); string method = jsonRpc.method; switch (method) { case “tools/call”: await HandleToolCall(jsonRpc); break; case “notifications/initialized”: Debug.Log(“Server initialized， registering tools...”); SendToolsList(); break; // 处理其他协议方法... default: Debug.LogWarning($“未知的RPC方法: {method}”); break; } } catch (Exception e) { Debug.LogError($“处理消息时出错: {e.Message}”); } } private async Task HandleToolCall(dynamic callRequest) { string callId = callRequest.id; string toolName = callRequest.@params.name; object arguments = callRequest.@params.arguments; object result = null; bool success = false; string error = null; try { if (tools.TryGetValue(toolName， out var toolFunc)) { result = await toolFunc(arguments); success = true; } else { error = $“未知的工具: {toolName}”; } } catch (Exception e) { error = e.Message; } var response = new { jsonrpc = “2.0”， id = callId， result = success ? new { content = new { { “type”， “text” }， { “text”， JsonConvert.SerializeObject(result) } } } : null， error = error != null ? new { message = error } : null }; string responseMessage = JsonConvert.SerializeObject(response); websocket.SendText(responseMessage); }

4. 心跳维持为了保持连接活跃，需要定期发送心跳（ping/pong）。

private void Update() { #if !UNITY_WEBGL || UNITY_EDITOR if (websocket != null && isConnected) { websocket.DispatchMessageQueue(); } #endif // 发送心跳 if (isConnected && Time.time - lastHeartbeatTime > heartbeatInterval) { SendHeartbeat(); lastHeartbeatTime = Time.time; } } private void SendHeartbeat() { var pingRequest = new { jsonrpc = “2.0”， id = “heartbeat_” + Time.time， method = “ping”， @params = new { } }; websocket.SendText(JsonConvert.SerializeObject(pingRequest)); }

3.4 封装游戏工具方法

现在，我们来实现几个具体的工具方法。以move_to_position为例：

// 这是一个独立的工具类或放在某个角色管理器中 public class AIToolSet : MonoBehaviour { private UnityEngine.AI.NavMeshAgent navMeshAgent; void Start() { navMeshAgent = GetComponent<UnityEngine.AI.NavMeshAgent>(); // 向MCP客户端管理器注册工具 MCPClientManager.Instance.RegisterTool(“move_to_position”， MoveToPosition， “Moves the character to the specified world coordinates. Returns success or failure reason.”); } public async Task<object> MoveToPosition(object args) { // 1. 参数解析与验证 var argsDict = JsonConvert.DeserializeObject<Dictionary<string， object>>(JsonConvert.SerializeObject(args)); if (!argsDict.ContainsKey(“destination”) || !(argsDict[“destination”] is Newtonsoft.Json.Linq.JArray destArray)) { return new { success = false， reason = “Missing or invalid ‘destination’ parameter. Expected format: [x， y， z]” }; } Vector3 destination = new Vector3(Convert.ToSingle(destArray[0])， Convert.ToSingle(destArray[1])， Convert.ToSingle(destArray[2])); // 2. 游戏逻辑验证（如目标点是否在NavMesh上） UnityEngine.AI.NavMeshHit hit; if (!UnityEngine.AI.NavMesh.SamplePosition(destination， out hit， 1.0f， UnityEngine.AI.NavMesh.AllAreas)) { return new { success = false， reason = “Destination is not on a navigable surface.” }; } // 3. 执行游戏内操作 navMeshAgent.SetDestination(hit.position); // 4. 等待到达（或超时） float timeout = 10f; float startTime = Time.time; while (navMeshAgent.pathPending || navMeshAgent.remainingDistance > navMeshAgent.stoppingDistance) { if (Time.time - startTime > timeout) { return new { success = false， reason = “Move command timeout.” }; } await Task.Delay(100); // 非阻塞等待，注意在Unity协程中需小心使用Task } return new { success = true， position = new float[] { transform.position.x， transform.position.y， transform.position.z } }; } }

实操心得：在工具方法中，await Task.Delay在Unity主线程中使用需谨慎，可能会阻塞主线程。更推荐的做法是使用Unity的协程（yield return new WaitForSeconds）或基于UniTask这样的库来处理异步，并在工具方法中启动一个等待完成的信号，通过回调或事件通知MCP客户端。这里为了示例清晰使用了Task.Delay，在实际生产环境中需要根据你的异步框架进行调整。

4. 构建与配置MCP服务器端

Unity客户端准备好了，我们需要一个MCP服务器来“翻译”和转发。服务器端不直接包含游戏逻辑，它只是一个中间件，负责管理AI模型会话、转发客户端的工具列表、并将AI的决策转发回客户端。

4.1 服务器选型与快速搭建

你可以选择任何支持WebSocket和JSON-RPC的语言来构建MCP服务器，如Python、Node.js、Go等。这里以Python为例，因为它有丰富的AI生态和快速的开发效率。

我们将使用mcp这个官方Python库来简化开发。首先确保你安装了Python 3.8+。

pip install mcp

创建一个简单的服务器脚本mcp_server.py：

import asyncio from mcp import ClientSession， StdioServerParameters from mcp.client.stdio import stdio_client # 这里我们假设使用一个兼容OpenAI API的LLM服务（如本地部署的Ollama，或直接使用OpenAI） # 我们需要一个LLM客户端，例如 openai 库 import openai openai.api_base = “http://localhost:11434/v1” # 例如 Ollama 的本地地址 openai.api_key = “ollama” # 非OpenAI官方服务，key可随意 async def run_mcp_server(): # 1. 创建与Unity客户端的会话管理（这里简化，实际需管理多个会话） # 2. 通过stdio_client连接到一个“工具源”，这里我们的工具源就是Unity客户端本身。 # 但更常见的架构是：MCP Server同时连接“Unity工具源”和“LLM”。 # 我们先实现一个简单的转发逻辑。 server_params = StdioServerParameters( command=“python”， args=[“-m”， “mcp.cli”， “run”， “—no-version-check”， “path/to/your/unity_tool_adapter.py”] # 一个适配器脚本，模拟工具 ) async with stdio_client(server_params) as (read， write): async with ClientSession(read， write) as session: # 初始化会话 await session.initialize() # 列出可用工具（将从适配器脚本获取） tools_result = await session.list_tools() print(“Available tools:”， tools_result.tools) # 主循环：接收来自某个渠道（如HTTP端点）的请求，调用LLM，然后使用工具 # 此处省略网络监听部分，仅展示核心调用逻辑 # 假设我们收到了一个游戏上下文 `game_context` game_context = “Player is at (10，0，5). An enemy is at (15，0，10). Mission: eliminate all enemies.” # 构建LLM提示词 system_prompt = “““你是一个游戏内的智能角色。根据当前游戏上下文，决定下一步行动。你可以使用提供的工具。请以JSON格式回复，包含 ‘thoughts’（你的思考过程）和 ‘action’（要调用的工具名及参数）。“”” user_prompt = f“游戏上下文：{game_context}\n\n请决定你的行动。” # 调用LLM response = openai.ChatCompletion.create( model=“llama3”， # 或 “gpt-4”， “gpt-3.5-turbo” 等 messages=[ {“role”: “system”， “content”: system_prompt}， {“role”: “user”， “content”: user_prompt} ]， temperature=0.7， ) llm_output = response.choices[0].message.content print(f“LLM Output: {llm_output}”) # 解析LLM输出，提取工具调用信息（这里需要稳健的解析逻辑） # 假设解析出 tool_name 和 arguments tool_name = “move_to_position” arguments = {“destination”: [12， 0， 7]} # 通过MCP会话调用工具 try: result = await session.call_tool(tool_name， arguments) print(f“Tool call result: {result}”) except Exception as e: print(f“Tool call failed: {e}”) if __name__ == “__main__”: asyncio.run(run_mcp_server())

这个示例展示了MCP服务器的核心循环：获取上下文 -> 询问LLM -> 解析决策 -> 调用工具 -> 获取结果。在实际项目中，服务器需要处理多个客户端的连接，并可能对接不同的LLM提供商。

4.2 连接AI模型：提示词工程与决策解析

让AI模型做出合理的游戏决策，提示词（Prompt）的设计至关重要。你需要清晰地定义AI的角色、目标、可用工具和输出格式。

一个更结构化的提示词示例：

你是一个第一人称射击游戏中的精英士兵AI。你的首要目标是高效、安全地完成当前任务。 ## 游戏规则 - 你有生命值，降至0即失败。 - 敌人会攻击你，寻找掩体是关键。 - 弹药是有限的。 ## 可用工具 {mcp_tools_list} // 这里动态插入从MCP获取的工具列表描述 ## 输出格式 你必须严格按以下JSON格式回应： { “reasoning”: “简要说明你的思考过程，为什么选择这个行动。”， “action”: { “name”: “工具名”， “arguments”: { /* 工具所需的参数对象 */ } } } ## 当前游戏上下文 {current_game_context} 现在，请决定你的下一个行动。

在服务器端，你需要编写逻辑来解析LLM的返回。LLM可能不会100%输出完美JSON，所以需要包含一个“后处理”步骤：使用正则表达式提取JSON块，或者让LLM在思考链（Chain-of-Thought）中先输出JSON。更可靠的方法是使用LLM的“函数调用”（Function Calling）或“JSON模式”（JSON Mode）功能，但这要求LLM API本身支持。对于不支持这些功能的模型，稳健的文本解析是必要的。

注意事项：LLM的“幻觉”（Hallucination）问题在游戏中也存在。它可能会尝试调用一个不存在的工具，或者给出参数格式完全错误的指令。因此，在服务器端调用session.call_tool之前，必须进行严格的参数校验和工具存在性检查。MCP库本身会进行一部分校验，但额外的防御性编程能让你的系统更健壮。

5. 在Unity中集成与测试智能角色

现在，我们将把前面所有的部分串联起来，在Unity场景中创建一个可被AI驱动的角色。

5.1 场景与角色设置

1. 在Unity中创建一个简单场景，包含地面（带NavMesh）、几个立方体作为掩体、一个代表敌人的简单物体。
2. 创建一个胶囊体作为你的AI角色，为其添加NavMeshAgent组件，并调整速度、加速度、制动距离等参数。
3. 将之前编写的AIToolSet脚本挂载到AI角色上。
4. 确保MCPClientManager预制体或游戏对象存在于场景中，并正确配置了MCP服务器的URL。

5.2 上下文收集器的实现

我们需要一个脚本，定期（例如每秒2-4次，或每次决策前）收集游戏状态，并格式化成MCP协议需要的上下文。

public class GameContextCollector : MonoBehaviour { public GameObject aiCharacter; // AI角色自身 public List<GameObject> enemies; // 敌人列表（可通过触发器动态更新） public MissionManager missionManager; // 任务管理器引用 public string CollectCurrentContext() { var context = new { timestamp = Time.time， self = new { health = aiCharacter.GetComponent<HealthComponent>()?.CurrentHealth ?? 100， position = new float[] { aiCharacter.transform.position.x， aiCharacter.transform.position.y， aiCharacter.transform.position.z }， state = aiCharacter.GetComponent<NavMeshAgent>().isStopped ? “idle” : “moving” }， mission = missionManager?.GetCurrentMissionSummary()， environment = new { timeOfDay = WorldTime.Instance?.CurrentHour ?? 12 }， perceivedEntities = enemies.Where(e => e != null).Select(e => new { id = e.name， type = “enemy”， position = new float[] { e.transform.position.x， e.transform.position.y， e.transform.position.z }， health = e.GetComponent<HealthComponent>()?.CurrentHealth ?? 100 }).ToList() }; return JsonConvert.SerializeObject(context); } // 这个方法由MCPClientManager定期调用，或由某个决策触发器调用 public string GetContextAndTriggerDecision() { string context = CollectCurrentContext(); // 将上下文发送给MCP服务器，触发AI决策 MCPClientManager.Instance.SendContextToServer(context); return context; } }

5.3 决策循环与动作执行

最后，我们需要建立一个决策循环。这个循环不应该每帧运行，那样会给服务器和网络带来巨大压力，也不符合人类反应的节奏。一个更合理的方式是基于事件驱动：

• 定时驱动：每2-3秒触发一次决策。
• 状态变化驱动：当关键状态改变时触发（如发现新敌人、生命值低于阈值、到达路径点）。
• 动作完成驱动：当一个工具调用（如移动）执行完毕后，自动触发下一次决策。

在MCPClientManager中，我们可以添加一个协程来管理这个循环：

private IEnumerator DecisionLoopCoroutine(float interval) { while (isConnected) { yield return new WaitForSeconds(interval); if (!isWaitingForResponse) { // 避免重叠请求 RequestAIDecision(); } } } private async void RequestAIDecision() { isWaitingForResponse = true; try { // 1. 收集上下文 string context = FindObjectOfType<GameContextCollector>().CollectCurrentContext(); // 2. 通过WebSocket发送一个自定义的RPC请求，通知服务器“请基于此上下文进行决策” // 或者，服务器端可以主动轮询或通过其他方式获取上下文。 // 这里我们假设服务器在收到 `request_decision` 后，会主动调用LLM并返回工具调用。 var decisionRequest = new { jsonrpc = “2.0”， id = “decision_” + Time.time， method = “request_decision”， @params = new { context = context } }; websocket.SendText(JsonConvert.SerializeObject(decisionRequest)); } catch (Exception e) { Debug.LogError($“请求决策失败: {e.Message}”); isWaitingForResponse = false; } // isWaitingForResponse 会在收到 tools/call 响应后被重置 }

6. 调试、优化与常见问题排查

将这样一个涉及网络、AI和游戏逻辑的系统跑起来，一定会遇到各种问题。这里分享一些实战中积累的调试技巧和常见坑点。

6.1 网络与通信调试

问题1：连接失败

• 排查：首先检查MCP服务器是否已启动（python mcp_server.py）。使用netstat -an | findstr :8080(Windows) 或lsof -i :8080(Mac/Linux) 查看端口监听情况。
• 检查：Unity中的serverUrl是否正确（ws://localhost:8080）。注意WebSocket协议是ws或wss，不是http。
• 进阶：在服务器端和Unity客户端都添加详细的连接状态日志。可以在WebSocket的OnOpen，OnError，OnClose事件中打印信息。

问题2：收不到AI响应

• 排查：打开Unity的Debug Log和MCP服务器的控制台输出。查看从Unity发出的request_decision消息是否被服务器收到，服务器调用LLM的过程是否出错，以及服务器返回的tools/call指令是否发送回Unity。
• 工具：使用Wireshark或浏览器开发者工具中的Network标签（如果服务器支持WebSocket）来监控WebSocket帧，这是最直接的网络层排查手段。

6.2 AI行为逻辑调试

问题3：AI行为愚蠢或循环

• 检查提示词：LLM的表现极度依赖提示词。检查你的系统提示词是否清晰定义了目标、规则和输出格式。尝试在提示词中加入“避免重复无效动作”等约束。
• 检查上下文质量：AI的决策基于你提供的上下文。打印出CollectCurrentContext生成的JSON，看看信息是否准确、完整、无歧义。过多无关信息会干扰AI。
• 检查工具反馈：当AI调用工具失败时，返回的错误信息是否清晰？例如“目标点不可达”比“调用失败”更有用。AI可以根据清晰的错误信息调整策略。

问题4：工具调用参数错误

• 强化参数校验：在工具方法的开头，严格检查参数类型、范围。例如，destination的Y坐标是否在地面高度附近？
• 规范化参数描述：在向MCP注册工具时，尽可能使用JSON Schema来定义参数。这能帮助一些LLM更好地生成参数。例如：

  “parameters”: { “type”: “object”， “properties”: { “destination”: { “type”: “array”， “items”: { “type”: “number” }， “description”: “The [x， y， z] world coordinates to move to.”， “minItems”: 3， “maxItems”: 3 } }， “required”: [“destination”] }

6.3 性能优化与稳定性

1. 通信频率优化：

• 不要每帧发送上下文。对于大多数游戏场景，每秒2-5次决策请求已经足够产生流畅的智能行为。过高的频率会导致网络拥堵、API费用激增和LLM响应延迟。
• 实现请求队列和防抖。确保上一个AI决策执行完毕（或超时）后再发起下一个请求。

2. 上下文精简：

• 只发送AI做决策所必需的信息。例如，如果AI不需要知道远处的装饰物，就不要把它们放进perceivedEntities。
• 对数值进行量化或归一化。例如，位置坐标可以相对于某个参考点发送，或者将生命值从(0-100)发送，而不是(0-255)。

3. 异步操作处理：

• Unity的主线程不能阻塞。所有网络请求和长时间运行的工具操作（如寻路等待）都必须放在异步任务或协程中处理，避免游戏卡顿。
• 使用UniTask等库可以更好地在Unity中管理异步流程，避免回调地狱。

4. 错误恢复与重连：

• 在网络断开或服务器错误时，实现自动重连机制。
• 如果某个工具调用连续失败多次，可以考虑将其暂时禁用，并通知AI该工具不可用，防止AI陷入死循环。

构建基于MCP的AI角色是一个将前沿AI协议与实时游戏引擎结合的激动人心的过程。它打破了传统游戏AI的脚本化边界，引入了真正的涌现式行为可能性。从简单的巡逻兵到能与玩家进行复杂战术配合的队友，其潜力巨大。当然，这条路也充满挑战，从提示词打磨到系统稳定性，都需要细致的调校。但当你看到游戏中的角色开始做出让你意想不到的合理决策时，那种成就感无疑是传统脚本编程难以比拟的。