flowchart TB
    subgraph "外部接口层"
        CLI[CLI 命令行工具]
        API[CrewAI API<br/>Agent/Task/Crew/Flow]
    end

    subgraph "编排层"
        Crew[Crew 编排器<br/>Sequential/Hierarchical]
        Flow[Flow 引擎<br/>事件驱动编排]
    end

    subgraph "执行层"
        Agent[Agent 智能体]
        Task[Task 任务管理器]
        Executor[AgentExecutor<br/>任务执行引擎]
    end

    subgraph "LLM 层"
        LLM[LLM 抽象层]
        Providers[多提供商支持<br/>OpenAI/Anthropic/...]
    end

    subgraph "工具层"
        Tools[工具管理器]
        BuiltinTools[内置工具]
        CustomTools[自定义工具]
        MCPTools[MCP 工具]
    end

    subgraph "存储层"
        Memory[Memory 记忆系统]
        Knowledge[Knowledge 知识库]
        RAG[RAG 检索引擎]
    end

    subgraph "基础设施层"
        Events[事件总线]
        Telemetry[遥测与追踪]
        Config[配置管理]
        Security[安全与指纹]
    end

    CLI --> API
    API --> Crew
    API --> Flow
    Crew --> Agent
    Crew --> Task
    Flow --> Agent
    Flow --> Task
    Agent --> Executor
    Task --> Executor
    Executor --> LLM
    Executor --> Tools
    LLM --> Providers
    Tools --> BuiltinTools
    Tools --> CustomTools
    Tools --> MCPTools
    Agent --> Memory
    Agent --> Knowledge
    Memory --> RAG
    Knowledge --> RAG
    Crew --> Events
    Flow --> Events
    Agent --> Events
    Task --> Events
    Events --> Telemetry
    Agent --> Config
    Agent --> Security
    Task --> Security

用户输入 → Crew.kickoff(inputs) → Task.description/expected_output
→ Agent.execute_task → Executor.invoke → LLM.call → 输出
→ TaskOutput → Memory.save → 下一个 Task 的 context

sequenceDiagram
    autonumber
    participant User as 用户
    participant Crew as Crew 编排器
    participant Agent1 as Agent1
    participant Agent2 as Agent2
    participant Executor as AgentExecutor
    participant LLM as LLM 层
    participant Memory as Memory
    participant Tool as 工具

    User->>Crew: kickoff(inputs)
    Note over Crew: 插值 inputs 到 Task/Agent
    Crew->>Crew: _set_tasks_callbacks()
    Crew->>Agent1: set_knowledge(embedder)
    Crew->>Agent1: create_agent_executor()

    Crew->>Agent1: execute_task(task1, context=None)
    Agent1->>Memory: 检索相关记忆
    Memory-->>Agent1: 返回记忆片段
    Agent1->>Executor: invoke(task_prompt, tools)

    loop 推理循环（最多 max_iter 次）
        Executor->>LLM: call(messages)
        LLM-->>Executor: 返回 action/tool_call
        alt 需要调用工具
            Executor->>Tool: execute(tool_input)
            Tool-->>Executor: tool_output
            Executor->>LLM: call(messages + tool_output)
        else 输出 Final Answer
            LLM-->>Executor: final_answer
        end
    end

    Executor-->>Agent1: 返回结果
    Agent1->>Agent1: _export_output(result)
    Agent1->>Memory: save(task_output)
    Agent1-->>Crew: TaskOutput1

    Note over Crew: 处理 Task2，context=TaskOutput1
    Crew->>Agent2: execute_task(task2, context=output1)
    Agent2->>Executor: invoke(task_prompt_with_context)
    Executor->>LLM: call(messages)
    LLM-->>Executor: final_answer
    Executor-->>Agent2: 返回结果
    Agent2-->>Crew: TaskOutput2

    Crew->>Crew: _create_crew_output([output1, output2])
    Crew-->>User: CrewOutput

sequenceDiagram
    autonumber
    participant User as 用户
    participant Crew as Crew 编排器
    participant Manager as Manager Agent
    participant Worker1 as Worker Agent1
    participant Worker2 as Worker Agent2
    participant Tool as Delegation Tool

    User->>Crew: kickoff(inputs)
    Crew->>Crew: _create_manager_agent()
    Note over Crew: 创建 Manager Agent<br/>注入 delegation_tools

    Crew->>Manager: execute_task(task, tools=[delegation_tools])
    Manager->>Manager: 分析任务需求

    alt 委托给 Worker1
        Manager->>Tool: Delegate work to Worker1
        Tool->>Worker1: execute_sub_task(description)
        Worker1->>Worker1: 执行工作
        Worker1-->>Tool: 返回结果
        Tool-->>Manager: Worker1 结果
    end

    alt 委托给 Worker2
        Manager->>Tool: Ask question to Worker2
        Tool->>Worker2: execute_sub_task(question)
        Worker2->>Worker2: 回答问题
        Worker2-->>Tool: 返回答案
        Tool-->>Manager: Worker2 答案
    end

    Manager->>Manager: 整合所有结果
    Manager-->>Crew: 综合 TaskOutput
    Crew-->>User: CrewOutput

from crewai import Agent, Task, Crew, Process

# 1. 定义 Agent
researcher = Agent(
    role="Research Analyst",
    goal="Find the latest AI trends",
    backstory="Expert in AI research",
    verbose=True
)

# 2. 定义 Task
research_task = Task(
    description="Research the top 5 AI trends in 2024",
    expected_output="A list of 5 AI trends with brief descriptions",
    agent=researcher
)

# 3. 创建 Crew 并执行
crew = Crew(
    agents=[researcher],
    tasks=[research_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff()
print(result.raw)

from crewai import Agent, Task, Crew, Process

# 定义 Worker Agents
researcher = Agent(role="Researcher", goal="Research topics")
writer = Agent(role="Writer", goal="Write reports")

# 定义任务（无需指定 agent，由 Manager 分配）
task1 = Task(description="Research AI in healthcare", expected_output="Report")
task2 = Task(description="Write a summary", expected_output="Summary")

# 创建 Hierarchical Crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[task1, task2],
    process=Process.hierarchical,
    manager_llm="gpt-4"  # Manager 使用 GPT-4
)

result = crew.kickoff()

from crewai.flow.flow import Flow, start, listen, router

class DataPipeline(Flow):
    @start()
    def load_data(self):
        # 加载数据
        self.state["data"] = [1, 2, 3]
        return "loaded"

    @listen("load_data")
    def process_data(self, data):
        # 处理数据
        self.state["processed"] = sum(self.state["data"])
        return "processed"

    @router("process_data")
    def decide_next(self):
        if self.state["processed"] > 5:
            return "high_value"
        return "low_value"

    @listen("high_value")
    def handle_high_value(self):
        print("High value detected!")

flow = DataPipeline()
flow.kickoff()

sequenceDiagram
    autonumber
    participant User as 用户
    participant Crew as Crew
    participant Memory as Memory
    participant Knowledge as Knowledge
    participant ChromaDB as ChromaDB

    User->>Crew: 首次 kickoff()
    Crew->>Memory: 初始化 Memory
    alt Memory 未启用
        Memory-->>Crew: 跳过初始化
    else Memory 启用
        Memory->>ChromaDB: 检查 Collection 是否存在
        alt Collection 不存在
            ChromaDB->>ChromaDB: 创建新 Collection
        end
        ChromaDB-->>Memory: 初始化完成
    end

    Crew->>Knowledge: 初始化 Knowledge
    alt Knowledge 未配置
        Knowledge-->>Crew: 跳过初始化
    else Knowledge 已配置
        Knowledge->>Knowledge: add_sources()
        Knowledge->>ChromaDB: 批量插入文档
        ChromaDB-->>Knowledge: 完成
    end

    Crew->>Crew: 执行任务流程
    Crew-->>User: 返回结果

sequenceDiagram
    autonumber
    participant User as 用户（并发 100）
    participant LoadBalancer as 负载均衡器
    participant Crew1 as Crew 实例1
    participant Crew2 as Crew 实例2
    participant LLM as LLM API
    participant RPMController as RPM 限流器

    par 并发请求
        User->>LoadBalancer: kickoff() * 100
        LoadBalancer->>Crew1: 分发请求 1-50
        LoadBalancer->>Crew2: 分发请求 51-100
    end

    Crew1->>RPMController: check_or_wait()
    RPMController->>RPMController: 检查当前 RPM
    alt 超过限制
        RPMController->>Crew1: sleep(delay)
    else 未超过限制
        RPMController-->>Crew1: 允许执行
    end

    Crew1->>LLM: call(messages)
    LLM-->>Crew1: 返回结果
    Crew1-->>User: 返回结果

    Note over Crew2: 同样的限流和执行流程

sequenceDiagram
    autonumber
    participant User as 用户
    participant Crew as Crew
    participant Agent as Agent
    participant LLM as LLM
    participant Memory as Memory

    User->>Crew: kickoff(inputs)
    Crew->>Agent: execute_task(task1)
    Agent->>LLM: call(messages)

    alt LLM 超时
        LLM-->>Agent: TimeoutError
        Agent->>Agent: 不重试，直接抛出
        Agent-->>Crew: 抛出 TimeoutError
        Crew-->>User: 抛出异常
    else LLM 返回错误格式
        LLM-->>Agent: 返回无效 JSON
        Agent->>Agent: 验证失败，retry_count++
        alt retry_count < max_retry_limit
            Agent->>LLM: 重试 call(messages)
            LLM-->>Agent: 返回正确结果
        else retry_count >= max_retry_limit
            Agent-->>Crew: 抛出 AgentExecutionError
        end
    else Guardrail 验证失败
        Agent->>Agent: 调用 guardrail(output)
        Agent->>Agent: 验证失败，重新生成
        Agent->>LLM: call(messages + error_context)
        LLM-->>Agent: 返回修正结果
    end

    Agent->>Memory: save(task_output)
    Agent-->>Crew: TaskOutput
    Crew-->>User: CrewOutput

# crewai/__init__.py
__all__ = [
    "LLM",
    "Agent",
    "BaseLLM",
    "Crew",
    "CrewOutput",
    "Flow",
    "Knowledge",
    "LLMGuardrail",
    "Process",
    "Task",
    "TaskOutput",
    "__version__",
]