1
┌─────────────────────────────────────────────────────────────┐
2
│                    LangChain 核心概念                        │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  Model I/O                                                  │
6
│  ├── Chat Models：对话模型抽象（GPT-4、Claude 等）          │
7
│  ├── LLMs：文本补全模型                                     │
8
│  ├── Prompts：提示词模板管理                                │
9
│  └── Output Parsers：输出解析器                             │
10
│                                                             │
11
│  Chains                                                     │
12
│  ├── LCEL（LangChain Expression Language）：声明式链定义    │
13
│  ├── Runnable：可组合的执行单元                              │
14
│  └── Legacy Chains：传统链（如 LLMChain）                   │
15
│                                                             │
16
│  Agents                                                     │
17
│  ├── Agent Executor：Agent 执行器                           │
18
│  ├── Tools：工具定义与注册                                  │
19
│  └── Toolkits：工具包（预定义工具集合）                      │
20
│                                                             │
21
│  Memory                                                     │
22
│  ├── Conversation Memory：对话记忆                          │
23
│  ├── Vector Store Memory：向量存储记忆                       │
24
│  └── Entity Memory：实体记忆                                │
25
│                                                             │
26
│  LangGraph（新架构）                                         │
27
│  ├── State Graph：状态图                                    │
28
│  ├── Nodes：执行节点                                        │
29
│  └── Edges：转移边（支持条件）                               │
30
│                                                             │
31
└─────────────────────────────────────────────────────────────┘

1
from langchain_openai import ChatOpenAI
2
from langchain.agents import create_tool_calling_agent, AgentExecutor
3
from langchain_core.prompts import ChatPromptTemplate
4
from langchain_core.tools import tool
5

6
# 定义工具
7
@tool
8
def get_weather(city: str) -> str:
9
    """获取城市天气"""
10
    return f"{city}今天晴，温度 15-25°C"
11

12
@tool
13
def search_web(query: str) -> str:
14
    """搜索网络"""
15
    return f"搜索结果：{query} 相关信息..."
16

17
# 创建 Agent
18
llm = ChatOpenAI(model="gpt-4o")
19
tools = [get_weather, search_web]
20

21
prompt = ChatPromptTemplate.from_messages([
22
    ("system", "你是一个有帮助的助手。"),
23
    ("human", "{input}"),
24
    ("placeholder", "{agent_scratchpad}"),
25
])
26

27
agent = create_tool_calling_agent(llm, tools, prompt)
28
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
29

30
# 执行
31
result = agent_executor.invoke({"input": "北京今天天气怎么样？"})
32
print(result["output"])

1
from langgraph.graph import StateGraph, END
2
from typing import TypedDict
3

4
# 定义状态
5
class AgentState(TypedDict):
6
    messages: list
7
    next_action: str
8

9
# 定义节点
10
def research_node(state: AgentState) -> AgentState:
11
    # 研究逻辑
12
    return {**state, "next_action": "analyze"}
13

14
def analyze_node(state: AgentState) -> AgentState:
15
    # 分析逻辑
16
    return {**state, "next_action": "write"}
17

18
def write_node(state: AgentState) -> AgentState:
19
    # 写作逻辑
20
    return {**state, "next_action": "end"}
21

22
# 构建图
23
workflow = StateGraph(AgentState)
24
workflow.add_node("research", research_node)
25
workflow.add_node("analyze", analyze_node)
26
workflow.add_node("write", write_node)
27

28
workflow.add_edge("research", "analyze")
29
workflow.add_edge("analyze", "write")
30
workflow.add_edge("write", END)
31

32
workflow.set_entry_point("research")
33

34
# 执行
35
app = workflow.compile()
36
result = app.invoke({"messages": [], "next_action": ""})

1
优势：
2
• 生态系统最完整，文档丰富
3
• 支持几乎所有 LLM 提供商
4
• LCEL 声明式语法简洁优雅
5
• LangGraph 提供强大的状态管理
6
• 社区活跃，第三方集成多
7

8
劣势：
9
• 抽象层次多，学习曲线陡峭
10
• 版本迭代快，API 变化频繁
11
• 性能开销较大
12
• 复杂场景调试困难

1
┌─────────────────────────────────────────────────────────────┐
2
│                    AutoGen 核心概念                          │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  Agent 类型                                                  │
6
│  ├── ConversableAgent：可对话 Agent 基类                    │
7
│  ├── AssistantAgent：AI 助手 Agent                          │
8
│  ├── UserProxyAgent：用户代理（执行代码、人工输入）          │
9
│  └── GroupChatManager：群聊管理者                           │
10
│                                                             │
11
│  对话模式                                                    │
12
│  ├── Two-Agent Chat：两个 Agent 直接对话                    │
13
│  ├── Group Chat：多个 Agent 群聊                            │
14
│  ├── Nested Chat：嵌套对话（Agent 内部对话）                 │
15
│  └── Sequential Chat：顺序对话                              │
16
│                                                             │
17
│  人类参与                                                    │
18
│  ├── Human Input Mode：决定何时请求人类输入                  │
19
│  ├── Code Execution：自动执行代码                           │
20
│  └── Termination：对话终止条件                              │
21
│                                                             │
22
│  工具使用                                                    │
23
│  ├── Function Calling：原生工具调用支持                     │
24
│  └── Code Execution：代码执行作为工具                       │
25
│                                                             │
26
└─────────────────────────────────────────────────────────────┘

1
import autogen
2

3
# 配置 LLM
4
config_list = [
5
    {"model": "gpt-4o", "api_key": "your-api-key"}
6
]
7

8
# 创建助手 Agent
9
assistant = autogen.AssistantAgent(
10
    name="assistant",
11
    llm_config={"config_list": config_list}
12
)
13

14
# 创建用户代理 Agent
15
user_proxy = autogen.UserProxyAgent(
16
    name="user_proxy",
17
    human_input_mode="TERMINATE",  # 结束时请求人类确认
18
    max_consecutive_auto_reply=10,
19
    code_execution_config={
20
        "work_dir": "coding",
21
        "use_docker": False
22
    }
23
)
24

25
# 开始对话
26
user_proxy.initiate_chat(
27
    assistant,
28
    message="帮我写一个 Python 爬虫，抓取新闻标题"
29
)

1
import autogen
2

3
# 创建多个 Agent
4
researcher = autogen.AssistantAgent(
5
    name="Researcher",
6
    system_message="你是一个研究员，负责收集和分析信息。",
7
    llm_config={"config_list": config_list}
8
)
9

10
coder = autogen.AssistantAgent(
11
    name="Coder",
12
    system_message="你是一个程序员，负责编写和调试代码。",
13
    llm_config={"config_list": config_list}
14
)
15

16
reviewer = autogen.AssistantAgent(
17
    name="Reviewer",
18
    system_message="你是一个审核员，负责检查代码质量和正确性。",
19
    llm_config={"config_list": config_list}
20
)
21

22
# 创建群聊
23
groupchat = autogen.GroupChat(
24
    agents=[researcher, coder, reviewer],
25
    messages=[],
26
    max_round=20
27
)
28

29
manager = autogen.GroupChatManager(
30
    groupchat=groupchat,
31
    llm_config={"config_list": config_list}
32
)
33

34
# 用户代理发起群聊
35
user_proxy = autogen.UserProxyAgent(
36
    name="User",
37
    human_input_mode="NEVER",
38
    code_execution_config=False
39
)
40

41
user_proxy.initiate_chat(
42
    manager,
43
    message="开发一个数据分析工具，从 CSV 文件读取数据并生成可视化报告"
44
)

1
优势：
2
• 多 Agent 对话模式独特强大
3
• 代码自动执行能力出色
4
• 灵活的人类参与机制
5
• 微软背书，持续迭代
6
• 适合研究和原型开发
7

8
劣势：
9
• 生产环境支持相对较弱
10
• 性能优化空间大
11
• 对话控制粒度有限
12
• 文档有时不够清晰

1
┌─────────────────────────────────────────────────────────────┐
2
│                    CrewAI 核心概念                           │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  Agent（智能体）                                             │
6
│  ├── Role：角色定义（研究员、作家等）                        │
7
│  ├── Goal：目标（收集信息、写作等）                          │
8
│  ├── Backstory：背景故事（增强角色深度）                     │
9
│  ├── Tools：可用工具                                        │
10
│  └── Allow Delegation：是否允许委托任务                      │
11
│                                                             │
12
│  Task（任务）                                                │
13
│  ├── Description：任务描述                                  │
14
│  ├── Expected Output：预期输出                              │
15
│  ├── Agent：负责的 Agent                                    │
16
│  └── Context：上下文任务（依赖）                             │
17
│                                                             │
18
│  Crew（团队）                                                │
19
│  ├── Agents：团队成员                                       │
20
│  ├── Tasks：任务列表                                        │
21
│  ├── Process：执行流程                                      │
22
│  │   ├── Sequential：顺序执行                               │
23
│  │   └── Hierarchical：层级管理                             │
24
│  └── Manager LLM：管理者模型（层级模式）                     │
25
│                                                             │
26
│  Tools（工具）                                               │
27
│  ├── 预定义工具：搜索、文件、浏览器等                        │
28
│  └── 自定义工具：使用 @tool 装饰器                          │
29
│                                                             │
30
└─────────────────────────────────────────────────────────────┘

1
from crewai import Agent, Task, Crew, Process
2
from crewai_tools import SerperDevTool, WebsiteSearchTool
3

4
# 定义工具
5
search_tool = SerperDevTool()
6
web_tool = WebsiteSearchTool()
7

8
# 定义 Agent
9
researcher = Agent(
10
    role="高级研究员",
11
    goal="深入研究指定主题，收集全面的信息",
12
    backstory="""你是一位经验丰富的研究员，擅长从各种来源
13
    收集和分析信息。你的研究总是详尽、准确、有深度。""",
14
    tools=[search_tool, web_tool],
15
    verbose=True
16
)
17

18
writer = Agent(
19
    role="技术作家",
20
    goal="将研究结果转化为高质量的文章",
21
    backstory="""你是一位专业的技术作家，擅长将复杂的概念
22
    转化为清晰易懂的文章。你的文章结构清晰、逻辑严谨。""",
23
    verbose=True
24
)
25

26
editor = Agent(
27
    role="编辑",
28
    goal="审核和完善文章质量",
29
    backstory="""你是一位严谨的编辑，对文章质量有很高的要求。
30
    你会检查逻辑、语言、格式，确保文章达到专业标准。""",
31
    verbose=True
32
)
33

34
# 定义任务
35
research_task = Task(
36
    description="研究 AI Agent 的最新发展趋势",
37
    expected_output="一份详细的研究报告，包含关键技术、主要玩家、未来方向",
38
    agent=researcher
39
)
40

41
write_task = Task(
42
    description="基于研究报告撰写一篇技术文章",
43
    expected_output="一篇结构清晰、内容丰富的技术文章，约 2000 字",
44
    agent=writer,
45
    context=[research_task]  # 依赖研究任务
46
)
47

48
edit_task = Task(
49
    description="审核并完善文章",
50
    expected_output="最终版本的文章，确保质量达标",
51
    agent=editor,
52
    context=[write_task]
53
)
54

55
# 创建 Crew
56
crew = Crew(
57
    agents=[researcher, writer, editor],
58
    tasks=[research_task, write_task, edit_task],
59
    process=Process.sequential,
60
    verbose=True
61
)
62

63
# 执行
64
result = crew.kickoff()
65
print(result)

1
from crewai import Agent, Task, Crew, Process
2

3
# 定义 Manager
4
manager = Agent(
5
    role="项目经理",
6
    goal="协调团队完成复杂项目",
7
    backstory="你是一位经验丰富的项目经理，擅长分配任务和协调资源。",
8
    allow_delegation=True
9
)
10

11
# 定义 Worker Agents
12
developer = Agent(
13
    role="开发者",
14
    goal="编写高质量的代码",
15
    backstory="你是一位全栈开发者，精通多种编程语言和框架。",
16
    tools=[code_tool]
17
)
18

19
designer = Agent(
20
    role="设计师",
21
    goal="设计美观的界面",
22
    backstory="你是一位 UI/UX 设计师，擅长创建用户友好的界面。"
23
)
24

25
# 创建层级 Crew
26
crew = Crew(
27
    agents=[developer, designer],
28
    tasks=[...],  # 任务会由 Manager 分配
29
    process=Process.hierarchical,
30
    manager_llm="gpt-4o",  # Manager 使用的模型
31
    verbose=True
32
)

1
优势：
2
• 角色扮演设计直观易懂
3
• 声明式配置，代码简洁
4
• 内置协作流程，开箱即用
5
• 学习曲线平缓
6
• 适合快速原型和内容创作
7

8
劣势：
9
• 抽象层次高，定制灵活性受限
10
• 复杂工作流支持有限
11
• 性能和稳定性仍在迭代
12
• 社区和生态相对较小

1
┌─────────────────────────────────────────────────────────────┐
2
│                  Semantic Kernel 核心概念                    │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  Kernel（内核）                                              │
6
│  ├── 核心协调器，管理所有组件                                │
7
│  ├── 注册服务和插件                                         │
8
│  └── 管理依赖注入                                           │
9
│                                                             │
10
│  Skills/Plugins（技能/插件）                                 │
11
│  ├── Semantic Functions：基于提示词的函数                   │
12
│  ├── Native Functions：原生代码函数                         │
13
│  └── 可组合、可复用的功能单元                                │
14
│                                                             │
15
│  Connectors（连接器）                                        │
16
│  ├── LLM 连接器（OpenAI、Azure、HuggingFace）               │
17
│  ├── Memory 连接器（Redis、Qdrant、Azure AI Search）        │
18
│  └── 可扩展的第三方连接                                      │
19
│                                                             │
20
│  Planners（规划器）                                          │
21
│  ├── 自动组合函数完成目标                                    │
22
│  ├── Handlebars Planner：模板规划                           │
23
│  └── Function Calling Stepwise Planner：逐步规划            │
24
│                                                             │
25
│  Memory（记忆）                                              │
26
│  ├── Volatile Memory：临时存储                              │
27
│  ├── Semantic Memory：语义记忆（向量）                       │
28
│  └── 可持久化到各种存储后端                                  │
29
│                                                             │
30
└─────────────────────────────────────────────────────────────┘

1
import semantic_kernel as sk
2
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
3
from semantic_kernel.core_plugins import TimePlugin, MathPlugin
4

5
# 创建 Kernel
6
kernel = sk.Kernel()
7

8
# 添加 AI 服务
9
kernel.add_service(
10
    OpenAIChatCompletion(
11
        service_id="chat",
12
        ai_model_id="gpt-4o",
13
        api_key="your-api-key"
14
    )
15
)
16

17
# 添加原生插件
18
kernel.add_plugin(TimePlugin(), "time")
19
kernel.add_plugin(MathPlugin(), "math")
20

21
# 定义语义函数
22
summarize = kernel.add_function(
23
    plugin_name="utils",
24
    function_name="summarize",
25
    description="总结文本内容",
26
    prompt_template="""
27
请总结以下文本：
28

29
{{$input}}
30

31
要求：
32
1. 提取关键信息
33
2. 保持简洁
34
3. 不超过 100 字
35
"""
36
)
37

38
# 执行
39
result = await kernel.invoke(
40
    summarize,
41
    input="很长的一段文本..."
42
)
43
print(result)

1
from semantic_kernel.planners import FunctionCallingStepwisePlanner
2

3
# 创建规划器
4
planner = FunctionCallingStepwisePlanner(
5
    kernel,
6
    max_iterations=10,
7
    max_tokens=4000
8
)
9

10
# 执行复杂任务
11
result = await planner.invoke(
12
    "计算今天是一年中的第几天，然后告诉我这一年还剩多少天"
13
)
14
print(result.final_answer)

1
优势：
2
• 微软官方支持，企业级稳定性
3
• 与 Azure 生态深度集成
4
• 多语言支持（Python、C#、Java）
5
• 插件化设计，易于扩展
6
• 规划器功能强大
7

8
劣势：
9
• 学习曲线较陡
10
• 文档相对 LangChain 较少
11
• 社区规模较小
12
• Python 版本功能滞后于 C#

1
┌─────────────────────────────────────────────────────────────┐
2
│                 OpenAI Agents SDK 核心概念                   │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  Agent（智能体）                                             │
6
│  ├── name：Agent 名称                                       │
7
│  ├── instructions：系统指令                                 │
8
│  ├── model：使用的模型                                      │
9
│  ├── tools：可用工具列表                                    │
10
│  └── handoffs：可转交的其他 Agent                           │
11
│                                                             │
12
│  Tools（工具）                                               │
13
│  ├── Function Tools：自定义 Python 函数                     │
14
│  ├── Hosted Tools：OpenAI 托管工具（代码解释器、搜索等）     │
15
│  └── 工具定义使用装饰器 @function_tool                      │
16
│                                                             │
17
│  Handoffs（转交）                                            │
18
│  ├── Agent 间任务转交机制                                   │
19
│  ├── 实现 Agent 专业分工                                    │
20
│  └── 自动选择合适的 Agent                                   │
21
│                                                             │
22
│  Runner（运行器）                                            │
23
│  ├── run()：异步执行                                        │
24
│  ├── run_sync()：同步执行                                   │
25
│  └── run_streamed()：流式执行                               │
26
│                                                             │
27
│  Context（上下文）                                           │
28
│  ├── Local Context：Agent 本地上下文                        │
29
│  └── Session Context：会话级共享上下文                       │
30
│                                                             │
31
└─────────────────────────────────────────────────────────────┘

1
from agents import Agent, Runner, function_tool
2

3
# 定义工具
4
@function_tool
5
def get_weather(city: str) -> str:
6
    """获取城市天气"""
7
    return f"{city}今天晴，温度 15-25°C"
8

9
@function_tool
10
def send_email(to: str, subject: str, body: str) -> str:
11
    """发送邮件"""
12
    return f"邮件已发送至 {to}"
13

14
# 创建 Agent
15
agent = Agent(
16
    name="Assistant",
17
    instructions="你是一个有帮助的助手，可以查询天气和发送邮件。",
18
    tools=[get_weather, send_email],
19
    model="gpt-4o"
20
)
21

22
# 运行
23
result = Runner.run_sync(agent, "北京今天天气怎么样？")
24
print(result.final_output)

1
from agents import Agent, Runner, function_tool
2

3
# 定义专业 Agent
4
research_agent = Agent(
5
    name="Researcher",
6
    instructions="你是研究专家，负责收集和分析信息。",
7
    tools=[search_tool],
8
    model="gpt-4o"
9
)
10

11
writer_agent = Agent(
12
    name="Writer",
13
    instructions="你是写作专家，负责撰写高质量文章。",
14
    model="gpt-4o"
15
)
16

17
# 主 Agent，可以转交任务
18
main_agent = Agent(
19
    name="MainAgent",
20
    instructions="""你是主助手，根据任务类型转交给专家：
21
    - 研究任务转给 Researcher
22
    - 写作任务转给 Writer
23
    """,
24
    handoffs=[research_agent, writer_agent],
25
    model="gpt-4o"
26
)
27

28
# 运行
29
result = Runner.run_sync(
30
    main_agent,
31
    "帮我研究 AI Agent 的发展趋势并写一篇分析文章"
32
)
33
print(result.final_output)

1
优势：
2
• OpenAI 官方支持，与 GPT 模型深度集成
3
• 轻量简洁，学习成本低
4
• 原生支持 OpenAI 最新特性
5
• Handoffs 机制实现多 Agent 协作
6
• 流式输出支持完善
7

8
劣势：
9
• 仅支持 OpenAI 模型
10
• 功能相对基础，需要自建更多能力
11
• 生态和社区较小
12
• 生产级功能有待验证

1
┌─────────────────────────────────────────────────────────────┐
2
│                    功能对比矩阵                              │
3
├─────────────┬───────┬────────┬────────┬────────┬───────────┤
4
│ 功能        │Lang   │AutoGen │ CrewAI │ SemKer │ OpenAI    │
5
├─────────────┼───────┼────────┼────────┼────────┼───────────┤
6
│ 单 Agent    │   │   │   │   │     │
7
│ 多 Agent    │   │   │   │   │     │
8
│ 工具调用    │   │   │   │   │     │
9
│ 状态管理    │   │   │   │   │     │
10
│ 记忆系统    │   │   │   │   │     │
11
│ 代码执行    │   │   │   │   │     │
12
│ 工作流编排  │   │   │   │   │     │
13
│ LLM 兼容    │   │   │   │   │     │
14
│ 文档质量    │   │   │   │   │     │
15
│ 社区活跃    │   │   │   │   │     │
16
│ 生产就绪    │   │   │   │   │     │
17
└─────────────┴───────┴────────┴────────┴────────┴───────────┘

1
入门路径：
2
1. OpenAI Agents SDK → 理解 Agent 基础概念
3
2. LangChain → 学习 Chain、Agent、Memory
4
3. LangGraph → 掌握状态机工作流
5

6
进阶路径：
7
4. CrewAI → 多 Agent 角色协作
8
5. AutoGen → 多 Agent 对话模式
9

10
企业路径：
11
6. Semantic Kernel → 企业级集成
12
7. 生产部署最佳实践