微信扫码
与创始人交个朋友
本文介绍了大语言模型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). 自定义模型和嵌入
代理Agent是一个自主单元,被编程用于:执行任务
执行任务
做出决策
与其他代理进行通信
将代理看作团队的一员,具有特定的技能和特定的工作任务。代理可以担任不同的角色,如“研究员”、“作家”或“客户支持”,每个角色都为团队的整体目标做出贡献。
属性 | 描述 |
---|---|
角色 | 定义代理在团队中的功能。它决定了代理最适合执行的任务类型。 |
目标 | 代理旨在实现的个体目标。它指导代理的决策过程。 |
背景故事 | 为代理的角色和目标提供背景信息,丰富互动和协作动态。 |
LLM (可选) | 表示将运行代理的语言模型。如果未指定,默认从OPENAI_MODEL_NAME 环境变量中动态获取模型名称,否则默认为"gpt-4"。 |
工具 (可选) | 代理可以使用的一组能力或功能集。预计是与代理执行环境兼容的自定义类的实例。工具的默认值为一个空列表。 |
调用功能的LLM (可选) | 指定将处理该代理的工具调用的语言模型,如果传递,则会覆盖团队功能调用LLM。默认值为None 。 |
最大迭代次数 (可选) | 代理在被强制给出最佳答案之前可以执行的最大迭代次数。默认值为25 。 |
最大请求次数 (可选) | 代理可以执行的每分钟最大请求数,以避免速率限制。这是可选的,可以不指定,默认值为None 。 |
最大执行时间 (可选) | 代理执行任务的最大执行时间。这是可选的,可以不指定,默认值为None ,表示没有最大执行时间。 |
详细模式 (可选) | 将此设置为True 会配置内部记录器以提供详细的执行日志,有助于调试和监控。默认值为False 。 |
允许委托 (可选) | 代理可以相互委托任务或问题,确保每个任务由最合适的代理处理。默认值为True 。 |
步骤回调 (可选) | 在代理的每个步骤之后调用的函数。这可用于记录代理的操作或执行其他操作。它将覆盖团队step_callback 。 |
缓存 (可选) | 指示代理是否应使用工具使用缓存。默认值为True 。 |
代理可以使用 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 # 可选
)
代理是 CrewAI 框架的构建模块。通过了解如何定义和与代理交互,您可以创建利用协作智能力的复杂人工智能系统。
在 crewAI 框架中,任务是由代理完成的具体任务。它们提供执行所需的所有必要细节,如描述、负责代理、所需工具等,有助于促进各种行动复杂性。
crewAI 中的任务可以是协作的,需要多个代理共同工作。这通过任务属性进行管理,并由 Crew 的流程进行编排,增强团队合作和效率。
属性 | 描述 |
---|---|
描述 | 任务内容的清晰简明陈述。 |
代理 | 负责任务的代理,直接分配或由 Crew 的流程分配。 |
预期输出 | 任务完成后的详细描述。 |
工具 (可选) | 代理用于执行任务的功能或能力。 |
异步执行 (可选) | 如果设置,任务将异步执行,允许在不等待完成的情况下进行进展。 |
上下文 (可选) | 指定输出用作此任务上下文的任务。 |
配置 (可选) | 用于执行任务的代理的附加配置细节,允许进一步定制。 |
输出 JSON (可选) | 输出 JSON 对象,需要 OpenAI 客户端。只能设置一种输出格式。 |
输出 Pydantic (可选) | 输出 Pydantic 模型对象,需要 OpenAI 客户端。只能设置一种输出格式。 |
输出文件 (可选) | 将任务输出保存到文件。如果与 输出 JSON 或 输出 Pydantic 一起使用,指定输出保存方式。 |
回调 (可选) | 任务完成后执行的 Python 可调用函数。 |
人工输入 (可选) | 指示任务是否需要最终人工反馈,对需要人工监督的任务很有用。 |
创建任务涉及定义其范围、负责代理以及任何额外属性以实现灵活性:
from crewai import Task
task = Task(
description='查找并总结有关人工智能的最新和最相关新闻',
agent=sales_agent
)
"任务分配":直接为分配指定一个 代理
,或者让 分层
的 CrewAI 流程根据角色、可用性等决定。
利用 crewAI Toolkit 和 LangChain Tools 中的工具,增强任务性能和代理交互。
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)
这演示了如何使用特定工具的任务可以覆盖代理的默认设置,实现定制化任务执行。
在 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]
)
#...
您可以定义任务以异步执行。这意味着 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] # 将等待两个任务的输出完成
)
#...
在任务完成后执行回调函数,允许根据任务结果触发操作或通知。
# ...
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
)
#...
一组 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}
""")
在任务中指定工具允许动态调整代理能力,突出了 CrewAI 的灵活性。
在创建和执行任务时,存在某些验证机制,以确保任务属性的健壮性和可靠性。这些验证包括但不限于:
id
属性,以维护唯一标识符系统的完整性。这些验证有助于在 crewAI 框架内维护任务执行的一致性和可靠性。
任务是 crewAI 中代理行动的推动力。通过正确定义任务及其结果,您为 AI 代理有效地工作奠定了基础,无论是独立工作还是作为协作单位。为任务配备适当的工具,了解执行过程,并遵循健壮的验证实践对于最大化 CrewAI 的潜力至关重要,确保代理有效准备好执行其任务,并确保任务按预期执行。
crewAI 工具赋予代理能力,从网页搜索和数据分析到协作和任务委派等各种功能。本文档概述了如何在 crewAI 框架内创建、集成和利用这些工具,包括对协作工具的新重点。
CrewAI 中的工具是代理可以利用的用于执行各种操作的技能或功能。这包括来自 crewAI Toolkit 和 LangChain Tools 的工具,使代理之间能够进行从简单搜索到复杂互动以及有效团队合作的一切。
实用性:专为任务设计,如网页搜索、数据分析、内容生成和代理协作。
集成性:通过将工具无缝集成到工作流程中,提升代理的能力。
可定制性:提供灵活性,可以开发定制工具或利用现有工具,满足代理的特定需求。
错误处理:包含强大的错误处理机制,确保平稳运行。
缓存机制:具有智能缓存功能,优化性能并减少冗余操作。
要通过 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()
错误处理:所有工具都具有错误处理功能,允许代理优雅地处理异常并继续执行任务。
缓存机制:所有工具支持缓存,使代理能够高效地重用先前获得的结果,减少对外部资源的负载并加快执行时间,您还可以使用工具上的 cache_function
属性对缓存机制进行更精细的控制。
以下是可用工具及其描述的列表:
工具 | 描述 |
---|---|
CodeDocsSearchTool | 专为搜索代码文档和相关技术文档而优化的 RAG 工具。 |
CSVSearchTool | 专为在 CSV 文件中搜索而设计的 RAG 工具,适用于处理结构化数据。 |
DirectorySearchTool | 用于在目录中搜索的 RAG 工具,可用于浏览文件系统。 |
DOCXSearchTool | 旨在在 DOCX 文档中搜索的 RAG 工具,适用于处理 Word 文件。 |
DirectoryReadTool | 便于读取和处理目录结构及其内容。 |
FileReadTool | 可读取并提取文件中的数据,支持各种文件格式。 |
GithubSearchTool | 用于在 GitHub 存储库中搜索的 RAG 工具,适用于代码和文档搜索。 |
SerperDevTool | 专为开发目的而设计的专用工具,具有特定的功能正在开发中。 |
TXTSearchTool | 专注于在文本(.txt)文件中搜索的 RAG 工具,适用于非结构化数据。 |
JSONSearchTool | 专为在 JSON 文件中搜索而设计的 RAG 工具,适用于处理结构化数据。 |
MDXSearchTool | 专为在 Markdown(MDX)文件中搜索而定制的 RAG 工具,适用于文档。 |
PDFSearchTool | 旨在在 PDF 文档中搜索的 RAG 工具,适用于处理扫描文档。 |
PGSearchTool | 专为在 PostgreSQL 数据库中搜索而优化的 RAG 工具,适用于数据库查询。 |
RagTool | 通用的 RAG 工具,能够处理各种数据源和类型。 |
ScrapeElementFromWebsiteTool | 可从网站中抓取特定元素,适用于有针对性的数据提取。 |
ScrapeWebsiteTool | 便于抓取整个网站,适用于全面的数据收集。 |
WebsiteSearchTool | 用于搜索网站内容的 RAG 工具,优化了网络数据提取。 |
XMLSearchTool | 专为在 XML 文件中搜索而设计的 RAG 工具,适用于结构化数据格式。 |
YoutubeChannelSearchTool | 用于在 YouTube 频道中搜索的 RAG 工具,适用于视频内容分析。 |
YoutubeVideoSearchTool | 旨在在 YouTube 视频中搜索的 RAG 工具,适用于视频数据提取。 |
"自定义工具创建"
开发人员可以创建根据代理需求定制的自定义工具,或者利用预构建选项:
要创建自己的 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,
)
#...
"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]
)
# 代码的其余部分 ...
工具在扩展 CrewAI 代理的能力方面起着至关重要的作用,使它们能够执行各种任务并有效地进行协作。在使用 CrewAI 构建解决方案时,利用自定义和现有工具来赋能您的代理,并增强 AI 生态系统。考虑利用错误处理、缓存机制以及工具参数的灵活性来优化您的代理的性能和能力。
在 CrewAI 中,流程通过协调代理执行任务,类似于人类团队中的项目管理。这些流程确保任务被有效地分配和执行,与预定义的策略保持一致。
manager_llm
) 以启用分级流程,通过管理者便捷地创建和管理任务。流程使个体代理能够作为一个有凝聚力的整体运作,简化他们的努力,以高效和协调的方式实现共同目标。
要将流程分配给船员,在创建船员时指定流程类型以设置执行策略。对于分级流程,确保为管理者代理定义 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
。
该方法模拟动态团队工作流程,以深思熟虑和系统化的方式进行任务。任务执行遵循任务列表中预定义的顺序,一个任务的输出作为下一个任务的上下文。
要自定义任务上下文,可以利用 Task
类中的 context
参数指定应作为后续任务上下文使用的输出。
模拟公司的等级制度,CrewAI 会自动为您创建一个管理者,需要为管理者代理指定一个管理语言模型 (manager_llm
)。该代理负责监督任务执行,包括规划、委派和验证。任务不是预分配的;管理者根据代理的能力分配任务,审查输出,并评估任务完成情况。
Process
类被实现为一个枚举 (Enum
),确保类型安全并将流程值限制为定义的类型(sequential
、hierarchical
)。共识流程计划在未来加入,强调我们对持续发展和创新的承诺。
output_json
)、Pydantic 模型 (output_pydantic
) 和文件输出 (output_file
),灵活地捕获和利用任务结果。这允许各种输出可能性,满足不同的需求和要求。在 CrewAI 中通过流程实现的结构化协作对于促进代理之间的系统化团队合作至关重要。本文档已更新以反映最新功能、增强功能以及计划整合共识流程,确保用户可以访问最新和全面的信息。
在 crewAI 中,团队代表着一群代理共同合作以完成一组任务。每个团队定义了任务执行策略、代理协作以及整体工作流程。
属性 | 描述 |
---|---|
任务 | 分配给团队的任务列表。 |
代理 | 属于团队的代理列表。 |
流程 (可选) | 团队遵循的流程(例如,顺序、分层)。 |
详细程度 (可选) | 执行过程中日志记录的详细程度。 |
经理 LLM (可选) | 分层流程中经理代理使用的语言模型。在使用分层流程时必需。 |
功能调用 LLM (可选) | 如果传递,团队将使用此 LLM 为所有代理进行工具的功能调用。每个代理可以拥有自己的 LLM,这将覆盖团队的功能调用 LLM。 |
配置 (可选) | 团队的可选配置设置,以 Json 或 Dict[str, Any] 格式。 |
最大 RPM (可选) | 团队在执行过程中遵循的每分钟最大请求数。 |
语言 (可选) | 团队使用的语言,默认为英语。 |
语言文件 (可选) | 用于团队的语言文件路径。 |
内存 (可选) | 用于存储执行记忆(短期、长期、实体记忆)。 |
缓存 (可选) | 指定是否使用缓存来存储工具执行的结果。 |
嵌入器 (可选) | 用于团队使用的嵌入器配置。目前主要由内存使用。 |
完整输出 (可选) | 团队是否应返回包含所有任务输出的完整输出,或仅返回最终输出。 |
步骤回调 (可选) | 在每个代理的每个步骤之后调用的函数。可用于记录代理的操作或执行其他操作;不会覆盖特定于代理的 step_callback 。 |
任务回调 (可选) | 在每个任务完成后调用的函数。用于监控或任务执行后的其他操作。 |
共享团队 (可选) | 是否要与 crewAI 团队共享完整的团队信息和执行,以改进库,并允许我们训练模型。 |
输出日志文件 (可选) | 是否要有一个包含完整团队输出和执行的文件。您可以将其设置为 True,默认为当前文件夹,并将其命名为 logs.txt,或传递一个带有完整路径和文件名的字符串。 |
"团队最大 RPM":max_rpm
属性设置团队每分钟可执行的最大请求数,以避免速率限制,并将覆盖个别代理的 max_rpm
设置。
在组建团队时,您将具有互补角色和工具的代理结合在一起,分配任务,并选择一个流程,该流程规定了它们的执行顺序和互动。
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,
)
团队可以利用内存(短期、长期和实体内存)来增强它们的执行能力,并随着时间的推移进行学习。此功能允许团队存储和回忆执行记忆,有助于决策和任务执行策略。
可以使用缓存来存储工具执行的结果,通过减少重新执行相同任务的需求,使流程更加高效。
在团队执行后,您可以访问 usage_metrics
属性,查看团队执行的所有任务的语言模型(LLM)使用指标。这提供了关于运营效率和改进领域的见解。
# 访问团队的使用指标
crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
crew.kickoff()
print(crew.usage_metrics)
manager_llm
,对于验证流程流程至关重要。一旦您的团队组建完成,使用 kickoff()
方法启动工作流程。这将根据定义的流程流程开始执行过程。
# 启动团队的任务执行
result = my_crew.kickoff()
print(result)
"增强代理智能":crewAI框架引入了一个复杂的记忆系统,旨在显著增强AI代理的能力。该系统包括短期记忆、长期记忆、实体记忆和新识别的上下文记忆,每种记忆都在帮助代理记住、推理和从过去的互动中学习方面发挥着独特作用。
组件 | 描述 |
---|---|
短期记忆 | 暂时存储最近的互动和结果,使代理能够回忆和利用与当前情境相关的信息。 |
长期记忆 | 保留从过去执行中获得的宝贵见解和学习,使代理能够随着时间建立和完善知识。 |
实体记忆 | 捕获和组织在任务中遇到的实体(人、地点、概念)的信息,促进对复杂信息的更深入理解和关系映射。 |
上下文记忆 | 保持互动的上下文,有助于代理在一系列任务或对话中的响应连贯性和相关性。 |
上下文意识: 借助短期记忆和上下文记忆,代理能够在对话或任务序列中保持上下文,从而产生更连贯和相关的回应。
经验积累: 长期记忆使代理能够积累经验,从过去的行动中学习,以改进未来的决策和问题解决能力。
实体理解: 通过保持实体记忆,代理可以识别和记住关键实体,增强其处理和交互复杂信息的能力。
在配置团队时,您可以启用和定制每个记忆组件,以适应团队的目标和将执行的任务的性质。
默认情况下,记忆系统处于禁用状态,您可以通过在团队配置中设置 memory=True
来确保其处于活动状态。
记忆将默认使用OpenAI Embeddings,但您可以通过将 embedder
设置为不同的模型来进行更改。
from crewai import Crew, Agent, Task, Process
# 使用具有记忆功能的团队
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True
)
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'
}
}
)
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"
}
}
)
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"
}
}
)
from crewai import Crew, Agent, Task, Process
my_crew = Crew(
agents=[...],
tasks=[...],
process=Process.sequential,
memory=True,
verbose=True,
embedder={
"provider": "gpt4all"
}
)
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'
}
}
)
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
}
}
)
将crewAI的记忆系统集成到您的项目中非常简单。通过利用提供的记忆组件和配置,您可以快速赋予您的代理记忆、推理和从互动中学习的能力,从而开启新的智能和能力水平。
欢迎使用 crewAI!本指南将带领您完成 crewAI 及其依赖项的安装过程。crewAI 是一个灵活而强大的人工智能框架,可以帮助您高效地创建和管理 AI 代理、工具和任务。让我们开始吧!
要安装 crewAI,您需要在系统上安装 Python 版本 >=3.10 且 <=3.13:
# 安装主要的 crewAI 包
pip install crewai
# 安装主要的 crewAI 包和工具包
# 包括一系列有用的工具,供您的代理使用
pip install 'crewai[tools]'
本指南详细介绍了如何为 crewAI 框架创建自定义工具以及如何高效管理和利用这些工具,包括最新功能,如工具委派、错误处理和动态工具调用。它还强调了协作工具的重要性,使代理能够执行各种操作。
在创建自己的工具之前,请确保已安装 crewAI 额外工具包:
pip install 'crewai[tools]'
BaseTool
要创建个性化工具,请继承自 BaseTool
并定义必要的属性和 _run
方法。
from crewai_tools import BaseTool
class MyCustomTool(BaseTool):
name: str = "我的工具名称"
description: str = "这个工具的作用。对于有效利用至关重要。"
def _run(self, argument: str) -> str:
# 在这里编写工具的逻辑
return "工具的结果"
tool
装饰器或者,使用 tool
装饰器以直接方式创建工具。这需要在函数内指定属性和工具的逻辑。
from crewai_tools import tool
@tool("工具名称")
def my_simple_tool(question: str) -> str:
"""用于澄清的工具描述。"""
# 在这里编写工具的逻辑
return "工具输出"
为了通过缓存优化工具性能,可以使用 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 代理的效率。
CrewAI 提供了一个灵活的框架,以结构化方式执行任务,支持顺序和分层流程。本指南概述了如何有效实施这些流程,以确保任务执行高效并完成项目。顺序流程确保任务按顺序一个接一个地执行,遵循线性进展。这种方法非常适合需要按特定顺序完成任务的项目。
召集你的团队,并按照需要执行的顺序定义任务。
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
)
CrewAI 中的顺序和分层流程为任务执行提供了清晰、适应性强的路径。它们非常适合需要逻辑进展和动态决策的项目,确保每一步都有效完成,从而促进一个连贯的最终产品。
CrewAI 中的分层流程引入了一种结构化的任务管理方法,模拟传统组织层级结构,实现任务委派和执行的高效性。这种系统化的工作流通过确保任务以最佳效率和准确性处理,增强了项目结果。
"复杂性和效率":分层流程旨在利用像 GPT-4 这样的先进模型,优化令牌使用,同时处理复杂任务,提高效率。
在 CrewAI 中,默认情况下,任务通过顺序流程管理。然而,采用分层方法可以实现任务管理中的清晰层次结构,其中一个“经理”代理协调工作流程,委派任务,并验证结果,以实现流畅和有效的执行。这个经理代理是由 CrewAI 自动创建的,因此您无需担心。
要利用分层流程,必须将流程属性明确设置为 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, # 启用内存使用以增强任务执行
)
在 CrewAI 中采用分层流程,正确配置并了解系统的能力,有助于实现项目管理的有序和高效方法。
"默认 LLM":默认情况下,CrewAI 使用 OpenAI 的 GPT-4 模型进行语言处理。您可以配置您的代理以使用不同的模型或 API。本指南展示了如何通过环境变量和直接实例化将您的代理连接到各种 LLMs。
CrewAI 提供了连接到各种 LLMs 的灵活性,包括通过 Ollama 连接到本地模型以及与 Azure 等不同 API 集成。它与所有 LangChain LLM 组件兼容,为定制的 AI 解决方案提供了多样化的集成。
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
)
Ollama 是首选的本地 LLM 集成方式,提供定制和隐私优势。要将 Ollama 与 CrewAI 集成,设置如下适当的环境变量。注意:详细的 Ollama 设置超出了本文档的范围,但提供了一般指导。
OPENAI_API_BASE='http://localhost:11434/v1'
OPENAI_MODEL_NAME='openhermes' # 根据可用模型进行调整
OPENAI_API_KEY=''
您可以使用 HuggingFace 托管您的 LLM 的几种不同方式。
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
)
from langchain_community.llms import HuggingFaceHub
llm = HuggingFaceHub(
repo_id="HuggingFaceH4/zephyr-7b-beta",
huggingfacehub_api_token="<HF_TOKEN_HERE>",
task="text-generation",
)
通过环境变量无缝切换 API 和模型,支持 FastChat、LM Studio 和 Mistral AI 等平台。
OPENAI_API_BASE="http://localhost:8001/v1"
OPENAI_MODEL_NAME='oh-2.5m7b-q51'
OPENAI_API_KEY=NA
启动 LM Studio 并转到 Server 选项卡。然后从下拉菜单中选择一个模型,等待加载。加载完成后,点击绿色的 Start Server 按钮,并使用显示的 URL、端口和 API 密钥(您可以修改它们)。以下是截至 LM Studio 0.2.19 的默认设置示例:
OPENAI_API_BASE="http://localhost:1234/v1"
OPENAI_API_KEY="lm-studio"
OPENAI_API_KEY=your-mistral-api-key
OPENAI_API_BASE=https://api.mistral.ai/v1
OPENAI_MODEL_NAME="mistral-small"
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
OPENAI_API_BASE=http://localhost:5000/v1
OPENAI_MODEL_NAME=NA
OPENAI_API_KEY=NA
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 OpenAI API 集成,请设置以下环境变量:
AZURE_OPENAI_VERSION="2022-12-01"
AZURE_OPENAI_DEPLOYMENT=""
AZURE_OPENAI_ENDPOINT=""
AZURE_OPENAI_KEY=""
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
)
将 CrewAI 与不同的 LLMs 集成扩展了框架的多样性,允许在各种领域和平台上定制高效的 AI 解决方案。
打造高效的 CrewAI 团队的关键在于能够动态地调整 AI 代理,以满足任何项目的独特需求。本节将介绍您可以定制的基础属性。
除了基本属性外,CrewAI 还允许进行更深入的定制,以显著增强代理的行为和能力。
代理可以使用特定的语言模型(llm
)和函数调用语言模型(function_calling_llm
)进行定制,提供对其处理和决策能力的高级控制。值得注意的是,设置 function_calling_llm
允许覆盖默认的团队函数调用语言模型,提供更高程度的定制。
调整代理的性能并监控其操作对于高效执行任务至关重要。
max_rpm
)。此属性是可选的,可以设置为 None
以取消限制,如果需要的话,允许对外部服务进行无限查询。max_iter
属性允许用户定义代理为单个任务执行的最大迭代次数,防止无限循环或执行时间过长。默认值设置为 15,在彻底性和效率之间提供平衡。一旦代理接近这个数字,它将尽力给出一个好答案。
通过在初始化期间定义其属性和工具来定制代理。工具对代理的功能至关重要,使其能够执行专业任务。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
)
控制代理委托任务或提问的能力对于定制其自主权和在 CrewAI 框架内的协作动态至关重要。默认情况下,allow_delegation
属性设置为 True
,允许代理根据需要寻求帮助或委托任务。这种默认行为促进了 CrewAI 生态系统内的协作解决问题和效率。如果需要,可以禁用委托以适应特定的操作需求。
agent = Agent(
role='内容撰稿人',
goal='撰写有关市场趋势的引人入胜内容',
backstory='一位在市场分析方面拥有专业知识的资深撰稿人。',
allow_delegation=False # 禁用委托
)
通过设置代理的角色、目标、背景故事和工具,以及高级选项如语言模型定制、记忆、性能设置和委托偏好,定制 CrewAI 中的代理,为复杂挑战做好准备,使其成为一个细致而有能力的 AI 团队。
在几种代理执行场景中,人类输入至关重要,允许代理在必要时请求额外信息或澄清。这一功能在复杂决策过程中特别有用,或者当代理需要更多细节以有效完成任务时。
要将人类输入整合到代理执行中,在任务定义中设置 human_input
标志。启用后,代理会在提供最终答案之前提示用户输入。这种输入可以提供额外的上下文,澄清模糊之处,或验证代理的输出。
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)
可观察性是开发和部署会话式人工智能智能体的关键方面。它使开发人员能够了解他们的智能体的性能如何,他们的智能体如何与用户交互,以及他们的智能体如何使用外部工具和API。AgentOps是一个与CrewAI无关的产品,为智能体提供了全面的可观察性解决方案。
AgentOps 提供了智能体的会话重放、指标和监控。
在高层次上,AgentOps使您能够监控成本、令牌使用情况、延迟、智能体故障、会话范围统计数据等。欲了解更多信息,请查看AgentOps Repo。
AgentOps为开发和生产中的智能体提供监控。它提供了用于跟踪智能体性能、会话重放和自定义报告的仪表板。
此外,AgentOps提供了会话详细信息,可实时查看Crew智能体交互、LLM调用以及工具使用情况。此功能对于调试和了解智能体如何与用户以及其他智能体交互非常有用。
创建API密钥:在此处创建用户API密钥:创建API密钥
配置您的环境:将您的API密钥添加到您的环境变量中
AGENTOPS_API_KEY=<YOUR_AGENTOPS_API_KEY>
pip install crewai[agentops]
或
pip install agentops
在脚本中使用Crew
之前,包含以下行:
import agentops
agentops.init()
这将启动一个AgentOps会话,并自动跟踪Crew智能体。欲了解更多关于如何为更复杂的智能系统配备装备的信息,请查看AgentOps文档或加入Discord。
要开始使用,请创建一个AgentOps账户。
如有功能请求或错误报告,请联系AgentOps团队,访问AgentOps Repo。
要使用文本搜索工具,您首先需要安装 crewai_tools 软件包。这可以通过 pip(Python 的软件包管理器)来完成。打开您的终端或命令提示符,输入以下命令:
pip install 'crewai[tools]'
这个命令将下载并安装文本搜索工具以及任何必要的依赖项。
该工具用于在文本文件的内容中执行 RAG(检索增强生成)搜索。它允许在指定文本文件的内容中进行语义搜索,根据提供的查询快速提取信息或查找特定文本部分,是一个非常有价值的资源。
以下示例演示了如何使用文本搜索工具在文本文件中进行搜索。该示例展示了如何初始化工具并在文件内容中进行搜索。
from crewai_tools import TXTSearchTool
# 初始化工具以在执行期间学习到的任何文本文件内容中进行搜索
tool = TXTSearchTool()
# 或者
# 使用特定文本文件初始化工具,以便代理程序可以在给定文本文件的内容中进行搜索
tool = TXTSearchTool(txt='path/to/text/file.txt')
txt
(str): 可选。要搜索的文本文件的路径。只有在工具未使用特定文本文件进行初始化时才需要此参数;否则,搜索将在最初提供的文本文件中进行。默认情况下,该工具使用 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",
),
),
)
)
PDFSearchTool 是一款专为在 PDF 内容中进行语义搜索而设计的 RAG 工具。它允许输入搜索查询和 PDF 文档,利用先进的搜索技术高效地找到相关内容。这种能力使其特别适用于快速从大型 PDF 文件中提取特定信息。
以下是如何使用 PDFSearchTool 在 PDF 文档中进行搜索:
from crewai_tools import PDFSearchTool
# 初始化工具,允许在执行期间提供路径时进行任何 PDF 内容搜索
tool = PDFSearchTool()
# 或者
# 使用特定的 PDF 路径初始化工具,以在该文档中进行独占搜索
tool = PDFSearchTool(pdf='path/to/your/document.pdf')
pdf
: 可选 用于搜索的 PDF 路径。可以在初始化时提供,也可以在 run
方法的参数中提供。如果在初始化时提供,工具将限制其搜索范围为指定文档。默认情况下,该工具同时使用 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",
),
),
)
)
DOCXSearchTool 是一款专为在 DOCX 文档中进行语义搜索而设计的 RAG 工具。它使用户能够通过基于查询的搜索有效地搜索和提取 DOCX 文件中的相关信息。该工具对于数据分析、信息管理和研究任务至关重要,简化了在大型文档集合中查找特定信息的过程。
以下示例演示了如何初始化 DOCXSearchTool 来搜索任何 DOCX 文件的内容或特定 DOCX 文件路径中的内容。
from crewai_tools import DOCXSearchTool
# 初始化工具以搜索任何 DOCX 文件的内容
tool = DOCXSearchTool()
# 或者
# 使用特定的 DOCX 文件初始化工具,这样代理就只能搜索指定 DOCX 文件的内容
tool = DOCXSearchTool(docx='path/to/your/document.docx')
docx
: 要搜索的特定 DOCX 文档的可选文件路径。如果在初始化期间未提供,该工具允许稍后指定任何 DOCX 文件的内容路径进行搜索。默认情况下,该工具在嵌入和摘要方面使用 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",
),
),
)
)
DirectoryReadTool 是一个强大的实用工具,旨在提供目录内容的全面列表。它可以递归地浏览指定目录,为用户提供所有文件的详细枚举,包括子目录中的文件。这个工具对需要对目录结构进行彻底清点的任务或验证目录中文件组织的任务至关重要。
使用 DirectoryReadTool 很简单。以下代码片段演示了如何设置并使用该工具来列出指定目录的内容:
from crewai_tools import DirectoryReadTool
# 初始化工具,以便代理程序在执行过程中了解任何目录的内容
tool = DirectoryReadTool()
# 或者
# 使用特定目录初始化工具,以便代理程序仅能读取指定目录的内容
tool = DirectoryReadTool(directory='/path/to/your/directory')
DirectoryReadTool 需要进行最少配置以供使用。该工具的基本参数如下:
directory
:可选。指定要列出其内容的目录路径的参数。它接受绝对路径和相对路径,指导工具到达所需目录以进行内容列表。`目录搜索工具可以在指定目录的内容中进行语义搜索,利用检索增强生成(RAG)方法来实现对文件的高效导航。设计灵活,允许用户在运行时动态指定搜索目录,或在初始设置期间设置固定目录。
从 crewai_tools
包中导入 DirectorySearchTool 来开始。您可以在不指定目录的情况下初始化工具,从而可以在运行时设置搜索目录。另外,也可以使用预定义目录初始化工具。
from crewai_tools import DirectorySearchTool
# 对于在运行时动态指定目录
tool = DirectorySearchTool()
# 对于固定目录搜索
tool = DirectorySearchTool(directory='/path/to/directory')
directory
: 一个字符串参数,用于指定搜索目录。在初始化时是可选的,但如果最初未设置,则在搜索时是必需的。目录搜索工具默认使用 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",
),
),
)
)
该工具用于在 CSV 文件内容中执行 RAG(检索增强生成)搜索。它允许用户在指定 CSV 文件的内容中语义搜索查询。这个功能特别适用于从大型 CSV 数据集中提取信息,传统搜索方法可能效率低下的情况。所有名称中带有“Search”的工具,包括 CSVSearchTool,在设计上都是用于搜索不同数据源的 RAG 工具。
from crewai_tools import CSVSearchTool
# 使用特定的 CSV 文件初始化工具。这样设置允许代理只搜索给定的 CSV 文件。
tool = CSVSearchTool(csv='path/to/your/csvfile.csv')
# 或者
# 在没有特定 CSV 文件的情况下初始化工具。代理将需要在运行时提供 CSV 路径。
tool = CSVSearchTool()
csv
:要搜索的 CSV 文件的路径。如果工具在没有特定 CSV 文件的情况下初始化,则这是一个必需的参数;否则,它是可选的。默认情况下,该工具同时使用 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",
),
),
)
)
文件读取工具在 crewai_tools 软件包中概念上代表了一套旨在促进文件读取和内容检索的功能。该套件包括用于处理批量文本文件、读取运行时配置文件以及导入分析数据的工具。它支持多种基于文本的文件格式,如 .txt
、.csv
、.json
等。根据文件类型,该套件提供了专门的功能,例如将 JSON 内容转换为 Python 字典以便于使用。
要开始使用文件读取工具:
from crewai_tools import FileReadTool
# 初始化工具以读取代理已知的任何文件或学习指定文件的路径
file_read_tool = FileReadTool()
# 或者
# 使用特定文件路径初始化工具,这样代理只能读取指定文件的内容
file_read_tool = FileReadTool(file_path='path/to/your/file.txt')
file_path
: 您要读取的文件路径。它接受绝对路径和相对路径。确保文件存在并且您具有访问权限。MDXSearchTool 是 crewai_tools
软件包的一个组件,旨在促进高级市场数据提取。对于寻求快速获取市场见解的研究人员和分析师来说,这个工具非常宝贵,尤其是在人工智能领域。它通过与各种数据源进行接口,简化了获取、解释和组织市场数据的任务。
要使用 MDXSearchTool,您必须首先设置必要的环境变量。然后,将该工具集成到您的 crewAI 项目中,开始您的市场研究。以下是如何执行此操作的基本示例:
from crewai_tools import MDXSearchTool
# 初始化工具以搜索执行过程中了解到的任何 MDX 内容
tool = MDXSearchTool()
# 或者
# 使用特定的 MDX 文件路径初始化工具,以在该文档中进行独占搜索
tool = MDXSearchTool(mdx='path/to/your/document.mdx')
该工具默认使用 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",
),
),
)
)
这是一个旨在提取和阅读指定网站内容的工具。它能够通过发出 HTTP 请求并解析接收到的 HTML 内容来处理各种类型的网页。该工具特别适用于网络抓取任务、数据收集或从网站中提取特定信息。
from crewai_tools import ScrapeWebsiteTool
# 若要在执行期间启用对任何找到的网站进行抓取
tool = ScrapeWebsiteTool()
# 使用网站 URL 初始化工具,以便代理只能抓取指定网站的内容
tool = ScrapeWebsiteTool(website_url='https://www.example.com')
# 从网站提取文本
text = tool.run()
print(text)
website_url
:必填的网站 URL 以读取文件。这是工具的主要输入,指定应抓取和阅读哪个网站的内容。网站搜索工具旨在作为在网站内容中进行语义搜索的概念设计。它旨在利用像检索增强生成(RAG)这样的先进机器学习模型,以高效地浏览和提取指定 URL 中的信息。该工具旨在提供灵活性,允许用户在任何网站上执行搜索或专注于感兴趣的特定网站。请注意,网站搜索工具的当前实现细节正在开发中,所述功能可能尚不可访问。
以下是网站搜索工具在不同场景下的使用示例。请注意,这些示例是说明性的,代表了计划功能:
from crewai_tools import WebsiteSearchTool
# 初始化工具,代理可以使用它在任何发现的网站上进行搜索
tool = WebsiteSearchTool()
# 限制搜索范围为特定网站的内容,现在代理只能在该网站内进行搜索
tool = WebsiteSearchTool(website='https://example.com')
website
:一个可选参数,用于指定用于重点搜索的网站 URL。此参数旨在通过在必要时允许定向搜索来增强工具的灵活性。默认情况下,该工具在嵌入和摘要生成方面使用 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",
),
),
)
)
SeleniumScrapingTool 专为高效的网络抓取任务而设计。它通过使用 CSS 选择器来精确提取网页内容,满足各种抓取需求,灵活处理任何提供的网站 URL。
以下是 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)
以下参数可用于自定义 SeleniumScrapingTool 的抓取过程:
website_url
:必填。指定要从中抓取内容的网站 URL。css_element
:必填。要在网站上定位的特定元素的 CSS 选择器。这使得可以集中抓取网页的特定部分。cookie
:可选。包含 cookie 信息的字典。用于模拟已登录会话,从而提供对可能仅限于未登录用户的内容的访问。wait_time
:可选。指定在抓取内容之前的延迟时间(以秒为单位)。此延迟确保网站和任何动态内容完全加载,以确保成功抓取。PGSearchTool 被设想为一个强大的工具,用于在 PostgreSQL 数据库表中进行语义搜索。通过利用先进的检索和生成(RAG)技术,它旨在提供一种有效的方式来查询数据库表内容,专门为 PostgreSQL 数据库定制。该工具的目标是通过语义搜索查询简化查找相关数据的过程,为需要在 PostgreSQL 环境中对大型数据集进行高级查询的用户提供宝贵资源。
以下是一个示例,展示如何使用 PGSearchTool 在 PostgreSQL 数据库中的表上进行语义搜索:
from crewai_tools import PGSearchTool
# 使用数据库 URI 和目标表名初始化工具
tool = PGSearchTool(db_uri='postgresql://user:password@localhost:5432/mydatabase', table_name='employees')
PGSearchTool 设计为需要以下参数才能运行:
db_uri
:表示要查询的 PostgreSQL 数据库的 URI 的字符串。此参数将是必需的,必须包括必要的身份验证详细信息和数据库的位置。table_name
:指定将在其中执行语义搜索的数据库中表的名称的字符串。此参数也将是必需的。该工具打算默认使用 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",
),
),
)
)
53AI,企业落地应用大模型首选服务商
产品:大模型应用平台+智能体定制开发+落地咨询服务
承诺:先做场景POC验证,看到效果再签署服务协议。零风险落地应用大模型,已交付160+中大型企业
2024-08-18
当产品经理谈到用LLM Agent构建新一代智能体的时候,他们在说什么?
2024-08-15
对话AI教育从业者们:AI如何解决因材施教的难题?
2024-08-03
工业应用中的向量数据库与知识向量化存储方案
2024-07-25
两大深度学习框架TensorFlow与PyTorch对比
2024-07-17
让生成式 AI 触手可及:NVIDIA NIM on VKE 部署实践
2024-07-16
中文大模型基准测评2024上半年报告
2024-07-16
一文看懂人工智能的起源、发展、三次浪潮与未来趋势
2024-07-14
"自拍" 秒变 "证件照" 看Coze如何实现
2024-05-14
2024-05-22
2024-04-26
2024-04-12
2024-08-13
2024-07-18
2024-05-10
2024-03-30
2024-04-25
2024-04-11
2024-09-08
2024-09-08
2024-09-07
2024-09-07
2024-09-07
2024-09-07
2024-09-07
2024-09-07