update bold in chapter10

docs/chapter10/第十章 智能体通信协议.md

@@ -1,8 +1,8 @@
 # 第十章 智能体通信协议
 
-在前面的章节中，我们构建了功能完备的单体智能体，它们具备推理、工具调用和记忆能力。然而，当我们尝试构建更复杂的AI系统时，自然会有疑问：**如何让智能体与外部世界高效交互？如何让多个智能体相互协作？**
+在前面的章节中，我们构建了功能完备的单体智能体，它们具备推理、工具调用和记忆能力。然而，当我们尝试构建更复杂的AI系统时，自然会有疑问：<strong>如何让智能体与外部世界高效交互？如何让多个智能体相互协作？</strong>
 
-这正是智能体通信协议要解决的核心问题。本章将为HelloAgents框架引入三种通信协议：**MCP（Model Context Protocol）**用于智能体与工具的标准化通信，**A2A（Agent-to-Agent Protocol）**用于智能体间的点对点协作，**ANP（Agent Network Protocol）**用于构建大规模智能体网络。这三种协议共同构成了智能体通信的基础设施层。
+这正是智能体通信协议要解决的核心问题。本章将为HelloAgents框架引入三种通信协议：<strong>MCP（Model Context Protocol）</strong>用于智能体与工具的标准化通信，<strong>A2A（Agent-to-Agent Protocol）</strong>用于智能体间的点对点协作，<strong>ANP（Agent Network Protocol）</strong>用于构建大规模智能体网络。这三种协议共同构成了智能体通信的基础设施层。
 
 通过本章的学习，您将掌握智能体通信协议的设计理念和实践技能，理解三种主流协议的设计差异，学会如何选择合适的协议来解决实际问题。
 
@@ -25,7 +25,7 @@ agent.add_tool(SearchTool())
 response = agent.run("搜索最新的AI新闻，并计算相关公司的市值总和")
 ```
 
-这个智能体工作得很好，但它面临着三个根本性的限制。首先是**工具集成的困境**：每当需要访问新的外部服务（如GitHub API、数据库、文件系统），我们都必须编写专门的Tool类。这不仅工作量大，而且不同开发者编写的工具无法互相兼容。其次是**能力扩展的瓶颈**：智能体的能力被限制在预先定义的工具集内，无法动态发现和使用新的服务。最后是**协作的缺失**：当任务复杂到需要多个专业智能体协作时（如研究员+撰写员+编辑），我们只能通过手动编排来协调它们的工作。
+这个智能体工作得很好，但它面临着三个根本性的限制。首先是<strong>工具集成的困境</strong>：每当需要访问新的外部服务（如GitHub API、数据库、文件系统），我们都必须编写专门的Tool类。这不仅工作量大，而且不同开发者编写的工具无法互相兼容。其次是<strong>能力扩展的瓶颈</strong>：智能体的能力被限制在预先定义的工具集内，无法动态发现和使用新的服务。最后是<strong>协作的缺失</strong>：当任务复杂到需要多个专业智能体协作时（如研究员+撰写员+编辑），我们只能通过手动编排来协调它们的工作。
 
 让我们通过一个更具体的例子来理解这些限制。假设你要构建一个智能研究助手，它需要：
 
@@ -57,7 +57,7 @@ agent.add_tool(WeatherTool())
 
 这种方式存在明显的问题：代码重复（每个工具都要处理HTTP请求、错误处理、认证等），难以维护（API变更需要修改所有相关工具），无法复用（其他开发者的工具无法直接使用），扩展性差（添加新服务需要大量编码工作）。
 
-**通信协议的核心价值**正是解决这些问题。它提供了一套标准化的接口规范，让智能体能够以统一的方式访问各种外部服务，而无需为每个服务编写专门的适配器。这就像互联网的TCP/IP协议，它让不同的设备能够相互通信，而不需要为每种设备编写专门的通信代码。
+<strong>通信协议的核心价值</strong>正是解决这些问题。它提供了一套标准化的接口规范，让智能体能够以统一的方式访问各种外部服务，而无需为每个服务编写专门的适配器。这就像互联网的TCP/IP协议，它让不同的设备能够相互通信，而不需要为每种设备编写专门的通信代码。
 
 有了通信协议，上面的代码可以简化为：
 
@@ -77,15 +77,15 @@ agent.add_tool(github_mcp)
 agent.add_tool(database_mcp)
 ```
 
-通信协议带来的改变是根本性的：**标准化接口**让不同服务提供统一的访问方式，**互操作性**使得不同开发者的工具可以无缝集成，**动态发现**允许智能体在运行时发现新的服务和能力，**可扩展性**让系统能够轻松添加新的功能模块。
+通信协议带来的改变是根本性的：<strong>标准化接口</strong>让不同服务提供统一的访问方式，<strong>互操作性</strong>使得不同开发者的工具可以无缝集成，<strong>动态发现</strong>允许智能体在运行时发现新的服务和能力，<strong>可扩展性</strong>让系统能够轻松添加新的功能模块。
 
 ### 10.1.2 三种协议设计理念比较
 
 智能体通信协议并非单一的解决方案，而是针对不同通信场景设计的一系列标准。在本章以目前业界主流的三种协议MCP、A2A和ANP为例进行实践，下面是一个总览的比较。
 
-**（1）MCP：智能体与工具的桥梁**
+<strong>（1）MCP：智能体与工具的桥梁</strong>
 
-MCP（Model Context Protocol）由Anthropic团队提出<sup>[1]</sup>，其核心设计理念是**标准化智能体与外部工具/资源的通信方式**。想象一下，你的智能体需要访问文件系统、数据库、GitHub、Slack等各种服务。传统做法是为每个服务编写专门的适配器，这不仅工作量大，而且难以维护。MCP通过定义统一的协议规范，让所有服务都能以相同的方式被访问。
+MCP（Model Context Protocol）由Anthropic团队提出<sup>[1]</sup>，其核心设计理念是<strong>标准化智能体与外部工具/资源的通信方式</strong>。想象一下，你的智能体需要访问文件系统、数据库、GitHub、Slack等各种服务。传统做法是为每个服务编写专门的适配器，这不仅工作量大，而且难以维护。MCP通过定义统一的协议规范，让所有服务都能以相同的方式被访问。
 
 MCP的设计哲学是"上下文共享"。它不仅仅是一个RPC（远程过程调用）协议，更重要的是它允许智能体和工具之间共享丰富的上下文信息。如图10.1所示，当智能体访问一个代码仓库时，MCP服务器不仅能提供文件内容，还能提供代码结构、依赖关系、提交历史等上下文信息，让智能体能够做出更智能的决策。
 
@@ -94,9 +94,9 @@ MCP的设计哲学是"上下文共享"。它不仅仅是一个RPC（远程过程
   <p>图 10.1 MCP设计思想</p>
 </div>
 
-**（2）A2A：智能体间的对话**
+<strong>（2）A2A：智能体间的对话</strong>
 
-A2A（Agent-to-Agent Protocol）协议由Google团队提出<sup>2</sup>，其核心设计理念是**实现智能体之间的点对点通信**。与MCP关注智能体与工具的通信不同，A2A关注的是智能体之间如何相互协作。这种设计让智能体能够像人类团队一样进行对话、协商和协作。
+A2A（Agent-to-Agent Protocol）协议由Google团队提出<sup>2</sup>，其核心设计理念是<strong>实现智能体之间的点对点通信</strong>。与MCP关注智能体与工具的通信不同，A2A关注的是智能体之间如何相互协作。这种设计让智能体能够像人类团队一样进行对话、协商和协作。
 
 A2A的设计哲学是"对等通信"。如图10.2所示，在A2A网络中，每个智能体既是服务提供者，也是服务消费者。智能体可以主动发起请求，也可以响应其他智能体的请求。这种对等的设计避免了中心化协调器的瓶颈，让智能体网络更加灵活和可扩展。
 
@@ -105,9 +105,9 @@ A2A的设计哲学是"对等通信"。如图10.2所示，在A2A网络中，每
   <p>图 10.2 A2A设计思想</p>
 </div>
 
-**（3）ANP：智能体网络的基础设施**
+<strong>（3）ANP：智能体网络的基础设施</strong>
 
-ANP（Agent Network Protocol）是一个概念性的协议框架<sup>3</sup>，目前由开源社区维护，还没有成熟的生态，其核心设计理念是**构建大规模智能体网络的基础设施**。如果说MCP解决的是"如何访问工具"，A2A解决的是"如何与其他智能体对话"，那么ANP解决的是"如何在大规模网络中发现和连接智能体"。
+ANP（Agent Network Protocol）是一个概念性的协议框架<sup>3</sup>，目前由开源社区维护，还没有成熟的生态，其核心设计理念是<strong>构建大规模智能体网络的基础设施</strong>。如果说MCP解决的是"如何访问工具"，A2A解决的是"如何与其他智能体对话"，那么ANP解决的是"如何在大规模网络中发现和连接智能体"。
 
 ANP的设计哲学是"去中心化服务发现"。在一个包含成百上千个智能体的网络中，如何让智能体能够找到它需要的服务？如图10.3所示，ANP提供了服务注册、发现和路由机制，让智能体能够动态地发现网络中的其他服务，而不需要预先配置所有的连接关系。
 
@@ -123,19 +123,19 @@ ANP的设计哲学是"去中心化服务发现"。在一个包含成百上千个
   <img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/10-figures/10-table-1.png" alt="" width="85%"/>
 </div>
 
-**（4）如何选择合适的协议？**
+<strong>（4）如何选择合适的协议？</strong>
 
 目前的协议还处于发展早期，MCP的生态相对成熟，不过各种工具的时效性取决于维护者，更推荐选择大公司背书的MCP工具。
 
 选择协议的关键在于理解你的需求：
 
-- 如果你的智能体需要访问外部服务（文件、数据库、API），选择**MCP**
-- 如果你需要多个智能体相互协作完成任务，选择**A2A**
-- 如果你要构建大规模的智能体生态系统，考虑**ANP**
+- 如果你的智能体需要访问外部服务（文件、数据库、API），选择<strong>MCP</strong>
+- 如果你需要多个智能体相互协作完成任务，选择<strong>A2A</strong>
+- 如果你要构建大规模的智能体生态系统，考虑<strong>ANP</strong>
 
 ### 10.1.3 HelloAgents通信协议架构设计
 
-在理解了三种协议的设计理念后，让我们看看如何在HelloAgents框架中实现和使用它们。我们的设计目标是：**让学习者能够以最简单的方式使用这些协议，同时保持足够的灵活性以应对复杂场景**。
+在理解了三种协议的设计理念后，让我们看看如何在HelloAgents框架中实现和使用它们。我们的设计目标是：<strong>让学习者能够以最简单的方式使用这些协议，同时保持足够的灵活性以应对复杂场景</strong>。
 
 如图10.4所示，HelloAgents的通信协议架构采用三层设计，从底层到上层分别是：协议实现层、工具封装层和智能体集成层。
 
@@ -144,11 +144,11 @@ ANP的设计哲学是"去中心化服务发现"。在一个包含成百上千个
   <p>图 10.4 HelloAgents通信协议设计</p>
 </div>
 
-**（1）协议实现层**：这一层包含了三种协议的具体实现。MCP基于FastMCP库实现，提供客户端和服务器功能；A2A基于Google官方的a2a-sdk实现；ANP是我们自研的轻量级实现，提供服务发现和网络管理功能，当然目前也有官方的[实现](https://github.com/agent-network-protocol/AgentConnect)，考虑到后期的迭代，因此这里只做概念的模拟。
+<strong>（1）协议实现层</strong>：这一层包含了三种协议的具体实现。MCP基于FastMCP库实现，提供客户端和服务器功能；A2A基于Google官方的a2a-sdk实现；ANP是我们自研的轻量级实现，提供服务发现和网络管理功能，当然目前也有官方的[实现](https://github.com/agent-network-protocol/AgentConnect)，考虑到后期的迭代，因此这里只做概念的模拟。
 
-**（2）工具封装层**：这一层将协议实现封装成统一的Tool接口。MCPTool、A2ATool和ANPTool都继承自BaseTool，提供一致的`run()`方法。这种设计让智能体能够以相同的方式使用不同的协议。
+<strong>（2）工具封装层</strong>：这一层将协议实现封装成统一的Tool接口。MCPTool、A2ATool和ANPTool都继承自BaseTool，提供一致的`run()`方法。这种设计让智能体能够以相同的方式使用不同的协议。
 
-**（3）智能体集成层**：这一层是智能体与协议的集成点。所有的智能体（ReActAgent、SimpleAgent等）都通过Tool System来使用协议工具，无需关心底层的协议细节。
+<strong>（3）智能体集成层</strong>：这一层是智能体与协议的集成点。所有的智能体（ReActAgent、SimpleAgent等）都通过Tool System来使用协议工具，无需关心底层的协议细节。
 
 ### 10.1.4 本章学习目标与快速体验
 
@@ -217,7 +217,7 @@ print("A2A工具创建成功")
 
 ### 10.2.1 MCP协议概念介绍
 
-**（1）MCP：智能体的"USB-C"**
+<strong>（1）MCP：智能体的"USB-C"</strong>
 
 想象一下，你的智能体可能需要同时做很多事情，例如：
 - 读取本地文件系统的文档
@@ -228,9 +228,9 @@ print("A2A工具创建成功")
 
 传统方式下，你需要为每个服务编写适配器代码，处理不同的API、认证方式、错误处理等。这不仅工作量大，而且难以维护。更重要的是，不同LLM平台的function call实现差异巨大，切换模型时需要重写大量代码。
 
-MCP的出现改变了这一切。它就像USB-C统一了各种设备的连接方式一样，**MCP统一了智能体与外部工具的交互方式**。无论你使用Claude、GPT还是其他模型，只要它们支持MCP协议，就能无缝访问相同的工具和资源。
+MCP的出现改变了这一切。它就像USB-C统一了各种设备的连接方式一样，<strong>MCP统一了智能体与外部工具的交互方式</strong>。无论你使用Claude、GPT还是其他模型，只要它们支持MCP协议，就能无缝访问相同的工具和资源。
 
-**（2）MCP架构**
+<strong>（2）MCP架构</strong>
 
 MCP协议采用Host、Client、Servers三层架构设计，让我们通过图10.5的场景来理解这些组件如何协同工作。
 
@@ -241,19 +241,19 @@ MCP协议采用Host、Client、Servers三层架构设计，让我们通过图10.
   <p>图 10.5 MCP案例演示</p>
 </div>
 
-**三层架构的职责：**
+<strong>三层架构的职责：</strong>
 
-1. **Host（宿主层）**：Claude Desktop作为Host，负责接收用户提问并与Claude模型交互。Host是用户直接交互的界面，它管理整个对话流程。
+1. <strong>Host（宿主层）</strong>：Claude Desktop作为Host，负责接收用户提问并与Claude模型交互。Host是用户直接交互的界面，它管理整个对话流程。
 
-2. **Client（客户端层）**：当Claude模型决定需要访问文件系统时，Host中内置的MCP Client被激活。Client负责与适当的MCP Server建立连接，发送请求并接收响应。
+2. <strong>Client（客户端层）</strong>：当Claude模型决定需要访问文件系统时，Host中内置的MCP Client被激活。Client负责与适当的MCP Server建立连接，发送请求并接收响应。
 
-3. **Server（服务器层）**：文件系统MCP Server被调用，执行实际的文件扫描操作，访问桌面目录，并返回找到的文档列表。
+3. <strong>Server（服务器层）</strong>：文件系统MCP Server被调用，执行实际的文件扫描操作，访问桌面目录，并返回找到的文档列表。
 
-**完整的交互流程：**用户问题 → Claude Desktop(Host) → Claude模型分析 → 需要文件信息 → MCP Client连接 → 文件系统MCP Server → 执行操作 → 返回结果 → Claude生成回答 → 显示在Claude Desktop上
+<strong>完整的交互流程：</strong>用户问题 → Claude Desktop(Host) → Claude模型分析 → 需要文件信息 → MCP Client连接 → 文件系统MCP Server → 执行操作 → 返回结果 → Claude生成回答 → 显示在Claude Desktop上
 
-这种架构设计的优势在于**关注点分离**：Host专注于用户体验，Client专注于协议通信，Server专注于具体功能实现。开发者只需专注于开发对应的MCP Server，无需关心Host和Client的实现细节。
+这种架构设计的优势在于<strong>关注点分离</strong>：Host专注于用户体验，Client专注于协议通信，Server专注于具体功能实现。开发者只需专注于开发对应的MCP Server，无需关心Host和Client的实现细节。
 
-**（3）MCP的核心能力**
+<strong>（3）MCP的核心能力</strong>
 
 如表10.2所示，MCP协议提供了三大核心能力，构成完整的工具访问框架：
 
@@ -262,9 +262,9 @@ MCP协议采用Host、Client、Servers三层架构设计，让我们通过图10.
   <img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/10-figures/10-table-2.png" alt="" width="85%"/>
 </div>
 
-这三种能力的区别在于：**Tools是主动的**（执行操作），**Resources是被动的**（提供数据），**Prompts是指导性的**（提供模板）。
+这三种能力的区别在于：<strong>Tools是主动的</strong>（执行操作），<strong>Resources是被动的</strong>（提供数据），<strong>Prompts是指导性的</strong>（提供模板）。
 
-**（4）MCP的工作流程**
+<strong>（4）MCP的工作流程</strong>
 
 让我们通过一个具体例子来理解MCP的完整工作流程，如图10.6所示：
 
@@ -273,30 +273,30 @@ MCP协议采用Host、Client、Servers三层架构设计，让我们通过图10.
   <p>图 10.6 MCP案例演示</p>
 </div>
 
-一个关键问题是：**Claude（或其他LLM）是如何决定使用哪些工具的？** 
+一个关键问题是：<strong>Claude（或其他LLM）是如何决定使用哪些工具的？</strong> 
 
 当用户提出问题时，完整的工具选择流程如下：
 
-1. **工具发现阶段**：MCP Client连接到Server后，首先调用`list_tools()`获取所有可用工具的描述信息（包括工具名称、功能说明、参数定义）
+1. <strong>工具发现阶段</strong>：MCP Client连接到Server后，首先调用`list_tools()`获取所有可用工具的描述信息（包括工具名称、功能说明、参数定义）
 
-2. **上下文构建**：Client将工具列表转换为LLM能理解的格式，添加到系统提示词中。例如：
+2. <strong>上下文构建</strong>：Client将工具列表转换为LLM能理解的格式，添加到系统提示词中。例如：
    ```
    你可以使用以下工具：
    - read_file(path: str): 读取指定路径的文件内容
    - search_code(query: str, language: str): 在代码库中搜索
    ```
 
-3. **模型推理**：LLM分析用户问题和可用工具，决定是否需要调用工具以及调用哪个工具。这个决策基于工具的描述和当前对话上下文
+3. <strong>模型推理</strong>：LLM分析用户问题和可用工具，决定是否需要调用工具以及调用哪个工具。这个决策基于工具的描述和当前对话上下文
 
-4. **工具执行**：如果LLM决定使用工具，Client通过MCP Server执行所选工具，获取结果
+4. <strong>工具执行</strong>：如果LLM决定使用工具，Client通过MCP Server执行所选工具，获取结果
 
-5. **结果整合**：工具执行结果被送回给LLM，LLM结合结果生成最终回答
+5. <strong>结果整合</strong>：工具执行结果被送回给LLM，LLM结合结果生成最终回答
 
-这个过程是**完全自动化**的，LLM会根据工具描述的质量来决定是否使用以及如何使用工具。因此，编写清晰、准确的工具描述至关重要。
+这个过程是<strong>完全自动化</strong>的，LLM会根据工具描述的质量来决定是否使用以及如何使用工具。因此，编写清晰、准确的工具描述至关重要。
 
-**（5）MCP与Function Calling的差异**
+<strong>（5）MCP与Function Calling的差异</strong>
 
-很多开发者会问：**我已经在用Function Calling了，为什么还需要MCP？** 让我们通过表10.3来理解它们的区别。
+很多开发者会问：<strong>我已经在用Function Calling了，为什么还需要MCP？</strong> 让我们通过表10.3来理解它们的区别。
 
 <div align="center">
   <p>表 10.3 Function Calling 与 MCP 对比</p>
@@ -305,7 +305,7 @@ MCP协议采用Host、Client、Servers三层架构设计，让我们通过图10.
 
 这里我们以智能体需要访问GitHub仓库和本地文件系统为例子来详细对比同一个任务的两种实现
 
-**方式1：使用Function Calling**
+<strong>方式1：使用Function Calling</strong>
 
 ```python
 # 步骤1：为每个LLM提供商定义函数
@@ -363,7 +363,7 @@ if response.content[0].type == "tool_use":
     result = search_github(**tool_use.input)
 ```
 
-**方式2：使用MCP**
+<strong>方式2：使用MCP</strong>
 
 ```python
 from hello_agents.protocols import MCPClient
@@ -402,7 +402,7 @@ async with github_client:
 
 HelloAgents基于FastMCP 2.0实现了完整的MCP客户端功能。我们提供了异步和同步两种API，以适应不同的使用场景。对于大多数应用，推荐使用异步API，它能更好地处理并发请求和长时间运行的操作。下面我们将提供一个拆解的操作演示。
 
-**（1）连接到MCP服务器**
+<strong>（1）连接到MCP服务器</strong>
 
 MCP客户端支持多种连接方式，最常用的是Stdio模式（通过标准输入输出与本地进程通信）：
 
@@ -435,7 +435,7 @@ async def connect_to_server():
 asyncio.run(connect_to_server())
 ```
 
-**（2）发现可用工具**
+<strong>（2）发现可用工具</strong>
 
 连接成功后，第一步通常是查询服务器提供了哪些工具：
 
@@ -479,7 +479,7 @@ asyncio.run(discover_tools())
 #   - content (string): 文件内容
 ```
 
-**（3）调用工具**
+<strong>（3）调用工具</strong>
 
 调用工具时，只需提供工具名称和符合JSON Schema的参数：
 
@@ -524,7 +524,7 @@ async def safe_tool_call():
 asyncio.run(safe_tool_call())
 ```
 
-**（4）访问资源**
+<strong>（4）访问资源</strong>
 
 除了工具，MCP服务器还可以提供资源（Resources）：
 
@@ -538,7 +538,7 @@ resource_content = client.read_resource("file:///path/to/resource")
 print(f"资源内容：{resource_content}")
 ```
 
-**（5）使用提示模板**
+<strong>（5）使用提示模板</strong>
 
 MCP服务器可以提供预定义的提示模板（Prompts）：
 
@@ -552,7 +552,7 @@ prompt = client.get_prompt("code_review", {"language": "python"})
 print(f"提示内容：{prompt}")
 ```
 
-**（6）完整示例：使用GitHub MCP服务**
+<strong>（6）完整示例：使用GitHub MCP服务</strong>
 
 让我们通过一个完整的例子来看如何使用社区提供的GitHub MCP服务，我们将采用封装好的MCP Tools来：
 
@@ -594,9 +594,9 @@ print(result)
 
 ### 10.2.3 MCP传输方式详解
 
-MCP协议的一个重要特性是**传输层无关性**（Transport Agnostic）。这意味着MCP协议本身不依赖于特定的传输方式，可以在不同的通信通道上运行。HelloAgents基于FastMCP 2.0，提供了完整的传输方式支持，让你可以根据实际场景选择最合适的传输模式。
+MCP协议的一个重要特性是<strong>传输层无关性</strong>（Transport Agnostic）。这意味着MCP协议本身不依赖于特定的传输方式，可以在不同的通信通道上运行。HelloAgents基于FastMCP 2.0，提供了完整的传输方式支持，让你可以根据实际场景选择最合适的传输模式。
 
-**（1）传输方式概览**
+<strong>（1）传输方式概览</strong>
 
 HelloAgents的`MCPClient`支持五种传输方式，每种都有不同的使用场景，如表10.4所示：
 
@@ -605,7 +605,7 @@ HelloAgents的`MCPClient`支持五种传输方式，每种都有不同的使用
   <img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/10-figures/10-table-4.png" alt="" width="85%"/>
 </div>
 
-**（2）传输方式使用示例**
+<strong>（2）传输方式使用示例</strong>
 
 ```python
 from hello_agents.tools import MCPTool
@@ -631,7 +631,7 @@ mcp_tool = MCPTool(server_command=["npx", "-y", "@modelcontextprotocol/server-fi
 # 对于HTTP/SSE等远程传输，建议直接使用MCPClient
 ```
 
-**（3）Memory Transport - 内存传输**
+<strong>（3）Memory Transport - 内存传输</strong>
 
 适用场景：单元测试、快速原型开发
 
@@ -654,7 +654,7 @@ result = mcp_tool.run({
 print(result)
 ```
 
-**（4）Stdio Transport - 标准输入输出传输**
+<strong>（4）Stdio Transport - 标准输入输出传输</strong>
 
 适用场景：本地开发、调试、Python 脚本服务器
 
@@ -680,7 +680,7 @@ result = mcp_tool.run({
 print(result)
 ```
 
-**（5）HTTP Transport - HTTP 传输**
+<strong>（5）HTTP Transport - HTTP 传输</strong>
 
 适用场景：生产环境、远程服务、微服务架构
 
@@ -711,7 +711,7 @@ async def test_http_transport():
 # asyncio.run(test_http_transport())
 ```
 
-**（6）SSE Transport - Server-Sent Events 传输**
+<strong>（6）SSE Transport - Server-Sent Events 传输</strong>
 
 适用场景：实时通信、流式处理、长连接
 
@@ -741,7 +741,7 @@ async def test_sse_transport():
 # asyncio.run(test_sse_transport())
 ```
 
-**（7）StreamableHTTP Transport - 流式HTTP传输**
+<strong>（7）StreamableHTTP Transport - 流式HTTP传输</strong>
 
 适用场景：需要双向流式通信的HTTP场景
 
@@ -770,13 +770,13 @@ async def test_streamable_http_transport():
 
 ### 10.2.4 在智能体中使用MCP工具
 
-前面我们学习了如何直接使用MCP客户端。但在实际应用中，我们更希望让智能体**自动**调用MCP工具，而不是手动编写调用代码。HelloAgents提供了`MCPTool`包装器，让MCP服务器无缝集成到智能体的工具链中。
+前面我们学习了如何直接使用MCP客户端。但在实际应用中，我们更希望让智能体<strong>自动</strong>调用MCP工具，而不是手动编写调用代码。HelloAgents提供了`MCPTool`包装器，让MCP服务器无缝集成到智能体的工具链中。
 
-**（1）MCP工具的自动展开机制**
+<strong>（1）MCP工具的自动展开机制</strong>
 
-HelloAgents的`MCPTool`有一个特性：**自动展开**。当你添加一个MCP工具到Agent时，它会自动将MCP服务器提供的所有工具展开为独立的工具，让Agent可以像调用普通工具一样调用它们。
+HelloAgents的`MCPTool`有一个特性：<strong>自动展开</strong>。当你添加一个MCP工具到Agent时，它会自动将MCP服务器提供的所有工具展开为独立的工具，让Agent可以像调用普通工具一样调用它们。
 
-**方式1：使用内置演示服务器**
+<strong>方式1：使用内置演示服务器</strong>
 
 我们在之前实现过计算器的工具函数，在这里将他转化为MCP的服务。这是最简单的使用方式。
 
@@ -796,7 +796,7 @@ response = agent.run("计算 25 乘以 16")
 print(response)  # 输出：25 乘以 16 的结果是 400
 ```
 
-**自动展开后的工具**：
+<strong>自动展开后的工具</strong>：
 
 - `calculator_add` - 加法计算器
 - `calculator_subtract` - 减法计算器
@@ -807,11 +807,11 @@ print(response)  # 输出：25 乘以 16 的结果是 400
 
 Agent调用时只需提供参数，例如：`[TOOL_CALL:calculator_multiply:a=25,b=16]`，系统会自动处理类型转换和MCP调用。
 
-**方式2：连接外部MCP服务器**
+<strong>方式2：连接外部MCP服务器</strong>
 
 在实际项目中，你需要连接到功能更强大的MCP服务器。这些服务器可以是：
-- **社区提供的官方服务器**（如文件系统、GitHub、数据库等）
-- **你自己编写的自定义服务器**（封装业务逻辑）
+- <strong>社区提供的官方服务器</strong>（如文件系统、GitHub、数据库等）
+- <strong>你自己编写的自定义服务器</strong>（封装业务逻辑）
 
 ```python
 from hello_agents import SimpleAgent, HelloAgentsLLM
@@ -843,7 +843,7 @@ print(response)
 
 当使用多个MCP服务器时，务必为每个MCPTool指定不同的name，这个name会作为前缀添加到展开的工具名前，避免冲突。例如：`name="fs"` 会展开为 `fs_read_file`、`fs_write_file` 等。如果你需要编写自己的MCP服务器来封装特定的业务逻辑，请参考10.5节内容。
 
-**（2）MCP工具自动展开的工作原理**
+<strong>（2）MCP工具自动展开的工作原理</strong>
 
 理解自动展开机制有助于你更好地使用MCP工具。让我们深入了解它是如何工作的：
 
@@ -883,7 +883,7 @@ agent.run("计算 25 乘以 16")
 # MCP服务器接收到正确的数字类型
 ```
 
-**（3）实战案例：智能文档助手**
+<strong>（3）实战案例：智能文档助手</strong>
 
 让我们构建一个完整的智能文档助手，这里我们用一个简单的多智能体编排进行演示：
 
@@ -1028,21 +1028,21 @@ except Exception as e:
 
 ### 10.2.5 MCP社区生态
 
-MCP协议的一个巨大优势是**丰富的社区生态**。Anthropic和社区开发者已经创建了大量现成的MCP服务器，涵盖文件系统、数据库、API服务等各种场景。这意味着你不需要从零开始编写工具适配器，可以直接使用这些经过验证的服务器。
+MCP协议的一个巨大优势是<strong>丰富的社区生态</strong>。Anthropic和社区开发者已经创建了大量现成的MCP服务器，涵盖文件系统、数据库、API服务等各种场景。这意味着你不需要从零开始编写工具适配器，可以直接使用这些经过验证的服务器。
 
 这里给出MCP社区的三个资源库：
 
-1. **Awesome MCP Servers** (https://github.com/punkpeye/awesome-mcp-servers)
+1. <strong>Awesome MCP Servers</strong> (https://github.com/punkpeye/awesome-mcp-servers)
    - 社区维护的MCP服务器精选列表
    - 包含各种第三方服务器
    - 按功能分类，易于查找
 
-2. **MCP Servers Website** (https://mcpservers.org/)
+2. <strong>MCP Servers Website</strong> (https://mcpservers.org/)
    - 官方MCP服务器目录网站
    - 提供搜索和筛选功能
    - 包含使用说明和示例
 
-3. **Official MCP Servers** (https://github.com/modelcontextprotocol/servers)
+3. <strong>Official MCP Servers</strong> (https://github.com/modelcontextprotocol/servers)
    - Anthropic官方维护的服务器
    - 质量最高、文档最完善
    - 包含常用服务的实现
@@ -1061,7 +1061,7 @@ MCP协议的一个巨大优势是**丰富的社区生态**。Anthropic和社区
 
 以下是一些特别有趣的案例TODO可供参考：
 
-1. **自动化网页测试（Playwright）**
+1. <strong>自动化网页测试（Playwright）</strong>
    
    ```python
    # Agent可以自动：
@@ -1075,7 +1075,7 @@ MCP协议的一个巨大优势是**丰富的社区生态**。Anthropic和社区
    )
    ```
    
-2. **智能笔记助手（Obsidian + Perplexity）**
+2. <strong>智能笔记助手（Obsidian + Perplexity）</strong>
    ```python
    # Agent可以：
    # - 搜索最新技术资讯（Perplexity）
@@ -1084,7 +1084,7 @@ MCP协议的一个巨大优势是**丰富的社区生态**。Anthropic和社区
    # - 自动建立笔记间的链接
    ```
 
-3. **项目管理自动化（Jira + GitHub）**
+3. <strong>项目管理自动化（Jira + GitHub）</strong>
    ```python
    # Agent可以：
    # - 从GitHub Issue创建Jira任务
@@ -1093,7 +1093,7 @@ MCP协议的一个巨大优势是**丰富的社区生态**。Anthropic和社区
    # - 生成项目报告
    ```
 
-5. **内容创作工作流（YouTube + Notion + Spotify）**
+5. <strong>内容创作工作流（YouTube + Notion + Spotify）</strong>
    
    ```python
    # Agent可以：
@@ -1115,11 +1115,11 @@ MCP协议解决了智能体与工具的交互，而A2A协议则解决智能体
 
 传统的中央协调器（星型拓扑）方案存在三个主要问题：
 
-- **单点故障**：协调器失效导致系统整体瘫痪。
-- **性能瓶颈**：所有通信都经过中心节点，限制了并发。
-- **扩展困难**：增加或修改智能体需要改动中心逻辑。
+- <strong>单点故障</strong>：协调器失效导致系统整体瘫痪。
+- <strong>性能瓶颈</strong>：所有通信都经过中心节点，限制了并发。
+- <strong>扩展困难</strong>：增加或修改智能体需要改动中心逻辑。
 
-A2A协议采用点对点（P2P）架构（网状拓拓），允许智能体直接通信，从根本上解决了上述问题。它的核心是**任务（Task）**和**工件（Artifact）**这两个抽象概念，这是它与MCP最大的区别，如表10.7所示。
+A2A协议采用点对点（P2P）架构（网状拓拓），允许智能体直接通信，从根本上解决了上述问题。它的核心是<strong>任务（Task）</strong>和<strong>工件（Artifact）</strong>这两个抽象概念，这是它与MCP最大的区别，如表10.7所示。
 
 <div align="center">
   <p>表 10.7 A2A核心概念</p>
@@ -1147,7 +1147,7 @@ A2A 请求生命周期是一个序列，详细说明了请求遵循的四个主
 
 A2A现有实现大部分为`Sample Code`，并且即使有Python的实现也较为繁琐，因此这里我们只采用模拟协议思想的方式，通过A2A-SDK来继承部分功能实现。
 
-**（2）创建简单的 A2A 智能体**
+<strong>（2）创建简单的 A2A 智能体</strong>
 
 让我们创建一个A2A的智能体，同样是计算器案例作为演示：
 
@@ -1239,7 +1239,7 @@ if calc_agent:
         print()
 ```
 
-**（2）自定义 A2A 智能体**
+<strong>（2）自定义 A2A 智能体</strong>
 
 你也可以创建自己的 A2A 智能体，这里只是进行简单演示：
 
@@ -1298,7 +1298,7 @@ if custom_agent:
 
 HelloAgents 提供了统一的 A2A 工具接口。
 
-**（1）创建A2A Agent服务端**
+<strong>（1）创建A2A Agent服务端</strong>
 
 首先，让我们创建一个Agent服务端：
 
@@ -1347,7 +1347,7 @@ if __name__ == "__main__":
         print("\n服务已停止")
 ```
 
-**（2）创建A2A Agent客户端**
+<strong>（2）创建A2A Agent客户端</strong>
 
 现在，让我们创建一个客户端来与服务端通信：
 
@@ -1365,7 +1365,7 @@ print(f"收到响应：{response.get('result')}")
 # 收到响应：{'topic': 'AI在医疗领域的应用', 'findings': '关于AI在医疗领域的应用的研究结果...', 'sources': ['来源1', '来源2', '来源3']}
 ```
 
-**（3）创建Agent网络**
+<strong>（3）创建Agent网络</strong>
 
 对于多个Agent的协作，我们可以让多个Agent相互连接：
 
@@ -1461,7 +1461,7 @@ print(f"\n最终结果：\n{result}")
 
 现在让我们看看如何将A2A集成到HelloAgents的智能体中。
 
-**（1）使用A2ATool包装器**
+<strong>（1）使用A2ATool包装器</strong>
 
 ```python
 from hello_agents import SimpleAgent, HelloAgentsLLM
@@ -1489,12 +1489,12 @@ response = coordinator.run("请让研究员帮我研究AI在教育领域的应
 print(response)
 ```
 
-**（2）实战案例：智能客服系统**
+<strong>（2）实战案例：智能客服系统</strong>
 
 让我们构建一个完整的智能客服系统，包含三个Agent：
-- **接待员**：分析客户问题类型
-- **技术专家**：回答技术问题
-- **销售顾问**：回答销售问题
+- <strong>接待员</strong>：分析客户问题类型
+- <strong>技术专家</strong>：回答技术问题
+- <strong>销售顾问</strong>：回答销售问题
 
 ```python
 from hello_agents import SimpleAgent, HelloAgentsLLM
@@ -1582,7 +1582,7 @@ if __name__ == "__main__":
     handle_customer_query("如何集成到我的Python项目中？")
 ```
 
-**（3）高级用法：Agent间协商**
+<strong>（3）高级用法：Agent间协商</strong>
 
 A2A协议还支持Agent间的协商机制：
 
@@ -1655,15 +1655,15 @@ threading.Thread(target=lambda: agent2.run(port=7001), daemon=True).start()
 
 在MCP协议解决了工具调用、A2A协议解决点对点智能体协作之后，ANP协议则专注于解决大规模、开放网络环境下的智能体管理问题。
 
-在10.2和10.3节中，我们学习了MCP（工具访问）和A2A（智能体协作）。现在，让我们学习ANP（Agent Network Protocol）协议，它专注于构建**大规模、开放的智能体网络**。
+在10.2和10.3节中，我们学习了MCP（工具访问）和A2A（智能体协作）。现在，让我们学习ANP（Agent Network Protocol）协议，它专注于构建<strong>大规模、开放的智能体网络</strong>。
 
 ### 10.4.1 协议目标
 
 当一个网络中存在大量功能各异的智能体（例如，自然语言处理、图像识别、数据分析等）时，系统会面临一系列挑战：
 
-- **服务发现**：当新任务到达时，如何快速找到能够处理该任务的智能体？
-- **智能路由**：如果多个智能体都能处理同一任务，如何选择最合适的一个（如根据负载、成本等）并向其分派任务？
-- **动态扩展**：如何让新加入网络的智能体被其他成员发现和调用？
+- <strong>服务发现</strong>：当新任务到达时，如何快速找到能够处理该任务的智能体？
+- <strong>智能路由</strong>：如果多个智能体都能处理同一任务，如何选择最合适的一个（如根据负载、成本等）并向其分派任务？
+- <strong>动态扩展</strong>：如何让新加入网络的智能体被其他成员发现和调用？
 
 ANP的设计目标就是提供一套标准化的机制，来解决上述的服务发现、路由选择和网络扩展性问题。
 
@@ -1684,17 +1684,17 @@ ANP的设计目标就是提供一套标准化的机制，来解决上述的服
 
 在这个流程图里，主要包括以下几个步骤：
 
-**1. 服务的发现与匹配：**首先，智能体A通过一个公开的发现服务，基于语义或功能描述进行查询，以定位到符合其任务需求的智能体B。该发现服务通过预先爬取各智能体对外暴露的标准端点（`.well-known/agent-descriptions`）来建立索引，从而实现服务需求方与提供方的动态匹配。
+<strong>1. 服务的发现与匹配：</strong>首先，智能体A通过一个公开的发现服务，基于语义或功能描述进行查询，以定位到符合其任务需求的智能体B。该发现服务通过预先爬取各智能体对外暴露的标准端点（`.well-known/agent-descriptions`）来建立索引，从而实现服务需求方与提供方的动态匹配。
 
-**2. 基于DID的身份验证：**在交互开始时，智能体A使用其私钥对包含自身DID的请求进行签名。智能体B收到后，通过解析该DID获取对应的公钥，并以此验证签名的真实性与请求的完整性，从而建立起双方的可信通信。
+<strong>2. 基于DID的身份验证：</strong>在交互开始时，智能体A使用其私钥对包含自身DID的请求进行签名。智能体B收到后，通过解析该DID获取对应的公钥，并以此验证签名的真实性与请求的完整性，从而建立起双方的可信通信。
 
-**3. 标准化的服务执行：**身份验证通过后，智能体B响应请求，双方依据预定义的标准接口和数据格式进行数据交换或服务调用（如预订、查询等）。标准化的交互流程是实现跨平台、跨系统互操作性的基础。
+<strong>3. 标准化的服务执行：</strong>身份验证通过后，智能体B响应请求，双方依据预定义的标准接口和数据格式进行数据交换或服务调用（如预订、查询等）。标准化的交互流程是实现跨平台、跨系统互操作性的基础。
 
 总而言之，该机制的核心是利用DID构建了一个去中心化的信任根基，并借助标准化的描述协议实现了服务的动态发现。这套方法使得智能体能够在无需中央协调的前提下，安全、高效地在互联网上形成协作网络。
 
 ### 10.4.2 使用ANP服务发现
 
-**（1）创建服务发现中心**
+<strong>（1）创建服务发现中心</strong>
 
 ```python
 from hello_agents.protocols import ANPDiscovery, register_service
@@ -1726,7 +1726,7 @@ register_service(
 print("✅ 服务注册完成")
 ```
 
-**（2）发现服务**
+<strong>（2）发现服务</strong>
 
 ```python
 from hello_agents.protocols import discover_service
@@ -1740,7 +1740,7 @@ best_service = min(nlp_services, key=lambda s: s.metadata.get("load", 1.0))
 print(f"最佳服务：{best_service.service_name} (负载: {best_service.metadata['load']})")
 ```
 
-**（3）构建Agent网络**
+<strong>（3）构建Agent网络</strong>
 
 ```python
 from hello_agents.protocols import ANPNetwork
@@ -1887,18 +1887,18 @@ for i in range(10):
 
 ### 10.5.1 创建你的第一个 MCP 服务器
 
-**（1）为什么要构建自定义 MCP 服务器？**
+<strong>（1）为什么要构建自定义 MCP 服务器？</strong>
 
 虽然可以直接使用公开的MCP服务，但在许多实际应用场景中，需要构建自定义的MCP服务器以满足特定需求。
 
 主要动机包括以下几点：
 
-- **封装业务逻辑**：将企业内部特有的业务流程或复杂操作封装为标准化的MCP工具，供智能体统一调用。
-- **访问私有数据**：创建一个安全可控的接口或代理，用于访问内部数据库、API或其他无法对公网暴露的私有数据源。
-- **性能专项优化**：针对高频调用或对响应延迟有严苛要求的应用场景，进行深度优化。
-- **功能定制扩展**：实现标准MCP服务未提供的特定功能，例如集成专有算法模型或连接特定的硬件设备。
+- <strong>封装业务逻辑</strong>：将企业内部特有的业务流程或复杂操作封装为标准化的MCP工具，供智能体统一调用。
+- <strong>访问私有数据</strong>：创建一个安全可控的接口或代理，用于访问内部数据库、API或其他无法对公网暴露的私有数据源。
+- <strong>性能专项优化</strong>：针对高频调用或对响应延迟有严苛要求的应用场景，进行深度优化。
+- <strong>功能定制扩展</strong>：实现标准MCP服务未提供的特定功能，例如集成专有算法模型或连接特定的硬件设备。
 
-**（2）教学案例：天气查询 MCP 服务器**
+<strong>（2）教学案例：天气查询 MCP 服务器</strong>
 
 让我们从一个简单的天气查询服务器开始，逐步学习 MCP 服务器开发：
 
@@ -1981,7 +1981,7 @@ if __name__ == "__main__":
     weather_server.run()
 ```
 
-**（3）测试自定义 MCP 服务器**
+<strong>（3）测试自定义 MCP 服务器</strong>
 
 然后创建测试脚本：
 
@@ -2032,7 +2032,7 @@ if __name__ == "__main__":
     asyncio.run(test_weather_server())
 ```
 
-**（4）在 Agent 中使用自定义 MCP 服务器**
+<strong>（4）在 Agent 中使用自定义 MCP 服务器</strong>
 
 ```python
 """在 Agent 中使用天气 MCP 服务器"""
@@ -2271,10 +2271,10 @@ CMD ["python", "server.py"]
 
 Dockerfile 配置说明：
 
-- **基础镜像**: `python:3.12-slim-bookworm` - 轻量级 Python 镜像
-- **工作目录**: `/app` - 应用程序根目录
-- **端口**: `8081` - Smithery 平台标准端口
-- **启动命令**: `python server.py` - 运行 MCP 服务器
+- <strong>基础镜像</strong>: `python:3.12-slim-bookworm` - 轻量级 Python 镜像
+- <strong>工作目录</strong>: `/app` - 应用程序根目录
+- <strong>端口</strong>: `8081` - Smithery 平台标准端口
+- <strong>启动命令</strong>: `python server.py` - 运行 MCP 服务器
 
 在这里，我们需要Fork`hello-agents`仓库，得到`code`中的源码，并使用自己的github创建一个名为`weather-mcp-server`的仓库，将`yourusername`改为自己github的Username。
 
@@ -2333,7 +2333,7 @@ agent.add_tool(weather_tool)
 response = agent.run("北京今天天气怎么样？")
 ```
 
-当然，这里只是举例，还有更多的用法可以自行探索，下图10.11展示了当MCP工具发布成功会包含的信息，显示服务的名称“天气”，其唯一标识符 `@jjyaoao/weather-mcp-server`，以及状态信息。Tools区域就是我们刚刚实现的方法，Connect区则提供了连接和使用此服务所需的技术信息，包括服务的**接入URL地址**和多种语言/环境下的**配置代码片段**。如果想要更加深入了解可以点击这个[链接](https://smithery.ai/server/@jjyaoao/weather-mcp-server)。
+当然，这里只是举例，还有更多的用法可以自行探索，下图10.11展示了当MCP工具发布成功会包含的信息，显示服务的名称“天气”，其唯一标识符 `@jjyaoao/weather-mcp-server`，以及状态信息。Tools区域就是我们刚刚实现的方法，Connect区则提供了连接和使用此服务所需的技术信息，包括服务的<strong>接入URL地址</strong>和多种语言/环境下的<strong>配置代码片段</strong>。如果想要更加深入了解可以点击这个[链接](https://smithery.ai/server/@jjyaoao/weather-mcp-server)。
 
 <div align="center">
   <img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/10-figures/10-11.png" alt="" width="85%"/>
@@ -2348,13 +2348,13 @@ response = agent.run("北京今天天气怎么样？")
 
 本章系统性地介绍了智能体通信的三种核心协议：MCP、A2A与ANP，并探讨了它们的设计理念、应用场景与实践方法。
 
-**协议定位：**
+<strong>协议定位：</strong>
 
-- **MCP (Model Context Protocol)**: 作为智能体与工具之间的桥梁，提供统一的工具访问接口，适用于增强单个智能体的能力。
-- **A2A (Agent-to-Agent Protocol)**: 作为智能体之间的对话系统，支持直接通信与任务协商，适用于小规模团队的紧密协作。
-- **ANP (Agent Network Protocol)**: 作为智能体的“互联网”，提供服务发现、路由与负载均衡机制，适用于构建大规模、开放的智能体网络。
+- <strong>MCP (Model Context Protocol)</strong>: 作为智能体与工具之间的桥梁，提供统一的工具访问接口，适用于增强单个智能体的能力。
+- <strong>A2A (Agent-to-Agent Protocol)</strong>: 作为智能体之间的对话系统，支持直接通信与任务协商，适用于小规模团队的紧密协作。
+- <strong>ANP (Agent Network Protocol)</strong>: 作为智能体的“互联网”，提供服务发现、路由与负载均衡机制，适用于构建大规模、开放的智能体网络。
 
-**HelloAgents的集成方案**
+<strong>HelloAgents的集成方案</strong>
 
 在`HelloAgents`框架中，这三种协议被统一抽象为工具（Tool），实现了无缝集成，允许开发者灵活地为智能体添加不同层级的通信能力：
 
@@ -2368,27 +2368,27 @@ agent.add_tool(A2ATool(...))
 agent.add_tool(ANPTool(...))
 ```
 
-**实战经验总结**
+<strong>实战经验总结</strong>
 
 - 优先利用成熟的社区MCP服务，以减少不必要的重复开发。
 - 根据系统规模选择合适的协议：小规模协作场景推荐使用A2A，大规模网络场景则应采用ANP。
 
 完成本章后，建议你：
 
-1. **动手实践**：
+1. <strong>动手实践</strong>：
    - 构建自己的MCP服务器
    - 利用协议创建多Agent协作系统
    - MCP、A2A与ANP的组合应用策略
-2. **深入学习**：
+2. <strong>深入学习</strong>：
    - 阅读MCP官方文档：https://modelcontextprotocol.io
    - 阅读A2A官方文档：https://a2a-protocol.org/latest/
    - 阅读ANP官方文档：https://agent-network-protocol.com/guide/
-3. **参与社区**：
+3. <strong>参与社区</strong>：
    - 向社区贡献新的MCP服务
    - 分享个人开发的智能体实现案例
    - 参与相关协议的技术标准讨论，也可以在Issue提问或是直接帮助Helloagents支持新的example案例
 
-**恭喜你完成第十章的学习！**
+<strong>恭喜你完成第十章的学习！</strong>
 
 你现在已经掌握了智能体通信协议的核心知识。继续加油！🚀
 

fix_bold_format.py

@@ -53,7 +53,7 @@ def fix_bold_format_in_file(file_path):
 def main():
     """主函数"""
     # 查找所有Markdown文件
-    docs_dir = "xxx/xxx"
+    docs_dir = "D:\code\multiAgentBok\HL-MAS\hello-agents\docs\chapter10"
     
     # 递归查找所有.md文件
     md_files = []