使用[DALL·E], 创建
开发和精炼AI代理的分步工作流程及处理错误的方法当我们思考人工智能的未来时，我们想象中的未来是，这些直观的日常助手能够无缝地融入我们的工作流程中，它们能够承担复杂的日常任务。我们都发现了一些减轻精神上繁琐工作的触点。然而，目前主要涉及的任务包括文本的创建、修订和头脑风暴，这凸显了RAG（检索增强生成）管道在当前发展中所扮演的重要角色。我们的目标是为大型语言模型提供更好的上下文信息，从而生成更有价值的内容。
一想到人工智能的未来，我就会想到《钢铁侠》里的贾维斯或《命运》这款游戏里的拉斯普京。在这两个例子中，人工智能都作为复杂系统的语音控制界面，提供高层次的抽象功能。例如，托尼·斯塔克用它来管理研究、做计算和运行模拟。即使是R2D2这样的机器人也能通过语音控制来与陌生的计算机系统交互，提取数据或控制建筑系统。
在这样的情况下，人工智能让用户可以与复杂的系统互动，而无需深入理解这些系统。这可以与当今大型企业中的ERP系统相类比。在大型企业中，很少有人能够完全了解和掌握内部ERP系统的每一个细节。可以预见，在不久的将来，人工智能可能会协助几乎所有的与ERP系统互动的操作。从最终用户管理客户数据或记录订单，到软件开发者修复错误或实现新功能，这些操作很快都可能由熟悉ERP系统方方面面的AI助手来完成。这样的AI助手会知道客户数据该输入哪个数据库，以及哪些流程和代码可能与错误相关。
为了实现这一点，我们面临着几个挑战和需要创新的地方。今天的ERP流程是为人类设计的，为不同用户设定特定角色和设计。这些流程具有针对不同用户的特定角色和设计，人类使用的输入掩码，以及设计为直观且无误的用户互动。而在AI互动中，这些方面的设计会有所不同。我们需要为与AI互动设定特定的角色，并设计不同的流程，以实现直观且无误的AI互动流程。这一点在我们使用提示的过程中已经显而易见。我们往往发现，我们所认为的清晰任务其实并不像想象中那么简单直接。
让我们看看如何从概念到实际地建立AI代理的基础不过，让我们先回过头来看看代理的概念。即能利用所提供工具完成任务并决定如何使用这些工具的人工智能助手，是构建这样系统的基础。它们是我们希望嵌入到复杂系统每个环节中的组件。但是正如之前一篇文章中提到的，可靠地部署这些代理是一项挑战。在这篇文章中，我将展示如何设计并优化一个能可靠地与数据库交互的代理。
虽然AI未来的宏大愿景令人振奋，但实现这一愿景需要采取实际步骤。为了展示我们如何开始构建这样先进的AI系统的基础，让我们专注于为一个常见任务创建一个原型代理，比如费用追踪。这个原型将作为一个具体例子，展示AI如何帮助高效管理金融交易，同时展示AI在自动化常规任务方面的潜力，并突出设计一个能够与数据库无缝交互的AI系统所面临的挑战和需要考虑的因素。通过从一个具体且相关的用例开始，我们可以获得宝贵的见解，这些见解将指导未来更复杂AI代理的开发。
本篇文章的目的这篇文章将为一系列的文章奠定基础，这些文章旨在开发一个聊天机器人，它可以作为一个小企业的单一交互入口，支持和处理业务流程，或者在你的日常生活中，帮助你管理所有需要跟踪的事情。从数据、事项、文件到图片，我们希望只需和我们的助理聊天交流，让它来帮你存储和检索数据，让它来帮你确定如何存储和检索你的数据。
从对AI未来的大胆想象转向实际应用，让我们聚焦于创建一个原型。这个原型是我们之前讨论的雄心目标的基础步骤。我们将开始开发一个“费用跟踪”的工具，这是一项虽简单却至关重要的任务，这展示了AI如何帮助我们高效管理财务。
这个“费用追踪”的原型不仅将展示人工智能在自动化常规任务上的潜力，还将揭示设计一个能够与数据库无缝对接的AI系统所涉及的挑战和考量。通过这个例子，我们可以探讨代理设计、输入验证，以及AI与现有系统集成的过程——为未来更复杂的应用奠定坚实的基础。
1. 动手实践：测试 OpenAI 工具调用为了使我们的原型代理变得活跃并识别潜在瓶颈，我们正着手测试OpenAI的工具调用功能特性。从一个简单的费用跟踪基本示例开始，我们从一个基础组件开始，它模仿了一个现实世界的应用程序。这个阶段涉及创建一个基础模型，并使用langchain库的convert_to_openai_tool函数将其转换为OpenAI工具模式。此外，创建一个报告工具可以让我们的未来代理能够传达结果或指出缺失的信息和问题。
from pydantic.v1 import BaseModel, validator
from datetime import datetime
from langchain_core.utils.function_calling import convert_to_openai_tool
# 费用类
class Expense(BaseModel):
description: str # 描述
net_amount: float # 净金额
gross_amount: float # 毛金额
tax_rate: float # 税率
date: datetime # 日期
# 报告类
class Report(BaseModel):
report: str # 报告内容
# 将费用类转换为OpenAI工具
add_expense_tool = convert_to_openai_tool(Expense)
# 将报告类转换为OpenAI工具
report_tool = convert_to_openai_tool(Report)在搭建好数据模型和工具之后，下一步是使用OpenAI客户端SDK发起一次简单的工具调用。在这一初始测试中，我们故意给模型提供不完整的信息，看看它是否能正确指出缺失的信息。这种方法不仅检验了代理的功能能力，还检验了它的交互性和错误处理能力。
调用OpenAI API现在，我们将使用OpenAI客户端SDK来发起一次简单的工具调用。在第一次测试中，我们故意给模型提供不完整的信息，看看它是否会提醒我们缺少的信息。
from openai import OpenAI
from langchain_core.utils.function_calling import convert_to_openai_tool
系统消息 = """你被赋予了完成特定任务的职责，并需要报告任务的结果。你拥有多种工具，每种工具都有其特定的功能和用途。
为了成功完成任务：
思考：根据任务特性和工具功能选择最合适的工具。
使用报告工具并详细说明你的工作成果。
如果遇到问题无法完成任务：
使用报告工具报告遇到的挑战或任务无法完成的原因。
你将根据每个工具完成的任务结果或未能完成任务的原因收到反馈。这种反馈循环对于解决问题和策略性地部署工具至关重要。
"""
user_message = "我今天在咖啡上花费了5美元，请追踪我的开销。税率是20%。"
client = OpenAI()
model_name = "gpt-3.5-turbo-0125"
messages = [
{"role":"system", "content": 系统消息},
{"role":"user", "content": user_message}
]
response = client.chat.completions.create(
model=model_name,
messages=messages,
tools=[
convert_to_openai_tool(Expense),
convert_to_openai_tool(ReportTool)]
)然后，我们需要一个新函数从响应中提取函数调用的参数
def 解析函数参数(response):
消息 = response.choices[0].message
# 解析并返回消息中的函数参数
return json.loads(消息.tool_calls[0].function.arguments)
print(解析函数参数(response))
# 打印解析的函数参数 {'描述': '咖啡',
'净金额': 5,
'毛额': '无',
'税率': 0.2,
'日期': '2023年10月6日12:00:00Z'}正如我们所见，我们在执行中遇到了一些问题：
- 总金额尚未计算。
- 日期是假的。
那么有了这一点在心里，让我们试着解决这些问题并优化我们的代理操作流程吧。
2. 优化工具管理为了优化代理的工作方式，我发现优先考虑工作流程而非提示设计至关重要。虽然微调提示文本，使代理能够完美地使用提供的工具且不犯任何错误很有吸引力，但更明智的做法是首先调整工具和流程设置。遇到常见错误时，首先考虑的是如何用代码修复问题。
应对缺失的数据有效应对缺失信息是创建稳健可靠的代理的重要话题。在之前的例子中，为代理提供一个像“get_current_date”这样的工具只是特定场景下的临时解决办法。然而，我们必须假设在各种情境下都会出现缺失的信息，并且不能仅仅依赖提示工程和添加更多工具来避免模型生成虚假信息。
一个简单的解决办法是修改工具模式(schema)，将所有参数都设为可选。这样，代理只需提交它知道的参数，从而避免了不必要的错误。
所以，我们来看看openai这部分的schema.
add_expense_tool = convert_to_openai_tool(Expense)
# 打印添加开销工具
print(add_expense_tool) {"type": "function",
"function": {"name": "费用",
"description": "",
"parameters": {"type": "object",
"properties": {"说明": {"type": "string"},
"小计": {"type": "number"},
"总计": {"type": "number"},
"税率": {"type": "number"},
"时间": {"type": "string", "format": "date-time"}},
"required": ["说明",
"小计",
"总计",
"税率",
"时间"]}}
}正如我们所见，我们有一个特殊的键 required，需要将其删除。这里是如何调整 add_expense_tool 的架构，使参数变为可选，即删除 required 键的方法：
如下：
移除 `add_expense_tool["function"]["parameters"]["required"]` 这个部分。接下来，我们来设计一个 Tool 类，该类在初始时检查输入参数是否有缺失值。我们创建了 Tool 类，包含两个方法：.run() 和 .validate_input()，以及一个属性 openai_tool_schema，我们通过该属性删除工具结构中的必需参数。此外，我们定义了 ToolResult 基础模型，包含 content 和 success 字段，作为每个工具运行的输出对象。
from pydantic import BaseModel
from typing import Type, Callable, Dict, Any, List
class ToolResult(BaseModel):
content: str
success: bool
class Tool(BaseModel):
name: str
model: Type[BaseModel]
function: Callable
validate_missing: bool = False
class Config:
arbitrary_types_allowed = True
def run(self, **kwargs) -> ToolResult:
if self.validate_missing:
missing_values = self.validate_input(**kwargs)
if missing_values:
content = f"缺少以下值: {', '.join(missing_values)}"
return ToolResult(content=content, success=False)
result = self.function(**kwargs)
return ToolResult(content=str(result), success=True)
def validate_input(self, **kwargs) -> List[str]:
missing_values = []
for key in self.model.__fields__.keys():
if key not in kwargs:
missing_values.append(key)
return missing_values
@property
def openai_tool_schema(self) -> Dict[str, Any]:
schema = convert_to_openai_tool(self.model)
if "required" in schema["function"]["parameters"]:
del schema["function"]["parameters"]["required"]
return schemaTool 类是一个关键组件，是 AI 代理工作流程中的关键部分，作为创建和管理各种工具的蓝图，这些工具可以用于执行特定任务。它被设计用来处理输入验证，执行工具功能执行，并以标准格式返回结果。
Tool 类的主要组成部分：
name: 工具的名称。model: 定义工具输入模式的 Pydantic 基础模型 (BaseModel)。function: 工具执行的函数。validate_missing: 一个布尔标志，指示是否验证缺失的输入值，默认为False。
Tool 类的两个主要的方法：
**run(self, **kwargs) -> ToolResult**: 此方法负责执行工具的功能并使用提供的输入参数。它首先检查validate_missing是否设置为True。如果为True，则调用validate_input()方法来检查输入参数中是否有缺失值。如果发现任何缺失的值，它将返回一个带有错误消息且success设置为False的ToolResult对象。如果所有必需的输入值都存在，则继续使用提供的参数执行工具的function，并返回一个带有结果且success设置为True的ToolResult对象。**validate_input(self, **kwargs) -> List[str]**: 此方法将传递给工具的输入参数与在model中定义的预期输入模式进行比较。它会遍历model中定义的每个字段，并检查这些字段是否都在输入参数中存在。如果缺少任何字段，就会将这些字段的名称加入到缺失值列表中。最后，它返回缺失值列表。
Tool 类还包含一个名为 openai_tool_schema 的属性，该属性返回该工具的 OpenAI 工具模式的格式。它使用 convert_to_openai_tool() 函数将 model 转换为 OpenAI 工具模式的格式。此外，它还会从模式中移除 "required" 键，使所有输入参数变为可选参数。这使得代理程序可以仅提供可用的信息，而无需臆造缺失的值。
通过将工具的功能性、输入校验和模式创建封装起来，Tool 类提供了一个干净且可重用的接口，用于在 AI 代理的工作流程中创建和管理工具。它抽象了处理缺失值的复杂过程，并确保代理在执行合适的工具时可以优雅地处理不完整的输入。
接下来，我们将扩展我们的OpenAI API调用。希望客户端能用上我们的工具，并且响应对象可以直接触发工具运行。为此，我们需要在新创建的工具类中初始化这些工具。我们定义了两个返回成功消息的假函数。
def add_expense_func(**kwargs):
# 参数 kwargs 是 Python 中的关键字参数，通常保持英文或添加注释说明。
return f"已添加费用: {kwargs} 到数据库中。"
add_expense_tool = Tool(
name="add_expense_tool",
model=Expense,
function=add_expense_func
)
def report_func(report: str = None):
return f"已提交报告: {report}"
report_tool = Tool(
name="报告工具",
model=ReportTool,
function=report_func
)
tools = [add_expense_tool, report_tool]接下来我们定义辅助函数，每个函数都用来接受客户端的响应作为输入，并帮助与我们的工具互动。
def get_tool_from_response(response, tools=tools):
tool_name = response.choices[0].message.tool_calls[0].function.name
for t in tools:
if t.name == tool_name:
return t
raise ValueError(f"找不到名为 {tool_name} 的工具。")
def parse_function_args(response):
message = response.choices[0].message
return json.loads(message.tool_calls[0].function.arguments)
def run_tool_from_response(response, tools=tools):
tool = get_tool_from_response(response, tools)
tool_kwargs = parse_function_args(response)
return tool.run(**tool_kwargs) 我们现在可以用新的工具运行我们的客户端，并使用run_tool_from_response函数。
# 获取聊天完成结果并根据响应运行工具
response = client.chat.completions.create(
model=model_name,
messages=messages,
tools=[tool.openai_tool_schema for tool in tools]
)
# 获取响应结果
tool_result = run_tool_from_response(response, tools=tools)
# 打印工具结果
print(tool_result) 内容：缺失值：gross_amount和date 成功=False完美，我们现在可以看到这个工具提示有缺失值。感谢我们将所有参数都设为可选，我们现在避免了错传的参数。
- 构建代理流程
目前，我们还没有一个真正的代理流程。迄今为止，我们仅执行了一次API工具调用。为了将其转变为代理工作流，我们需要引入一个迭代流程，将工具执行的结果反馈给客户。基本流程可以是这样的:
作者供图
我们先新建一个OpenAIAgent类
class StepResult(BaseModel):
event: str
content: str
success: bool
class OpenAIAgent:
def __init__(
self,
tools: list[Tool],
client: OpenAI,
system_message: str = SYSTEM_MESSAGE,
model_name: str = "gpt-3.5-turbo-0125",
max_steps: int = 5,
verbose: bool = True
):
self.tools = tools
self.client = client
self.model_name = model_name
self.system_message = system_message
self.step_history = []
self.max_steps = max_steps
self.verbose = verbose
def to_console(self, tag: str, message: str, color: str = "green"):
# 将带有标签和消息的内容打印到控制台，可选指定颜色
if self.verbose:
# 如果启用了详细模式
color_prefix = Fore.__dict__[color.upper()]
# 打印带有指定颜色的消息，标签和消息之间用冒号分隔，颜色使用 Fore 模块中的相应属性
print(color_prefix + f"{tag}: {message}{Style.RESET_ALL}")和我们的 ToolResult 对象相似，我们定义了一个 StepResult 对象来表示每个代理步骤的结果。然后，我们定义了 OpenAIAgent 类的初始化方法 __init__ 和一个 to_console() 方法，用于将我们的中间步骤和工具调用打印到控制台，并使用 colorama 来实现彩色打印。接下来，我们定义了代理的核心部分，即关键的方法 run() 和 run_step()。
class OpenAIAgent:
# ... __init__...
# ... to_console ...
def run(self, user_input: str):
openai_tools = [tool.openai_tool_schema for tool in self.tools]
self.步骤记录 = [
{"role":"system", "content":self.system_message},
{"role":"user", "content":user_input}
]
step_result = None
i = 0
self.to_console("开始处理", f"启动代理，输入为{user_input}")
while i < self.max_steps:
step_result = self.run_step(self.步骤记录, openai_tools)
if step_result.event == "完成":
break
elif step_result.event == "错误":
self.to_console(step_result.event, step_result.content, "red")
else:
self.to_console(step_result.event, step_result.content, "yellow")
i += 1
self.to_console("最终输出", step_result.content, "green")
return "返回结果" + step_result.content在 run() 方法中，我们首先用预定义的系统消息和用户输入初始化 step_history，这将作为我们的消息历史。然后我们进入一个 while 循环，在每次迭代中，我们调用 run_step，它将返回一个 StepResult 对象。我们检查代理是否完成了任务或是否发生了错误，并将这些信息传递到控制台。
class OpenAIAgent:
# ... __init__...
# ... to_console ...
# ... run ...
def run_step(self, messages: list[dict], tools):
# 规划下一步
response = self.client.chat.completions.create(
model=self.model_name,
messages=messages,
tools=tools
)
# 将消息加入历史
self.step_history.append(response.choices[0].message)
# 检查是否包含工具调用
if not response.choices[0].message.tool_calls:
return StepResult(
event="Error",
content="未检测到任何工具调用。",
success=False
)
tool_name = response.choices[0].message.tool_calls[0].function.name
tool_kwargs = parse_function_args(response)
# 执行调用工具
self.to_console(
"工具调用", f"名称：{tool_name}\n参数为：{tool_kwargs}", "magenta"
)
tool_result = run_tool_from_response(response, tools=self.tools)
tool_result_msg = self.tool_call_message(response, tool_result)
self.step_history.append(tool_result_msg)
if tool_result.success:
step_result = StepResult(
event="tool_result",
content=tool_result.content,
success=True)
else:
step_result = StepResult(
event="error",
content=tool_result.content,
success=False
)
return step_result
def tool_call_message(self, response, tool_result: ToolResult):
tool_call = response.choices[0].message.tool_calls[0]
return {
"tool_call_id": tool_call.id,
"role": "工具",
"name": tool_call.function.name,
"content": tool_result.content,
}我们现在定义了每一步的逻辑。我们首先通过之前测试过的客户端API调用获取一个响应对象，并将其添加到我们的step_history中。然后，我们验证响应对象中是否包含工具调用，如果没有，则在StepResult中返回一个错误。接着，我们在控制台记录工具调用，并使用之前定义的方法run_tool_from_response()运行选定的工具。我们还需要将工具结果添加到消息历史中，以便跟踪。OpenAI为此定义了一个特定的格式，以便模型知道哪个工具调用对应哪个输出，通过将tool_call_id传递到我们的消息字典中实现。这是通过我们的方法tool_call_message()完成的，该方法接收响应对象和工具结果作为输入参数。在每一步的最后，我们将工具结果分配给StepResult对象，这不仅指示步骤是否成功，还将其返回给run()中的循环。
第四部分: 运行代理程序
现在我们可以用之前的例子来测试我们的代理，直接给它配上一个get_current_date_tool。我们可以将之前定义的validate_missing属性设为False，因为这个工具不需要任何输入参数，所以不用设置validate_missing属性。
class DateTool(BaseModel):
x: str = None
get_date_tool = 工具(
name="获取当前日期",
model=DateTool,
function=lambda: datetime.now().strftime("%Y-%m-%d"),
validate_missing=False
)
tools = [
add_expense_tool,
report_tool,
get_date_tool
]
agent = OpenAIAgent(tools, client)
agent.run("我花5美元买了一杯咖啡，请帮我记录这笔开销。税率是20%。") 开始：启动代理，输入：
"我今天在咖啡上花了5美元，请跟踪我的开销。税率是20%。"
工具调用：get_current_date
参数：{}
工具结果：2024-03-15
工具调用：add_expense_tool
参数：{'description': '咖啡开销', 'net_amount': 5, 'tax_rate': 0.2, 'date': '2024-03-15'}
错误：缺少值：gross_amount（总金额）
工具调用：add_expense_tool
参数：{'description': '咖啡开销', 'net_amount': 5, 'tax_rate': 0.2, 'date': '2024-03-15', 'gross_amount': 6}
工具结果：将开销（描述：咖啡开销，净金额：5美元，税率：20%，日期：2024-03-15，总金额：6美元）添加到数据库。
错误：没有返回任何工具调用。
工具调用：名称：report_tool
参数：{'report': '咖啡购买开销已成功追踪。'}
工具结果：报告：咖啡购买开销已成功追踪。
最终结果：报告：咖啡购买开销已成功追踪。成功执行我们的原型代理后，值得一提的是，代理如何有效地按照计划使用指定的工具。最初，它调用了get_current_date_tool，为费用条目建立了基础的时间戳。随后，在尝试通过add_expense_tool记录费用时，我们的智能设计工具识别出缺少了关键的gross_amount信息——这对于准确的财务追踪来说至关重要。更令人印象深刻的是，代理自主解决了这个问题，通过利用提供的tax_rate计算出了gross_amount。
重要的是要提到，在我们的测试运行中，并没有明确指明支出的性质——即这5美元买咖啡是净还是毛。在当前阶段，这种具体性对代理完成任务并不是必需的。然而，这揭示了一个有价值的见解，有助于提高我们代理的理解和交互能力：将此类详细信息纳入我们初始系统提示，可以显著提高代理处理费用条目的准确性和效率。这一调整将使代理从一开始就对财务数据有更全面的理解。
关键要点如下- 迭代开发：该项目强调了迭代开发周期的重要性，通过不断的反馈促进持续改进。这种做法在AI领域中尤为重要，因为在该领域中变化是常态化的，需要一个灵活且快速响应的开发策略。
- 处理不确定性：我们的经历突显了优雅地管理歧义和错误的重要性。诸如可选参数和严格的输入验证等创新措施在提高代理的可靠性和用户体验方面发挥了关键作用。
- 为特定任务定制代理工作流程：这项工作的关键见解是，定制代理工作流程以适应特定使用案例至关重要。除了组装工具集之外，工具之间的交互和响应的战略设计也非常重要。这种定制确保代理能够有效地应对特定挑战，从而实现更加专注和高效的解决问题的方式。
我们已经踏上了一段旅程，探索人工智能代理及其在各个领域的应用世界，这仅仅是开始。随着我们持续突破人工智能的可能性边界，我们诚邀您加入这场激动人心的旅程。基于本文奠定的基础，并关注即将推出的新功能，您将亲眼见证人工智能代理如何改变企业和个人处理数据和自动化复杂任务的方式。
让我们共同拥抱人工智能的力量，释放其潜力，从而改变我们工作和与技术互动的方式。人工智能的未来光明，而我们正站在塑造它的最前沿，一个接一个可靠的代理。
展望未来随着我们在探索AI代理潜力的旅程中继续前进，接下来的文章将着重于扩展我们原型的功能，并将其与现实世界系统进行集成。在下一篇文章中，我们将深入探讨一个稳健的项目架构，让我们的代理能够与SQL数据库无缝对接。通过利用我们在本文中开发的代理，我们将展示AI如何高效地管理并操作存储在数据库中的数据，从而为数据相关任务的自动化打开新的大门。
在此基础上，系列的第三篇文章将介绍高级查询功能特性，使我们的代理能够处理更复杂的数据检索和操作任务。我们还将探讨路由代理的观念，它将作为枢纽来管理多个子代理，每个子代理负责特定数据库表的交互。这种层次结构将允许用户用自然语言提出请求，路由代理将解析这些请求并转交给相应的子代理去执行。
为了进一步提高我们的人工智能系统的实用性和安全性，我们将引入基于角色的访问控制。这将确保用户根据其角色获得相应的访问和修改数据的权限。通过这一功能的实施，我们可以展示如何在确保数据完整性和安全性的前提下，将AI代理应用于实际场景。
通过这些即将推出的改进，我们旨在展示AI代理在简化数据管理和为用户提供更直观、高效数据库互动方式方面的真实潜力。通过结合自然语言处理、数据库管理和基于角色的访问控制，我们将为开发能够彻底改变企业及个人数据处理方式的高级AI助手奠定基础。
请继续关注这些激动人心的发展，我们将在数据管理和更广阔的领域中继续突破AI助理的可能边界。
代码：此外，整个源代码可在GitHub上找到。您可以在https://github.com/elokus/AgentDemo查看它。
共同学习，写下你的评论
评论加载中...
作者其他优质文章
