LangChain/LangGraph 执行 Claude Code/Code Buddy等 Skill 的技术方案研究
·
1. 背景：Claude Code Skill 是什么
Claude Code Skill（CodeBuddy/WorkBuddy 也遵循同一规范）是一个目录 + SKILL.md 文件组成的可复用能力单元：
~/.workbuddy/skills/ my-skill/ ├── SKILL.md # YAML frontmatter + Markdown 指令 ├── scripts/ # 可选：可执行脚本（Python/Shell） ├── references/ # 可选：参考文档 └── assets/ # 可选：模板/静态资源
SKILL.md 格式（遵循 Agent Skills Specification）：
--- name: my-skill description: 简短描述，决定何时触发此 Skill license: MIT compatibility: 环境要求 allowed-tools: Bash, Read, Write --- # 任务目标 描述这个 Skill 要完成什么 ## 执行步骤 1. 第一步... 2. 第二步...
核心特性：
-
渐进式披露（Progressive Disclosure）：启动时只加载
name+description（约 100 token），匹配时才加载完整SKILL.md -
Model-invoked：不是用户手动触发
/command，而是 AI 自己判断是否需要加载 -
与 MCP 互补：Skills 是"教 AI 怎么做"（方法论），MCP 是"给 AI 新能力"（工具）
来源：Claude Code Skills Complete Guide: SKILL.md, MCP, Subagents & Teams (2026) 、Specification - Agent Skills
2. 五大技术路线总览
| 路线 | 核心包 | 原理 | 复杂程度 | 推荐场景 |
|---|---|---|---|---|
| MCP 桥接 | langchain-mcp-adapters + mcp-skill-hub |
将 SKILL.md 暴露为 MCP Server → LangGraph 通过 MCP 适配器加载 | ⭐⭐⭐ 中等 | 生产级、多 Skill 管理 |
| DeepAgents 原生 | deepagents |
LangChain 官方支持 SKILL.md 格式，通过 SkillsMiddleware 加载 | ⭐⭐ 较低 | 纯 LangChain 技术栈 |
| Agent SDK | claude-agent-sdk |
Anthropic 官方 Python SDK，原生支持 Skills 参数 | ⭐⭐⭐ 中等 | 需要完整 Claude Code 能力 |
| CLI 子进程 | claude-code-botman 或 subprocess |
通过 CLI 调用 claude -p，包装为 LangChain Tool |
⭐ 简单 | 快速原型、一次性任务 |
| 自定义解析器 | 无三方依赖 | 自行解析 SKILL.md，注入 System Prompt 或包装为 BaseTool | ⭐⭐ 较低 | 完全可控、无外部依赖 |
3. 路线一：MCP 桥接（推荐生产级方案）
3.1 架构图
┌─────────────────────────────────────────────────┐ │ LangGraph Agent │ │ ┌──────────┐ ┌──────────────┐ ┌────────────┐ │ │ │call_model│──│ tools_cond │──│ ToolNode │ │ │ └──────────┘ └──────────────┘ └────────────┘ │ │ │ │ │ │ ┌───────┴───────┐ │ │ │ │ langchain-mcp │◄───────┘ │ │ │ -adapters │ │ │ └───────┬───────┘ │ └──────────────────────┼──────────────────────────┘ │ MCP Protocol (stdio/HTTP) ┌──────────────────────┼───────────────────────────┐ │ ┌───────┴───────┐ │ │ │ mcp-skill-hub │ MCP Server │ │ └───────┬───────┘ │ │ │ │ │ ~/.workbuddy/skills/ │ │ ├── code-reviewer/SKILL.md │ │ ├── pdf-editor/SKILL.md │ │ └── deploy/SKILL.md │ └──────────────────────────────────────────────────┘
3.2 所需包及版本
| 包名 | 版本 | 安装命令 | 用途 |
|---|---|---|---|
langchain-mcp-adapters |
≥ 0.3.0 | pip install langchain-mcp-adapters |
将 MCP 工具转为 LangChain Tool |
langgraph |
≥ 1.0 | pip install langgraph |
Agent 状态图框架 |
mcp-skill-hub |
latest | npx -y mcp-skill-hub serve |
将 SKILL.md 目录暴露为 MCP Server |
fastmcp |
latest | pip install fastmcp |
可选：自定义 MCP 服务器开发 |
来源：GitHub - langchain-ai/langchain-mcp-adapters: LangChain 🔌 MCP · GitHub (v0.3.0, 2026-06-10) 、GitHub - quentingosset/mcp-skill-hub · GitHub
3.3 核心代码实现
步骤 1：启动 mcp-skill-hub 作为 MCP Server
方式 A：直接通过 npx（推荐）
npx -y mcp-skill-hub serve \ --dir ~/.workbuddy/skills/ \ --env MCP_SKILL_EXPOSURE_MODE=hybrid
方式 B：通过 Node.js 脚本嵌入
// mcp_skill_server.js
const { serve } = require('mcp-skill-hub');
serve({ skillsDir: process.env.HOME + '/.workbuddy/skills/' });
步骤 2：在 LangGraph 中通过 langchain-mcp-adapters 加载
import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from langchain.chat_models import init_chat_model
async def build_agent_with_skills():
# 1. 配置 MCP 客户端，连接 mcp-skill-hub
client = MultiServerMCPClient({
"skills": {
"transport": "stdio",
"command": "npx",
"args": ["-y", "mcp-skill-hub", "serve"],
"env": {
"SKILLS_DIR": "/Users/xxx/.workbuddy/skills/",
"MCP_SKILL_EXPOSURE_MODE": "hybrid"
}
}
})
# 2. 加载 MCP 工具（包含 list_skills, get_skill, invoke_skill 等）
tools = await client.get_tools()
# 3. 初始化模型
model = init_chat_model("anthropic:claude-sonnet-4-6")
# 4. 定义模型调用节点
def call_model(state: MessagesState):
response = model.bind_tools(tools).invoke(state["messages"])
return {"messages": response}
# 5. 构建状态图
builder = StateGraph(MessagesState)
builder.add_node("call_model", call_model)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "call_model")
builder.add_conditional_edges("call_model", tools_condition)
builder.add_edge("tools", "call_model")
graph = builder.compile()
return graph
# 使用
async def main():
graph = await build_agent_with_skills()
result = await graph.ainvoke({
"messages": [{"role": "user", "content": "帮我审查这段代码的安全性"}]
})
# Agent 会自动通过 invoke_skill("code-reviewer", text="...")
# 加载 code-reviewer skill 的 SKILL.md 指令并执行
步骤 3：LangGraph 中使用 Tool Interceptor 注入上下文
from langchain_mcp_adapters.interceptors import MCPToolCallRequest
async def skill_context_injector(request: MCPToolCallRequest, handler):
"""在调用 skill 时注入当前项目上下文"""
if request.name == "invoke_skill":
# 注入工作目录、当前文件等信息
request = request.override(
args={
**request.args,
"text": f"[工作目录: /project/src] {request.args.get('text', '')}"
}
)
result = await handler(request)
return result
client = MultiServerMCPClient(
{...},
tool_interceptors=[skill_context_injector],
)
3.4 mcp-skill-hub 暴露的工具
| 工具名 | 功能 | 关键参数 |
|---|---|---|
list_skills |
列出所有可用 Skill | filter: 按名称筛选 |
get_skill |
获取单个 Skill 的元数据 | skill_id: Skill 名称 |
invoke_skill |
返回 Skill 的完整 SKILL.md 内容 | skill_id, text(可选任务描述) |
answer_user_request |
自动应用 mandatory skill + 选中 skill | text, skill_id |
Exposure Mode 说明：
-
direct：每个 Skill 暴露为独立 MCP 工具（如code-reviewer、deploy） -
hub：仅暴露上述 4 个通用工具 -
hybrid（默认）：两者都暴露
3.5 优缺点
✅ 优点：
-
标准化：MCP 是业内通用协议，Anthropic/LangChain/Cursor/CodeBuddy 都支持
-
不改 Skill 格式：直接复用 WorkBuddy 的
~/.workbuddy/skills/ -
渐进式披露：mcp-skill-hub 启动时只扫描 metadata，按需加载完整 SKILL.md
-
多服务器支持：可同时接入多个 Skill 目录
-
LangGraph 深度集成：支持 Tool Interceptor、Command 流程控制、LangGraph Store
❌ 缺点：
-
需要额外维护一个 Node.js MCP Server 进程
-
mcp-skill-hub社区项目，非官方维护 -
只能返回 SKILL.md 的文本指令，无法直接执行 scripts/ 下的脚本
4. 路线二：DeepAgents SkillsMiddleware（LangChain 原生方案）
4.1 架构
LangChain 的 deepagents 包原生实现了 Agent Skills 规范，与 Claude Code/WorkBuddy 使用相同的 SKILL.md 格式。通过 SkillsMiddleware 加载 Skill 目录。
4.2 所需包及版本
| 包名 | 版本 | 安装命令 |
|---|---|---|
deepagents |
≥ 0.6.8 | pip install deepagents |
langgraph |
≥ 1.0 | pip install langgraph |
来源：skills | deepagents | LangChain Reference (v0.6.8)
4.3 核心代码实现
from deepagents import create_deep_agent
from deepagents.backends.filesystem import FilesystemBackend
from deepagents.middleware.skills import SkillsMiddleware
# 方式 A：使用 create_deep_agent 高层 API（最简单）
agent = create_deep_agent(
model="anthropic:claude-sonnet-4-6",
backend=FilesystemBackend(root_dir="/Users/xxx/project"),
skills=[
"~/.workbuddy/skills/", # 用户级 Skill
"/project/.codebuddy/skills/", # 项目级 Skill
],
)
# 调用
result = agent.invoke({
"messages": [{"role": "user", "content": "帮我审查这段代码"}]
})
# 方式 B：使用 SkillsMiddleware 底层 API（更灵活）
from deepagents.middleware.skills import SkillsMiddleware
from deepagents.backends.filesystem import FilesystemBackend
from langgraph.graph import StateGraph, MessagesState
backend = FilesystemBackend(root_dir="/")
# 配置多个 Skill 源，后者覆盖前者（last one wins）
middleware = SkillsMiddleware(
backend=backend,
sources=[
"/Users/xxx/.workbuddy/skills/", # 用户级
("/Users/xxx/project/.codebuddy/skills", "Project"), # 项目级
],
)
# middleware 会自动：
# 1. 扫描 sources 中的每个 SKILL.md
# 2. 解析 frontmatter（name, description）
# 3. 将摘要注入 System Prompt
# 4. Agent 需要时通过 backend 读取完整 SKILL.md
# 方式 C：StateBackend（适合无文件系统的场景）
from deepagents.backends import StateBackend
from deepagents.backends.utils import create_file_data
backend = StateBackend()
# 将 SKILL.md 内容作为虚拟文件传入
skill_content = """---
name: code-reviewer
description: 代码安全审查专家
---
# 代码审查 Skill
1. 检查 SQL 注入风险
2. 检查 XSS 漏洞
...
"""
agent = create_deep_agent(
model="anthropic:claude-sonnet-4-6",
backend=backend,
skills=["/skills/"],
)
result = agent.invoke({
"messages": [{"role": "user", "content": "审查 auth.py"}],
"files": {
"/skills/code-reviewer/SKILL.md": create_file_data(skill_content),
}
})
4.4 Backend 支持对比
| Backend | 存储位置 | 持久化 | 适用场景 |
|---|---|---|---|
StateBackend |
LangGraph State（当前线程） | ❌ 会话级别 | 动态 Skill、无文件系统 |
StoreBackend |
LangGraph Store | ✅ 跨线程 | 多租户、持久化 Skill |
FilesystemBackend |
磁盘文件（相对 root_dir） | ✅ 永久 | 本地开发、直接复用 Skill 目录 |
4.5 与 WorkBuddy Skill 的兼容性
DeepAgents 的 SKILL.md 格式遵循 Agent Skills Specification，与 WorkBuddy 完全一致：
| 特性 | WorkBuddy Skill | DeepAgents Skill | 兼容 |
|---|---|---|---|
YAML frontmatter (name, description) |
✅ | ✅ | ✅ |
| Markdown 指令正文 | ✅ | ✅ | ✅ |
scripts/ 目录 |
✅ | ✅（通过 Sandbox Backend） | ✅ |
references/ 目录 |
✅ | ✅ | ✅ |
assets/ 目录 |
✅ | ✅ | ✅ |
allowed-tools |
✅ | ✅（实验性） | ✅ |
license, compatibility, metadata |
✅ | ✅ | ✅ |
| 渐进式披露 | ✅ | ✅ | ✅ |
4.6 优缺点
✅ 优点：
-
LangChain 官方原生支持：无需转换层，直接使用
-
完全兼容 WorkBuddy Skill 格式：可以直接指向
~/.workbuddy/skills/ -
无额外进程：纯 Python 实现，无需启动 MCP Server
-
Subagent Skill 隔离：通用 Subagent 自动继承主 Agent 的 Skills
-
多种 Backend：文件系统、内存、持久化存储均支持
-
权限管理：支持只读 Skill、写入需审批
❌ 缺点：
-
deepagents是相对较新的包（2026 年发布），生态不如 MCP 成熟 -
不能直接执行 Skill 中的 Shell 脚本（需要 Sandbox Backend）
-
深度定制可能受限于 Middleware 架构
5. 路线三：Claude Code Agent SDK（Anthropic 官方方案）
5.1 架构
Anthropic 官方提供的 Python SDK，可以编程方式调用 Claude Code，并直接在参数中指定使用的 Skills。
┌────────────────────────────────────────┐ │ LangGraph Agent │ │ ┌──────────────────────────────────┐ │ │ │ ClaudeCodeSkillTool (BaseTool) │ │ │ │ 内部调用 claude-agent-sdk │ │ │ └──────────────┬───────────────────┘ │ └─────────────────┼──────────────────────┘ │ ┌─────────────────┼──────────────────────┐ │ claude-agent-sdk (Python) │ │ ClaudeAgentOptions( │ │ skills=["code-reviewer", "deploy"], │ │ allowed_tools=["Read","Write","Bash"]│ │ ) │ └────────────────────────────────────────┘
5.2 所需包及版本
| 包名 | 安装命令 | 依赖 |
|---|---|---|
claude-agent-sdk |
pip install claude-agent-sdk |
Python ≥ 3.10, Anthropic API Key |
5.3 核心代码实现
方式 A：包装为 LangChain BaseTool
import asyncio from typing import Any, Type from langchain.tools import BaseTool from pydantic import BaseModel, Field from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, TextBlock class ClaudeSkillInput(BaseModel): prompt: str = Field(description="发送给 Claude Code 的任务描述") skill: str = Field(description="要使用的 Skill 名称") class ClaudeCodeSkillTool(BaseTool): """将 Claude Code Skill 包装为 LangChain Tool""" name: str = "claude_code_skill" description: str = "使用 Claude Code 执行指定 Skill 的任务" args_schema: Type[BaseModel] = ClaudeSkillInput skills_dir: str = "~/.workbuddy/skills/" model: str = "claude-sonnet-4-6" def _run(self, prompt: str, skill: str) -> str: """同步包装""" return asyncio.run(self._arun(prompt, skill)) async def _arun(self, prompt: str, skill: str) -> str: options = ClaudeAgentOptions( skills=[skill], # 指定要使用的 Skill allowed_tools=["Read", "Write", "Bash"], permission_mode="acceptEdits", cwd="/Users/xxx/project", model=self.model, max_turns=15, ) results = [] async for message in query(prompt=prompt, options=options): if isinstance(message, AssistantMessage): for block in message.content: if isinstance(block, TextBlock): results.append(block.text) return "\n".join(results) # 在 LangGraph 中使用 tool = ClaudeCodeSkillTool()
方式 B：使用 ClaudeSDKClient 保持会话
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions class ClaudeCodeSession: """保持 Claude Code 会话的包装器""" def __init__(self, skills: list[str] = None): self.options = ClaudeAgentOptions( skills=skills or ["all"], allowed_tools=["Read", "Write", "Bash"], permission_mode="acceptEdits", ) self.client = ClaudeSDKClient(options=self.options) async def execute(self, prompt: str) -> str: results = [] async with self.client: await self.client.query(prompt) async for message in self.client.receive_response(): if isinstance(message, AssistantMessage): for block in message.content: if isinstance(block, TextBlock): results.append(block.text) return "\n".join(results)
方式 C：将 SDK 工具暴露为 MCP Server 再接入 LangGraph
from claude_agent_sdk import tool, create_sdk_mcp_server
# 使用 SDK 的 @tool 装饰器定义工具
@tool("analyze_code", "分析代码质量并给出建议", {"code": str})
async def analyze_code(args: dict) -> dict:
# 这里可以调用 Claude Code 内部逻辑
return {
"content": [{
"type": "text",
"text": f"代码分析完成：代码行数 {len(args['code'])}"
}]
}
# 创建进程内 MCP 服务器
server = create_sdk_mcp_server(
name="code-analyzer",
tools=[analyze_code],
)
# 然后通过 langchain-mcp-adapters 加载此 MCP Server
5.4 Skills 配置参数
在 ClaudeAgentOptions 中：
# 启用所有已发现的 Skill ClaudeAgentOptions(skills="all") # 只启用特定 Skill ClaudeAgentOptions(skills=["code-reviewer", "deploy", "pdf-editor"])
-
设置
skills后，SDK 自动将"Skill"工具加入allowed_tools -
Skill 的发现路径：
~/.claude/skills/、.claude/skills/
5.5 优缺点
✅ 优点：
-
Anthropic 官方支持：API 稳定、文档完善
-
完整 Skill 能力：不仅加载 SKILL.md 指令，还能执行
scripts/、调用子 Agent -
会话管理：支持多轮对话、中断恢复
-
结构化输出：支持 JSON Schema、流式输出
❌ 缺点：
-
需要 Anthropic API 密钥：需要付费
-
不直接操作 Skill 目录：SDK 默认从
~/.claude/skills/加载，需要配置路径映射 -
与 LangGraph 集成需要封装：无官方 LangChain 集成模块
-
从 2026-06-15 起 Agent SDK 使用量计入月度配额
6. 路线四：CLI 子进程包装（轻量方案）
6.1 架构
通过 Python subprocess 或 claude-code-botman 调用 claude CLI，包装为 LangChain Tool。
6.2 所需包
| 包名 | 安装命令 | 说明 |
|---|---|---|
claude-code-botman |
pip install claude-code-botman |
Python 包装库（非官方） |
或直接用 subprocess |
Python 内置 | 无需额外依赖 |
6.3 核心代码实现
方式 A：使用 claude-code-botman
from claude_code_botman import ClaudeCode from langchain.tools import BaseTool class ClaudeSkillTool(BaseTool): name: str = "claude_skill" description: str = "通过 Claude CLI 执行 Skill 任务" def _run(self, prompt: str) -> str: claude = ClaudeCode( model="sonnet", timeout=120, rules="./CLAUDE.md" # 可以用 CLAUDE.md 注入 Skill 内容 ) return claude(prompt)
方式 B：直接 subprocess
import subprocess
from langchain.tools import BaseTool
class ClaudeCLISkillTool(BaseTool):
name: str = "claude_cli_skill"
description: str = "通过 claude CLI 执行任务"
skills_dir: str = "~/.workbuddy/skills/"
def _run(self, prompt: str) -> str:
# 将 SKILL.md 内容注入到 system prompt
skill_content = self._load_skill("code-reviewer")
result = subprocess.run(
["claude", "-p", prompt,
"--system-prompt", skill_content,
"--allowedTools", "Read,Write,Bash",
"--output-format", "json"],
capture_output=True, text=True,
timeout=120
)
return result.stdout
def _load_skill(self, skill_name: str) -> str:
import os
path = os.path.expanduser(f"{self.skills_dir}/{skill_name}/SKILL.md")
with open(path) as f:
return f.read()
6.4 优缺点
✅ 优点：
-
实现极简，几十行代码
-
零学习成本
❌ 缺点：
-
每次调用创建新进程，性能差
-
不稳定：依赖 CLI 输出格式
-
无会话管理：每轮都是新会话
-
无法利用渐进式披露特性
-
claude-code-botman为社区项目，非官方维护
7. 路线五：自定义 SKILL.md 解析器（完全可控方案）
7.1 架构
自行解析 SKILL.md 文件，将 frontmatter 和指令内容转换为 LangChain 的 System Message 或 Tool。
7.2 核心代码实现
import yaml
import os
from pathlib import Path
from typing import Dict, List
from langchain.tools import BaseTool
from langchain.schema import SystemMessage
class SkillParser:
"""解析 SKILL.md 文件"""
def __init__(self, skills_root: str = "~/.workbuddy/skills/"):
self.skills_root = Path(skills_root).expanduser()
def list_skills(self) -> List[Dict]:
"""列出所有 Skill 的元数据（渐进式披露 Level 1）"""
skills = []
for skill_dir in self.skills_root.iterdir():
if skill_dir.is_dir():
skill_md = skill_dir / "SKILL.md"
if skill_md.exists():
metadata, _ = self._parse_skill_file(skill_md)
skills.append(metadata)
return skills
def load_skill(self, skill_name: str) -> str:
"""加载完整 Skill 指令（渐进式披露 Level 2）"""
skill_path = self.skills_root / skill_name / "SKILL.md"
_, instructions = self._parse_skill_file(skill_path)
return instructions
def _parse_skill_file(self, path: Path) -> tuple:
"""解析 YAML frontmatter + Markdown 正文"""
with open(path) as f:
content = f.read()
if content.startswith("---"):
parts = content.split("---", 2)
if len(parts) >= 3:
metadata = yaml.safe_load(parts[1])
instructions = parts[2].strip()
return metadata, instructions
return {}, content
def get_skills_summary_prompt(self) -> str:
"""生成所有 Skill 的摘要，注入 System Prompt"""
skills = self.list_skills()
lines = ["## 可用 Skills\n"]
for s in skills:
name = s.get("name", "unknown")
desc = s.get("description", "无描述")
lines.append(f"- **{name}**: {desc}")
return "\n".join(lines)
class SkillTool(BaseTool):
"""将单个 Skill 包装为 LangChain Tool"""
name: str
description: str
parser: SkillParser
skill_name: str
def _run(self, query: str = "") -> str:
"""返回完整 Skill 指令，由 Agent 自行执行"""
instructions = self.parser.load_skill(self.skill_name)
if query:
return f"# Skill: {self.skill_name}\n\n## 任务\n{query}\n\n## 指令\n{instructions}"
return instructions
# ===== 在 LangGraph 中使用 =====
def build_agent_with_custom_skills():
parser = SkillParser("~/.workbuddy/skills/")
skills_summary = parser.get_skills_summary_prompt()
# 方式 A：注入 System Prompt（推荐）
model = init_chat_model("anthropic:claude-sonnet-4-6")
# 方式 B：每个 Skill 包装为独立 Tool
tools = [
SkillTool(
name=s["name"],
description=s["description"],
parser=parser,
skill_name=s["name"]
)
for s in parser.list_skills()
]
def call_model(state: MessagesState):
# 注入 Skill 摘要到 System Message
messages = [SystemMessage(content=skills_summary)] + state["messages"]
response = model.bind_tools(tools).invoke(messages)
return {"messages": response}
builder = StateGraph(MessagesState)
builder.add_node("call_model", call_model)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "call_model")
builder.add_conditional_edges("call_model", tools_condition)
builder.add_edge("tools", "call_model")
return builder.compile()
# 使用
graph = build_agent_with_custom_skills()
result = graph.invoke({
"messages": [{"role": "user", "content": "审查代码安全性"}]
})
7.3 优缺点
✅ 优点：
-
零外部依赖（仅需
pyyaml） -
完全可控：可以自定义任何加载、缓存、注入逻辑
-
灵活性最高：可以混合注入 System Prompt、包装为 Tool、或动态生成 Subagent
❌ 缺点：
-
需要自行维护：Skill 格式变化需手动适配
-
无渐进式披露：需要自己实现 token 优化
-
无法执行 scripts/：需要自行实现沙箱执行逻辑
-
缺乏标准生态：不与 MCP/Agent Skills 生态系统互通
8. 横向对比与选型建议
8.1 多维度对比
| 维度 | MCP 桥接 | DeepAgents | Agent SDK | CLI 子进程 | 自定义解析 |
|---|---|---|---|---|---|
| 实现复杂度 | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ | ⭐ | ⭐⭐ |
| 与 WorkBuddy Skill 兼容 | ✅ 完全 | ✅ 完全 | ⚠️ 路径需配置 | ⚠️ 需手动注入 | ✅ 完全 |
| 渐进式披露 | ✅ | ✅ | ✅ | ❌ | ❌（需自实现） |
| 执行 scripts/ | ❌ | ⚠️ Sandbox | ✅ | ✅ | ❌ |
| 会话管理 | ✅ | ✅ | ✅ | ❌ | ✅ |
| 额外进程 | Node.js MCP Server | 无 | 无 | CLI 进程 | 无 |
| 外部依赖 | 2 包 | 1 包 | 1 包 + API Key | 1 包 | 仅 pyyaml |
| 生产就绪 | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐ |
| MCP 生态互通 | ✅ | ⚠️ 通过 MCP 适配器 | ✅ | ❌ | ❌ |
8.2 场景选型
| 你的场景 | 推荐路线 | 理由 |
|---|---|---|
| 已有 WorkBuddy Skill 库，希望 LangGraph 直接复用 | DeepAgents（路线二） | 原生格式兼容，零转换，直接指向 ~/.workbuddy/skills/ |
| 需要同时接入多个 MCP 服务，Skill 是其中之一 | MCP 桥接（路线一） | MCP 统一协议，Skill 和其他 MCP 工具无缝共存 |
| 需要使用 Claude Code 的完整能力（scripts、subagents） | Agent SDK（路线三） | Anthropic 官方 SDK，完整 Claude Code 能力 |
| 快速原型验证 | CLI 子进程（路线四） | 最低实现成本 |
| 对可控性有极致要求，不想引入外部依赖 | 自定义解析器（路线五） | 完全自主 |
9. 推荐方案
推荐采用混合方案：
推荐架构：DeepAgents（主力）+ MCP 桥接（扩展）
┌─────────────────────────────────────────────────────────┐ │ LangGraph Agent │ │ │ │ ┌─────────────────────┐ ┌───────────────────────────┐ │ │ │ SkillsMiddleware │ │ langchain-mcp-adapters │ │ │ │ (DeepAgents) │ │ (MCP 桥接) │ │ │ │ │ │ │ │ │ │ 加载 WorkBuddy │ │ 连接 MCP Servers: │ │ │ │ ~/.workbuddy/skills/│ │ - mcp-skill-hub │ │ │ │ 原生格式兼容 │ │ - 自建自定义工具 │ │ │ └─────────┬───────────┘ └──────────┬────────────────┘ │ │ │ │ │ │ └─────────┬───────────────┘ │ │ │ │ │ ┌───────┴───────┐ │ │ │ ToolNode │ │ │ └───────────────┘ │ └─────────────────────────────────────────────────────────┘
核心依赖清单
# 基础框架 pip install langgraph>=1.0 # 方案二：LangChain 原生 Skill 支持（主力） pip install deepagents>=0.6.8 # 方案一：MCP 工具接入（扩展其他 MCP 服务） pip install langchain-mcp-adapters>=0.3.0 # 可选：Claude Code Agent SDK（需要完整 Claude Code 能力时） pip install claude-agent-sdk
为什么选 DeepAgents 作为主力？
-
格式完全兼容：DeepAgents 遵循与 WorkBuddy 完全相同的 Agent Skills 规范，目录结构
~/.workbuddy/skills/<name>/SKILL.md可直接复用 -
渐进式披露：天然支持 Level 1（摘要）→ Level 2（指令）→ Level 3（资源）三级加载，不会造成 token 浪费
-
LangGraph 原生集成：SkillsMiddleware 可直接嵌入你已有的 StateGraph 架构
-
Subagent 能力：支持通用 Subagent 自动继承 Skills，自定义 Subagent 独立配置
-
多 Backend：支持文件系统、内存、持久化存储，适配不同部署场景
为什么保留 MCP 桥接？
-
扩展性：除了 Skills，还可以接入你自建的 MCP 工具和外部 MCP 服务
-
标准化：符合你项目"同时支持 MCP 工具与自定义 Skills"的架构要求
-
社区生态：可接入社区提供的各种 MCP 服务
附录：参考来源
小龙虾开发者社区是 CSDN 旗下专注 OpenClaw 生态的官方阵地，聚焦技能开发、插件实践与部署教程，为开发者提供可直接落地的方案、工具与交流平台，助力高效构建与落地 AI 应用
更多推荐
9
0- 0
已为社区贡献3条内容
所有评论(0)