本文介绍了大语言模型Agent协作工具CrewAI的核心概念、常规操作、工具使用。

• 1. Agent-什么是代理？

• (1). 代理属性

• (2). 创建代理

• (3). 结论

• 2. Task-任务概述

• (1). 任务属性

• (2). 创建任务

• (3). 将工具与任务集成

• (4). 使用工具创建任务

• (5). 参考其他任务

• (6). 异步执行

• (7). 回调机制

• (8). 访问特定任务输出

• (9). 工具覆盖机制

• (10). 错误处理和验证机制

• (11). 结论

• 3. Tool-什么是工具？

• (1). 工具的关键特征

• (2). 使用 crewAI 工具

• (3). 可用的 crewAI 工具

• (4). 创建自己的工具

• (5). 使用 LangChain 工具

• (6). 结论

• 4. Process-理解流程

• (1). 流程实现

• (2). 流程在团队合作中的作用

• (3). 将流程分配给船员

• (4). 顺序流程

• (5). 分级流程

• (6). 流程类：详细概述

• (7). 附加任务特性

• (8). 结论

• 5. Crews-什么是团队？

• (1). 团队属性

• (2). 创建团队

• (3). 内存利用

• (4). 缓存利用

• (5). 团队使用指标

• (6). 团队执行流程

• 6. Memory-记忆系统简介

• (1). 记忆系统组成部分

• (2). 记忆系统如何赋能代理

• (3). 在你的团队中实施记忆

• (4). 其他嵌入提供商

• (5). 使用crewAI记忆系统的好处

• 1. 安装 crewAI

• (1). 安装

• 2. 在 crewAI 中创建和利用工具

• (1). 先决条件

• (2). 子类化 `BaseTool`

• (3). 使用 `tool` 装饰器

• (4). 为工具定义缓存函数

• 3. 顺序流程概述

• (1). 主要特点

• (2). 实施顺序流程

• (3). 工作流程示例

• (4). 结论

• 4. 分层流程概述

• (1). 主要特点

• (2). 实施分层流程

• (3). 工作流程实例

• (4). 结论

• 5. 将 CrewAI 连接到 LLMs

• (1). CrewAI 代理概述

• (2). Ollama 集成

• (3). HuggingFace 集成

• (4). OpenAI 兼容的 API 端点

• (5). 结论

• 6. 可定制属性

• (1). 定制的关键属性

• (2). 高级定制选项

• (3). 性能和调试设置

• (4). 定制代理和工具

• (5). 委托和自主权

• (6). 结论

• 7. 代理执行中的人类输入

• (1). 使用 CrewAI 进行人类输入

• (2). 示例：

• 8. AgentOps

• (1). 概述

• (2). 特点

• (3). 使用AgentOps

• (4). Crew + AgentOps示例

• (5). 更多信息

• 1. 安装

• 2. 文本搜索工具

• (1). 描述

• (2). 示例

• (3). 参数

• (4). 自定义模型和嵌入

• 3. PDFSearchTool

• (1). 描述

• (2). 示例

• (3). 参数

• (4). 自定义模型和嵌入

• 4. DOCXSearchTool

• (1). 描述

• (2). 示例

• (3). 参数

• (4). 自定义模型和嵌入

• 5. DirectoryReadTool

• (1). 描述

• (2). 示例

• (3). 参数

• 6. 目录搜索工具

• (1). 描述

• (2). 初始化和使用

• (3). 参数

• (4). 自定义模型和嵌入

• 7. CSVSearchTool

• (1). 描述

• (2). 示例

• (3). 参数

• (4). 自定义模型和嵌入

• 8. 文件读取工具

• (1). 描述

• (2). 使用示例

• (3). 参数

• 9. MDXSearchTool

• (1). 描述

• (2). 使用示例

• (3). 参数

• (4). 模型和嵌入的定制化

• 10. 网页抓取工具

• (1). 描述

• (2). 示例

• (3). 参数

• 11. 网站搜索工具

• (1). 描述

• (2). 示例用法

• (3). 参数

• (4). 自定义选项

• 12. SeleniumScrapingTool

• (1). 描述

• (2). 使用示例

• (3). 参数

• 13. PGSearchTool

• (1). 描述

• (2). 示例用法

• (3). 参数

• (4). 自定义模型和嵌入

一、CrewAI核心概念

1. Agent-什么是代理？

代理Agent是一个自主单元，被编程用于：执行任务

• 执行任务

• 做出决策

• 与其他代理进行通信

将代理看作团队的一员，具有特定的技能和特定的工作任务。代理可以担任不同的角色，如“研究员”、“作家”或“客户支持”，每个角色都为团队的整体目标做出贡献。

(1). 代理属性

(2). 创建代理

代理可以使用 crewAI 内置的委托和通信机制相互交互。这允许在团队内进行动态任务管理和问题解决。

要创建代理，通常会使用所需属性初始化Agent类的实例。以下是一个包含所有属性的概念示例：

# 示例：创建具有所有属性的代理
from crewai import Agent

agent = Agent(
  role='数据分析师',
  goal='提取可操作的见解',
  backstory="""您是一家大公司的数据分析师。
  您负责分析数据并为业务提供见解。
  您目前正在进行一个项目，分析我们营销活动的表现。""",
  tools=[my_tool1, my_tool2],  # 可选，默认为空列表
  llm=my_llm,  # 可选
  function_calling_llm=my_llm,  # 可选
  max_iter=15,  # 可选
  max_rpm=None, # 可选
  verbose=True,  # 可选
  allow_delegation=True,  # 可选
  step_callback=my_intermediate_step_callback,  # 可选
  cache=True  # 可选
)

(3). 结论

代理是 CrewAI 框架的构建模块。通过了解如何定义和与代理交互，您可以创建利用协作智能力的复杂人工智能系统。

2. Task-任务概述

在 crewAI 框架中，任务是由代理完成的具体任务。它们提供执行所需的所有必要细节，如描述、负责代理、所需工具等，有助于促进各种行动复杂性。

crewAI 中的任务可以是协作的，需要多个代理共同工作。这通过任务属性进行管理，并由 Crew 的流程进行编排，增强团队合作和效率。

(1). 任务属性

(2). 创建任务

创建任务涉及定义其范围、负责代理以及任何额外属性以实现灵活性：

from crewai import Task

task = Task(
    description='查找并总结有关人工智能的最新和最相关新闻',
    agent=sales_agent
)

"任务分配"：直接为分配指定一个 代理，或者让 分层 的 CrewAI 流程根据角色、可用性等决定。

(3). 将工具与任务集成

利用 crewAI Toolkit 和 LangChain Tools 中的工具，增强任务性能和代理交互。

(4). 使用工具创建任务

import os
os.environ["OPENAI_API_KEY"] = "Your Key"
os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key

from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool

research_agent = Agent(
  role='研究员',
  goal='查找并总结最新的人工智能新闻',
  backstory="""您是一家大公司的研究员。
  您负责分析数据并为业务提供见解。""",
  verbose=True
)

search_tool = SerperDevTool()

task = Task(
  description='查找并总结最新的人工智能新闻',
  expected_output='对前 5条最重要的人工智能新闻进行项目符号列表总结',
  agent=research_agent,
  tools=[search_tool]
)

crew = Crew(
    agents=[research_agent],
    tasks=[task],
    verbose=2
)

result = crew.kickoff()
print(result)

这演示了如何使用特定工具的任务可以覆盖代理的默认设置，实现定制化任务执行。

(5). 参考其他任务

在 crewAI 中，一个任务的输出会自动传递到下一个任务，但您可以明确定义哪些任务的输出，包括多个任务应作为另一个任务的上下文。

当您有一个任务依赖于另一个任务的输出，但并非立即在其后执行时，这将非常有用。这通过任务的 上下文 属性完成：

# ...

research_ai_task = Task(
    description='查找并总结最新的人工智能新闻',
    expected_output='对前 5条最重要的人工智能新闻进行项目符号列表总结',
    async_execution=True,
    agent=research_agent,
    tools=[search_tool]
)

research_ops_task = Task(
    description='查找并总结最新的人工智能运营新闻',
    expected_output='对前 5条最重要的人工智能运营新闻进行项目符号列表总结',
    async_execution=True,
    agent=research_agent,
    tools=[search_tool]
)

write_blog_task = Task(
    description="撰写一篇关于人工智能重要性及其最新新闻的完整博客文章",
    expected_output='4段长的完整博客文章',
    agent=writer_agent,
    context=[research_ai_task, research_ops_task]
)

#...

(6). 异步执行

您可以定义任务以异步执行。这意味着 Crew 不会等待其完成才继续下一个任务。这对于需要很长时间完成的任务或对下一个任务执行不是至关重要的任务非常有用。

然后，您可以使用 上下文 属性在将来的任务中定义，它应等待异步任务的输出完成。

#...

list_ideas = Task(
    description="探索有关人工智能文章的 5个有趣想法。",
    expected_output="一份包含 5个文章想法的项目符号列表。",
    agent=researcher,
    async_execution=True # 将以异步方式执行
)

list_important_history = Task(
    description="研究人工智能的历史，并告诉我 5个最重要的事件。",
    expected_output="包含 5个重要事件的项目符号列表。",
    agent=researcher,
    async_execution=True # 将以异步方式执行
)

write_article = Task(
    description="撰写一篇关于人工智能、其历史和有趣想法的文章。",
    expected_output="一篇关于人工智能的 4段文章。",
    agent=writer,
    context=[list_ideas, list_important_history] # 将等待两个任务的输出完成
)

#...

(7). 回调机制

在任务完成后执行回调函数，允许根据任务结果触发操作或通知。

# ...

def callback_function(output: TaskOutput):
    # 任务完成后执行某些操作
    # 例如：向经理发送电子邮件
    print(f"""
        任务完成！
        任务：{output.description}
        输出：{output.raw_output}
    """)

research_task = Task(
    description='查找并总结最新的人工智能新闻',
    expected_output='对前 5条最重要的人工智能新闻进行项目符号列表总结',
    agent=research_agent,
    tools=[search_tool],
    callback=callback_function
)

#...

(8). 访问特定任务输出

一组 Crew 运行完成后，您可以通过使用任务对象的 output 属性访问特定任务的输出：

# ...
task1 = Task(
    description='查找并总结最新的人工智能新闻',
    expected_output='对前 5条最重要的人工智能新闻进行项目符号列表总结',
    agent=research_agent,
    tools=[search_tool]
)

#...

crew = Crew(
    agents=[research_agent],
    tasks=[task1, task2, task3],
    verbose=2
)

result = crew.kickoff()

# 返回一个 TaskOutput 对象，其中包含任务的描述和结果
print(f"""
    任务完成！
    任务：{task1.output.description}
    输出：{task1.output.raw_output}
""")

(9). 工具覆盖机制

在任务中指定工具允许动态调整代理能力，突出了 CrewAI 的灵活性。

(10). 错误处理和验证机制

在创建和执行任务时，存在某些验证机制，以确保任务属性的健壮性和可靠性。这些验证包括但不限于：

• 确保每个任务仅设置一种输出类型，以保持清晰的输出期望。
• 防止手动分配 id 属性，以维护唯一标识符系统的完整性。

这些验证有助于在 crewAI 框架内维护任务执行的一致性和可靠性。

(11). 结论

任务是 crewAI 中代理行动的推动力。通过正确定义任务及其结果，您为 AI 代理有效地工作奠定了基础，无论是独立工作还是作为协作单位。为任务配备适当的工具，了解执行过程，并遵循健壮的验证实践对于最大化 CrewAI 的潜力至关重要，确保代理有效准备好执行其任务，并确保任务按预期执行。

3. Tool-什么是工具？

crewAI 工具赋予代理能力，从网页搜索和数据分析到协作和任务委派等各种功能。本文档概述了如何在 crewAI 框架内创建、集成和利用这些工具，包括对协作工具的新重点。

CrewAI 中的工具是代理可以利用的用于执行各种操作的技能或功能。这包括来自 crewAI Toolkit 和 LangChain Tools 的工具，使代理之间能够进行从简单搜索到复杂互动以及有效团队合作的一切。

(1). 工具的关键特征

• 实用性：专为任务设计，如网页搜索、数据分析、内容生成和代理协作。

• 集成性：通过将工具无缝集成到工作流程中，提升代理的能力。

• 可定制性：提供灵活性，可以开发定制工具或利用现有工具，满足代理的特定需求。

• 错误处理：包含强大的错误处理机制，确保平稳运行。

• 缓存机制：具有智能缓存功能，优化性能并减少冗余操作。

(2). 使用 crewAI 工具

要通过 crewAI 工具增强代理的能力，请先安装我们的额外工具包：

pip install 'crewai[tools]'

以下是演示它们使用的示例：

import os
from crewai import Agent, Task, Crew

# 导入 crewAI 工具
from crewai_tools import (
    DirectoryReadTool,
    FileReadTool,
    SerperDevTool,
    WebsiteSearchTool
)
# 设置 API 密钥
os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API 密钥
os.environ["OPENAI_API_KEY"] = "Your Key"

# 实例化工具
docs_tool = DirectoryReadTool(directory='./blog-posts')
file_tool = FileReadTool()
search_tool = SerperDevTool()
web_rag_tool = WebsiteSearchTool()

# 创建代理
researcher = Agent(
    role='市场研究分析师',
    goal='提供关于人工智能行业最新市场分析',
    backstory='一位对市场趋势敏锐的专家分析师。',
    tools=[search_tool, web_rag_tool],
    verbose=True
)

writer = Agent(
    role='内容撰写人员',
    goal='撰写有关人工智能行业的引人入胜的博客文章',
    backstory='一位对技术充满激情的熟练撰稿人。',
    tools=[docs_tool, file_tool],
    verbose=True
)
# 定义任务

research = Task(
    description='研究人工智能行业的最新趋势并提供摘要。',
    expected_output='关于人工智能行业前三个热门发展的摘要，并对其重要性提供独特视角。',
    agent=researcher
)
write = Task(
    description='根据研究分析师的摘要撰写一篇引人入胜的博客文章。从目录中最新的博客文章中汲取灵感。',
    expected_output='一篇以 markdown 格式排版的四段博客文章，内容引人入胜、信息丰富且易懂，避免使用复杂术语。',
    agent=writer,
    output_file='blog-posts/new_post.md'  # 最终的博客文章将保存在此处
)

# 组建团队
crew = Crew(
    agents=[researcher, writer],
    tasks=[research, write],
    verbose=2
)

# 执行任务
crew.kickoff()

(3). 可用的 crewAI 工具

• 错误处理：所有工具都具有错误处理功能，允许代理优雅地处理异常并继续执行任务。

• 缓存机制：所有工具支持缓存，使代理能够高效地重用先前获得的结果，减少对外部资源的负载并加快执行时间，您还可以使用工具上的 cache_function 属性对缓存机制进行更精细的控制。

以下是可用工具及其描述的列表：

(4). 创建自己的工具

"自定义工具创建"

开发人员可以创建根据代理需求定制的自定义工具，或者利用预构建选项：

要创建自己的 crewAI 工具，您需要安装我们的额外工具包：

pip install 'crewai[tools]'

一旦您这样做了，有两种主要方法可以创建 crewAI 工具：

子类化 BaseTool

from crewai_tools import BaseTool
class MyCustomTool(BaseTool):
    name: str = "我的工具名称"
    description: str = "清晰描述此工具用于什么，您的代理将需要这些信息来使用它。"
    def _run(self, argument: str) -> str:
        # 实现在这里
        return "自定义工具的结果"

利用 tool 装饰器

from crewai_tools import tool
@tool("我的工具名称")
def my_tool(question: str) -> str:
    """清晰描述此工具用于什么，您的代理将需要这些信息来使用它。"""
    # 函数逻辑在这里
    return "您的自定义工具的结果"

自定义缓存机制

"缓存"

工具可以选择实现 `cache_function` 来微调缓存行为。此函数根据特定条件确定何时缓存结果，提供对缓存逻辑的细粒度控制

from crewai_tools import tool
@tool
def multiplication_tool(first_number: int, second_number: int) -> str:
    """当您需要将两个数字相乘时有用。"""
    return first_number * second_number

def cache_func(args, result):
    # 在这种情况下，仅在结果是 2 的倍数时才缓存结果
    cache = result % 2 == 0
    return cache

multiplication_tool.cache_function = cache_func

writer1 = Agent(
        role="作家",
        goal="为孩子们编写数学课程。",
        backstory="您是一位写作专家，热爱教孩子，但您对数学一无所知。",
        tools=[multiplication_tool],
        allow_delegation=False,
    )
    #...

(5). 使用 LangChain 工具

"LangChain 集成"

CrewAI 与 LangChain 的全面工具包无缝集成，用于基于搜索的查询等，以下是 Langchain 提供的内置工具列表 [LangChain Toolkit](https://python.langchain.com/docs/integrations/tools/)

from crewai import Agent
from langchain.agents import Tool
from langchain.utilities import GoogleSerperAPIWrapper

# 设置 API 密钥
os.environ["SERPER_API_KEY"] = "Your Key"
search = GoogleSerperAPIWrapper()

# 创建并将搜索工具分配给代理
serper_tool = Tool(
  name="中级答案",
  func=search.run,
  description="用于基于搜索的查询的工具",
)

agent = Agent(
  role='研究分析师',
  goal='提供最新的市场分析',
  backstory='一位对市场趋势敏锐的专家分析师。',
  tools=[serper_tool]
)

# 代码的其余部分 ...

(6). 结论

工具在扩展 CrewAI 代理的能力方面起着至关重要的作用，使它们能够执行各种任务并有效地进行协作。在使用 CrewAI 构建解决方案时，利用自定义和现有工具来赋能您的代理，并增强 AI 生态系统。考虑利用错误处理、缓存机制以及工具参数的灵活性来优化您的代理的性能和能力。

4. Process-理解流程

在 CrewAI 中，流程通过协调代理执行任务，类似于人类团队中的项目管理。这些流程确保任务被有效地分配和执行，与预定义的策略保持一致。

(1). 流程实现

• 顺序执行: 顺序执行任务，确保任务按照有序的进展完成。
• 分级: 将任务组织在管理层级中，任务根据结构化的指挥链被委派和执行。在船员中必须指定一个管理语言模型 (manager_llm) 以启用分级流程，通过管理者便捷地创建和管理任务。
• 共识流程（计划中）: 旨在实现代理之间在任务执行上的协作决策，这种流程类型在 CrewAI 中引入了一种民主的任务管理方式。这是计划中的未来发展方向，目前尚未在代码库中实施。

(2). 流程在团队合作中的作用

流程使个体代理能够作为一个有凝聚力的整体运作，简化他们的努力，以高效和协调的方式实现共同目标。

(3). 将流程分配给船员

要将流程分配给船员，在创建船员时指定流程类型以设置执行策略。对于分级流程，确保为管理者代理定义 manager_llm。

from crewai import Crew
from crewai.process import Process
from langchain_openai import ChatOpenAI

# 示例：创建一个具有顺序流程的船员
crew = Crew(
    agents=my_agents,
    tasks=my_tasks,
    process=Process.sequential
)

# 示例：创建一个具有分级流程的船员
# 确保提供 manager_llm
crew = Crew(
    agents=my_agents,
    tasks=my_tasks,
    process=Process.hierarchical,
    manager_llm=ChatOpenAI(model="gpt-4")
)

注意： 确保在创建 Crew 对象之前定义了 my_agents 和 my_tasks，对于分级流程，还需要 manager_llm。

(4). 顺序流程

该方法模拟动态团队工作流程，以深思熟虑和系统化的方式进行任务。任务执行遵循任务列表中预定义的顺序，一个任务的输出作为下一个任务的上下文。

要自定义任务上下文，可以利用 Task 类中的 context 参数指定应作为后续任务上下文使用的输出。

(5). 分级流程

模拟公司的等级制度，CrewAI 会自动为您创建一个管理者，需要为管理者代理指定一个管理语言模型 (manager_llm)。该代理负责监督任务执行，包括规划、委派和验证。任务不是预分配的；管理者根据代理的能力分配任务，审查输出，并评估任务完成情况。

(6). 流程类：详细概述

Process 类被实现为一个枚举 (Enum)，确保类型安全并将流程值限制为定义的类型（sequential、hierarchical）。共识流程计划在未来加入，强调我们对持续发展和创新的承诺。

(7). 附加任务特性

• 异步执行: 现在可以异步执行任务，实现并行处理和效率改进。此功能旨在使任务能够同时进行，提高船员的整体生产力。
• 人工输入审查: 一项可选功能，允许人类审查任务输出，以确保质量和准确性在最终确定之前。这一额外步骤引入了一层监督，为人类干预和验证提供了机会。
• 输出定制: 任务支持各种输出格式，包括 JSON (output_json)、Pydantic 模型 (output_pydantic) 和文件输出 (output_file)，灵活地捕获和利用任务结果。这允许各种输出可能性，满足不同的需求和要求。

(8). 结论

在 CrewAI 中通过流程实现的结构化协作对于促进代理之间的系统化团队合作至关重要。本文档已更新以反映最新功能、增强功能以及计划整合共识流程，确保用户可以访问最新和全面的信息。

5. Crews-什么是团队？

在 crewAI 中，团队代表着一群代理共同合作以完成一组任务。每个团队定义了任务执行策略、代理协作以及整体工作流程。

(1). 团队属性

"团队最大 RPM":max_rpm 属性设置团队每分钟可执行的最大请求数，以避免速率限制，并将覆盖个别代理的 max_rpm 设置。

(2). 创建团队

在组建团队时，您将具有互补角色和工具的代理结合在一起，分配任务，并选择一个流程，该流程规定了它们的执行顺序和互动。

示例：组建一个团队

from crewai import Crew, Agent, Task, Process
from langchain_community.tools import DuckDuckGoSearchRun

# 定义具有特定角色和工具的代理
researcher = Agent(
    role='高级研究分析师',
    goal='发现创新的人工智能技术',
    tools=[DuckDuckGoSearchRun()]
)

writer = Agent(
    role='内容撰稿人',
    goal='撰写有关人工智能发现的引人入胜的文章',
    verbose=True
)

# 为代理创建任务
research_task = Task(
    description='识别突破性人工智能技术',
    agent=researcher
)
write_article_task = Task(
    description='撰写关于最新人工智能技术的文章',
    agent=writer
)

# 使用顺序流程组装团队
my_crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_article_task],
    process=Process.sequential,
    full_output=True,
    verbose=True,
)

(3). 内存利用

团队可以利用内存（短期、长期和实体内存）来增强它们的执行能力，并随着时间的推移进行学习。此功能允许团队存储和回忆执行记忆，有助于决策和任务执行策略。

(4). 缓存利用

可以使用缓存来存储工具执行的结果，通过减少重新执行相同任务的需求，使流程更加高效。

(5). 团队使用指标

在团队执行后，您可以访问 usage_metrics 属性，查看团队执行的所有任务的语言模型（LLM）使用指标。这提供了关于运营效率和改进领域的见解。

# 访问团队的使用指标
crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
crew.kickoff()
print(crew.usage_metrics)

(6). 团队执行流程

• 顺序流程：任务依次执行，允许工作的线性流动。
• 分层流程：经理代理协调团队，委派任务并在继续之前验证结果。注意：此流程需要一个 manager_llm，对于验证流程流程至关重要。

启动团队

一旦您的团队组建完成，使用 kickoff() 方法启动工作流程。这将根据定义的流程流程开始执行过程。

# 启动团队的任务执行
result = my_crew.kickoff()
print(result)

6. Memory-记忆系统简介

"增强代理智能":crewAI框架引入了一个复杂的记忆系统，旨在显著增强AI代理的能力。该系统包括短期记忆、长期记忆、实体记忆和新识别的上下文记忆，每种记忆都在帮助代理记住、推理和从过去的互动中学习方面发挥着独特作用。

(1). 记忆系统组成部分

(2). 记忆系统如何赋能代理

1. 上下文意识: 借助短期记忆和上下文记忆，代理能够在对话或任务序列中保持上下文，从而产生更连贯和相关的回应。

2. 经验积累: 长期记忆使代理能够积累经验，从过去的行动中学习，以改进未来的决策和问题解决能力。

3. 实体理解: 通过保持实体记忆，代理可以识别和记住关键实体，增强其处理和交互复杂信息的能力。

(3). 在你的团队中实施记忆

在配置团队时，您可以启用和定制每个记忆组件，以适应团队的目标和将执行的任务的性质。 默认情况下，记忆系统处于禁用状态，您可以通过在团队配置中设置 memory=True 来确保其处于活动状态。 记忆将默认使用OpenAI Embeddings，但您可以通过将 embedder 设置为不同的模型来进行更改。

示例：为团队配置记忆

from crewai import Crew, Agent, Task, Process

# 使用具有记忆功能的团队
my_crew = Crew(
    agents=[...],
    tasks=[...],
    process=Process.sequential,
    memory=True,
    verbose=True
)

(4). 其他嵌入提供商

使用OpenAI嵌入（已默认）

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
    "provider": "openai",
    "config":{
      "model": 'text-embedding-3-small'
    }
  }
)

使用Google AI嵌入

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
   "provider": "google",
   "config":{
    "model": 'models/embedding-001',
    "task_type": "retrieval_document",
    "title": "Embeddings for Embedchain"
   }
  }
)

使用Azure OpenAI嵌入

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
   "provider": "azure_openai",
   "config":{
    "model": 'text-embedding-ada-002',
    "deployment_name": "you_embedding_model_deployment_name"
   }
  }
)

使用GPT4ALL嵌入

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
   "provider": "gpt4all"
  }
)

使用Vertex AI嵌入

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
   "provider": "vertexai",
   "config":{
    "model": 'textembedding-gecko'
   }
  }
)

使用Cohere嵌入

from crewai import Crew, Agent, Task, Process

my_crew = Crew(
  agents=[...],
  tasks=[...],
  process=Process.sequential,
  memory=True,
  verbose=True,
  embedder={
   "provider": "cohere",
   "config":{
    "model": "embed-english-v3.0"
      "vector_dimension": 1024
   }
  }
)

(5). 使用crewAI记忆系统的好处

• 自适应学习: 队伍随着时间变得更加高效，适应新信息并完善其处理任务的方法。
• 增强个性化: 记忆使代理能够记住用户偏好和历史互动，从而产生个性化体验。
• 改善问题解决: 访问丰富的记忆存储库有助于代理做出更明智的决策，借鉴过去的学习和上下文洞见。

将crewAI的记忆系统集成到您的项目中非常简单。通过利用提供的记忆组件和配置，您可以快速赋予您的代理记忆、推理和从互动中学习的能力，从而开启新的智能和能力水平。

二、CrewAI如何做How-To

1. 安装 crewAI

欢迎使用 crewAI！本指南将带领您完成 crewAI 及其依赖项的安装过程。crewAI 是一个灵活而强大的人工智能框架，可以帮助您高效地创建和管理 AI 代理、工具和任务。让我们开始吧！

(1). 安装

要安装 crewAI，您需要在系统上安装 Python 版本 >=3.10 且 <=3.13：

# 安装主要的 crewAI 包
pip install crewai

# 安装主要的 crewAI 包和工具包
# 包括一系列有用的工具，供您的代理使用
pip install 'crewai[tools]'

2. 在 crewAI 中创建和利用工具

本指南详细介绍了如何为 crewAI 框架创建自定义工具以及如何高效管理和利用这些工具，包括最新功能，如工具委派、错误处理和动态工具调用。它还强调了协作工具的重要性，使代理能够执行各种操作。

(1). 先决条件

在创建自己的工具之前，请确保已安装 crewAI 额外工具包：

pip install 'crewai[tools]'

(2). 子类化 BaseTool

要创建个性化工具，请继承自 BaseTool 并定义必要的属性和 _run 方法。

from crewai_tools import BaseTool

class MyCustomTool(BaseTool):
    name: str = "我的工具名称"
    description: str = "这个工具的作用。对于有效利用至关重要。"

    def _run(self, argument: str) -> str:
        # 在这里编写工具的逻辑
        return "工具的结果"

(3). 使用 tool 装饰器

或者，使用 tool 装饰器以直接方式创建工具。这需要在函数内指定属性和工具的逻辑。

from crewai_tools import tool

@tool("工具名称")
def my_simple_tool(question: str) -> str:
    """用于澄清的工具描述。"""
    # 在这里编写工具的逻辑
    return "工具输出"

(4). 为工具定义缓存函数

为了通过缓存优化工具性能，可以使用 cache_function 属性定义自定义缓存策略。

@tool("带缓存的工具")
def cached_tool(argument: str) -> str:
    """工具功能描述。"""
    return "可缓存的结果"

def my_cache_strategy(arguments: dict, result: str) -> bool:
    # 定义自定义缓存逻辑
    return True if 某些条件 else False

cached_tool.cache_function = my_cache_strategy

通过遵循这些准则，并将新功能和协作工具纳入工具创建和管理流程中，您可以充分利用 crewAI 框架的全部功能，提升开发体验和 AI 代理的效率。

3. 顺序流程概述

CrewAI 提供了一个灵活的框架，以结构化方式执行任务，支持顺序和分层流程。本指南概述了如何有效实施这些流程，以确保任务执行高效并完成项目。顺序流程确保任务按顺序一个接一个地执行，遵循线性进展。这种方法非常适合需要按特定顺序完成任务的项目。

(1). 主要特点

• 线性任务流程：通过按照预定顺序处理任务，确保有序进展。
• 简单性：最适合具有清晰、逐步任务的项目。
• 易监控：便于跟踪任务完成情况和项目进度。

(2). 实施顺序流程

召集你的团队，并按照需要执行的顺序定义任务。

from crewai import Crew, Process, Agent, Task

# 定义你的代理人
researcher = Agent(
  role='研究员',
  goal='进行基础研究',
  backstory='一位经验丰富的研究员，热衷于发现洞察'
)
analyst = Agent(
  role='数据分析师',
  goal='分析研究结果',
  backstory='一位细致的分析师，擅长发现模式'
)
writer = Agent(
  role='作家',
  goal='起草最终报告',
  backstory='一位技艺高超的作家，擅长撰写引人入胜的叙事'
)

# 按顺序定义任务
research_task = Task(description='收集相关数据...', agent=researcher)
analysis_task = Task(description='分析数据...', agent=analyst)
writing_task = Task(description='撰写报告...', agent=writer)

# 以顺序流程形式组建团队
report_crew = Crew(
  agents=[researcher, analyst, writer],
  tasks=[research_task, analysis_task, writing_task],
  process=Process.sequential
)

(3). 工作流程示例

1. 初始任务：在顺序流程中，第一个代理人完成他们的任务并发出完成信号。
2. 后续任务：代理人根据流程类型接手任务，前期任务的结果或管理者的指导指引他们的执行。
3. 完成：一旦执行最终任务，流程结束，项目完成。

(4). 结论

CrewAI 中的顺序和分层流程为任务执行提供了清晰、适应性强的路径。它们非常适合需要逻辑进展和动态决策的项目，确保每一步都有效完成，从而促进一个连贯的最终产品。

4. 分层流程概述

CrewAI 中的分层流程引入了一种结构化的任务管理方法，模拟传统组织层级结构，实现任务委派和执行的高效性。这种系统化的工作流通过确保任务以最佳效率和准确性处理，增强了项目结果。

"复杂性和效率"：分层流程旨在利用像 GPT-4 这样的先进模型，优化令牌使用，同时处理复杂任务，提高效率。

在 CrewAI 中，默认情况下，任务通过顺序流程管理。然而，采用分层方法可以实现任务管理中的清晰层次结构，其中一个“经理”代理协调工作流程，委派任务，并验证结果，以实现流畅和有效的执行。这个经理代理是由 CrewAI 自动创建的，因此您无需担心。

(1). 主要特点

• 任务委派：经理代理根据成员的角色和能力分配任务。
• 结果验证：经理评估结果，确保其符合要求的标准。
• 高效工作流：模拟公司结构，提供组织良好的任务管理方法。

(2). 实施分层流程

要利用分层流程，必须将流程属性明确设置为 Process.hierarchical，因为默认行为是 Process.sequential。定义一个具有指定经理的团队，并建立清晰的指挥链。

"工具和代理分配"：在代理级别分配工具，以便由经理指导下的指定代理执行任务委派和执行。还可以在任务级别指定工具，以精确控制任务执行期间的工具可用性。

"经理 LLM 要求"：配置 manager_llm 参数对于分层流程至关重要。系统需要设置经理 LLM 以确保适当的功能，确保定制决策。

from langchain_openai import ChatOpenAI
from crewai import Crew, Process, Agent

# 代理定义了背景故事、缓存和详细模式等属性
researcher = Agent(
    role='研究员',
    goal='进行深入分析',
    backstory='经验丰富的数据分析师，擅长发现隐藏的趋势。',
    cache=True,
    verbose=False,
    # tools=[]  # 可选指定；默认为空列表
)
writer = Agent(
    role='作家',
    goal='创作引人入胜的内容',
    backstory='对技术领域中的叙事充满激情的创意作家。',
    cache=True,
    verbose=False,
    # tools=[]  # 可选指定工具；默认为空列表
)

# 使用分层流程和其他配置建立团队
project_crew = Crew(
    tasks=[...],  # 在经理监督下委派和执行的任务
    agents=[researcher, writer],
    manager_llm=ChatOpenAI(temperature=0, model="gpt-4"),  # 分层流程必需
    process=Process.hierarchical,  # 指定分层管理方法
    memory=True,  # 启用内存使用以增强任务执行
)

(3). 工作流程实例

1. 任务分配：经理根据每个代理的能力和可用工具策略性地分配任务。
2. 执行和审查：代理完成任务，可以选择异步执行，并使用回调函数实现流畅的工作流程。
3. 顺序任务进展：尽管是分层流程，任务按照逻辑顺序进行，经理的监督促进了任务的顺利进行。

(4). 结论

在 CrewAI 中采用分层流程，正确配置并了解系统的能力，有助于实现项目管理的有序和高效方法。

5. 将 CrewAI 连接到 LLMs

"默认 LLM"：默认情况下，CrewAI 使用 OpenAI 的 GPT-4 模型进行语言处理。您可以配置您的代理以使用不同的模型或 API。本指南展示了如何通过环境变量和直接实例化将您的代理连接到各种 LLMs。

CrewAI 提供了连接到各种 LLMs 的灵活性，包括通过 Ollama 连接到本地模型以及与 Azure 等不同 API 集成。它与所有 LangChain LLM 组件兼容，为定制的 AI 解决方案提供了多样化的集成。

(1). CrewAI 代理概述

Agent 类是在 CrewAI 中实现 AI 解决方案的基石。以下是反映最新代码库更改的更新概述：

• 属性:
• role: 定义解决方案中代理的角色。
• goal: 指定代理的目标。
• backstory: 为代理提供背景故事。
• llm: 将运行代理的语言模型。默认情况下，它使用环境变量 "OPENAI_MODEL_NAME" 中定义的 GPT-4 模型。
• function_calling_llm: 将处理此代理的工具调用的语言模型，覆盖 crew function_calling_llm。可选。
• max_iter: 代理执行任务的最大迭代次数，默认为 15。
• memory: 允许代理在执行过程中保留信息。默认为 False。
• max_rpm: 代理执行应遵守的每分钟请求的最大数量。可选。
• verbose: 启用对代理执行的详细记录。默认为 False。
• allow_delegation: 允许代理将任务委托给其他代理。默认为 True。
• tools: 指定代理用于任务执行的工具。可选。
• step_callback: 提供在每个步骤之后执行的回调函数。可选。
• cache: 确定代理是否应使用缓存进行工具使用。默认为 True。

# 必需
os.environ["OPENAI_MODEL_NAME"]="gpt-4-0125-preview"

# 代理将自动使用环境变量中定义的模型
example_agent = Agent(
  role='本地专家',
  goal='提供有关城市的见解',
  backstory="一位知识渊博的当地向导。",
  verbose=True,
  memory=True
)

(2). Ollama 集成

Ollama 是首选的本地 LLM 集成方式，提供定制和隐私优势。要将 Ollama 与 CrewAI 集成，设置如下适当的环境变量。注意：详细的 Ollama 设置超出了本文档的范围，但提供了一般指导。

设置 Ollama

• 环境变量配置：要集成 Ollama，请设置以下环境变量：

OPENAI_API_BASE='http://localhost:11434/v1'
OPENAI_MODEL_NAME='openhermes'  # 根据可用模型进行调整
OPENAI_API_KEY=''

(3). HuggingFace 集成

您可以使用 HuggingFace 托管您的 LLM 的几种不同方式。

您自己的 HuggingFace 端点

from langchain_community.llms import HuggingFaceEndpoint

llm = HuggingFaceEndpoint(
    endpoint_url="<YOUR_ENDPOINT_URL_HERE>",
    huggingfacehub_api_token="<HF_TOKEN_HERE>",
    task="text-generation",
    max_new_tokens=512
)

agent = Agent(
    role="HuggingFace 代理",
    goal="使用 HuggingFace 生成文本",
    backstory="GitHub 文档的勤奋探索者。",
    llm=llm
)

从 HuggingFaceHub 端点

from langchain_community.llms import HuggingFaceHub

llm = HuggingFaceHub(
    repo_id="HuggingFaceH4/zephyr-7b-beta",
    huggingfacehub_api_token="<HF_TOKEN_HERE>",
    task="text-generation",
)

(4). OpenAI 兼容的 API 端点

通过环境变量无缝切换 API 和模型，支持 FastChat、LM Studio 和 Mistral AI 等平台。

配置示例

FastChat

OPENAI_API_BASE="http://localhost:8001/v1"
OPENAI_MODEL_NAME='oh-2.5m7b-q51'
OPENAI_API_KEY=NA

LM Studio

启动 LM Studio 并转到 Server 选项卡。然后从下拉菜单中选择一个模型，等待加载。加载完成后，点击绿色的 Start Server 按钮，并使用显示的 URL、端口和 API 密钥（您可以修改它们）。以下是截至 LM Studio 0.2.19 的默认设置示例：

OPENAI_API_BASE="http://localhost:1234/v1"
OPENAI_API_KEY="lm-studio"

Mistral API

OPENAI_API_KEY=your-mistral-api-key
OPENAI_API_BASE=https://api.mistral.ai/v1
OPENAI_MODEL_NAME="mistral-small"

Solar

from langchain_community.chat_models.solar import SolarChat
# 初始化语言模型
os.environ["SOLAR_API_KEY"] = "your-solar-api-key"
llm = SolarChat(max_tokens=1024)

免费的开发者 API 密钥在此处获取：https://console.upstage.ai/services/solar
Langchain 示例：https://github.com/langchain-ai/langchain/pull/18556

text-gen-web-ui

OPENAI_API_BASE=http://localhost:5000/v1
OPENAI_MODEL_NAME=NA
OPENAI_API_KEY=NA

Cohere

from langchain_community.chat_models import ChatCohere
# 初始化语言模型
os.environ["COHERE_API_KEY"] = "your-cohere-api-key"
llm = ChatCohere()

免费的开发者 API 密钥在此处获取：https://cohere.com/
Langchain 文档：https://python.langchain.com/docs/integrations/chat/cohere

Azure Open AI 配置

要进行 Azure OpenAI API 集成，请设置以下环境变量：

AZURE_OPENAI_VERSION="2022-12-01"
AZURE_OPENAI_DEPLOYMENT=""
AZURE_OPENAI_ENDPOINT=""
AZURE_OPENAI_KEY=""

使用 Azure LLM 的示例代理

from dotenv import load_dotenv
from crewai import Agent
from langchain_openai import AzureChatOpenAI

load_dotenv()

azure_llm = AzureChatOpenAI(
    azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key=os.environ.get("AZURE_OPENAI_KEY")
)

azure_agent = Agent(
  role='示例代理',
  goal='演示自定义 LLM 配置',
  backstory='GitHub 文档的勤奋探索者。',
  llm=azure_llm
)

(5). 结论

将 CrewAI 与不同的 LLMs 集成扩展了框架的多样性，允许在各种领域和平台上定制高效的 AI 解决方案。

6. 可定制属性

打造高效的 CrewAI 团队的关键在于能够动态地调整 AI 代理，以满足任何项目的独特需求。本节将介绍您可以定制的基础属性。

(1). 定制的关键属性

• 角色：指定代理在团队中的工作，如“分析师”或“客服代表”。
• 目标：定义代理的目标，与其角色和团队整体目标保持一致。
• 背景故事：为代理的角色赋予深度，丰富其动机和在团队中的参与。
• 工具：代表代理用于执行任务的能力或方法，从简单功能到复杂集成。

(2). 高级定制选项

除了基本属性外，CrewAI 还允许进行更深入的定制，以显著增强代理的行为和能力。

语言模型定制

代理可以使用特定的语言模型（llm）和函数调用语言模型（function_calling_llm）进行定制，提供对其处理和决策能力的高级控制。值得注意的是，设置 function_calling_llm 允许覆盖默认的团队函数调用语言模型，提供更高程度的定制。

(3). 性能和调试设置

调整代理的性能并监控其操作对于高效执行任务至关重要。

冗长模式和 RPM 限制

• 冗长模式：启用对代理操作的详细记录，有助于调试和优化。具体来说，它提供了关于代理执行过程的见解，有助于性能优化。
• RPM 限制：设置每分钟请求的最大数量（max_rpm）。此属性是可选的，可以设置为 None 以取消限制，如果需要的话，允许对外部服务进行无限查询。

任务执行的最大迭代次数

max_iter 属性允许用户定义代理为单个任务执行的最大迭代次数，防止无限循环或执行时间过长。默认值设置为 15，在彻底性和效率之间提供平衡。一旦代理接近这个数字，它将尽力给出一个好答案。

(4). 定制代理和工具

通过在初始化期间定义其属性和工具来定制代理。工具对代理的功能至关重要，使其能够执行专业任务。tools 属性应该是代理可以利用的工具数组，默认情况下初始化为空列表。可以在代理初始化后添加或修改工具，以适应新的需求。

pip install 'crewai[tools]'

示例：为代理分配工具

import os
from crewai import Agent
from crewai_tools import SerperDevTool

# 为工具初始化设置 API 密钥
os.environ["OPENAI_API_KEY"] = "Your Key"
os.environ["SERPER_API_KEY"] = "Your Key"

# 初始化一个搜索工具
search_tool = SerperDevTool()

# 使用高级选项初始化代理
agent = Agent(
  role='研究分析师',
  goal='提供最新的市场分析',
  backstory='一位对市场趋势敏锐的专业分析师。',
  tools=[search_tool],
  memory=True, # 启用记忆功能
  verbose=True,
  max_rpm=None, # 每分钟请求无限制
  max_iter=15, # 最大迭代次数的默认值
  allow_delegation=False
)

(5). 委托和自主权

控制代理委托任务或提问的能力对于定制其自主权和在 CrewAI 框架内的协作动态至关重要。默认情况下，allow_delegation 属性设置为 True，允许代理根据需要寻求帮助或委托任务。这种默认行为促进了 CrewAI 生态系统内的协作解决问题和效率。如果需要，可以禁用委托以适应特定的操作需求。

示例：禁用代理的委托

agent = Agent(
  role='内容撰稿人',
  goal='撰写有关市场趋势的引人入胜内容',
  backstory='一位在市场分析方面拥有专业知识的资深撰稿人。',
  allow_delegation=False # 禁用委托
)

(6). 结论

通过设置代理的角色、目标、背景故事和工具，以及高级选项如语言模型定制、记忆、性能设置和委托偏好，定制 CrewAI 中的代理，为复杂挑战做好准备，使其成为一个细致而有能力的 AI 团队。

7. 代理执行中的人类输入

在几种代理执行场景中，人类输入至关重要，允许代理在必要时请求额外信息或澄清。这一功能在复杂决策过程中特别有用，或者当代理需要更多细节以有效完成任务时。

(1). 使用 CrewAI 进行人类输入

要将人类输入整合到代理执行中，在任务定义中设置 human_input 标志。启用后，代理会在提供最终答案之前提示用户输入。这种输入可以提供额外的上下文，澄清模糊之处，或验证代理的输出。

(2). 示例：

pip install crewai

import os
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool

os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
os.environ["OPENAI_API_KEY"] = "Your Key"

# 加载工具
search_tool = SerperDevTool()

# 使用角色、目标、工具和其他属性定义您的代理
researcher = Agent(
  role='高级研究分析师',
  goal='发现人工智能和数据科学领域的前沿发展',
  backstory=(
    "您是一家领先科技智库的高级研究分析师。"
    "您擅长识别人工智能和数据科学领域的新兴趋势和技术。"
    "您善于剖析复杂数据并提供可操作的见解。"
  ),
  verbose=True,
  allow_delegation=False,
  tools=[search_tool],
  max_rpm=100
)
writer = Agent(
  role='科技内容策略师',
  goal='撰写关于科技进步的引人入胜内容',
  backstory=(
    "您是一位著名的科技内容策略师，以撰写富有洞察力和引人入胜的科技和创新文章而闻名。"
    "凭借对科技行业的深刻理解，您将复杂概念转化为引人入胜的叙事。"
  ),
  verbose=True,
  allow_delegation=True,
  tools=[search_tool],
  cache=False, # 为该代理禁用缓存
)

# 为您的代理创建任务
task1 = Task(
  description=(
    "对2024年人工智能领域的最新进展进行全面分析。"
    "识别关键趋势、突破性技术和潜在的行业影响。"
    "将您的研究结果编制成详细报告。"
    "在最终确定答案之前，请确保与人类核对草稿是否合适。"
  ),
  expected_output='一份关于2024年最新人工智能进展的全面报告，不遗漏任何细节',
  agent=researcher,
  human_input=True,
)

task2 = Task(
  description=(
    "利用研究员报告中的见解，撰写一篇引人入胜的博客文章，重点介绍最重要的人工智能进展。"
    "您的文章应既具信息性又易于理解，迎合科技爱好者的观众。"
    "力求以叙述方式捕捉这些突破性进展的本质及其对未来的影响。"
  ),
  expected_output='一篇引人入胜的、格式为 markdown 的三段博客文章，介绍2024年最新人工智能进展',
  agent=writer
)

# 使用顺序流程实例化您的团队
crew = Crew(
  agents=[researcher, writer],
  tasks=[task1, task2],
  verbose=2
)

# 让您的团队开始工作！
result = crew.kickoff()

print("######################")
print(result)

8. AgentOps

可观察性是开发和部署会话式人工智能智能体的关键方面。它使开发人员能够了解他们的智能体的性能如何，他们的智能体如何与用户交互，以及他们的智能体如何使用外部工具和API。AgentOps是一个与CrewAI无关的产品，为智能体提供了全面的可观察性解决方案。

AgentOps 提供了智能体的会话重放、指标和监控。

在高层次上，AgentOps使您能够监控成本、令牌使用情况、延迟、智能体故障、会话范围统计数据等。欲了解更多信息，请查看AgentOps Repo。

(1). 概述

AgentOps为开发和生产中的智能体提供监控。它提供了用于跟踪智能体性能、会话重放和自定义报告的仪表板。

此外，AgentOps提供了会话详细信息，可实时查看Crew智能体交互、LLM调用以及工具使用情况。此功能对于调试和了解智能体如何与用户以及其他智能体交互非常有用。

(2). 特点

• LLM成本管理和跟踪：跟踪基础模型提供商的支出
• 重放分析：观看逐步智能体执行图
• 递归思考检测：识别智能体何时陷入无限循环
• 自定义报告：创建关于智能体性能的自定义分析
• 分析仪表板：监视有关开发和生产中智能体的高级统计信息
• 公共模型测试：针对基准和排行榜测试您的智能体
• 自定义测试：针对特定领域的测试运行您的智能体
• 时光旅行调试：从检查点重新启动您的会话
• 合规性和安全性：创建审计日志并检测潜在威胁，如粗话和个人身份信息泄漏
• 提示注入检测：识别潜在的代码注入和秘密泄漏

(3). 使用AgentOps

1. 创建API密钥：在此处创建用户API密钥：创建API密钥

2. 配置您的环境：将您的API密钥添加到您的环境变量中

AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>

1. 安装AgentOps：使用以下命令安装AgentOps：

pip install crewai[agentops]

或

pip install agentops

在脚本中使用Crew之前，包含以下行：

import agentops
agentops.init()

这将启动一个AgentOps会话，并自动跟踪Crew智能体。欲了解更多关于如何为更复杂的智能系统配备装备的信息，请查看AgentOps文档或加入Discord。

(4). Crew + AgentOps示例

• 职位发布
• Markdown验证器
• Instagram帖子

(5). 更多信息

要开始使用，请创建一个AgentOps账户。

如有功能请求或错误报告，请联系AgentOps团队，访问AgentOps Repo。

三、CrewAI工具使用

1. 安装

要使用文本搜索工具，您首先需要安装 crewai_tools 软件包。这可以通过 pip（Python 的软件包管理器）来完成。打开您的终端或命令提示符，输入以下命令：

pip install 'crewai[tools]'

这个命令将下载并安装文本搜索工具以及任何必要的依赖项。

2. 文本搜索工具

(1). 描述

该工具用于在文本文件的内容中执行 RAG（检索增强生成）搜索。它允许在指定文本文件的内容中进行语义搜索，根据提供的查询快速提取信息或查找特定文本部分，是一个非常有价值的资源。

(2). 示例

以下示例演示了如何使用文本搜索工具在文本文件中进行搜索。该示例展示了如何初始化工具并在文件内容中进行搜索。

from crewai_tools import TXTSearchTool

# 初始化工具以在执行期间学习到的任何文本文件内容中进行搜索
tool = TXTSearchTool()

# 或者

# 使用特定文本文件初始化工具，以便代理程序可以在给定文本文件的内容中进行搜索
tool = TXTSearchTool(txt='path/to/text/file.txt')

(3). 参数

• txt (str): 可选。要搜索的文本文件的路径。只有在工具未使用特定文本文件进行初始化时才需要此参数；否则，搜索将在最初提供的文本文件中进行。

(4). 自定义模型和嵌入

默认情况下，该工具使用 OpenAI 进行嵌入和摘要生成。要自定义模型，您可以使用以下配置字典：

tool = TXTSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

3. PDFSearchTool

(1). 描述

PDFSearchTool 是一款专为在 PDF 内容中进行语义搜索而设计的 RAG 工具。它允许输入搜索查询和 PDF 文档，利用先进的搜索技术高效地找到相关内容。这种能力使其特别适用于快速从大型 PDF 文件中提取特定信息。

(2). 示例

以下是如何使用 PDFSearchTool 在 PDF 文档中进行搜索：

from crewai_tools import PDFSearchTool

# 初始化工具，允许在执行期间提供路径时进行任何 PDF 内容搜索
tool = PDFSearchTool()

# 或者
# 使用特定的 PDF 路径初始化工具，以在该文档中进行独占搜索
tool = PDFSearchTool(pdf='path/to/your/document.pdf')

(3). 参数

• pdf: 可选 用于搜索的 PDF 路径。可以在初始化时提供，也可以在 run 方法的参数中提供。如果在初始化时提供，工具将限制其搜索范围为指定文档。

(4). 自定义模型和嵌入

默认情况下，该工具同时使用 OpenAI 进行嵌入和摘要生成。要自定义模型，可以使用以下配置字典：

tool = PDFSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

4. DOCXSearchTool

(1). 描述

DOCXSearchTool 是一款专为在 DOCX 文档中进行语义搜索而设计的 RAG 工具。它使用户能够通过基于查询的搜索有效地搜索和提取 DOCX 文件中的相关信息。该工具对于数据分析、信息管理和研究任务至关重要，简化了在大型文档集合中查找特定信息的过程。

(2). 示例

以下示例演示了如何初始化 DOCXSearchTool 来搜索任何 DOCX 文件的内容或特定 DOCX 文件路径中的内容。

from crewai_tools import DOCXSearchTool

# 初始化工具以搜索任何 DOCX 文件的内容
tool = DOCXSearchTool()

# 或者

# 使用特定的 DOCX 文件初始化工具，这样代理就只能搜索指定 DOCX 文件的内容
tool = DOCXSearchTool(docx='path/to/your/document.docx')

(3). 参数

• docx: 要搜索的特定 DOCX 文档的可选文件路径。如果在初始化期间未提供，该工具允许稍后指定任何 DOCX 文件的内容路径进行搜索。

(4). 自定义模型和嵌入

默认情况下，该工具在嵌入和摘要方面使用 OpenAI。要自定义模型，可以使用以下配置字典：

tool = DOCXSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

5. DirectoryReadTool

(1). 描述

DirectoryReadTool 是一个强大的实用工具，旨在提供目录内容的全面列表。它可以递归地浏览指定目录，为用户提供所有文件的详细枚举，包括子目录中的文件。这个工具对需要对目录结构进行彻底清点的任务或验证目录中文件组织的任务至关重要。

(2). 示例

使用 DirectoryReadTool 很简单。以下代码片段演示了如何设置并使用该工具来列出指定目录的内容：

from crewai_tools import DirectoryReadTool

# 初始化工具，以便代理程序在执行过程中了解任何目录的内容
tool = DirectoryReadTool()

# 或者

# 使用特定目录初始化工具，以便代理程序仅能读取指定目录的内容
tool = DirectoryReadTool(directory='/path/to/your/directory')

(3). 参数

DirectoryReadTool 需要进行最少配置以供使用。该工具的基本参数如下：

• directory：可选。指定要列出其内容的目录路径的参数。它接受绝对路径和相对路径，指导工具到达所需目录以进行内容列表。`

6. 目录搜索工具

(1). 描述

目录搜索工具可以在指定目录的内容中进行语义搜索，利用检索增强生成（RAG）方法来实现对文件的高效导航。设计灵活，允许用户在运行时动态指定搜索目录，或在初始设置期间设置固定目录。

(2). 初始化和使用

从 crewai_tools 包中导入 DirectorySearchTool 来开始。您可以在不指定目录的情况下初始化工具，从而可以在运行时设置搜索目录。另外，也可以使用预定义目录初始化工具。

from crewai_tools import DirectorySearchTool

# 对于在运行时动态指定目录
tool = DirectorySearchTool()

# 对于固定目录搜索
tool = DirectorySearchTool(directory='/path/to/directory')

(3). 参数

• directory: 一个字符串参数，用于指定搜索目录。在初始化时是可选的，但如果最初未设置，则在搜索时是必需的。

(4). 自定义模型和嵌入

目录搜索工具默认使用 OpenAI 进行嵌入和摘要生成。这些设置的自定义选项包括更改模型提供商和配置，为高级用户增强了灵活性。

tool = DirectorySearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 选项包括 ollama、google、anthropic、llama2 等
            config=dict(
                model="llama2",
                # 这里添加额外的配置
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

7. CSVSearchTool

(1). 描述

该工具用于在 CSV 文件内容中执行 RAG（检索增强生成）搜索。它允许用户在指定 CSV 文件的内容中语义搜索查询。这个功能特别适用于从大型 CSV 数据集中提取信息，传统搜索方法可能效率低下的情况。所有名称中带有“Search”的工具，包括 CSVSearchTool，在设计上都是用于搜索不同数据源的 RAG 工具。

(2). 示例

from crewai_tools import CSVSearchTool

# 使用特定的 CSV 文件初始化工具。这样设置允许代理只搜索给定的 CSV 文件。
tool = CSVSearchTool(csv='path/to/your/csvfile.csv')

# 或者

# 在没有特定 CSV 文件的情况下初始化工具。代理将需要在运行时提供 CSV 路径。
tool = CSVSearchTool()

(3). 参数

• csv：要搜索的 CSV 文件的路径。如果工具在没有特定 CSV 文件的情况下初始化，则这是一个必需的参数；否则，它是可选的。

(4). 自定义模型和嵌入

默认情况下，该工具同时使用 OpenAI 进行嵌入和摘要。要自定义模型，可以使用以下配置字典：

tool = CSVSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

8. 文件读取工具

(1). 描述

文件读取工具在 crewai_tools 软件包中概念上代表了一套旨在促进文件读取和内容检索的功能。该套件包括用于处理批量文本文件、读取运行时配置文件以及导入分析数据的工具。它支持多种基于文本的文件格式，如 .txt、.csv、.json 等。根据文件类型，该套件提供了专门的功能，例如将 JSON 内容转换为 Python 字典以便于使用。

(2). 使用示例

要开始使用文件读取工具：

from crewai_tools import FileReadTool

# 初始化工具以读取代理已知的任何文件或学习指定文件的路径
file_read_tool = FileReadTool()

# 或者

# 使用特定文件路径初始化工具，这样代理只能读取指定文件的内容
file_read_tool = FileReadTool(file_path='path/to/your/file.txt')

(3). 参数

• file_path: 您要读取的文件路径。它接受绝对路径和相对路径。确保文件存在并且您具有访问权限。

9. MDXSearchTool

(1). 描述

MDXSearchTool 是 crewai_tools 软件包的一个组件，旨在促进高级市场数据提取。对于寻求快速获取市场见解的研究人员和分析师来说，这个工具非常宝贵，尤其是在人工智能领域。它通过与各种数据源进行接口，简化了获取、解释和组织市场数据的任务。

(2). 使用示例

要使用 MDXSearchTool，您必须首先设置必要的环境变量。然后，将该工具集成到您的 crewAI 项目中，开始您的市场研究。以下是如何执行此操作的基本示例：

from crewai_tools import MDXSearchTool

# 初始化工具以搜索执行过程中了解到的任何 MDX 内容
tool = MDXSearchTool()

# 或者

# 使用特定的 MDX 文件路径初始化工具，以在该文档中进行独占搜索
tool = MDXSearchTool(mdx='path/to/your/document.mdx')

(3). 参数

• mdx: 可选。指定搜索的 MDX 文件路径。可以在初始化过程中提供。

(4). 模型和嵌入的定制化

该工具默认使用 OpenAI 进行嵌入和摘要生成。要进行定制化，可以使用如下所示的配置字典：

tool = MDXSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 选项包括 google, openai, anthropic, llama2 等。
            config=dict(
                model="llama2",
                # 可在此处包括可选参数。
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # 可在此处添加嵌入的可选标题。
                # title="Embeddings",
            ),
        ),
    )
)

10. 网页抓取工具

(1). 描述

这是一个旨在提取和阅读指定网站内容的工具。它能够通过发出 HTTP 请求并解析接收到的 HTML 内容来处理各种类型的网页。该工具特别适用于网络抓取任务、数据收集或从网站中提取特定信息。

(2). 示例

from crewai_tools import ScrapeWebsiteTool

# 若要在执行期间启用对任何找到的网站进行抓取
tool = ScrapeWebsiteTool()

# 使用网站 URL 初始化工具，以便代理只能抓取指定网站的内容
tool = ScrapeWebsiteTool(website_url='https://www.example.com')

# 从网站提取文本
text = tool.run()
print(text)

(3). 参数

• website_url：必填的网站 URL 以读取文件。这是工具的主要输入，指定应抓取和阅读哪个网站的内容。

11. 网站搜索工具

(1). 描述

网站搜索工具旨在作为在网站内容中进行语义搜索的概念设计。它旨在利用像检索增强生成（RAG）这样的先进机器学习模型，以高效地浏览和提取指定 URL 中的信息。该工具旨在提供灵活性，允许用户在任何网站上执行搜索或专注于感兴趣的特定网站。请注意，网站搜索工具的当前实现细节正在开发中，所述功能可能尚不可访问。

(2). 示例用法

以下是网站搜索工具在不同场景下的使用示例。请注意，这些示例是说明性的，代表了计划功能：

from crewai_tools import WebsiteSearchTool

# 初始化工具，代理可以使用它在任何发现的网站上进行搜索
tool = WebsiteSearchTool()

# 限制搜索范围为特定网站的内容，现在代理只能在该网站内进行搜索
tool = WebsiteSearchTool(website='https://example.com')

(3). 参数

• website：一个可选参数，用于指定用于重点搜索的网站 URL。此参数旨在通过在必要时允许定向搜索来增强工具的灵活性。

(4). 自定义选项

默认情况下，该工具在嵌入和摘要生成方面使用 OpenAI。要自定义模型，您可以使用以下配置字典：

tool = WebsiteSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)

12. SeleniumScrapingTool

(1). 描述

SeleniumScrapingTool 专为高效的网络抓取任务而设计。它通过使用 CSS 选择器来精确提取网页内容，满足各种抓取需求，灵活处理任何提供的网站 URL。

(2). 使用示例

以下是 SeleniumScrapingTool 可以使用的一些场景：

from crewai_tools import SeleniumScrapingTool

# 示例 1：初始化工具，无需任何参数即可抓取当前导航到的页面
tool = SeleniumScrapingTool()

# 示例 2：抓取给定 URL 的整个网页
tool = SeleniumScrapingTool(website_url='https://example.com')

# 示例 3：从网页中定位并抓取特定的 CSS 元素
tool = SeleniumScrapingTool(website_url='https://example.com', css_element='.main-content')

# 示例 4：使用附加参数执行抓取，获得定制化体验
tool = SeleniumScrapingTool(website_url='https://example.com', css_element='.main-content', cookie={'name': 'user', 'value': 'John Doe'}, wait_time=10)

(3). 参数

以下参数可用于自定义 SeleniumScrapingTool 的抓取过程：

• website_url：必填。指定要从中抓取内容的网站 URL。
• css_element：必填。要在网站上定位的特定元素的 CSS 选择器。这使得可以集中抓取网页的特定部分。
• cookie：可选。包含 cookie 信息的字典。用于模拟已登录会话，从而提供对可能仅限于未登录用户的内容的访问。
• wait_time：可选。指定在抓取内容之前的延迟时间（以秒为单位）。此延迟确保网站和任何动态内容完全加载，以确保成功抓取。

13. PGSearchTool

(1). 描述

PGSearchTool 被设想为一个强大的工具，用于在 PostgreSQL 数据库表中进行语义搜索。通过利用先进的检索和生成（RAG）技术，它旨在提供一种有效的方式来查询数据库表内容，专门为 PostgreSQL 数据库定制。该工具的目标是通过语义搜索查询简化查找相关数据的过程，为需要在 PostgreSQL 环境中对大型数据集进行高级查询的用户提供宝贵资源。

(2). 示例用法

以下是一个示例，展示如何使用 PGSearchTool 在 PostgreSQL 数据库中的表上进行语义搜索：

from crewai_tools import PGSearchTool

# 使用数据库 URI 和目标表名初始化工具
tool = PGSearchTool(db_uri='postgresql://user:password@localhost:5432/mydatabase', table_name='employees')

(3). 参数

PGSearchTool 设计为需要以下参数才能运行：

• db_uri：表示要查询的 PostgreSQL 数据库的 URI 的字符串。此参数将是必需的，必须包括必要的身份验证详细信息和数据库的位置。
• table_name：指定将在其中执行语义搜索的数据库中表的名称的字符串。此参数也将是必需的。

(4). 自定义模型和嵌入

该工具打算默认使用 OpenAI 进行嵌入和摘要。用户将可以使用以下配置字典自定义模型：

tool = PGSearchTool(
    config=dict(
        llm=dict(
            provider="ollama", # 或 google, openai, anthropic, llama2, ...
            config=dict(
                model="llama2",
                # temperature=0.5,
                # top_p=1,
                # stream=true,
            ),
        ),
        embedder=dict(
            provider="google",
            config=dict(
                model="models/embedding-001",
                task_type="retrieval_document",
                # title="Embeddings",
            ),
        ),
    )
)