CrewAI 安装、使用方法详细全解

洛星核2026-06-14 14:30

CrewAI 安装、使用方法详细全解

数据来源: GitHub API、官方文档 (docs.crewai.com)、README、社区文章

一、概述

基本信息

项目 内容
项目名称 CrewAI
官方仓库 https://github.com/crewAIInc/crewAI
官方文档 https://docs.crewai.com
官方网站 https://crewai.com
示例仓库 https://github.com/crewAIInc/crewAI-examples
开源协议 MIT License
定位 多智能体编排框架，专注于角色扮演式自主 AI 智能体协作

项目简介

CrewAI 是一个开源的 Python 框架，用于编排角色扮演式自主 AI 智能体。它通过协作智能让多个智能体无缝协作，共同完成复杂任务。

核心理念：将 AI 智能体组织成"团队"（Crew），每个智能体有明确的角色（Role）、目标（Goal）和背景故事（Backstory），通过不同的执行流程（Process）协作完成任务。

CrewAI 提供两种互补的编排方式：

  • Crews（团队）：优化自主性和协作智能，适合需要灵活决策的场景
  • Flows（流程）：面向企业/生产环境的架构，提供精确的事件驱动控制和状态管理

GitHub 数据

指标 数值
Stars 53,272
Forks 7,450
Watchers 381
开放 Issues 427
创建时间 2023-10-27
最近推送 2026-06-11（活跃维护中）
社区认证开发者 100,000+

二、安装方法

1. 环境要求

  • Python 版本: >= 3.10 且 < 3.14
  • OpenAI SDK: >= 1.13.3（如果使用 OpenAI 模型）
  • 推荐使用 uv 作为依赖管理工具

2. 检查 Python 版本

bash 复制代码 
python3 --version

3. 安装 uv（推荐）

bash 复制代码 
# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

4. 安装 CrewAI

bash 复制代码 
# 基本安装
uv pip install crewai

# 或 pip 安装
pip install crewai

# 安装带额外工具的完整版（推荐）
uv pip install 'crewai[tools]'

# 安装带嵌入支持的版本
uv pip install 'crewai[embeddings]'

5. 常见问题解决

  • ModuleNotFoundError: No module named 'tiktoken'
    • 解决: uv pip install 'crewai[embeddings]'
  • Failed building wheel for tiktoken
    • 需要安装 Rust 编译器
    • Windows 需要 Visual C++ Build Tools
    • 或使用预编译包: uv pip install tiktoken --prefer-binary

6. 配置环境变量

在 .env 文件中设置:

bash 复制代码 
OPENAI_API_KEY=sk-...          # OpenAI API 密钥
SERPER_API_KEY=YOUR_KEY_HERE   # 搜索工具 API 密钥（可选）

7. AI 编码助手集成（可选）

让 Claude Code / Cursor 等 AI 编码助手自动学习 CrewAI 最佳实践：

bash 复制代码 
# Claude Code
/plugin marketplace add crewAIInc/skills
/plugin install crewai-skills@crewai-plugins
/reload-plugins

# Cursor / Codex / Windsurf
npx skills add crewaiinc/skills

三、核心概念详解

3.1 整体架构

CrewAI 的核心概念层次：

复制代码 
Flow（流程）
 └── Crew（团队）
      └── Agent（智能体）执行 Task（任务）
           └── 使用 Tool（工具）
           └── 拥有 Memory（记忆）

3.2 Agent（智能体）

Agent 是 CrewAI 的基本单元，代表一个有特定角色和能力的"团队成员"。

智能体能力：

  • 执行特定任务
  • 基于角色和目标做决策
  • 使用工具完成目标
  • 与其他智能体通信和协作
  • 维护交互记忆
  • 在允许时委派任务

Agent 属性：

属性 参数 类型 说明
角色 role str 定义智能体在团队中的职能和专长
目标 goal str 指导智能体决策的个人目标
背景故事 backstory str 为智能体提供背景和个性
语言模型 llm str/LLM 驱动智能体的模型，默认 gpt-4
工具 tools ListBaseTool 智能体可用的能力/函数
函数调用模型 function_calling_llm OptionalAny 工具调用的专用模型
最大迭代次数 max_iter int 强制输出最佳答案前的最大迭代数，默认 20
最大 RPM max_rpm Optionalint 每分钟最大请求数，避免速率限制
最大执行时间 max_execution_time Optionalint 任务执行的最大秒数
详细日志 verbose bool 启用详细执行日志，默认 False
允许委派 allow_delegation bool 允许智能体将任务委派给其他智能体，默认 False
步骤回调 step_callback OptionalAny 每个步骤后调用的函数
缓存 cache bool 启用工具使用缓存，默认 True
系统模板 system_template Optionalstr 自定义系统提示模板
提示模板 prompt_template Optionalstr 自定义提示模板
响应模板 response_template Optionalstr 自定义响应模板

创建 Agent 的代码示例：

python 复制代码 
from crewai import Agent

# 方式1：直接创建
researcher = Agent(
    role="高级数据研究员",
    goal="发现{topic}领域的最新进展",
    backstory="你是一位经验丰富的研究员，擅长寻找最相关的信息"
              "并以清晰简洁的方式呈现。",
    tools=[search_tool],  # 可选工具
    llm="gpt-4o",         # 指定模型
    verbose=True,
    allow_delegation=False
)

# 方式2：从 YAML 配置加载
researcher = Agent(
    config=self.agents_config['researcher'],
    verbose=True,
    tools=[SerperDevTool()]
)

3.3 Task（任务）

Task 是由 Agent 执行的具体工作分配。

Task 属性：

属性 参数 类型 说明
描述 description str 任务的清晰描述（必填）
期望输出 expected_output str 任务完成时的理想结果描述（必填）
名称 name Optionalstr 任务的名称标识符
执行者 agent OptionalBaseAgent 负责执行此任务的智能体
工具 tools ListBaseTool 此任务限定使用的工具
上下文 context OptionalList\[Task] 其他任务的输出，作为此任务的上下文
异步执行 async_execution Optionalbool 是否异步执行，默认 False
人工审核 human_input Optionalbool 是否需要人工审核最终答案，默认 False
Markdown 输出 markdown Optionalbool 是否要求 Markdown 格式输出
输出文件 output_file Optionalstr 将任务输出存储到文件
输出 JSON Schema output_json OptionalType 输出为指定 Pydantic 模型的 JSON
输出 Pydantic output_pydantic OptionalType 输出为指定 Pydantic 模型
回调 callback OptionalCallable 任务完成后的回调函数
中断回调 interupt_before_proceed OptionalCallable 执行前的中断检查

创建 Task 的代码示例：

python 复制代码 
from crewai import Task

# 方式1：直接创建
research_task = Task(
    description="对{topic}进行全面研究，确保找到2025年所有相关的最新信息。",
    expected_output="包含关于{topic}最重要的10条信息的要点列表",
    agent=researcher,
    tools=[search_tool]
)

reporting_task = Task(
    description="基于研究结果，编写详细的分析报告。",
    expected_output="格式化的 Markdown 报告，包含主要发现和建议",
    agent=reporting_analyst,
    context=[research_task],  # 依赖 research_task 的输出
    output_file="report.md"   # 输出到文件
)

# 方式2：从 YAML 配置加载
research_task = Task(
    config=self.tasks_config['research_task'],
)

# 方式3：结构化输出
from pydantic import BaseModel, Field

class StockAnalysis(BaseModel):
    ticker: str = Field(description="股票代码")
    rating: float = Field(description="推荐评分")
    summary: str = Field(description="分析摘要")

analysis_task = Task(
    description="分析给定的股票",
    expected_output="结构化的股票分析结果",
    agent=analyst,
    output_pydantic=StockAnalysis  # 强制结构化输出
)

3.4 Crew（团队）

Crew 是将 Agents 和 Tasks 组织在一起的工作单元。

Crew 属性：

属性 说明
agents 智能体列表
tasks 任务列表
process 执行流程（sequential / hierarchical）
verbose 详细日志模式
memory 是否启用记忆系统
manager_llm 层级模式下的管理智能体模型
manager_agent 层级模式下的自定义管理智能体
cache 是否启用缓存
shared_memory 团队是否共享记忆
max_rpm 每分钟最大请求数
max_execution_time 最大执行时间
llm 默认语言模型
step_callback 步骤回调函数
embedder 嵌入模型配置（用于记忆）
plugins OpenAI 插件
task_callback 任务完成回调

创建 Crew 的代码示例：

python 复制代码 
from crewai import Crew, Process

# 顺序执行
crew = Crew(
    agents=[researcher, reporting_analyst],
    tasks=[research_task, reporting_task],
    process=Process.sequential,
    verbose=True,
    memory=True  # 启用记忆
)

# 层级执行（需要指定 manager_llm）
crew = Crew(
    agents=[researcher, reporting_analyst],
    tasks=[research_task, reporting_task],
    process=Process.hierarchical,
    manager_llm="gpt-4o",
    verbose=True
)

# 启动执行
result = crew.kickoff(inputs={"topic": "AI Agents"})

# 异步启动
result = crew.kickoff_async(inputs={"topic": "AI Agents"})

# 重置团队状态
crew.reset()

3.5 Process（执行流程）

Process 控制任务如何在智能体之间分配和执行。

顺序流程（Sequential）：

  • 任务按预定义顺序依次执行
  • 前一个任务的输出作为下一个任务的上下文
  • 适合线性流水线
python 复制代码 
crew = Crew(
    agents=my_agents,
    tasks=my_tasks,
    process=Process.sequential
)

层级流程（Hierarchical）：

  • 模拟公司层级结构
  • 自动创建或指定一个 Manager Agent
  • Manager 负责任务分配、进度监控和结果验证
  • 任务不是预分配的，Manager 根据智能体能力动态分配
  • 必须指定 manager_llm 或 manager_agent
python 复制代码 
crew = Crew(
    agents=my_agents,
    tasks=my_tasks,
    process=Process.hierarchical,
    manager_llm="gpt-4o"
    # 或
    # manager_agent=my_manager_agent
)

3.6 Tools（工具）

工具赋予智能体执行具体操作的能力。

工具特点：

  • 实用性：网络搜索、数据分析、内容生成、智能体协作
  • 集成性：无缝集成到智能体工作流
  • 可定制性：可开发自定义工具或使用现有工具
  • 错误处理：内置健壮的异常处理机制
  • 缓存机制：智能缓存优化性能
  • 异步支持：支持同步和异步工具

安装工具包：

bash 复制代码 
pip install 'crewai[tools]'

使用内置工具：

python 复制代码 
from crewai_tools import (
    SerperDevTool,        # 网页搜索
    ScrapeWebsiteTool,    # 网站内容抓取
    PDFSearchTool,        # PDF 搜索
    CodeInterpreterTool,  # 代码解释器
    FileReadTool,         # 文件读取
    DirectorySearchTool,  # 目录搜索
)

agent = Agent(
    role="研究员",
    goal="进行网络调研",
    tools=[SerperDevTool(), ScrapeWebsiteTool()],
)

创建自定义工具：

python 复制代码 
from crewai_tools import BaseTool

class MyCustomTool(BaseTool):
    name: str = "自定义工具"
    description: str = "工具的功能描述"

    def _run(self, input: str) -> str:
        # 实现工具逻辑
        return f"处理结果: {input}"

# 异步工具
class AsyncTool(BaseTool):
    name: str = "异步工具"
    description: str = "异步执行"

    async def _arun(self, input: str) -> str:
        return f"异步结果: {input}"

# 使用装饰器创建
from crewai_tools import tool

@tool("Calculator")
def calculator(expression: str) -> str:
    """执行数学计算"""
    return str(eval(expression))

其他能力（与工具配合使用）：

  • MCPs：远程工具服务器
  • Apps：平台集成
  • Skills：领域专业知识
  • Knowledge：检索增强的事实库

3.7 Memory（记忆系统）

CrewAI 提供统一的记忆系统 ------ 单个 Memory 类替代了旧版的短期、长期、实体和外部记忆。

核心特性：

  • LLM 在保存时自动分析内容（推断作用域、分类和重要性）
  • 自适应深度召回，综合评分融合语义相似度、时间近度和重要性
  • 四种使用方式：独立使用、配合 Crews、配合 Agents、在 Flows 内部使用

独立使用（脚本/Notebook）：

python 复制代码 
from crewai import Memory

memory = Memory()

# 存储 - LLM 自动推断分类和重要性
memory.remember("我们决定使用 PostgreSQL 作为用户数据库。")

# 检索 - 按综合评分排序
matches = memory.recall("我们选择了什么数据库？")
for m in matches:
    print(f"[{m.score:.2f}] {m.record.content}")

# 从长文本提取原子事实
raw = "会议记录：我们决定下季度从 MySQL 迁移到 PostgreSQL。" \
      "预算 5 万美元。Sarah 负责领导迁移。"
facts = memory.extract_memories(raw)
for fact in facts:
    memory.remember(fact)

# 遗忘
memory.forget(scope="/project/old")

# 查看自组织的作用域树
print(memory.tree())

配合 Crew 使用：

python 复制代码 
from crewai import Crew, Memory

# 方式1：默认记忆
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    memory=True,
)

# 方式2：自定义记忆（调整评分权重）
memory = Memory(
    recency_weight=0.4,       # 时间近度权重
    semantic_weight=0.4,      # 语义相似度权重
    importance_weight=0.2,    # 重要性权重
    recency_half_life_days=14, # 时间衰减半衰期
)
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    memory=memory,
)

配合 Agent 使用：

python 复制代码 
agent = Agent(
    role="研究员",
    goal="收集信息",
    memory=Memory(recency_weight=0.6)  # 更关注近期信息
)

在 Flows 中使用：

python 复制代码 
from crewai.flow.flow import Flow, start, listen

class MyFlow(Flow):
    @start()
    def collect_data(self):
        self.memory.remember("收集到数据X")
        return "data"

    @listen(collect_data)
    def analyze_data(self):
        matches = self.memory.recall("之前收集了什么数据？")
        # 使用记忆进行分析

3.8 Flows（流程）

Flows 是面向生产环境的事件驱动工作流编排方式。

核心特性：

  1. 简化工作流创建：链式组合多个 Crews 和任务
  2. 状态管理：在任务间轻松管理和共享状态
  3. 事件驱动架构：动态响应的工作流
  4. 灵活的控制流：条件分支、循环、路由

Flow 核心装饰器：

  • @start() / @start(input_param) --- 标记流程入口
  • @listen(task_method) --- 监听某个任务的完成
  • @listen(event_string) --- 监听事件字符串
  • @router(task_method) --- 路由到不同分支
  • or_() / and_() --- 逻辑组合多个条件

Flow 代码示例：

python 复制代码 
from crewai.flow.flow import Flow, listen, start, router, or_
from crewai import Crew, Agent, Task, Process
from pydantic import BaseModel

# 定义结构化状态
class MarketState(BaseModel):
    sentiment: str = "neutral"
    confidence: float = 0.0
    recommendations: list = []

class AdvancedAnalysisFlow(Flow[MarketState]):

    @start()
    def fetch_market_data(self):
        # 基本数据处理
        self.state.sentiment = "analyzing"
        return {"sector": "tech", "timeframe": "1W"}

    @listen(fetch_market_data)
    def analyze_with_crew(self, market_data):
        # 在 Flow 中创建并执行 Crew
        analyst = Agent(
            role="高级市场分析师",
            goal="进行深入市场分析",
            backstory="你是一位善于发现微妙市场模式的资深分析师"
        )
        analysis_task = Task(
            description="分析 {sector} 部门过去 {timeframe} 的数据",
            expected_output="带置信度评分的详细市场分析",
            agent=analyst
        )
        analysis_crew = Crew(
            agents=[analyst],
            tasks=[analysis_task],
            process=Process.sequential
        )
        return analysis_crew.kickoff(inputs=market_data)

    @router(analyze_with_crew)
    def determine_next_steps(self):
        # 条件路由
        if self.state.confidence > 0.8:
            return "high_confidence"
        elif self.state.confidence > 0.5:
            return "medium_confidence"
        return "low_confidence"

    @listen("high_confidence")
    def execute_strategy(self):
        strategy_crew = Crew(
            agents=[Agent(role="策略专家", goal="制定最优策略")],
            tasks=[Task(description="基于分析制定详细策略",
                       expected_output="逐步行动计划")]
        )
        return strategy_crew.kickoff()

    @listen(or_("medium_confidence", "low_confidence"))
    def request_additional_analysis(self):
        self.state.recommendations.append("需要更多数据")
        return "需要额外分析"

# 运行 Flow
flow = AdvancedAnalysisFlow()
flow.plot()  # 可视化流程图
result = flow.kickoff()

简单 Flow 示例：

python 复制代码 
from crewai.flow.flow import Flow, listen, start
from litellm import completion

class ExampleFlow(Flow):
    model = "gpt-4o-mini"

    @start()
    def generate_city(self):
        print(f"Flow State ID: {self.state['id']}")
        response = completion(
            model=self.model,
            messages=[{"role": "user", "content": "返回一个随机城市名。"}]
        )
        random_city = response["choices"][0]["message"]["content"]
        self.state["city"] = random_city
        return random_city

    @listen(generate_city)
    def generate_fun_fact(self, random_city):
        response = completion(
            model=self.model,
            messages=[{"role": "user",
                       "content": f"告诉我关于 {random_city} 的一个趣事"}]
        )
        fun_fact = response["choices"][0]["message"]["content"]
        self.state["fun_fact"] = fun_fact
        return fun_fact

flow = ExampleFlow()
flow.plot()  # 生成流程图
result = flow.kickoff()

3.9 Knowledge（知识库）

Knowledge 为智能体提供检索增强的事实库能力，支持 RAG（检索增强生成）。

使用方式：

  • 内置 RAG 功能（如 PDFSearchTool）
  • 自定义 Knowledge 对象
  • 与外部向量数据库集成
python 复制代码 
from crewai import Knowledge

# 从文件创建知识库
knowledge = Knowledge(
    files=["docs/*.pdf", "docs/*.md"],
    # 配置嵌入模型等
)

agent = Agent(
    role="领域专家",
    goal="基于知识库回答问题",
    knowledge=knowledge
)

四、使用方法详解

4.1 项目创建与结构

使用 CLI 创建项目：

bash 复制代码 
crewai create crew <project_name>

生成的项目结构：

复制代码 
my_project/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
└── src/
    └── my_project/
        ├── __init__.py
        ├── main.py           # 入口文件
        ├── crew.py           # Crew 定义
        ├── tools/            # 自定义工具
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml   # 智能体配置
            └── tasks.yaml    # 任务配置

4.2 YAML 配置方式

agents.yaml 示例：

yaml 复制代码 
researcher:
  role: >
    {topic} 高级数据研究员
  goal: >
    发现{topic}领域的最新进展
  backstory: >
    你是一位经验丰富的研究员，擅长寻找最相关的信息
    并以清晰简洁的方式呈现。

reporting_analyst:
  role: >
    {topic} 报告分析师
  goal: >
    基于{topic}的数据分析和研究结果创建详细报告
  backstory: >
    你是一位细致的分析师，善于将复杂数据转化为
    清晰简洁的报告。

tasks.yaml 示例：

yaml 复制代码 
research_task:
  description: >
    对{topic}进行全面研究
    确保找到2025年所有有趣且相关的信息。
  expected_output: >
    包含关于{topic}最重要的10条信息的要点列表
  agent: researcher

reporting_task:
  description: >
    基于研究结果，将每个主题扩展为报告中的完整章节。
    确保报告详细且包含所有相关信息。
  expected_output: >
    完整的 Markdown 格式报告，包含主要主题和详细信息
  agent: reporting_analyst
  output_file: report.md

4.3 完整的 Crew 定义

crew.py 示例：

python 复制代码 
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class LatestAiDevelopmentCrew():
    """AI 最新研发团队"""
    agents: List[BaseAgent]
    tasks: List[Task]

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            verbose=True,
            tools=[SerperDevTool()]
        )

    @agent
    def reporting_analyst(self) -> Agent:
        return Agent(
            config=self.agents_config['reporting_analyst'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config['research_task'],
        )

    @task
    def reporting_task(self) -> Task:
        return Task(
            config=self.tasks_config['reporting_task'],
            output_file='report.md'
        )

    @crew
    def crew(self) -> Crew:
        """创建团队"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

main.py 入口：

python 复制代码 
#!/usr/bin/env python
import sys
from latest_ai_development.crew import LatestAiDevelopmentCrew

def run():
    inputs = {
        'topic': 'AI Agents'
    }
    LatestAiDevelopmentCrew().crew().kickoff(inputs=inputs)

if __name__ == '__main__':
    run()

4.4 运行方式

bash 复制代码 
# 方式1：使用 CLI
cd my_project
crewai install   # 锁定并安装依赖（可选）
crewai run       # 运行 Crew

# 方式2：直接运行 Python
python src/my_project/main.py

4.5 连接不同的 LLM 模型

CrewAI 默认使用 OpenAI API，但也支持多种其他模型：

python 复制代码 
from langchain_openai import ChatOpenAI
from langchain_ollama import ChatOllama

# 使用 OpenAI（默认）
agent = Agent(role="...", goal="...", llm="gpt-4o")

# 使用 Ollama 本地模型
agent = Agent(role="...", goal="...", llm="ollama/llama3")

# 使用 LangChain 包装器
openai_llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
agent = Agent(role="...", goal="...", llm=openai_llm)

# 通过环境变量设置默认模型
# OPENAI_MODEL_NAME=gpt-4o

4.6 结构化输出

python 复制代码 
from pydantic import BaseModel, Field
import json

class ResearchReport(BaseModel):
    title: str = Field(description="报告标题")
    sections: list = Field(description="报告章节")
    summary: str = Field(description="执行摘要")
    recommendations: list = Field(description="建议列表")

task = Task(
    description="撰写研究分析报告",
    expected_output="结构化的研究报告",
    agent=analyst,
    output_pydantic=ResearchReport
)

# 或输出 JSON
task = Task(
    description="分析数据",
    expected_output="JSON 格式的分析结果",
    agent=analyst,
    output_json=ResearchReport,
    output_file="analysis.json"
)

4.7 人工审核（Human-in-the-loop）

python 复制代码 
task = Task(
    description="起草决策文档",
    expected_output="经过审核的最终文档",
    agent=writer,
    human_input=True  # 执行后暂停，等待人工审核
)

4.8 异步执行

python 复制代码 
# 任务级别异步
task1 = Task(description="...", async_execution=True)
task2 = Task(description="...", async_execution=True)

# Crew 级别异步
result = crew.kickoff_async(inputs={"topic": "AI"})

# 重置执行状态
crew.reset()

4.9 回调函数

python 复制代码 
def task_callback(task_output):
    print(f"任务完成: {task_output}")

def step_callback(step):
    print(f"执行步骤: {step}")

# 任务回调
task = Task(
    description="...",
    expected_output="...",
    agent=agent,
    callback=task_callback
)

# Crew 级回调
crew = Crew(
    agents=[agent],
    tasks=[task],
    step_callback=step_callback,
    task_callback=task_callback
)

4.10 Crews 与 Flows 结合使用

这是 CrewAI 最强大的模式，将自主性（Crews）与精确控制（Flows）结合起来：

python 复制代码 
from crewai.flow.flow import Flow, listen, start, router, or_
from crewai import Crew, Agent, Task, Process

class MarketAnalysisFlow(Flow):

    @start()
    def fetch_data(self):
        """第一步：获取市场数据"""
        return {"sector": "tech", "timeframe": "1W"}

    @listen(fetch_data)
    def run_analysis_crew(self, data):
        """第二步：使用 Crew 进行分析"""
        analyst = Agent(role="分析师", goal="深入分析")
        task = Task(
            description="分析 {sector} 的数据",
            expected_output="分析报告",
            agent=analyst
        )
        crew = Crew(agents=[analyst], tasks=[task])
        result = crew.kickoff(inputs=data)
        self.state.confidence = 0.85
        return result

    @router(run_analysis_crew)
    def route_based_on_confidence(self):
        """第三步：基于置信度路由"""
        if self.state.confidence > 0.8:
            return "high"
        return "low"

    @listen("high")
    def execute_trading(self):
        """高置信度：执行策略"""
        return "执行交易策略"

    @listen("low")
    def gather_more_data(self):
        """低置信度：收集更多数据"""
        return "需要更多数据"

五、项目 CLI 命令

命令 说明
crewai create crew <name> 创建新项目
crewai create flow <name> 创建 Flow 项目
crewai install 锁定并安装依赖
crewai run 运行 Crew/Flow
crewai update 更新 CrewAI 包

六、CrewAI AMP 企业套件

CrewAI 提供企业级解决方案 CrewAI AMP Suite：

核心功能

功能 说明
控制平面 统一管理、监控和扩展 AI 智能体和工作流
可观测性 实时监控、指标、日志和追踪
安全合规 内置安全与合规措施
深度集成 连接现有企业系统、数据源和云基础设施
可视化构建器 可视化创建 Agent 和 Task（无需写代码）
工具仓库 预建的企业系统集成连接器
分析洞察 实时分析和报告优化性能
24/7 支持 专属企业支持
部署选项 支持云端和本地部署

定价

方案 价格 说明
Basic（免费版） 免费 开源 MIT 许可，可自行部署
Cloud（云端试用） 免费试用 通过 app.crewai.com 免费试用 Control Plane
Enterprise（企业版） 定制报价 预估 $500+/月，含托管部署和管理

实际成本估算：

  • 个人/小团队：LLM API 费用 50-150/月 + 基础设施 10-50/月
  • 中型团队（20+工程师）：$475+/月，建议使用企业版或自托管

七、与其他框架对比

CrewAI vs LangGraph vs AutoGen

维度 CrewAI LangGraph AutoGen
核心理念 角色扮演团队协作 状态机工作流 对话式智能体
独立性 完全独立，不依赖 LangChain 基于 LangChain 独立框架
上手难度 低（声明式 YAML 配置） 高（大量样板代码） 中
执行速度 快（5.76x 于 LangGraph） 较慢 中
工作流程 内置 sequential/hierarchical 自定义状态图 需额外编程编排
状态管理 Flow 提供结构化状态 原生状态机 较弱
记忆系统 统一 Memory API 需手动实现 需手动实现
事件驱动 原生支持（Flows） 有限 有限
适用场景 快速原型 + 生产环境 复杂状态机 对话系统
社区规模 10万+认证开发者 大（LangChain 生态） 中
许可证 MIT MIT MIT

各框架特点总结

CrewAI 优势：

  • 声明式配置（YAML）降低上手门槛
  • 两种编排模式（Crews + Flows）覆盖自主和精确控制
  • 性能优势（比 LangGraph 快 5.76 倍）
  • 统一记忆系统
  • 生产级事件驱动架构

LangGraph 优势：

  • 精确的状态机控制
  • LangChain 生态集成
  • 适合复杂状态管理工作流

AutoGen 优势：

  • 对话式多智能体交互
  • 微软 backing
  • 适合对话驱动的场景

八、实际应用场景

8.1 研究分析报告

python 复制代码 
# 研究员收集信息 -> 分析师撰写报告 -> 审核员质量检查
researcher = Agent(role="研究员", goal="信息收集", tools=[search_tool])
analyst = Agent(role="分析师", goal="数据分析")
reviewer = Agent(role="审核员", goal="质量把关")

crew = Crew(
    agents=[researcher, analyst, reviewer],
    tasks=[research_task, analysis_task, review_task],
    process=Process.sequential,
    memory=True
)

8.2 旅行规划

  • 目的地研究智能体
  • 酒店预订智能体
  • 行程规划智能体
  • 预算分析智能体

8.3 股票分析

  • 市场数据收集
  • 技术面分析
  • 基本面分析
  • 风险评估
  • 投资建议生成

8.4 内容创作

  • 研究阶段：资料收集
  • 大纲阶段：结构规划
  • 写作阶段：内容创作
  • 编辑阶段：质量优化

8.5 代码评审

  • 安全扫描智能体
  • 代码质量检查智能体
  • 文档审核智能体
  • 综合报告生成

九、学习资源

官方资源

示例项目

  • Landing Page Generator（落地页生成器）
  • Trip Planner（旅行规划器）
  • Stock Analysis（股票分析）
  • Job Posting（职位发布）

十、优缺点总结

优点

  1. 完全独立：不依赖 LangChain 等框架，轻量快速
  2. 声明式配置：YAML 配置降低上手门槛
  3. 双重编排：Crews（自主协作）+ Flows（精确控制）
  4. 高性能：比 LangGraph 快 5.76 倍
  5. 统一记忆系统：单个 Memory 类管理所有记忆类型
  6. 生产就绪：事件驱动、状态管理、条件路由
  7. MIT 开源：无商业限制
  8. 活跃社区：10万+认证开发者，持续维护
  9. 丰富的工具生态：内置 + 自定义 + LangChain 工具兼容
  10. 企业套件：CrewAI AMP 提供企业级功能

缺点/注意事项

  1. 相对年轻：2023年10月创建，成熟度不及 LangChain
  2. LLM API 成本：多智能体模式消耗大量 API 调用
  3. 主要支持 Python：其他语言需通过 API 集成
  4. 层级流程需要更强的模型：Manager Agent 建议使用 GPT-4 级别模型
  5. 文档仍在完善：部分高级功能文档不够详细
  6. 记忆系统消耗 token：记忆检索会增加 prompt 长度

十一、结论

CrewAI 是目前最活跃、最受欢迎的多智能体编排框架之一（GitHub 53K+ Stars）。它通过"角色扮演"的理念让开发者直观地定义智能体团队，配合 YAML 声明式配置和双重编排模式（Crews + Flows），在易用性和生产级功能之间取得了很好的平衡。

推荐场景：

  • 需要多个 AI 智能体协作完成复杂任务的场景
  • 研究分析、内容创作、代码评审等多步骤流水线
  • 需要平衡自主性和精确控制的场景
  • 快速原型开发到生产部署的完整生命周期

不推荐场景：

  • 简单单次 LLM 调用（直接用 API 更直接）
  • 纯对话式智能体（考虑 AutoGen）
  • 极度复杂的条件状态机（考虑 LangGraph）
相关推荐
chen_zn951 小时前
RLinf复现RECAP（一）：从轨迹回报到优势标签
人工智能·强化学习·具身智能·vla
w3296362712 小时前
八、OpenCode 高阶玩法：CLI 自动化、CI/CD 集成与远程协作
运维·ci/cd·自动化·ai编程·开发工具·opencode
Xiaofeng36932 小时前
GPT-4o国内注册保姆级教程（2026最新版）：开发者高效访问与避坑实战
人工智能·chatgpt
伍肆聊AI2 小时前
一篇讲清 CLAUDE.md，让 Claude Code AI 编程稳定高效不踩坑
ai编程
AI科技星2 小时前
数术江湖·全卷合集 - 硬核江湖・数理史诗
android·人工智能·架构·概率论·学习方法
humors2212 小时前
AI案例：头脑风暴创作-正反论证-报告撰写-摘要总结
人工智能·ai·写作·总结·案例·论证
HIT_Weston2 小时前
115、【Agent】【OpenCode】项目配置（SemVer）
人工智能·agent·opencode
Sam09272 小时前
OpenClaw 和 Hermes 怎么结合：从聊天入口到隔离执行器的 Agent 工程实践
人工智能·ai
沪漂阿龙2 小时前
LangChain 系列之 Messages：为什么大模型对话不是简单字符串？
人工智能·深度学习·langchain
热门推荐
01HTTP 与 HTTPS 的区别：从原理到实战详解022026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？03【AI】2026 年具身智能模型和世界模型总结042026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？05AI科技热点日报 | 2026年6月1日06《置身钉内》原文-可播放阅读07GitHub 镜像站点08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf10AI一周事件 · 2026-06-03 至 2026-06-09