CrewAI学习笔记

> 学习时间：2026-04-11
> 课程来源：DeepLearning.AI - Multi AI Agent Systems with CrewAI
> 授课教师：João Moura (CrewAI创始人兼CEO)
> 学习背景：已学LangGraph课程、31个Skill、LLM-Agent-Survey论文

一、课程概要

1.1 课程信息

1.2 课程核心收获

1. 角色驱动设计：用role、goal、backstory定义Agent行为
2. Crew编排模式：Sequential、Hierarchical、Parallel三种协作模式
3. Task任务管理：定义任务描述、预期输出、Agent归属
4. 工具集成：内置工具（SerperDevTool、ScrapeWebsiteTool）和自定义工具
5. 协作机制：Agent间委托、问答、上下文共享
6. Memory系统：短时记忆、长时记忆、实体记忆

1.3 课程大纲

1. Introduction (3分钟)
Overview (11分钟) - 多Agent系统概述
AI Agents (8分钟) - Agent核心概念
Create agents to research and write an article (15分钟) - 代码示例
Key elements of AI agents (11分钟) - Agent关键要素
Multi agent customer support automation (18分钟) - 代码示例
Mental framework for agent creation (3分钟) - Agent创建思维框架
Key elements of agent tools (7分钟) - 工具关键要素
Tools for a customer outreach campaign (16分钟) - 代码示例
Recap of tools (1分钟)
Key elements of well defined tasks (4分钟) - 任务关键要素
Automate event planning (15分钟) - 代码示例
Recap on tasks (1分钟)
Multi agent collaboration (5分钟) - Agent协作
Mutli agent collaboration for financial analysis (12分钟) - 代码示例
Build a crew to tailor job applications (17分钟) - 代码示例
Next steps with AI agent systems (5分钟)
Conclusion (1分钟)

二、CrewAI核心概念

2.1 核心架构：Agent / Task / Crew

┌─────────────────────────────────────────────────────────────┐
│                        CrewAI 架构                           │
├─────────────────────────────────────────────────────────────┤
│  Agent（智能体）                                              │
│  ├─ role: 角色定义（如"研究员"、"作家"）                        │
│  ├─ goal: 目标描述（Agent要达成的目标）                         │
│  ├─ backstory: 背景故事（塑造Agent行为风格）                    │
│  ├─ tools: 工具列表（Agent可使用的工具）                        │
│  └─ allow_delegation: 是否允许委托任务给其他Agent                │
├─────────────────────────────────────────────────────────────┤
│  Task（任务）                                                 │
│  ├─ description: 任务描述（具体要做什么）                       │
│  ├─ expected_output: 预期输出（输出格式和内容要求）              │
│  ├─ agent: 归属Agent（谁来执行这个任务）                        │
│  └─ context: 上下文（依赖的其他任务输出）                        │
├─────────────────────────────────────────────────────────────┤
│  Crew（团队）                                                 │
│  ├─ agents: Agent列表（团队成员）                              │
│  ├─ tasks: Task列表（待执行任务）                              │
│  ├─ process: 协作模式（Sequential/Hierarchical）              │
│  └─ verbose: 日志级别                                        │
└─────────────────────────────────────────────────────────────┘

2.2 CrewAI vs LangGraph 核心对比

2.3 CrewAI适用场景

✅ 适合用CrewAI：
├─ 内容创作流水线（研究→写作→编辑）
├─ 快速原型验证（MVP阶段）
├─ 业务工作流自动化（角色清晰）
├─ 研究自动化（信息搜集→分析→报告）
└─ 团队协作模拟（清晰的层级结构）
❌ 考虑LangGraph：
├─ 需要条件分支的复杂流程
├─ 需要故障恢复能力
├─ 需要人类审批节点
├─ 需要精确控制状态流转
└─ 生产级复杂系统

三、可运行代码示例

3.1 基础Sequential模式：研究+报告

#!/usr/bin/env python
"""
CrewAI快速上手：研究+报告流水线
对应课程：Multi AI Agent Systems with CrewAI
"""
import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool
设置API密钥
os.environ["OPENAI_API_KEY"] = "your-api-key"
os.environ["SERPER_API_KEY"] = "your-serper-key"  # 搜索工具需要
1. 定义Agent
researcher = Agent(
    role="高级AI研究员",
    goal="深入研究{topic}领域的最新发展",
    backstory="""
    你是一位资深AI研究员，擅长从官方文档、论文、新闻中
    提炼关键信息，并用结构化的方式呈现。
    """,
    tools=[SerperDevTool()],  # 搜索工具
    verbose=True
)
writer = Agent(
    role="技术作家",
    goal="将研究内容转化为清晰、专业的技术报告",
    backstory="""
    你是一名技术作家，曾在AI媒体发表多篇文章，
    擅长用通俗易懂的语言解释复杂技术概念。
    """,
    verbose=True
)
2. 定义Task
research_task = Task(
    description="深入研究{topic}，包括：1) 核心概念 2) 最新进展 3) 应用场景 4) 未来趋势",
    expected_output="10个要点的结构化研究摘要",
    agent=researcher
)
writing_task = Task(
    description="基于研究摘要，撰写一篇专业技术报告",
    expected_output="完整的Markdown格式技术报告",
    agent=writer,
    context=[research_task]  # 依赖研究任务输出
)
3. 创建Crew并运行
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,  # 顺序执行
    verbose=2
)
运行
result = crew.kickoff(inputs={"topic": "AI Agents"})
print(result)

3.2 Hierarchical模式：经理+专家团队

#!/usr/bin/env python
"""
CrewAI Hierarchical模式：自动化技术报告生成
对应课程：Multi AI Agent Systems with CrewAI - 高级示例
"""
import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
from langchain_openai import ChatOpenAI
os.environ["OPENAI_API_KEY"] = "your-api-key"
os.environ["SERPER_API_KEY"] = "your-serper-key"
使用更强模型作为Manager
manager_llm = ChatOpenAI(model="gpt-4o", temperature=0.2)
worker_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.4)
1. Manager Agent（项目经理）
manager = Agent(
    role="AI项目经理",
    goal="高效协调团队，产出高质量、准确及时的技术分析报告",
    backstory="""
    你是一位经验丰富的AI项目经理，曾领导多个前沿技术情报项目。
    你擅长任务分解、进度监控、质量把控。
    """,
    llm=manager_llm,
    verbose=True,
    allow_delegation=True  # 关键：允许经理分配任务
)
2. Specialist Agents（专家团队）
researcher = Agent(
    role="资深AI情报研究员",
    goal="获取最新官方动态与技术细节",
    backstory="你精通情报搜集，能从官网、X平台、新闻中提炼可靠信息",
    tools=[SerperDevTool(), ScrapeWebsiteTool()],
    llm=worker_llm,
    verbose=True,
    allow_delegation=False  # 专家专注执行
)
analyst = Agent(
    role="Grok技术分析师",
    goal="深入分析技术原理、性能提升与应用价值",
    backstory="你对xAI技术栈和LLM架构有深刻理解",
    llm=worker_llm,
    verbose=True,
    allow_delegation=False
)
writer = Agent(
    role="高级技术作家",
    goal="撰写逻辑清晰、专业性强的技术分析报告",
    backstory="你的文章曾刊登于AI媒体，文风严谨且易懂",
    llm=worker_llm,
    allow_delegation=False
)
reviewer = Agent(
    role="技术报告审核专家",
    goal="确保报告事实准确、逻辑严密、无幻觉内容",
    backstory="你是严谨的AI学术编辑，对AI动态高度敏感",
    llm=worker_llm,
    verbose=True
)
3. 定义主任务（交给Manager）
final_task = Task(
    description="""
    产出一篇深度技术报告，主题为：{topic}
    
    要求：
    - 基于最新真实信息
    - 涵盖：技术原理、性能分析、应用场景、未来展望
    - 结构清晰（引言、正文、结论）
    - 引用可靠来源
    - 字数约1000字，Markdown格式
    """,
    expected_output="完整的高质量技术分析报告",
    agent=manager  # 主任务交给Manager，它会分配给专家
)
4. 创建Hierarchical Crew
crew = Crew(
    agents=[manager, researcher, analyst, writer, reviewer],
    tasks=[final_task],
    process=Process.hierarchical,  # 层级模式
    manager_agent=manager,
    verbose=2
)
运行
result = crew.kickoff(inputs={"topic": "xAI最新动态与Grok新功能分析"})

3.3 协作模式：Agent间委托与问答

#!/usr/bin/env python
"""
CrewAI协作模式：Agent间动态协作
对应课程：Multi Agent Collaboration
"""
import os
from crewai import Agent, Task, Crew
os.environ["OPENAI_API_KEY"] = "your-api-key"
1. 创建可协作的Agent（allow_delegation=True）
researcher = Agent(
    role="研究专家",
    goal="找到准确、最新的信息",
    backstory="你是一位资深研究员，精通信息检索和事实核查",
    allow_delegation=True,  # 允许委托和提问
    verbose=True
)
writer = Agent(
    role="内容作家",
    goal="创作引人入胜的内容",
    backstory="你是一位专业作家，擅长将复杂信息转化为通俗内容",
    allow_delegation=True,
    verbose=True
)
editor = Agent(
    role="资深编辑",
    goal="确保内容质量",
    backstory="你编辑过数百篇技术文章，对模糊表述非常敏感",
    allow_delegation=True,
    verbose=True
)
2. 定义协作任务
article_task = Task(
    description="""
    撰写一篇关于'AI Agent未来发展'的1000字文章。
    文章应包括：
    - AI Agent当前应用
    - 新兴趋势和技术
    - 潜在挑战和伦理考量
    - 未来5年专家预测
    
    与团队成员协作确保准确性和质量。
    """,
    expected_output="结构良好、有据可查的1000字文章",
    agent=writer  # 作家主导，但可以委托研究给researcher
)
3. 创建Crew（协作模式）
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[article_task],
    process=Process.sequential,  # 顺序执行，但Agent间可协作
    verbose=True
)
运行
result = crew.kickoff()

3.4 带Guardrails的任务验证

#!/usr/bin/env python
"""
CrewAI Guardrails：任务输出验证
对应课程：Key elements of well defined tasks
"""
from typing import Tuple, Any
from crewai import Task, Agent, Crew, TaskOutput
1. 定义验证函数
def validate_word_count(result: TaskOutput) -> Tuple[bool, Any]:
    """验证字数是否符合要求"""
    word_count = len(result.raw.split())
    if word_count < 100:
        return (False, f"内容太短：{word_count}字，至少需要100字")
    if word_count > 500:
        return (False, f"内容太长：{word_count}字，最多500字")
    return (True, result.raw)
def validate_no_hallucination(result: TaskOutput) -> Tuple[bool, Any]:
    """检查是否有幻觉内容（简单示例）"""
    # 实际项目中应该用更复杂的验证逻辑
    hallucination_keywords = ["我确定", "毫无疑问", "100%确定"]
    for keyword in hallucination_keywords:
        if keyword in result.raw:
            return (True, result.raw)  # 警告但不阻止
    return (True, result.raw)
def format_output(result: TaskOutput) -> Tuple[bool, Any]:
    """格式化输出"""
    formatted = result.raw.strip()
    formatted = formatted[0].upper() + formatted[1:] if formatted else formatted
    return (True, formatted)
2. 创建Agent
writer = Agent(
    role="博客作者",
    goal="撰写吸引人的AI博客文章",
    backstory="你是一位AI领域的专业博主"
)
3. 创建带Guardrails的任务
blog_task = Task(
    description="写一篇关于AI发展趋势的博客文章",
    expected_output="格式良好的博客文章，100-500字",
    agent=writer,
    guardrails=[
        validate_word_count,      # 第一步：验证字数
        validate_no_hallucination,  # 第二步：检查准确性
        format_output             # 第三步：格式化
    ],
    guardrail_max_retries=3  # 验证失败最多重试3次
)
4. 运行Crew
crew = Crew(agents=[writer], tasks=[blog_task], verbose=True)
result = crew.kickoff()

四、Memory系统详解

4.1 CrewAI Memory架构

┌─────────────────────────────────────────────────────────────┐
│                    CrewAI Memory 架构                        │
├─────────────────────────────────────────────────────────────┤
│  Memory (统一记忆类)                                          │
│  ├─ Short-term (短时记忆)                                    │
│  │  └─ ChromaDB向量存储，当前会话内的上下文                     │
│  ├─ Long-term (长时记忆)                                     │
│  │  └─ SQLite存储，跨会话的任务结果                            │
│  ├─ Entity (实体记忆)                                        │
│  │  └─ RAG索引人名、地点、概念等实体                           │
│  └─ Contextual (上下文记忆)                                   │
│     └─ 综合以上三种，智能组合                                  │
├─────────────────────────────────────────────────────────────┤
│  Scope (作用域)                                              │
│  ├─ /project/alpha                                          │
│  ├─ /agent/researcher                                       │
│  └─ /company/knowledge                                      │
├─────────────────────────────────────────────────────────────┤
│  Slice (记忆切片)                                            │
│  └─ 跨多个作用域查询，只读视图                                 │
└─────────────────────────────────────────────────────────────┘

4.2 Memory使用示例

#!/usr/bin/env python
"""
CrewAI Memory系统使用示例
"""
from crewai import Agent, Crew, Memory
1. 创建Memory实例
memory = Memory()
2. 基本使用：remember和recall
memory.remember("我们选择了PostgreSQL作为用户数据库")
memory.remember("Sprint速度是42点", scope="/team/metrics")
查询
matches = memory.recall("数据库选型决策")
print(matches)
3. 作用域隔离
agent_memory = memory.scope("/agent/researcher")
agent_memory.remember("发现了3篇关于LLM记忆的论文")
查询只在这个作用域
results = agent_memory.recall("LLM记忆")
4. 记忆切片（跨作用域查询，只读）
writer_view = memory.slice(
    scopes=["/agent/writer", "/company/knowledge"],
    read_only=True  # 不能写入，只能查询
)
matches = writer_view.recall("公司技术栈")
5. 启用Agent记忆
researcher = Agent(
    role="研究员",
    goal="提供准确的研究和分析",
    backstory="...",
    memory=True,  # 启用记忆
    verbose=True
)
6. 查看记忆树结构
print(memory.tree())
/
  /project (8 records)
    /project/alpha (5 records)
  /agent (7 records)
    /agent/researcher (4 records)

五、对看宝AI项目的启发

5.1 看宝AI多Agent架构设计

基于CrewAI课程，看宝AI可以设计如下多Agent团队：

┌─────────────────────────────────────────────────────────────┐
│                     看宝AI Agent团队                         │
├─────────────────────────────────────────────────────────────┤
│  Manager (看宝项目经理)                                      │
│  ├─ 协调所有子Agent工作                                      │
│  ├─ 任务分解和分配                                           │
│  └─ 质量把控和最终整合                                       │
├─────────────────────────────────────────────────────────────┤
│  Specialist Agents                                           │
│  ├─ UserUnderstander (用户理解专家)                          │
│  │  └─ 分析用户意图、情感、偏好                               │
│  ├─ KnowledgeRetriever (知识检索专家)                        │
│  │  └─ RAG知识库查询、相关文档检索                            │
│  ├─ ResponsePlanner (响应规划专家)                           │
│  │  └─ 制定回复策略、选择表达风格                              │
│  └─ SafetyChecker (安全检查专家)                             │
│     └─ 内容安全、幻觉检测、合规检查                            │
└─────────────────────────────────────────────────────────────┘

5.2 具体实现方案

#!/usr/bin/env python
"""
看宝AI多Agent架构设计
基于CrewAI Hierarchical模式
"""
import os
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerpAPIWrapper, WikipediaSearchTool
os.environ["OPENAI_API_KEY"] = "your-api-key"
Manager
kanbao_manager = Agent(
    role="看宝AI项目经理",
    goal="协调团队，提供精准、温暖、个性化的AI陪伴服务",
    backstory="""
    你是一位经验丰富的AI陪伴助手项目经理，
    擅长理解用户情感需求，协调多个专业模块协作，
    确保最终输出既准确又有温度。
    """,
    llm=ChatOpenAI(model="gpt-4o", temperature=0.3),
    verbose=True,
    allow_delegation=True
)
Specialist Agents
user_understander = Agent(
    role="用户理解专家",
    goal="深入分析用户意图、情感状态和潜在需求",
    backstory="你擅长情感分析和意图识别，能从字里行间读懂用户",
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.4),
    allow_delegation=False
)
knowledge_retriever = Agent(
    role="知识检索专家",
    goal="准确检索相关知识，为回应提供事实支撑",
    backstory="你精通知识检索，能快速找到最相关的信息",
    tools=[SerpAPIWrapper(), WikipediaSearchTool()],
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.2),
    allow_delegation=False
)
response_planner = Agent(
    role="响应规划专家",
    goal="制定最适合当前场景的回复策略",
    backstory="你擅长对话策略，能根据场景选择最恰当的表达方式",
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.5),
    allow_delegation=False
)
safety_checker = Agent(
    role="安全检查专家",
    goal="确保输出内容安全、合规、无有害信息",
    backstory="你是严谨的内容安全专家，对潜在风险高度敏感",
    llm=ChatOpenAI(model="gpt-4o-mini", temperature=0.1),
    allow_delegation=False
)
主任务
companion_task = Task(
    description="""
    作为看宝AI，为用户提供温暖、个性化的AI陪伴服务。
    
    用户输入：{user_input}
    
    请协调团队完成：
    1. 理解用户意图和情感状态
    2. 检索相关知识和信息
    3. 规划最合适的回应方式
    4. 确保内容安全
    5. 最终整合输出温暖、专业的回应
    """,
    expected_output="温暖、专业、个性化的AI陪伴回应",
    agent=kanbao_manager
)
创建Crew
kanbao_crew = Crew(
    agents=[
        kanbao_manager,
        user_understander,
        knowledge_retriever,
        response_planner,
        safety_checker
    ],
    tasks=[companion_task],
    process=Process.hierarchical,
    manager_agent=kanbao_manager,
    verbose=2,
    memory=True  # 启用团队记忆
)
运行
result = kanbao_crew.kickoff(inputs={
    "user_input": "我今天工作压力很大，有点累..."
})

5.3 看宝AI vs 传统客服Bot

六、CrewAI与LangGraph混合使用

6.1 混合架构设计

┌─────────────────────────────────────────────────────────────┐
│                    混合架构：CrewAI + LangGraph              │
├─────────────────────────────────────────────────────────────┤
│  LangGraph (编排层)                                          │
│  ├─ 主流程控制（状态机、条件分支）                              │
│  ├─ Checkpoint持久化                                         │
│  ├─ Human-in-the-loop                                        │
│  └─ 外部系统集成                                             │
├─────────────────────────────────────────────────────────────┤
│  CrewAI (执行层)                                             │
│  ├─ 角色定义（role/goal/backstory）                          │
│  ├─ Crew执行（Agent团队协作）                                 │
│  └─ 记忆系统（短时/长时/实体）                                │
└─────────────────────────────────────────────────────────────┘

6.2 混合使用代码示例

#!/usr/bin/env python
"""
混合使用：LangGraph编排 + CrewAI执行
结合两者的优势
"""
from langgraph.graph import StateGraph, END
from crewai import Agent, Task, Crew, Process
from typing import TypedDict
LangGraph状态定义
class KanbaoState(TypedDict):
    user_input: str
    intent: str
    sentiment: str
    knowledge_context: str
    response: str
    approved: bool
LangGraph节点（调用CrewAI执行具体任务）
def understand_user(state: KanbaoState):
    """使用CrewAI理解用户"""
    understander = Agent(
        role="用户理解专家",
        goal="分析用户意图和情感",
        backstory="..."
    )
    
    task = Task(
        description=f"分析用户输入：{state['user_input']}",
        expected_output="意图和情感分析结果",
        agent=understander
    )
    
    crew = Crew(agents=[understander], tasks=[task])
    result = crew.kickoff()
    
    return {
        "intent": "companion_talk",  # 从结果中提取
        "sentiment": "tired"  # 从结果中提取
    }
def retrieve_knowledge(state: KanbaoState):
    """使用CrewAI检索知识"""
    retriever = Agent(
        role="知识检索专家",
        goal="提供相关知识支持",
        backstory="...",
        tools=[...]
    )
    # ...
    return {"knowledge_context": "..."}
def generate_response(state: KanbaoState):
    """使用CrewAI生成回应"""
    responder = Agent(
        role="温暖陪伴师",
        goal="提供温暖、专业的回应",
        backstory="..."
    )
    # ...
    return {"response": "..."}
def check_approval(state: KanbaoState):
    """人类审批节点"""
    # LangGraph原生支持中断
    return "approved" if state.get("approved") else "needs_review"
def human_review(state: KanbaoState):
    """人工审核（通过中断机制）"""
    # 这里会暂停，等待人类反馈
    pass
LangGraph流程
workflow = StateGraph(KanbaoState)
workflow.add_node("understand", understand_user)
workflow.add_node("retrieve", retrieve_knowledge)
workflow.add_node("respond", generate_response)
workflow.add_node("review", human_review)
workflow.set_entry_point("understand")
workflow.add_edge("understand", "retrieve")
workflow.add_edge("retrieve", "respond")
workflow.add_conditional_edges(
    "respond",
    check_approval,
    {"approved": END, "needs_review": "review"}
)
app = workflow.compile()

七、实践项目建议

7.1 入门项目：自动化内容生成流水线

#!/usr/bin/env python
"""
项目1：自动化内容生成流水线
目标：研究 → 写作 → 编辑 → 发布
"""
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool
researcher = Agent(
    role="内容研究员",
    goal="搜集准确、最新的相关信息",
    backstory="...",
    tools=[SerperDevTool()]
)
writer = Agent(
    role="内容作家",
    goal="创作高质量的文章",
    backstory="..."
)
editor = Agent(
    role="资深编辑",
    goal="确保文章质量",
    backstory="..."
)
research_task = Task(...)
writing_task = Task(..., context=[research_task])
editing_task = Task(..., context=[writing_task])
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential
)

7.2 进阶项目：智能客服系统

#!/usr/bin/env python
"""
项目2：智能客服系统
目标：问题分类 → 知识检索 → 响应生成 → 质量检查
"""
triage = Agent(role="分诊员", goal="分类客户问题")
retriever = Agent(role="知识库专家", goal="检索解决方案")
responder = Agent(role="客服专员", goal="生成专业回复")
quality = Agent(role="质量专员", goal="审核回复质量")
triage_task = Task(...)
retrieve_task = Task(..., context=[triage_task])
respond_task = Task(..., context=[retrieve_task])
quality_task = Task(..., context=[respond_task])

7.3 高级项目：看宝AI多Agent系统

#!/usr/bin/env python
"""
项目3：看宝AI多Agent陪伴系统
完整实现参考本文第5.2节
"""
使用Hierarchical模式
Manager协调 + 多专家协作
启用Memory系统
添加Guardrails安全检查

八、学习心得与反思

8.1 CrewAI核心设计哲学

1. 角色即心智模型：用自然语言描述Agent，比状态机更直观
2. 团队即工作流：Crew模拟真实团队协作模式
3. 隐式优于显式：任务输出自动传递，减少样板代码
4. 快速原型优先：先用CrewAI验证，再考虑迁移LangGraph

8.2 与LangGraph的选择决策

选择CrewAI：
├─ 项目初期，需要快速验证概念
├─ 工作流清晰，角色分工明确
├─ 不需要复杂的条件分支
└─ 团队成员不熟悉图论概念
选择LangGraph：
├─ 需要Checkpoint持久化
├─ 需要Human-in-the-loop
├─ 工作流有复杂条件分支
├─ 需要精确控制状态流转
└─ 生产环境，需要调试能力
混合使用：
├─ LangGraph做主流程编排
├─ CrewAI执行具体的Agent团队任务
└─ 兼顾灵活性和可控性

8.3 对未来Agent架构的思考

1. 多Agent协作是必然：单Agent能力有限，多Agent分工协作是趋势
2. 角色驱动设计：CrewAI的角色模型更符合人类认知
3. 渐进式复杂度：从CrewAI起步，需要时迁移LangGraph
4. 记忆是核心竞争力：持久化记忆是多轮对话的关键

九、参考资料

1. Multi AI Agent Systems with CrewAI - DeepLearning.AI
2. CrewAI Documentation
3. CrewAI vs LangGraph - Crewship
4. LangGraph vs CrewAI Comparison - Engineering Path
5. Multi-Agent框架对比 - 腾讯云

学习完成时间：2026-04-11 下一步：结合看宝AI项目实践，尝试用CrewAI实现多Agent架构