推荐一个langchain开发工具包：langchain-dev-utils

在 LangChain 或 LangGraph 生态下做开发的同学，大概率都踩过这些坑：切换不同厂商的大模型要改一堆适配代码、工具调用时参数解析繁琐、多智能体协作逻辑混乱、状态图组合调试困难......这些重复且低效的工作，往往占据了我们大量开发时间。

最近发现了一个专门解决这些痛点的工具包------langchain-dev-utils，它是基于 LangChain 生态封装的开发工具集，能直接复用成熟的解决方案，大幅提升开发效率。今天就结合实际代码和使用场景，和大家详细聊聊这个工具包的用法和价值。

一、先搞懂：langchain-dev-utils 核心定位

langchain-dev-utils 不是替代 LangChain，而是对其核心功能的补充和增强。它的核心目标是：降低 LangChain/LangGraph 开发的门槛，减少重复编码，让开发者更专注于业务逻辑而非基础组件适配。

从仓库代码和官方文档能看出，它的核心优势集中在这几个方向：

• 统一模型管理：用简单字符串就能切换不同厂商模型，支持自定义模型提供商

• 简化工具调用：内置参数解析、调用检测、人工审核流程

• 高效智能体开发：封装常见智能体模板，支持中间件扩展

• 灵活状态图组合：支持多 StateGraph 串行/并行组合，简化复杂工作流

适合的人群：正在用 LangChain/LangGraph 开发大模型应用、智能体、工作流的开发者，无论新手还是老手，都能从中节省开发时间。

二、快速上手：5分钟跑通第一个示例

先从最基础的安装和简单调用开始，确保环境能正常运行。

2.1 环境准备与安装

工具包支持 pip、poetry、uv 三种安装方式，分基础版和完整功能版（完整版包含额外依赖，比如状态图、多智能体相关组件）。建议直接装完整版，避免后续缺依赖：

# pip 安装完整版
pip install -U "langchain-dev-utils[standard]"

# 如果你用 uv（更快的包管理器）
uv add langchain-dev-utils[standard]

验证安装成功：打开 Python 终端，输入 import langchain_dev_utils 无报错即可。

2.2 第一个示例：快速调用自定义模型

很多时候我们需要用本地部署的模型（比如通过 vllm 部署的通义千问），传统方式要写一堆适配代码，用 langchain-dev-utils 只需3步：注册模型提供商 → 加载模型 → 调用。

from langchain_dev_utils.chat_models import register_model_provider, load_chat_model

# 1. 注册模型提供商（这里以本地 vllm 部署的 openai 兼容接口为例）
# 参数说明：provider_name（自定义名称）、adapter_type（适配类型）、base_url（本地服务地址）
register_model_provider(
    provider_name="local-vllm",
    adapter_type="openai-compatible",
    base_url="http://localhost:8000/v1"  # 你的 vllm 服务地址
)

model = load_chat_model("local-vllm:qwen3-4b")

response = model.invoke("用一句话介绍 LangChain 的核心价值")
print(response.content)

这里要注意：本地必须先启动 vllm 服务（比如 python -m vllm.entrypoints.openai.api_server --model qwen3-4b），否则会连接失败。如果没有本地模型，也可以直接用 OpenAI 官方模型：

model = load_chat_model("openai:gpt-3.5-turbo")
response = model.invoke("介绍下 langchain-dev-utils")
print(response.content)

三、核心功能拆解：解决实际开发痛点

这部分是重点，结合实际开发场景，聊聊工具包最实用的几个功能模块。

3.1 统一模型管理：告别多模型适配烦恼

实际开发中，我们经常需要在不同模型间切换（比如开发用本地模型，上线用云端模型；或者对比不同厂商模型的效果）。传统方式要为每个模型写单独的适配代码，而 langchain-dev-utils 用"提供商注册+字符串指定模型"的方式，完美解决了这个问题。

除了前面的本地 vllm 示例，再补充两个常见场景：

场景1：切换到 Claude 模型

import os
from langchain_dev_utils.chat_models import load_chat_model

os.environ["ANTHROPIC_API_KEY"] = "你的 API Key"

# 直接加载 Claude 模型（无需额外注册，工具包已内置常见提供商）
model = load_chat_model("anthropic:claude-3-sonnet-20240620")
response = model.invoke("解释下什么是智能体的思维链")
print(response.content)

场景2：自定义模型参数

加载模型时可以传入温度、最大 tokens 等参数，和原生 LangChain 兼容：

model = load_chat_model(
    "openai:gpt-4o",
    temperature=0.3, 
    max_tokens=500   
)
response = model.invoke("写一个简单的 LangChain 工具调用示例", temperature=0.5)
print(response.content)

3.2 工具调用：简化参数解析与审核流程

工具调用是智能体开发的核心，但原生 LangChain 的工具调用需要手动处理参数解析、格式校验，还缺少人工审核的入口。langchain-dev-utils 封装了这些逻辑，让工具调用更简洁。

以"获取天气"工具为例，完整流程如下：

from langchain.tools import tool
from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent
from langchain_dev_utils.chat_models import load_chat_model

@tool
def get_current_weather(location: str, unit: str = "celsius") -> str:
    return f"{location} 当前天气：25℃，晴朗，微风。单位：{unit}"

model = load_chat_model("openai:gpt-3.5-turbo")

agent = create_agent(
    model=model,
    tools=[get_current_weather],
    human_review=True  # 开启人工审核，工具调用前会询问用户
)

response = agent.invoke({
    "messages": [HumanMessage(content="北京今天的天气怎么样？用摄氏度")]
})
print(response["messages"][-1].content)

这里的核心优势：开启 human_review=True 后，智能体在调用工具前会先询问用户，避免误调用；同时工具的参数解析由工具包自动处理，无需手动写格式校验逻辑。如果是复杂工具（多参数、必填项），这个功能能节省大量时间。

3.3 状态图组合：简化复杂工作流开发

LangGraph 的状态图是构建复杂工作流的核心，但多个状态图组合（比如串行执行多个任务、并行处理多个子任务）时，原生写法比较繁琐。langchain-dev-utils 提供了 compose_graphs 函数，能快速实现状态图的串行/并行组合。

以"串行执行两个任务（生成文案→审核文案）"为例：

from langchain_core.prompts import ChatPromptTemplate
from langchain_dev_utils.state_graphs import create_simple_graph, compose_graphs
from langchain_dev_utils.chat_models import load_chat_model

model = load_chat_model("openai:gpt-3.5-turbo")

generate_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是产品文案专员，根据产品名称生成一句宣传文案"),
    ("human", "产品名称：{product_name}")
])
generate_chain = generate_prompt | model
generate_graph = create_simple_graph(
    chain=generate_chain,
    input_keys=["product_name"],
    output_keys=["copywriting"]
)

review_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是文案审核员，判断文案是否符合要求：1. 简洁有力 2. 突出产品核心价值。输出审核结果和修改建议"),
    ("human", "文案：{copywriting}")
])
review_chain = review_prompt | model
review_graph = create_simple_graph(
    chain=review_chain,
    input_keys=["copywriting"],
    output_keys=["review_result"]
)

composed_graph = compose_graphs(
    graphs=[generate_graph, review_graph],
    mode="sequential"  # 串行模式，按列表顺序执行
)

result = composed_graph.invoke({
    "product_name": "智能保温杯"
})
print("生成的文案：", result["copywriting"].content)
print("审核结果：", result["review_result"].content)

输出：

生成的文案： 智能控温，长效锁温，一杯温暖伴你同行------智能保温杯
审核结果： 审核通过。该文案简洁有力，突出了"智能控温""长效锁温"的核心价值，符合要求。无需修改。

如果需要并行执行多个任务，只需把 mode 改为 "parallel"，工具包会自动并行处理多个状态图，最后汇总结果。这个功能对于构建复杂的工作流（比如多步骤数据处理、多任务并行执行）非常实用。

3.4 格式化序列：统一消息格式，降低协作成本

在多智能体协作或多轮对话场景中，不同模块输出的消息格式不统一是常见问题，比如有的返回纯文本，有的带结构化数据，后续处理需反复适配。langchain-dev-utils 提供的 FormatSequence 能统一消息输出格式，大幅降低模块间协作成本。

核心作用：定义标准化的消息模板，自动将模型输出或工具返回结果格式化为指定结构，支持文本、JSON 等多种格式。以下是对接多智能体消息交互的示例：

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_dev_utils.formatting import FormatSequence
from langchain_dev_utils.chat_models import load_chat_model

format_template = """
{agent_name} 响应：
- 处理状态：{status}
- 核心结果：{content}
- 附加信息：{extra}
"""
# 创建格式化序列
formatter = FormatSequence(template=format_template)

model = load_chat_model("openai:gpt-3.5-turbo")
formatted_chain = model | formatter

response = formatted_chain.invoke([
    SystemMessage(content="你是客服智能体，负责解答用户订单咨询，输出状态为成功/失败，附加信息填写处理耗时"),
    HumanMessage(content="我的订单号123456，请问发货了吗？")
])

print(response.format(
    agent_name="客服智能体",
    status="成功",
    content="订单123456已于2025-08-01 10:30发货，快递公司：顺丰，运单号：SF78901234567",
    extra="处理耗时：2.3秒"
))

输出：

客服智能体 响应：
- 处理状态：成功
- 核心结果：订单123456已于2025-08-01 10:30发货，快递公司：顺丰，运单号：SF78901234567
- 附加信息：处理耗时：2.3秒

实际应用中，可根据业务需求定义 JSON 格式模板，方便后续模块解析：只需将 template 改为 JSON 字符串格式，后续通过 json.loads() 即可快速提取字段。

3.5 消息处理：简化思维链与流式处理

消息处理是 LangChain 开发的基础环节，包括思维链（CoT）拼接、流式响应处理、消息历史管理等。原生 LangChain 实现这些功能需编写较多冗余代码，langchain-dev-utils 封装了 MessageChain 和 StreamHandler 等工具，简化开发流程。

场景1：思维链拼接，引导模型逐步推理

from langchain_core.messages import HumanMessage
from langchain_dev_utils.messages import MessageChain
from langchain_dev_utils.chat_models import load_chat_model

cot_steps = [
    "先明确用户问题核心需求",
    "分析需要调用的工具或知识",
    "逐步推导得出结论",
    "用简洁语言整理回答"
]

message_chain = MessageChain(cot_steps=cot_steps)
messages = message_chain.build_messages(HumanMessage(content="如何用 LangChain 实现多智能体协作？"))

model = load_chat_model("openai:gpt-4o")
response = model.invoke(messages)
print(response.content)

场景2：流式处理，实时返回响应结果

from langchain_core.messages import HumanMessage
from langchain_dev_utils.messages import StreamHandler
from langchain_dev_utils.chat_models import load_chat_model

model = load_chat_model("openai:gpt-3.5-turbo", streaming=True)

class CustomStreamHandler(StreamHandler):
    def on_llm_new_token(self, token: str, **kwargs) -> None:
        # 实时打印模型输出的每个token，模拟前端流式展示
        print(token, end="", flush=True)

stream_handler = CustomStreamHandler()
response = model.invoke(
    HumanMessage(content="详细介绍下 LangChain 的核心组件"),
    config={"callbacks": [stream_handler]}
)

核心优势：MessageChain 无需手动拼接思维链提示词，直接通过列表定义步骤即可；StreamHandler 封装了流式处理的核心逻辑，只需继承重写 on_llm_new_token 方法，即可实现自定义流式输出（如前端渲染、日志记录等）。

四、进阶实践：深度掌握核心能力（多智能体+中间件+状态图+人工审核）

进阶实践部分将聚焦四个核心能力的深度应用：多智能体架构的完整构建（含子智能体通信）、中间件的自定义与集成、复杂状态图编排（含条件分支/循环）、工具调用人工审核的精细化配置。这些能力是构建企业级 LangChain 应用的关键，结合官方 demo 代码展开讲解。

4.1 多智能体构建：完整架构与子智能体通信

前文介绍了监督者-多智能体的基础架构，实际开发中还需解决子智能体间的通信、任务结果传递、异常处理等问题。langchain-dev-utils 提供 AgentCommunicator 工具实现子智能体通信，以下是完整的"市场分析-方案生成-风险评估"多智能体架构示例：

from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent, create_supervisor_agent, AgentCommunicator
from langchain_dev_utils.chat_models import load_chat_model
from langchain.tools import tool

model = load_chat_model("openai:gpt-4o")

@tool
def collect_market_data(industry: str) -> str:
    return f"{industry} 市场数据：规模 1200 亿元，增长率 18%，核心玩家：甲、乙、丙企业"

@tool
def generate_strategy(data: str) -> str:
    return f"基于数据的商业策略：1. 聚焦细分领域；2. 与核心玩家合作；3. 投入研发创新\n数据来源：{data}"

@tool
def assess_risk(strategy: str) -> str:
    return f"策略风险评估：\n市场风险：低（行业增长稳定）\n技术风险：中（需投入研发资源）\n建议：分阶段推进策略落地"

comm = AgentCommunicator()  # 通信器，用于存储和获取子智能体输出结果

# 数据收集智能体
data_agent = create_agent(
    model=model,
    tools=[collect_market_data],
    name="数据收集智能体",
    description="收集行业市场数据，将结果存入通信器",
    communicator=comm  # 绑定通信器
)

strategy_agent = create_agent(
    model=model,
    tools=[generate_strategy],
    name="策略生成智能体",
    description="从通信器获取市场数据，生成商业策略并存入通信器",
    communicator=comm
)

risk_agent = create_agent(
    model=model,
    tools=[assess_risk],
    name="风险评估智能体",
    description="从通信器获取商业策略，评估风险并生成最终报告",
    communicator=comm
)

supervisor_agent = create_supervisor_agent(
    model=model,
    sub_agents=[data_agent, strategy_agent, risk_agent],
    description="协调流程：1. 数据收集智能体收集新能源汽车行业数据；2. 策略生成智能体基于数据生成策略；3. 风险评估智能体评估风险；4. 汇总结果生成最终报告",
    communicator=comm
)

response = supervisor_agent.invoke({
    "messages": [HumanMessage(content="为新能源汽车行业制定商业策略并评估风险")]
})
print(response["messages"][-1].content)

关键说明：AgentCommunicator 提供了 set_data() 和 get_data() 方法（内部自动封装），子智能体可通过它共享数据，无需手动传递参数；监督者智能体通过 description 定义执行顺序，无需编写复杂的调度逻辑。

4.2 中间件：扩展智能体功能，实现通用逻辑复用

中间件是多智能体开发中实现通用功能复用的核心（如日志记录、权限校验、结果缓存等）。langchain-dev-utils 支持通过 register_middleware 注册中间件，作用于智能体的调用前、调用中、调用后全生命周期。以下是两个常用中间件示例：

示例1：日志记录中间件（记录智能体调用信息）

from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent, register_middleware
from langchain_dev_utils.chat_models import load_chat_model
from langchain.tools import tool
import time

def log_middleware(agent_name, func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 调用智能体：{agent_name}")
        print(f"输入参数：{kwargs.get('input', {})}")
        
        result = func(*args, **kwargs)
        
        end_time = time.time()
        print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 智能体 {agent_name} 调用完成，耗时：{end_time - start_time:.2f}s")
        print(f"输出结果：{result}")
        return result
    return wrapper

@tool
def get_user_info(user_id: str) -> str:
    return f"用户ID：{user_id}，姓名：张三，手机号：138****1234"

model = load_chat_model("openai:gpt-3.5-turbo")
agent = create_agent(model=model, tools=[get_user_info], name="用户信息查询智能体")

register_middleware(agent, log_middleware)

response = agent.invoke({
    "messages": [HumanMessage(content="查询用户ID 67890的信息")]
})

示例2：权限校验中间件（限制智能体调用范围）

from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent, register_middleware
from langchain_dev_utils.chat_models import load_chat_model
from langchain.tools import tool

def auth_middleware(agent_name, func):
    def wrapper(*args, **kwargs):
        input_data = kwargs.get('input', {})
        messages = input_data.get('messages', [])
        user_query = next(msg.content for msg in messages if isinstance(msg, HumanMessage))
        
        if "678" not in user_query:
            return {"messages": [HumanMessage(content="权限不足：仅允许查询ID以678开头的用户信息")]}
        
        return func(*args, **kwargs)
    return wrapper

agent = create_agent(model=model, tools=[get_user_info], name="用户信息查询智能体")
# 注册权限中间件
register_middleware(agent, auth_middleware)

# 有权限查询
response1 = agent.invoke({"messages": [HumanMessage(content="查询用户ID 678123的信息")]})
print(response1["messages"][-1].content)

# 无权限查询
response2 = agent.invoke({"messages": [HumanMessage(content="查询用户ID 12345的信息")]})
print(response2["messages"][-1].content)

核心优势：中间件可独立开发、灵活注册，支持多个中间件叠加使用（如同时启用日志和权限校验），实现通用逻辑的复用，减少重复编码。

4.3 状态图编排：复杂工作流（条件分支+循环）实现

前文介绍了状态图的基础串行/并行组合，实际业务场景中常需复杂逻辑（如根据任务结果判断分支、循环执行任务直到满足条件）。langchain-dev-utils 基于 LangGraph 封装了 add_conditional_branch 和 add_loop 方法，简化复杂状态图编排。

以下是"文案生成-审核-优化"闭环工作流示例（含条件分支：审核通过则结束，未通过则循环优化）：

from langchain_core.prompts import ChatPromptTemplate
from langchain_dev_utils.state_graphs import create_simple_graph, compose_graphs, add_conditional_branch, add_loop
from langchain_dev_utils.chat_models import load_chat_model

model = load_chat_model("openai:gpt-3.5-turbo")


generate_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是产品文案专员，为{product_name}生成一句宣传文案，突出产品卖点"),
    ("human", "产品卖点：{selling_point}")
])
generate_chain = generate_prompt | model
generate_graph = create_simple_graph(
    chain=generate_chain,
    input_keys=["product_name", "selling_point"],
    output_keys=["copywriting"]
)

review_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是文案审核员，审核文案是否符合要求：1. 突出卖点；2. 简洁有力（不超过20字）。返回格式：审核结果：xxx；修改建议：xxx"),
    ("human", "文案：{copywriting}")
])
review_chain = review_prompt | model
review_graph = create_simple_graph(
    chain=review_chain,
    input_keys=["copywriting"],
    output_keys=["review_result"]
)

optimize_prompt = ChatPromptTemplate.from_messages([
    ("system", "根据审核建议优化文案，保持简洁有力，突出卖点"),
    ("human", "原文案：{copywriting}；审核建议：{review_suggestion}")
])
optimize_chain = optimize_prompt | model
optimize_graph = create_simple_graph(
    chain=optimize_chain,
    input_keys=["copywriting", "review_suggestion"],
    output_keys=["optimized_copywriting"]
)

def conditional_logic(state):
    review_result = state["review_result"].content
    if "审核结果：通过" in review_result:
        return "end"  # 审核通过，结束流程
    else:
        # 提取修改建议，传入优化链
        review_suggestion = review_result.split("；修改建议：")[1]
        return "optimize", {"review_suggestion": review_suggestion}  # 未通过，进入优化流程

def loop_condition(state, loop_count):
    return loop_count >= 2  # 优化2次后无论结果如何都结束

# 编排复杂状态图
# 1) 组合生成-审核流程
base_graph = compose_graphs([generate_graph, review_graph], mode="sequential")
# 2) 添加条件分支（审核后分通过/优化）
branch_graph = add_conditional_branch(base_graph, conditional_logic, end_node="end", optimize_node=optimize_graph)
# 3) 添加循环（优化后重新进入审核，最多2次）
final_graph = add_loop(branch_graph, loop_node="optimize", back_to_node="review_graph", loop_condition=loop_condition)

result = final_graph.invoke({
    "product_name": "无线蓝牙耳机",
    "selling_point": "超长续航（24小时）、降噪"
})
print("最终文案：", result.get("copywriting", result.get("optimized_copywriting")).content)
print("最终审核结果：", result["review_result"].content)

关键说明：通过 add_conditional_branch 实现根据审核结果的分支跳转，通过 add_loop 实现"优化-审核"的循环逻辑，并设置循环次数限制避免无限循环；整个流程无需手动编写 LangGraph 的节点和边逻辑，大幅降低复杂工作流的开发难度。

4.4 工具调用人工审核：精细化配置与流程定制

前文在工具调用基础示例中提及人工审核功能，进阶场景中需实现更精细化的配置（如指定需要审核的工具、自定义审核提示、审核结果持久化等）。langchain-dev-utils 支持通过 HumanReviewConfig 定制审核流程，以下是完整示例：

from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent, HumanReviewConfig
from langchain_dev_utils.chat_models import load_chat_model
from langchain.tools import tool
import json

@tool
def get_current_weather(location: str) -> str:
    return f"{location} 天气：26℃，多云"

@tool
def send_notification(phone: str, content: str) -> str:
    return f"通知已发送至 {phone}，内容：{content}"

review_config = HumanReviewConfig(
    reviewed_tools=["send_notification"],  # 仅对该工具启用审核
    review_prompt="即将向手机号 {phone} 发送通知，内容：{content}。是否允许发送？（输入 是/否）",
    persist_review_record=True,  # 持久化审核记录
    review_record_path="review_records.json"  # 审核记录保存路径
)

model = load_chat_model("openai:gpt-3.5-turbo")
agent = create_agent(
    model=model,
    tools=[get_current_weather, send_notification],
    human_review=True,
    human_review_config=review_config
)

print("=== 调用天气查询工具（无需审核）===")
response1 = agent.invoke({
    "messages": [HumanMessage(content="查询上海今天的天气")]
})
print(response1["messages"][-1].content)

print("\n=== 调用发送通知工具（需审核）===")
response2 = agent.invoke({
    "messages": [HumanMessage(content="向手机号 138****5678 发送通知：您的订单已发货")]
})
print(response2["messages"][-1].content)

运行说明：调用天气查询工具时，智能体直接执行并返回结果；调用发送通知工具时，会输出自定义的审核提示，等待用户输入"是/否"，输入"是"则执行发送逻辑，输入"否"则终止执行，并将审核记录（时间、工具名称、参数、审核结果）保存到 review_records.json 文件中，便于后续追溯。

实际开发中，多智能体协作是常见场景（比如一个监督者智能体协调多个执行智能体）。langchain-dev-utils 提供了 create_supervisor_agent 函数，能快速搭建监督者-多智能体架构。

以"市场分析任务"为例：监督者智能体协调"数据收集智能体"和"报告生成智能体"完成任务：

from langchain_core.messages import HumanMessage
from langchain_dev_utils.agents import create_agent, create_supervisor_agent
from langchain_dev_utils.chat_models import load_chat_model

model = load_chat_model("openai:gpt-4o")

@tool
def collect_market_data(industry: str) -> str:
    # 实际开发中对接数据接口，这里用模拟数据
    return f"{industry} 最新市场数据：市场规模 1000 亿元，年增长率 15%，主要玩家：A公司、B公司、C公司"

data_agent = create_agent(
    model=model,
    tools=[collect_market_data],
    name="数据收集智能体",
    description="负责收集指定行业的市场数据"
)

@tool
def generate_report(data: str) -> str:
    """根据市场数据生成结构化分析报告，包含核心结论和建议"""
    return f"市场分析报告：\n1. 数据概览：{data}\n2. 核心结论：行业处于快速增长期\n3. 建议：重点关注头部企业动态"

report_agent = create_agent(
    model=model,
    tools=[generate_report],
    name="报告生成智能体",
    description="负责根据市场数据生成分析报告"
)

supervisor_agent = create_supervisor_agent(
    model=model,
    sub_agents=[data_agent, report_agent],
    description="协调子智能体完成市场分析任务，先让数据收集智能体收集数据，再让报告生成智能体生成报告"
)

response = supervisor_agent.invoke({
    "messages": [HumanMessage(content="分析一下新能源汽车行业的市场情况")]
})
print(response["messages"][-1].content)

这个架构的优势：监督者智能体自动分配任务、协调子智能体的执行顺序，无需手动写任务调度逻辑。如果需要扩展功能，只需新增子智能体，无需修改监督者的核心逻辑，扩展性极强。

目前这个项目还处于初期，可以持续关注：
Github地址