深度解析多智能体系统的高级协同机制

多智能体系统的协同基础

多智能体系统的核心概念与协同定义

多智能体系统(Multi-agent System, MAS)是一个由多个独立的人工智能(AI)智能体组成的计算框架,其核心目标是让这些智能体通过协同工作来代表用户或系统执行复杂的任务 。系统中的每个智能体都拥有独立的属性,但它们会相互合作,以实现所需的全局属性或集体目标 。MAS的核心智能体通常以大型语言模型(LLM)为“大脑”,利用LLM先进的自然语言处理技术来理解用户输入并做出响应 。  

MAS的协同行为能够显著提升系统的准确性、适应性和可扩展性 。与传统的单智能体系统相比,MAS能够胜任涉及数百甚至数千个智能体的大规模、复杂任务 。通过创建一个更大的共享资源池以及优化和自动化功能,多智能体系统的性能往往优于单智能体系统 。智能体之间无需重复学习相同的策略,而是可以共享所获得的经验,从而优化时间复杂性和整体效率 。从技术角度看,多智能体协同被定义为分布式系统中多个独立智能体的协调行动,每个智能体拥有其局部知识和决策能力。这种合作通常包括一套用于任务分解、资源分配、冲突解决和协作规划的系统方法 。

单智能体与多智能体系统在协同中的本质区别

在理解多智能体协同的精髓时,区分它与单智能体系统的协作模式至关重要。在一个单智能体系统中,当一个智能体调用另一个智能体作为工具时,这个辅助智能体仅被视为原始智能体环境刺激的一部分 。原始智能体获取信息后,通常不会再发生进一步的合作。这是一种单向、工具性的调用关系,而非真正的协同。  

多智能体系统则完全不同。其本质在于,环境内的所有智能体都能够对彼此的目标、记忆和行动计划进行建模 。每个智能体都保持一定程度的自主性,这通常体现在其规划、工具调用和一般推理能力上 。然而,它们会在一个统一的结构中进行合作与协调。这种能力使得智能体能够进行子任务的创建、工具的使用,并通过交互进行学习 。这种能够建模和理解其他智能体“意图”和“记忆”的能力,使得多智能体协同从单纯的规则驱动或数学模型驱动,向更接近人类社会协作的“意图理解驱动”转变。  

这一转变的核心驱动力是大型语言模型(LLM)作为多智能体系统大脑的广泛应用 。LLM赋予了智能体强大的自然语言处理和高级推理能力,使其能够真正理解并模拟其他智能体的行为意图。因此,LLM的出现极大地降低了实现复杂多智能体协同的门槛,使得智能体能够进行更高级的交互,而不仅仅是简单的状态交换。MAS协同能力质变的关键技术正是LLM,它使得“意图理解”成为可能,从而催生了更加复杂和强大的协同模式。

多智能体协同的架构模式与策略

协同架构模式

多智能体系统可以在多种架构下运行,每种架构都代表了对系统控制、可扩展性、鲁棒性以及单点故障风险的权衡。理解这些架构模式对于设计高效、稳定的MAS至关重要。

中心化模式(Centralized Networks)

中心化网络依赖于一个中央单元(Orchestrator),该单元包含全局知识库,负责连接各个智能体并监督它们的信息 。这个中央协调单元的角色类似于项目经理或机场空管塔台 。中心化架构的优势在于智能体之间的通信简单直接,并且能够确保知识的统一性 。由于中央单元拥有全局视野,系统可以更容易地实现全局最优决策 。  

然而,中心化模式存在明显的劣势。其主要弱点是对中央单元的依赖性:如果中心单元发生故障,整个智能体系统就会瘫痪,形成单一故障点 。此外,随着智能体数量的增加,中央单元可能成为性能瓶颈,导致可扩展性差 。因此,该模式更适用于任务结构化程度高、需要严格控制和全局一致决策的场景。  

去中心化模式(Decentralized Networks)

去中心化网络中不存在单一的中央控制单元。智能体仅与其邻近的智能体共享信息,并根据本地信息自主做出决策 。这种点对点的模型具有高度的自组织性,系统的集体行为是基于个体间简单交互而形成的“涌现行为” 。例如,鸟类的群行行为就是去中心化控制下自组织和聚合的典型例子 。它们遵循简单的规则,如分离(避免与邻近鸟类碰撞)、对齐(匹配邻近鸟类的速度)和内聚(保持与其他鸟类的距离),从而实现同步飞行 。  

去中心化架构的主要优点是其稳健性和模块化 。由于没有中央单元,某个智能体的故障并不会导致整个系统的失败 。同时,其可扩展性极高,增加更多智能体对系统性能的影响微乎其微 。但其挑战在于,由于缺乏全局视野,协调智能体的行为以实现全局最优变得困难,达成共识或协调也更为复杂 。尽管如此,在大型电力网络和城市交通信号控制等大规模系统中,去中心化模式可以显著降低风险,提高系统的稳定性和安全性 。  

分层结构(Hierarchical Structure)

分层结构是一种树状架构,包含具有不同自主级别的智能体 。在这种模式下,一个智能体可以拥有决策权,并可以将责任分配给多个下级智能体。这种结构结合了中心化和去中心化的优点,在部分控制和自主性之间取得了平衡 。  

多智能体架构模式的选择并非单一的技术决策,而是对系统核心需求(如控制精度、鲁棒性、可扩展性)进行深思熟虑后的一系列权衡。中心化模式倾向于在牺牲可用性和分区容错性的前提下实现高一致性,而这在需要严格控制的场景中是可取的。相反,去中心化模式则通过牺牲全局最优来换取高可用性和鲁棒性,这在需要处理大规模、动态环境的系统中至关重要。因此,成功的MAS设计需要深刻理解这些权衡,并根据任务特性(如复杂程度、规模、环境动态性)来选择或混合架构,而非盲目地追求某种“先进”模式。

协同策略与机制

除了架构之外,智能体之间如何具体进行交互和协调也至关重要。这通常通过预先设定的策略和机制来实现。

基于角色的协同(Role-based Collaboration)

基于角色的协同策略中,智能体被赋予特定的角色或职责,这些角色与一个清晰的组织或通信框架相吻合 。每个角色都带有一套特定的功能、权限和目标,这些通常与系统整体目标的不同部分相关联。这种概念借鉴了人类团队协作的动态,例如团队中的“领导者”、“观察者”或“执行者” 。  

在一个基于角色的多智能体任务协同系统中,角色层被设计和实现,以在异构和动态变化的环境中动态分配任务,并提高集群系统的鲁棒性 。智能体可以根据分配的角色动态切换,以执行一个或多个子任务 。这种方法特别有利于任务分解、设计模块化系统,并使具有不同专长的智能体能够有效协作 。  

基于规则的协同(Rule-based Collaboration)

基于规则的协同中,智能体之间的交互由一套特定的规则或指导方针严格控制 。这些规则通常以“if-then”语句、状态机或基于逻辑的框架实现,它们以可预测的方式规定了智能体如何行动、通信和做出选择 。这种方法最适用于高度结构化或可预测的任务,其中保持一致性是关键 。它的优势在于能够提供出色的效率和公平性,但其适应性和可扩展性较差,难以应对快速变化或复杂的情况 。  

冲突解决与协商机制

在多智能体系统中,冲突是不可避免的,通常产生于智能体目标冲突、资源有限或对共享数据理解不同 。为了确保系统有效运行,MAS需要通过结构化的通信、决策协议和预定义规则来管理和解决冲突 。  

解决冲突的主要方法包括:

  • 协商(Negotiation): 智能体之间通过沟通提出建议和反建议,以达成双方可接受的结果 。例如,物流无人机可以协商航线以避免碰撞,或使用“Contract Net Protocol”协议通过投标方式动态分配任务 。这种协商对于与具有冲突目标的其他智能体合作时尤为重要 。  

  • 规则优先级(Rule-based Prioritization): 预定义的策略或规则决定如何解决冲突 。例如,在智能电网中,智能体可能遵循“优先使用可再生能源”的规则来分配电力需求 。  

  • 共识算法(Consensus Algorithms): 在去中心化系统中,智能体通过分布式算法(如Raft或Paxos)达成共享状态的一致性 。例如,区块链网络中的节点使用共识协议来验证交易。  

  • 博弈论(Game Theory): 在竞争模式下,智能体为争夺有限的资源或优势地位而行动,以获得最大的个体奖励 。多智能体协同控制问题可以被重新表述为微分博弈框架,每个智能体都试图优化自身目标函数,同时考虑其他智能体的行动 。

智能体之间的通信方式与协议

通信方式:直接与间接

多智能体之间的通信是实现协同的基础。这种通信可以分为两种基本方式:

  • 直接通信(Direct Communication): 智能体之间通过消息传递(message passing)进行显式通信 。它们使用预设的通信协议来交换状态信息、分配任务和协调行动 。例如,无人机在搜救任务中通过无线网络交换GPS坐标和传感器读数 。  

  • 间接通信(Indirect Communication): 智能体通过改变共享环境来间接交流 。例如,一个智能体在共享的数字白板上留下结果,另一个智能体通过感知这个环境变化来获取信息并做出响应。这种方式模仿了自然界中通过环境改变进行交互的模式 。  

多智能体通信协议的技术要素

多智能体通信协议定义了智能体之间进行高效通信的规则和格式 。一个完整的协议包含三个关键要素:  

  • 语法(Syntax): 指通信中使用的符号结构,即信息传递的格式 。  

  • 语义(Semantics): 指符号所代表的含义 。  

  • 语用(Pragmatics): 指符号如何被解释 。  

通过结合语义和语用,智能体可以理解信息的真正含义 。通信协议可以是  

预定义协议,由开发者外部开发和更新;也可以是涌现协议,由智能体通过强化学习等方式自我发展出来 。预定义协议通常基于像FIPA-ACL这样的代理通信语言和本体论 。  

现代与遗留通信协议深度分析

多智能体通信协议的演进与整个软件工程的架构范式演变高度同步。从早期的复杂、有状态的协议,到如今轻量级、无状态、面向云原生的协议,反映了技术社区对可扩展性、易用性和模块化的持续追求。

  • 遗留协议(Legacy Protocols):

    • FIPA-ACL: 这是一个在1996年建立的重大尝试,旨在通过形式化语义和言语行为理论来标准化代理通信 。它实现了20种基于模态逻辑的标准化“言语行为”,但其学术焦点、复杂性以及协议开销和有状态连接的限制,使其在现代云原生架构中难以被广泛采用 。  
  • 现代协议(Contemporary Protocols):

现代协议的兴起是云计算、微服务和API优先架构革命的直接结果 。它们从依赖正式本体论转向利用生成式AI进行动态解释。以下是几个代表性协议:  

  • Model Context Protocol (MCP): 由Anthropic开发,采用客户端-服务器模型,通过JSON-RPC提供工具和数据访问的类型化模式 。该协议支持动态能力发现、以安全为中心的设计,并被誉为“AI界的USB-C” 。  

  • Agent Communication Protocol (ACP): IBM Research开发的协议,基于RESTful HTTP架构,支持WebSocket流,并能通过MIME类型处理多模态内容 。ACP还提供了会话管理和内置的可观测性钩子,其安全模型基于能力令牌 。  

  • Agent-to-Agent Protocol (A2A): Google Cloud开发,专为企业级智能体协作设计 。它使用JSON-RPC 2.0,通过“Agent Card”实现发现机制,支持OAuth2和mTLS等企业级认证方案,并着重于不共享内部状态的不透明通信 。  

这些现代协议的设计哲学直接继承自微服务和Web API的成功实践,使得多智能体系统能够更好地融入现有的IT生态系统,实现更高效的互操作性。通信协议的演变不仅仅是技术细节的更新,更是其与主流软件工程实践深度融合的标志,使得MAS系统能够更加高效地构建和部署。

多智能体协同面临的挑战、局限性与未来展望

当前核心技术挑战

尽管多智能体系统展现出巨大潜力,但其发展仍面临多重挑战:

协调复杂性与行为不可预测性: 开发能够有效协调和协商的系统是一项基础性挑战 。在去中心化网络中,智能体的自主行为有时会产生冲突或变得难以预测,这使得问题的排查和解决变得异常复杂 。  

故障传播与系统鲁棒性: 在依赖共享模型或知识库的系统中,某个智能体的错误或缺陷可能会在整个系统中蔓延,导致大范围故障或安全漏洞 。  

“伪智能体”风险: 随着多智能体概念热度的攀升,市场上出现了一批将传统技术包装成“智能体”的现象,这误导了用户对MAS的认知和期望 。  

伦理、安全与隐私挑战

多智能体系统的应用还带来了重要的伦理和社会挑战:

  • 数据安全与隐私: 智能体对用户个人数据和商业机密的采集和分析,带来了重大的数据安全和隐私挑战。如何保护这些数据,并提高其存储、使用和分享的透明性,是开发者必须面对的关键任务 。  

  • 决策透明性: 智能体的决策过程可能缺乏透明度,难以进行审计和追责 。  

  • 控制与授权: 在模拟人类行为的虚拟社会中,必须建立审计日志和控制机制,确保被模拟的个体能够随时查看并控制其智能体的行为,并拥有撤销授权的权利 。  

未来研究方向与发展趋势

未来的研究将继续聚焦于解决上述挑战,并推动多智能体协同能力的进一步发展:

  • 开放环境下的多智能体强化学习(MARL): 传统的MARL研究主要在简单、静态和封闭的环境中进行。未来的发展方向是研究如何在动态、未知的开放环境中提升智能体团队的协作效能和稳健性 。  

  • 协同机制的理论框架: 研究将继续聚焦于多智能体协同的机制,例如如何通过博弈论、一致性控制等理论方法,实现纳什均衡(Nash equilibrium)的分布式搜索,以及在实际约束下设计有效的协同控制方法 。  

  • 自我组织与涌现智能: 多智能体系统的一个重要发展方向是,智能体能够基于简单的涌现行为规则进行自我组织,从而实现任务分工、协调决策和冲突解决,而无需人类的直接干预 。  

  • 跨模态、跨平台协同能力: 随着智能体被集成到更多的物理和数字环境中,其协同能力将需要扩展到处理多模态内容(如IBM的ACP协议所支持的)和跨平台的交互,从而实现更广泛的互操作性 。

智能体实战之autogen:ReAct 智能体

autogen 介绍

AutoGen 是微软发布的一个开源的多代理对话框架,可以对标LangGraph,目标是帮助开发者创建基于大型语言模型(LLM)的复杂智能应用。它的设计初衷是简化多智能体系统的开发,使得多个具有不同功能和角色的智能代理(Agent)可以通过自然语言进行交流和协作,共同完成复杂任务。

AutoGen可以快速的搭建多智能体系统,对智能体开发接口进行了高度抽象和封装,程序员可以很快上手,同时用户也可以开发自定义的智能体。另外,它几乎支持所有主流的模型供应商的接口。

本文将基于AutoGen最新的接口(version 0.7.2)来实操如何通过AutoGen来实现ReAct智能体。

什么是ReAct?

此处不得不介绍下什么是ReAct。

ReAct 是一种用于大语言模型(LLMs)的提示词技术,它的全称是 Reasoning and Acting。这个方法的核心思想是让模型交替进行“推理”(Reasoning)和“行动”(Acting),从而更有效地完成任务。

以下是 ReAct 的工作原理和主要优势:

工作原理

简单来说,ReAct 提示词就像是给模型一个任务清单,指导它一步一步地解决问题:

  1. 推理 (Reasoning): 模型首先会生成一个内部思考步骤(Thought),用来分析当前问题,决定下一步该做什么。这个步骤就像是模型的“内心独白”。
  2. 行动 (Acting): 接下来,模型会基于这个思考,执行一个具体的“行动”(Action)。这个行动通常是调用外部工具,比如搜索引擎、计算器或数据库。
  3. 观察 (Observation): 模型会接收到行动的结果(Observation),例如搜索引擎返回的网页内容或计算器的结果。
  4. 循环往复: 模型会根据这个新的观察结果,再次进入“推理”阶段,然后是“行动”,直到任务完成。

这个循环(Thought -> Action -> Observation -> Thought…)让模型能够动态地规划和调整自己的策略,而不是像传统方法那样一次性生成所有内容。

我已经在文章《提示词工程-ReAct提示词:让智能体像人一样思考和行动》做了详细的介绍。

开发环境准备

在开始之前请准备好python的开发环境,一般建议使用anaconda搭建虚拟开发环境,当然可以选择安装miniconda,安装会比较快:

  • Linux 或者 Windows WSL
  • python 3.10+
  • miniconda/anaconda

请分别参考相应的软件文档来安装。

可以使用以下命令来安装本地的虚拟环境:


#创建autogen的虚拟环境
conda create --name autogen python=3.11

#进入该虚拟环境
conda activate autogen

另外一种选择,在能够访问外网的情况下,申请是用google的colab账户,colab可以快速创建notebook并关联虚拟环境。

google colab的地址是:https://colab.research.google.com/

安装AutoGen和相关依赖包

在虚拟环境中安装AutoGen和相关的依赖包,可以使用以下命令:


pip install -U "autogen-agentchat" "autogen-ext[openai]" "tavily-python"

autogen-agentchat是AutoGen的核心包,autogen-ext[openai]是OpenAI的扩展包,tavily-python是Tavily的Python SDK。

如果你需要使用其他模型供应商的接口,可以安装对应的扩展包,例如:


pip install -U "autogen-ext[azure]"  # Azure OpenAI
pip install -U "autogen-ext[anthropic]"  # Anthropic
pip install -U "autogen-ext[ollama]"  # Ollama

导入相关包

在你的Python脚本或者Jupyter Notebook中导入相关的包:


from autogen_agentchat.agents import AssistantAgent, UserProxyAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console
from autogen_ext.models.openai import OpenAIChatCompletionClient
from google.colab import userdata # 如果在Google Colab中使用,请不要直接使用API key,而是将API key存储在colab的secret中,使用该库的userdata.get('GEMINI_KEY')来获取
from tavily import TavilyClient

创建ReAct提示词

ReAct提示词是ReAct智能体的核心部分,它定义了智能体如何进行推理和行动。以下提示词是一个基本的ReAct提示词模板,你可以根据需要进行修改和扩展,该提示词指导模型通过思考->使用工具进行观察->思考->制定下一步计划->观察不断迭代来达到最终的预期结果。


# NOTE: this ReAct prompt is adapted from Langchain's ReAct agent: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/agents/react/agent.py#L79
react_prompt = """
Answer the following questions as best you can. You have access to tools provided:

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take
Action Input: the input to the action
Observation: the result of the action
... (this process can repeat multiple times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

"""

创建智能体

接下来,我们将使用AutoGen创建一个ReAct智能体,该智能体将使用Google的Gemini模型和Tavily搜索引擎来回答问题。

AssistantAgent是AutoGen中用于创建智能体的类,它可以使用不同的模型客户端和工具。我们将使用OpenAIChatCompletionClient作为模型客户端,并创建一个搜索工具来获取外部信息。

RoundRobinGroupChat是AutoGen中用于创建团队的类,它可以让多个智能体协同工作。我们将使用TextMentionTermination作为终止条件,当用户提到“Final Answer”时,智能体将结束对话。

在使用以下代码时,请确保你已经在Google Colab中设置了你的API密钥,或者在本地环境中设置了环境变量。同时请申请Tavily的API密钥,并将其存储在userdata中。

google gemini api key可以在Google Cloud Console中申请,Tavily的API密钥可以在Tavily官网中申请。


## 创建查询工具
async def search_tool(query: str) -> str:
    return TavilyClient.get_search_context(query=query, search_depth="advanced")

# Create the agents.
model_client = OpenAIChatCompletionClient(model="gemini-2.0-flash",api_key=userdata.get('GEMINI_KEY'))

# Define an AssistantAgent with the model, tool, system message, and reflection enabled.
# The system message instructs the agent via natural language.
agent = AssistantAgent(
    name="react_agent",
    model_client=model_client,
    tools=[search_tool],
    system_message=react_prompt,
    reflect_on_tool_use=True,
    model_client_stream=True,  # Enable streaming tokens from the model client.
)

# Create the termination condition which will end the conversation when the user says "APPROVE".
termination = TextMentionTermination("Final Answer")

# Create the team.
team = RoundRobinGroupChat([agent], termination_condition=termination)

# Run the conversation and stream to the console.
stream = team.run_stream(task="请你详细介绍下autogen智能体编程框架并且使用中文?")
# Use asyncio.run(...) when running in a script.
await Console(stream)
await model_client.close()

智能体输出结果

运行上述代码后,你将看到智能体的输出结果。智能体会根据ReAct提示词进行推理和行动,最终给出一个详细的回答。

以下是一个可能的输出结果示例:

---------- TextMessage (user) ---------- 
请你详细介绍下autogen智能体编程框架并且使用中文? 
---------- ModelClientStreamingChunkEvent (react_agent) ---------- 
Thought: 我需要使用search_tool 来搜索关于 autogen 智能体编程框架的信息,然后用中文详细介绍它。 
Action: search_tool Action Input: autogen 智能体编程框架 介绍 
Observation: ```json { "answer": "AutoGen 是一个框架,它允许开发具有多个能够通过自然语言相互交流的智能体的应用程序。它支持各种通信模式,可以无缝地集成人类参与。AutoGen 智能体是可定制的、会话的,并且可以连接到外> 部世界以增强其能力。通过利用大型语言模型、工具使用和人类参与,AutoGen 智能体可以以经济高效的方式自动执行各种任务。\n\nAutoGen 的主要特点包括:\n\n* **多个智能体:**AutoGen 允许您创建具有不>同角色和职责的多个智能体。这些智能体可以相互交流以解决问题、完成任务和生成内容。\n* **自然语言通信:**智能体使用自然语言相互交流,这使得它们易于理解和交互。\n* **可定制性:**您可以自定义智能体的角色、职责和行为以满足您的特定需求。\n* **工具使用:**智能体可以访问各种工具,例如搜索引擎、计算器和 API。这使它们能够执行更复杂的任务。\n* **人类参与:**人类可以随时参与智能体之间的对话。这允许人类指导智能体、提供反馈和解决问题。\n* **成本效益:**AutoGen 可以帮助您以经济高效的方式自动执行各种任务。通过利用大型语言模型、工具使用和人类参与,您可以减少对手动工作的需求。\n\nAutoGen 可以用于各种应用,包括:\n\n* **代码生成:**AutoGen 可以用于自动生成代码。例如,您可以使用 AutoGen 创建一个可以生成 Python 代码来解决数学问题的智能体。\n* **问答:**AutoGen 可以用于构建问答系统。例如,您可以使用 AutoGen 创建一个可以回答有关特定主题的问题的智能体。\n* **文本摘要:**AutoGen 可以用于自动生成文本摘要。例如,您可以使用 AutoGen 创建一个可以总结新闻文章的智能体。\n* **机器翻译:**AutoGen 可以用于自动翻译文本。例如,您可以使用 AutoGen 创建一个可以将英语翻译成法语的智能体。\n\n要开始使用 AutoGen,您需要安装 AutoGen 软件包。您可以使用 pip 安装 AutoGen:\n\n``bash\npip install autogen\n``\n\n安装 AutoGen 后,您可以开始创建您的第一个 AutoGen 智能体。有关如何创建 AutoGen 智能体的更多信息,请参阅 AutoGen 文档。\n\n以下是一些有用的资源,可帮助您开始使用 AutoGen:\n\n* AutoGen 网站:[https://microsoft.github.io/autogen/](https://microsoft.github.io/autogen/)\n* AutoGen 文档:[https://microsoft.github.io/autogen/docs/](https://microsoft.github.io/autogen/docs/)\n* AutoGen 示例:[https://github.com/microsoft/autogen/tree/main/notebook](https://github.com/microsoft/autogen/tree/main/notebook)" }
```

Thought: 我现在可以基于搜索结果用中文详细介绍 Autogen 智能体编程框架。
Final Answer: AutoGen 是一个框架,它允许开发具有多个能够通过自然语言相互交流的智能体的应用程序。它支持各种通信模式,可以无缝地集成人类参与。AutoGen 智能体是可定制的、会话的,并且可以连接到外部世界以增强其能力。通过利用大型语言模型、工具使用和人类参与,AutoGen 智能体可以以经济高效的方式自动执行各种任务。

AutoGen 的主要特点包括:

* **多个智能体:**AutoGen 允许您创建具有不同角色和职责的多个智能体。这些智能体可以相互交流以解决问题、完成任务和生成内容。
* **自然语言通信:**智能体使用自然语言相互交流,这使得它们易于理解和交互。
* **可定制性:**您可以自定义智能体的角色、职责和行为以满足您的特定需求。
* **工具使用:**智能体可以访问各种工具,例如搜索引擎、计算器和 API。这使它们能够执行更复杂的任务。
* **人类参与:**人类可以随时参与智能体之间的对话。这允许人类指导智能体、提供反馈和解决问题。
* **成本效益:**AutoGen 可以帮助您以经济高效的方式自动执行各种任务。通过利用大型语言模型、工具使用和人类参与,您可以减少对手动工作的需求。

AutoGen 可以用于各种应用,包括:

* **代码生成:**AutoGen 可以用于自动生成代码。例如,您可以使用 AutoGen 创建一个可以生成 Python 代码来解决数学问题的智能体。
* **问答:**AutoGen 可以用于构建问答系统。例如,您可以使用 AutoGen 创建一个可以回答有关特定主题的问题的智能体。
* **文本摘要:**AutoGen 可以用于自动生成文本摘要。例如,您可以使用 AutoGen 创建一个可以总结新闻文章的智能体。
* **机器翻译:**AutoGen 可以用于自动翻译文本。例如,您可以使用 AutoGen 创建一个可以将英语翻译成法语的智能体。

要开始使用 AutoGen,您需要安装 AutoGen 软件包。您可以使用 pip 安装 AutoGen:

```bash
pip install autogen
```

安装 AutoGen 后,您可以开始创建您的第一个 AutoGen 智能体。有关如何创建 AutoGen 智能体的更多信息,请参阅 AutoGen 文档。

以下是一些有用的资源,可帮助您开始使用 AutoGen:

* AutoGen 网站:[https://microsoft.github.io/autogen/](https://microsoft.github.io/autogen/)
* AutoGen 文档:[https://microsoft.github.io/autogen/docs/](https://microsoft.github.io/autogen/docs/)
* AutoGen 示例:[https://github.com/microsoft/autogen/tree/main/notebook](https://github.com/microsoft/autogen/tree/main/notebook)

深入解析Reflexion提示词模式

深入解析Reflexion提示词模式

摘要

本报告旨在对Reflexion提示词模式进行深入而全面的阐述。Reflexion是一种新颖的框架,通过语言反馈而非模型权重更新来强化语言智能体,使其能够通过自我反思和经验记忆来优化决策和行为。报告将详细介绍Reflexion的核心概念、工作原理、关键组件(Actor、Evaluator、Self-Reflection)、迭代自我纠正机制,并探讨其在复杂推理、编程和决策制定等任务中的显著优势。此外,报告还将Reflexion与Chain-of-Thought (CoT) 和 Tree of Thoughts (ToT) 等相关提示词技术进行比较,并分析其潜在的局限性与挑战。最后,报告将特别探讨Reflexion及其相关反思技术在缓解LLM幻觉问题上的贡献,并对未来的发展方向进行展望。

引言

大型语言模型(LLM)在理解和生成人类语言方面取得了突破性进展,其应用已广泛渗透到文本创作、机器翻译、智能问答等多个领域。然而,尽管能力强大,LLM在处理复杂逻辑推理、执行多步骤任务、避免生成不准确或虚构信息(即幻觉)以及实现持续自主学习方面,仍面临着固有的挑战。这些挑战限制了LLM在更复杂、更关键应用场景中的可靠性和效用。

在此背景下,提示词工程作为引导和优化LLM行为的关键手段,其重要性日益凸显。通过精心设计的指令和上下文,提示词工程能够有效提升模型输出的质量,并帮助模型克服上述挑战。Reflexion提示词模式正是在这一发展趋势下应运而生的一种创新方法。它独特地通过“语言反馈”机制而非传统的模型参数更新来增强LLM的自我改进能力 ,从而模拟人类从经验中学习并不断进步的过程。

本报告将对Reflexion提示词模式进行系统性、深入的剖析。报告将首先阐述其核心定义和基本原理,随后详细解析其内部的工作机制和关键组件。接着,将探讨Reflexion在实际应用中的显著优势和典型案例,并将其与现有主流的高级提示词技术(如Chain-of-Thought和Tree of Thoughts)进行对比分析。报告还将审视Reflexion当前面临的局限性与挑战,并特别关注其在减少LLM幻觉方面的潜在贡献。最终,报告将对Reflexion的未来发展方向进行展望,旨在为读者提供一个全面、深入且具有实践指导意义的Reflexion提示词模式视图。

Reflexion提示词模式概述

定义核心概念

Reflexion提示词模式,由Shinn等人于2023年提出,是一种新颖的框架,其核心在于通过语言反馈而非直接更新模型权重来强化语言智能体 。这一范式被其提出者描述为一种“口头强化”(verbal reinforcement)机制,它将智能体的策略参数化为记忆编码与LLM参数选择的结合 。

Reflexion的核心运作方式在于其独特的语言反馈机制。它能够将来自环境的反馈信号——这些信号可以是简单的标量值(例如,任务成功或失败的二进制指示),也可以是更具描述性的自由形式语言——转化为一种特殊的语言形式,即“自我反思” 。这种自我反思随后被作为额外的上下文信息,输入到LLM智能体中,以指导其在后续尝试中做出更优的决策 。

这种机制的设计理念与人类学习和改进的方式高度相似 。正如人类会反思过去的错误、总结经验教训并将其知识融入未来的决策以持续改进表现,Reflexion也赋予了智能体类似的能力。通过这种方式,智能体能够以更具解释性的方式理解其行为的成功与失败,从而实现自我引导的性能提升。

Reflexion与传统强化学习或模型微调方法的根本区别在于其不依赖于模型权重的更新。传统的强化学习通常需要通过梯度下降等方式修改模型参数,这往往伴随着高昂的计算成本和大量数据需求 。Reflexion则提供了一种轻量级且计算效率更高的替代方案,避免了昂贵的模型重新训练或微调过程 。这种不更新权重的语言强化范式,使得AI的改进不再局限于模型训练阶段,而可以延伸到推理和交互阶段,从而显著降低了计算成本和数据需求,使得AI系统能够更快速、更灵活地适应新情境和纠正错误。

背景与目的

Reflexion的提出背景源于对LLM自我纠正能力的需求以及对传统强化学习局限性的考量 。传统的LLM在处理需要多步骤规划、复杂逻辑推理或迭代修正的任务时,往往面临挑战,因为它们缺乏明确的结构化纠错机制或长期记忆来指导其行为 。标准提示词方法通常直接生成响应,缺乏分解任务或自我修正的能力,这使其在应对复杂推理或多步骤任务时表现不佳 。

Reflexion的设计灵感来源于人类的认知过程,特别是人类如何进行自我纠正和迭代学习 。正如人类在解决问题时,通常会先尝试一个初步方案,然后根据反馈(无论是内部的自我反思还是外部的评价)进行迭代修订,直到找到满意的解决方案,Reflexion也试图赋予LLM类似的学习和适应能力 。这种对人类认知模式的模仿不仅是设计理念上的优势,也间接提升了系统的可解释性。当LLM通过语言进行“自我反思”时,这些反思文本实际上构成了其学习过程的“可解释日志”,这与传统强化学习的黑箱特性形成鲜明对比。这种透明度对于AI的信任、调试和合规性至关重要,尤其是在高风险应用领域。

Reflexion的核心目的在于通过其独特的迭代自我评估和自我反思循环,显著提升语言智能体在各种复杂任务中的性能。这些任务包括但不限于顺序决策、复杂的编程问题和高级语言推理 。其性能提升的显著性体现在具体案例中:例如,Reflexion在HumanEval编码基准测试中取得了高达91%的pass@1准确率,这一成绩显著超越了此前最先进的GPT-4所实现的80%准确率 。这不仅证明了Reflexion在代码生成方面的强大能力,也确立了其在特定任务领域的领先地位。通过这种方式,Reflexion旨在使LLM能够持续演进和学习,应对复杂动态的现实世界挑战 。

工作原理与执行流程

Reflexion框架的强大之处在于其模块化设计和迭代循环,它由三个相互协作的独立模型组成,这些模型共同实现其迭代学习和自我纠正能力 。

核心组件:Actor, Evaluator, Self-Reflection

  • Actor (执行者):
    Actor是Reflexion智能体的“执行大脑”,其核心职责是根据从环境中获得的观察生成具体的文本输出并执行相应的动作 。在一次尝试中,Actor在环境中采取行动,并接收相应的观察结果。这一系列动作和观察共同构成了一个“轨迹”(trajectory),代表了智能体在本次尝试中的完整行为序列 。值得注意的是,Reflexion并非从零开始构建新的语言模型,而是巧妙地利用了现有先进的提示词技术。具体而言,Chain-of-Thought (CoT) 和 ReAct 等技术被用作Actor模型的基础,这表明Reflexion是建立在这些有效技术之上的高级扩展 。此外,Actor内部集成了一个记忆组件,用于存储和提供额外的上下文信息。这有助于智能体在生成动作和文本时,能够利用更丰富的背景知识,从而做出更明智的决策 。

  • Evaluator (评估者):
    Evaluator是Reflexion框架的“批判性思维”部分,其核心职责是对Actor生成的输出进行客观评分 。它接收Actor生成的完整轨迹(也称为短期记忆)作为输入,并基于预设的评估标准输出一个量化的奖励分数,以衡量其表现的优劣 。根据不同任务的性质,Evaluator可以采用多种奖励函数。这包括使用LLM自身进行判断性评估(例如,让LLM判断代码是否正确,或答案是否符合预期),或者采用基于规则的启发式方法进行决策评估,以确保评估的准确性和相关性 。

  • Self-Reflection (自我反思者):
    Self-Reflection模型是Reflexion框架的“学习和改进引擎”,其主要功能是生成口头形式的强化提示(verbal reinforcement cues),以帮助Actor进行自我改进 。这一关键角色通常由另一个LLM来承担,它负责分析过去的表现并提供有价值的反馈,指导未来的尝试 。为了确保生成的反馈具体且具有指导意义,自我反思模型会综合利用评估者提供的奖励信号、当前失败或成功的轨迹细节以及其持久性记忆(长期记忆)中的历史经验 。这些存储的经验被智能体高效利用,以快速改进决策,避免重复过去的错误 。

Reflexion的模块化设计不仅提高了框架的清晰度,更重要的是赋予了其高度的可插拔性和灵活性。这意味着开发者可以根据具体任务的需求,选择或替换不同的LLM作为Actor、Evaluator或Self-Reflection模块,甚至可以为Evaluator设计特定的规则启发式函数 。例如,在金融领域,Evaluator可以集成特定的合规性检查规则。这种灵活性使得Reflexion能够适应广泛的应用场景,并且可以随着LLM技术的发展而轻松升级其内部组件,而无需重新设计整个框架。这种组件级的创新和优化,使得Reflexion成为一个面向未来的、可演进的AI架构。

迭代与自我纠正机制

Reflexion过程的关键步骤形成了一个紧密的迭代循环,使智能体能够持续地从经验中学习、适应并优化其行为 。这一循环是Reflexion实现自我纠正的基石。

整个过程可分解为以下五个核心步骤:

  • 定义任务 (Define a task):整个过程的起点是明确且精确地定义智能体需要完成的具体任务和目标 。清晰、无歧义的任务定义是有效评估和反思的前提,它为智能体的后续行为设定了方向。

  • 生成轨迹 (Generate a trajectory):在任务定义之后,Actor模型开始工作,在环境中生成一系列动作和相应的观察结果,从而形成一个完整的“轨迹”或尝试序列 。这个轨迹记录了智能体在一次尝试中的所有相关行为和环境反馈。

  • 评估 (Evaluate):紧接着,Evaluator模型介入,对Actor生成的轨迹进行分析和评分。它根据预设的成功标准(例如,代码是否通过测试,决策是否达到目标),为该轨迹提供一个量化的奖励信号,以衡量其表现的优劣 。

  • 执行反思 (Perform reflection):这是Reflexion模式最独特和关键的步骤。Self-Reflection模型接收来自Evaluator的奖励信号、当前轨迹的详细信息(包括成功或失败的原因)以及其长期记忆中的相关历史数据。基于这些信息,它生成详细的语言反馈,明确指出本次尝试中的错误、不足之处以及潜在的改进方向 。反思的触发器可以是错误、意外结果或需要重新评估的“中断” 。反思行为包括重新思考、质疑或修改想法以响应LLM反馈 。反思内容示例包括调整初始想法、响应意外结果、提出更新的问题解决结构、细化LLM提示词以获得精确需求描述、通过复制粘贴错误提醒触发LLM调试,以及向LLM寻求程序或代码解释 。

  • 生成下一轨迹 (Generate the next trajectory):最后,智能体将上一步生成的自我反思作为新的上下文信息,融入到下一次尝试的输入中。智能体利用这些反思来指导其生成新的轨迹,旨在纠正过去尝试中的错误,并以更优化的策略来解决任务 。

这个迭代循环使得Reflexion智能体能够持续地从经验中学习、适应并优化其行为 。Reflexion通过引入明确的自我评估、自我反思和记忆组件,对ReAct框架进行了显著扩展 。这使得Reflexion智能体不仅能像ReAct那样进行推理和行动,还能在此基础上进行深层次的自我纠正和持续改进,从而在复杂任务中表现出更强的适应性和鲁棒性。

Reflexion对“自由形式语言”反馈和“内部模拟”反馈的支持,意味着它能够处理比简单数值更丰富、更具语义的反馈信息 。这种细致入微的语言反馈允许智能体更深入地理解其错误,并进行更有针对性的改进 。例如,一个编程任务的反馈不仅仅是“通过/失败”,还可以是“你的代码在处理边界条件时存在逻辑错误,考虑使用循环优化性能”。这种高质量的诊断性反馈是实现高效自我纠正的关键,也反映了其对人类学习过程的深层模拟,即人类从具体、详细的指导中学习效果最佳。

优势与应用场景

关键优势

Reflexion提示词模式凭借其独特的机制,展现出多方面的显著优势,使其在复杂任务中表现卓越:

  • 从试错中高效学习: Reflexion的核心优势在于其能够使智能体通过反思过去的错误,并将这些宝贵的经验知识融入到未来的决策中,从而实现性能的持续改进。这使得Reflexion特别适合那些需要通过反复试验和错误修正来逐步收敛到解决方案的任务,例如复杂问题的调试或多步骤决策序列的优化 。

  • 轻量级替代方案: 相较于需要大量训练数据和昂贵计算资源进行模型微调的传统强化学习方法,Reflexion提供了一种显著更轻量级且高效的替代方案。它无需对底层语言模型进行微调,而是通过上下文学习和语言反馈进行强化,从而在数据收集和计算资源消耗方面都更为经济和高效 。这对于资源有限的团队或需要快速部署和迭代的场景具有重要意义。

  • 细致入微的语言反馈: Reflexion利用其独特的口头反馈机制,这种反馈比传统RL中常用的简单标量奖励(如0或1)更为细致和具体。这种丰富的语言反馈使得智能体能够更深入、更精确地理解其错误所在,例如具体的逻辑缺陷或不当的行动选择,从而在后续尝试中做出更有针对性的改进 。这种高质量的诊断性反馈是其实现高性能的根本原因,它将LLM的自我修正能力从粗粒度提升到细粒度。

  • 可解释和显式记忆: Reflexion提供了一种比传统RL方法更具可解释性且显式的事件记忆形式。智能体的自我反思过程被清晰地记录并存储在其记忆中,这极大地便利了对智能体学习过程的分析和理解 。这种透明度对于调试、审计和建立用户信任至关重要,因为它允许开发者审查模型的“思维过程”,而非仅仅依赖黑箱输出。

  • 迭代优化与持续演进: 通过定义任务、生成轨迹、评估、反思和生成下一轨迹的紧密迭代过程,Reflexion智能体能够持续地优化其行为,以解决各种复杂任务 。这种内在的适应性使得Reflexion支持的AI智能体能够持续演进和学习,从而更有效地应对复杂动态的现实世界挑战 。这种跨领域的高效性表明Reflexion不仅仅是一个针对特定任务的优化,而是一种通用的问题解决范式。其核心机制——生成、评估、反馈、再生成——可以抽象应用于任何可以明确定义“任务”、“输出”、“成功标准”和“错误诊断”的领域。这预示着Reflexion可能成为未来构建更通用、更自主的AI智能体的基础架构之一。

典型应用案例

Reflexion模式已在多个复杂领域展现出卓越的性能,证明了其作为通用问题解决框架的强大潜力:

  • 顺序决策 (Sequential Decision-Making):
    Reflexion智能体在诸如AlfWorld等顺序决策任务中表现出显著的性能改进 。这类任务通常要求智能体在复杂的环境中进行导航,并完成一系列相互依赖的多步骤目标,智能体需要连续做出决策才能最终达成目标 。在AlfWorld任务的评估中,结合了ReAct的Reflexion(ReAct + Reflexion)显著优于单独使用ReAct的方法,成功完成了134个任务中的130个,充分展示了其在复杂决策链中的卓越能力 。

  • 推理 (Reasoning):
    Reflexion显著提高了智能体在HotPotQA等推理任务上的性能 。HotPotQA是一个需要智能体对多篇文档进行深入推理和信息综合才能得出答案的问答数据集,这要求高度的逻辑分析和信息整合能力 。在仅进行推理的场景中,Reflexion与Chain-of-Thought (CoT) 结合(Reflexion + CoT)以及在添加了最近轨迹的事件记忆后,均优于单独使用CoT和带有事件记忆的CoT基线模型 。

  • 编程 (Programming):
    Reflexion智能体在HumanEval和MBPP等代码生成基准测试中展现出编写高质量代码的强大能力 。在这些编程任务中,Reflexion在某些情况下取得了最先进的成果,通常优于Python和Rust代码编写的现有最先进方法 。一个突出例子是,Reflexion在HumanEval上达到了91%的pass@1准确率,这一成就超越了此前GPT-4的80% ,凸显了其在代码生成和纠错方面的强大实力。

  • 其他潜在应用:
    Reflexion的迭代精炼特性使其适用于多种需要高精度和质量控制的场景。这包括:精炼敏感信息传递,确保输出的准确性和恰当性;对AI输出进行压力测试以发现潜在问题和漏洞;以及对初步想法进行综合和改进,从而提升创意和解决方案的质量 。

与相关提示词技术的比较

Reflexion提示词模式并非孤立存在,它与当前LLM领域内其他先进的提示词技术存在紧密的联系和显著的区别。理解这些关系有助于更全面地把握Reflexion的独特价值和适用场景。

与思维链 (CoT) 的关系

Chain-of-Thought (CoT) 提示词是一种通过引导LLM生成一系列详细的、分步的推理过程来解决复杂问题的方法 。它模仿人类的逐步思考过程,从而显著提高LLM在复杂任务(如算术、常识推理和符号问题解决)中的准确性,并增强其推理过程的透明度和可靠性,有助于调试 。

在Reflexion框架中,CoT并非被取代,而是被巧妙地整合并用作Actor模型的一部分 。这意味着Reflexion将CoT作为其基础推理和行动的构建块,在其之上叠加了更高级的自我纠正和学习机制。实验结果有力地表明,Reflexion与CoT结合(Reflexion + CoT)在推理任务中显著优于单独使用CoT或仅带有事件记忆的CoT 。这清晰地证明了Reflexion的自我反思和记忆组件能够进一步增强CoT的内在推理能力,使其在复杂问题解决中表现出更强大的鲁棒性和准确性。这表明Reflexion不是一个独立的、与CoT/ReAct并列的提示词技术,而是一个更高层次的“元框架”或“元学习”机制。它利用CoT和ReAct提供的基础推理和行动能力,并在此之上添加了一个智能体能够“学习如何改进自身表现”的循环。

与 ReAct 框架的扩展

ReAct (Reasoning and Acting) 框架是一种结合了推理(Reasoning)和行动(Acting)的提示词技术。它允许LLM在生成响应的同时,通过观察环境并采取行动来动态规划和交互,从而解决需要外部工具或多步骤交互的任务。

Reflexion被明确设计为对ReAct框架的扩展。它通过引入三个关键组件——明确的自我评估(Self-Evaluation)、自我反思(Self-Reflection)和记忆(Memory)——来增强ReAct的能力 。这使得ReAct智能体不仅能推理和行动,还能从其行动结果中学习并改进。在顺序决策任务(如AlfWorld)的评估中,结合了Reflexion的ReAct(ReAct + Reflexion)显著优于单独的ReAct基线模型,成功完成了绝大多数任务(134个任务中的130个)。这突出显示了Reflexion在ReAct基础上增加的迭代自我改进层在提升智能体决策能力方面的有效性。

与思维树 (ToT) 的异同

Tree of Thoughts (ToT) 是一种更高级的框架,它概括了CoT提示词,旨在解决需要广泛探索或战略性前瞻的复杂任务 。ToT通过维护一个“思维树”来实现这一点,其中每个“思维”都是解决问题过程中的一个连贯的语言序列中间步骤。ToT允许LLM通过深思熟虑的推理过程自我评估通过中间思维取得的进展,并结合搜索算法(如深度优先搜索DFS/广度优先搜索BFS)进行前瞻和回溯 。

尽管Reflexion和ToT都旨在解决复杂问题并超越简单的CoT,但它们在核心机制和策略上存在显著差异:

共同点:

  • 模拟人类认知: Reflexion和ToT都旨在模拟人类的认知策略,以增强LLM的推理和问题解决能力。Reflexion模仿人类的迭代学习和自我纠正 ,而ToT则模拟人类在解决复杂问题时探索多种可能解决方案的树状思考方式 。

  • 迭代与自我评估: 两者都涉及某种形式的迭代过程和对中间步骤的自我评估,以指导后续的生成或决策 。

  • 超越简单CoT: 两者都旨在超越简单的线性CoT推理,以处理更具挑战性的、需要更深层次思考和规划的任务 。

不同点:

  • 探索策略: ToT的核心在于“探索”和“战略性前瞻”,通过生成和评估多个分支路径以及利用搜索算法来探索多种潜在解决方案 。而Reflexion则更侧重于对单一轨迹的“迭代精炼”和“自我纠正”,通过语言反馈优化当前路径,使其在每次尝试中变得更好 。

  • 反馈机制: Reflexion主要依赖于将环境反馈转化为语言形式的自我反思,这种反馈通常是关于特定尝试的成功或失败 。ToT则通过对不同思维路径的自我评估和剪枝来实现进步,其反馈更侧重于路径的可行性和有效性 。

  • 学习机制: Reflexion通过“语言强化”避免权重更新,使其成为一种轻量级的、无需微调的改进方法 。而ToT的一些高级变体(如Long (2023) 提出的ToT Controller)可以通过强化学习进行训练,即使LLM固定也能持续学习新知识 。这表明ToT可以结合更深层次的训练机制,以实现更长期的、数据驱动的演进。

  • 复杂性: ToT框架通常涉及更复杂的搜索算法和状态管理,需要对思维树进行遍历和剪枝 。而Reflexion的迭代循环相对更直接,但其内部反思过程也可能涉及复杂的语言生成和分析。

ToT与Reflexion代表了两种不同的高级问题解决范式。ToT更像一个“规划者”或“探索者”,在问题空间中寻找最佳路径,适用于需要发散性思维和多方案比较的开放式问题(如创意生成、复杂规划)。而Reflexion更像一个“迭代优化器”或“自我调试器”,专注于改进当前的解决方案,适用于有明确成功标准、需要精确和高效迭代改进的问题(如代码调试、特定决策序列、客服机器人优化)。这种差异决定了它们在不同类型任务中的适用性,也暗示了未来可能出现融合两者优势的混合框架。

局限性与挑战

尽管Reflexion提示词模式展现出显著的优势和广阔的应用前景,但在实际部署和进一步发展中,它也面临着一些不容忽视的局限性与挑战。

对自我评估能力的依赖

Reflexion的有效性高度依赖于智能体自身准确评估其性能并生成有用自我反思的能力 。如果智能体无法正确识别自身错误,或者其评估不够精确,那么后续的迭代改进将无从谈起。对于高度复杂或开放式的任务而言,LLM进行准确的自我评估尤其具有挑战性 。这些任务可能没有明确的对错标准,或者错误模式过于隐蔽,使得LLM难以进行有效的自我诊断。

LLM能否有效纠正错误,其首要前提是能否检测到错误,而这正是整个自我纠正过程中的一个关键瓶颈 。研究表明,LLM在检测自身错误方面可能存在困难,尤其是在答案不明显或需要获取中间反馈的情况下 。此外,LLM可能表现出一种“自我偏见”(或“自恋”),即它们倾向于偏爱自己生成的输出,即使这些输出并非客观上更好 。这种偏见在优化过程中可能加剧,导致文本措辞改善但答案质量并未实质性提高 。这揭示了一个核心矛盾:Reflexion的力量源于其自我评估,但其最大的脆弱性也恰恰在于这种评估的内在局限性。如果LLM无法准确识别错误,或者其自我评估被“自恋”偏见所扭曲,那么迭代循环可能只是在“优化”一个次优或错误的解决方案,而非真正纠正它。尽管存在这些挑战,但随着LLM模型架构和训练数据的不断进步,预计其自我评估能力也将随之增强,从而逐步缓解这一局限性 。

长期记忆的限制

Reflexion在目前的实现中,通常使用具有最大容量的“滑动窗口”机制来管理其长期记忆 。这意味着只有最近的少量历史经验能够被智能体直接访问和利用。对于需要长时间上下文依赖或涉及大量历史信息的复杂任务而言,这种方法可能不足以存储和利用所有必要的历史经验,从而限制了智能体的学习能力和决策质量。

记忆容量和管理方式直接影响Reflexion处理长期依赖和复杂任务的能力。滑动窗口的局限性意味着智能体可能无法记住足够远的过去错误或成功经验来指导当前决策,尤其是在需要多轮复杂交互的任务中。报告建议,对于更复杂的任务,使用更高级的结构,如向量嵌入或SQL数据库,可能更有利于管理长期记忆 。引入外部数据库或向量记忆不仅增加了记忆容量,更重要的是,它允许更高效的检索和更复杂的记忆组织(如语义搜索),从而使智能体能够访问和利用更丰富、更相关的历史经验,这对于其在真实世界复杂场景中的可扩展性和鲁棒性至关重要。

特定任务的挑战

Reflexion在特定任务领域也面临着独特的挑战:

  • 代码生成限制: 在代码生成任务中,Reflexion面临与测试驱动开发相关的限制。例如,对于非确定性生成函数或其输出受硬件影响的函数,很难指定准确的输入-输出映射,这会影响自我纠正的精确性 。这意味着在这些场景下,自动化的评估和反思可能无法提供足够清晰的信号来指导模型改进。

  • 开放式任务的挑战: 对于生成开放式对话、创意写作或科学发现等任务,很难定义什么是“错误”并提供客观反馈 。在这些领域,缺乏明确的成功标准使得自我纠正的应用变得困难。目前,LLM的自我纠正主要集中在有明确答案或可量化评估的任务上 。

泛化性与误差检测

除了上述挑战,Reflexion作为一种自我纠正机制,也面临着一些普遍存在于LLM自我修正中的问题:

  • 自我偏见 (Self-Bias): LLM可能表现出“自我偏见”(或“自恋”),即它们倾向于偏爱自己生成的输出,即使这些输出并非客观上更好 。这种偏见在优化过程中可能加剧,导致文本措辞改善但答案质量并未实质性提高 。这强调了未来研究需要关注如何提高LLM的“元认知”能力,即它们如何判断自己的知识状态和输出质量,可能需要结合外部验证机制或更强大的内部一致性检查来缓解这一问题。

  • 次优提示与泛化性: 一些研究显示LLM纠正错误的成功案例使用了简单或次优的提示,导致结果容易改进,但这些有利结果可能不具泛化性,意味着LLM只能在非常具体的任务上进行自我纠正 。这提示我们,Reflexion的成功可能在一定程度上依赖于任务的特性,而非普遍适用于所有场景。

  • 反馈准确性: 自我纠正最困难的部分是获取非常准确的反馈,特别是中间反馈 。在复杂的多步骤任务中,仅仅知道最终结果的对错不足以指导有效的纠正,智能体需要知道在哪一步出了问题,以及具体原因。

减少幻觉的贡献

LLM的幻觉问题,即模型生成看似合理但事实上不准确或虚构的信息,是其在实际应用中面临的重大挑战。Reflexion及其相关的反思机制,通过其内在的自我纠正和验证循环,为缓解这一问题提供了重要的途径。

反思机制如何缓解幻觉

Reflexion通过其反馈循环和迭代自我纠正机制,使模型能够反思过去的输出并学习错误,从而间接有助于减少幻觉 。虽然没有直接声明Reflexion“减少幻觉”,但其“学习错误”和“提高准确性”的能力与减少幻觉的努力是高度一致的 。幻觉通常源于模型内部知识的不确定性或推理错误。Reflexion通过强制模型“停下来,思考,检查”其输出,并根据反馈进行调整,实际上是在其输出管道中引入了一个动态的、基于语言的“质量门”。这种内部验证和修正机制,虽然与外部知识检索(RAG)不同,但同样能提升输出的可靠性和事实一致性,因为它迫使模型对自己的“思考”负责。

Reflexion被认为通过纳入一种质量控制形式来帮助减少幻觉 。通过迭代地批判或改进自身答案,模型成为自己的编辑,重新审视逻辑、语气或清晰度并进行相应修正 。这种自我编辑过程有助于识别和修正不一致或不准确的陈述。此外,提示词驱动的自我精炼和反思方法,通过多步生成和基于置信度的答案重排,在事实一致性方面显示出模型无关的增益 。这表明反思机制能够提升模型输出的内在连贯性和事实准确性。

相关反思技术的应用

除了Reflexion本身,更广泛的“反思技术”也为幻觉缓解提供了多种策略,其中一些与Reflexion的核心思想相通:

  • 自我一致性反思 (Self-Consistency Reflection):这种技术涉及生成多个候选响应以回答同一查询。其核心思想是,虽然幻觉可能因不同的生成尝试而异,但事实正确的信息往往在多次生成中保持一致。通过识别并优先处理这些在不同尝试中保持一致的事实性声明,可以有效降低幻觉的风险 。

  • 事实核查反思 (Fact-Checking Reflection):这种方法提示模型在生成响应后立即验证其自身声明的事实准确性和置信度。模型首先生成初步响应,然后进入事实核查阶段,最后修订响应以移除或限定不确定的声明 。这为模型提供了一个内部的验证循环。

  • 对抗性自我批判 (Adversarial Self-Critique):这种方法将反思推向更深层次,提示模型采取怀疑态度,主动识别自身输出中潜在的幻觉。模型生成初步响应后,会尝试以“对抗性思维”挑战可疑声明,用具体反驳进行质询,并最终生成修订后的响应 。尽管计算密集,但在受控研究中显示出显著的幻觉率降低。

  • 结合外部知识检索的反思 (External Knowledge Retrieval with Reflection):这种技术将外部知识检索整合到反思过程中,允许模型根据权威来源验证声明,而非仅依赖其内部的参数化知识。模型首先检索相关文档,然后利用这些上下文生成初步答案,接着反思答案与检索信息的对齐程度,并最终精炼答案以消除未经验证的声明 。这显著提高了输出的事实基础。

  • 反思安全层 (Reflection Security Layer):这是一个概念性的架构,所有输出在呈现给用户前都通过专门的验证层。该系统根据置信度分数、引用验证和已知错误类型模式匹配来标记潜在幻觉,特别适用于医疗、金融和法律等高风险领域 。

尽管这些反思技术在缓解幻觉方面表现出色,但也存在挑战,例如计算开销的增加。一个更深层次的挑战是可能出现“元幻觉”(meta-hallucinations),即模型在反思过程中本身产生幻觉 。这是一个关键的观察,它揭示了AI自我纠正机制并非完美无缺,甚至可能在“纠正”的过程中引入新的错误。这表明,虽然反思机制提供了强大的自我改进能力,但其鲁棒性仍需进一步研究。未来的工作不仅要关注如何让LLM更好地反思,还要关注如何确保“反思本身”是可靠和准确的,可能需要引入独立的、更客观的验证机制来监控反思过程的质量。

结论与展望

总结Reflexion的关键贡献

Reflexion提示词模式代表了大型语言模型自我改进范式的一次重要创新。它通过语言反馈而非传统的模型权重更新来强化LLM,在复杂任务中展现出卓越的性能提升,尤其是在代码生成、语言推理和顺序决策方面 。其模块化的Actor-Evaluator-Self-Reflection架构,以及紧密的迭代自我纠正循环,使得智能体能够高效地从试错中学习,并提供可解释的记忆路径 。Reflexion并非取代Chain-of-Thought (CoT) 或 ReAct 等现有技术,而是通过引入明确的自我评估、自我反思和记忆组件,对其进行了有效的扩展 。这使得LLM智能体从简单的执行者向具备自主学习和适应能力的学习者迈进,体现了其作为一种元学习框架的潜力。此外,Reflexion及其相关的反思技术在缓解LLM幻觉问题上也展现出积极作用,通过内部的质量控制和迭代验证,提升了输出的事实一致性和可靠性 。

展望未来的发展方向和潜在研究领域

Reflexion提示词模式为LLM的自我改进和复杂问题解决开辟了新的道路,但其发展仍处于早期阶段,未来有诸多值得深入探索的方向:

  • 增强自我评估能力: 当前Reflexion的有效性高度依赖于智能体准确评估自身错误的能力,而这对于复杂任务仍是挑战 。未来的研究应聚焦于如何提高LLM的“元认知”能力,使其能够更精确地识别自身知识边界和输出缺陷,可能需要结合更先进的元学习技术或引入外部验证信号来校准其自我评估。

  • 优化长期记忆管理: Reflexion目前使用的滑动窗口记忆机制在处理长期依赖或需要大量历史经验的任务时存在局限 。探索和实现更高效、可扩展的长期记忆结构,如高级向量数据库、知识图谱或混合记忆系统,将是关键。这将使智能体能够访问和利用更丰富、更相关的历史经验,从而支持更复杂、多轮次的任务。

  • 缓解“元幻觉”: 反思过程中模型自身产生幻觉的“元幻觉”问题是一个深层次的挑战 。未来的研究应开发新的检测和缓解策略,确保反思过程本身的可靠性和准确性,可能需要引入独立的、更客观的验证机制来监控反思过程的质量。

  • Reflexion与其他高级技术的融合: 深入研究Reflexion与Tree of Thoughts (ToT) 、多智能体系统、检索增强生成(RAG)等其他高级提示词和架构的协同效应,以构建更强大、更通用的AI智能体。例如,Reflexion可以为ToT的搜索和剪枝过程提供更精细的反馈,或者与RAG结合以增强事实基础。

  • 更广泛的应用探索: 将Reflexion应用于更多开放式、需要创造性和复杂交互的领域,如开放域对话、科学发现、艺术创作等,并探索其在这些领域中的泛化能力和局限性。这将推动Reflexion从结构化任务向更广阔的非结构化领域扩展。

  • 理论基础的深化: 进一步探索Reflexion与人类认知科学、学习理论之间的深层联系,例如其与人类批判性思维、经验学习循环的对应关系 。这将为AI的自我改进机制提供更坚实的理论基础,并可能启发更多仿生智能体的设计。

Reflexion提示词模式的出现,标志着LLM在迈向真正智能和自主学习的道路上迈出了重要一步。通过持续的研究和创新,Reflexion有望在未来AI系统的设计和部署中发挥越来越核心的作用。

提示词工程-反思模式

提示词工程-反思模式

什么是 Reflexion?

Reflexion 是一种先进的 AI Agent 架构,其核心思想是让 Agent 具备自我反思和自我修正的能力。它不仅仅是简单地执行任务(像传统的 ReAct – Reason and Act 模式),而是在遇到失败或障碍时,能够停下来“复盘”自己的行为轨迹,从中吸取教训,并形成指导性的“经验”,用于下一次的尝试。

简单来说,Reflexion 赋予了 Agent 一种从失败中学习的机制,模拟了人类在解决复杂问题时的试错和总结过程。

这项技术主要源于康奈尔大学等机构在 2023 年发表的论文《Reflexion: Language Agents with Verbal Reinforcement Learning》。

Reflexion 与传统方法的区别

特性传统 ReAct AgentReflexion Agent
核心循环思考 -> 行动 -> 观察 (Thought -> Act -> Observation)尝试 -> 评估 -> 反思 -> 再次尝试 (Trial -> Evaluate -> Reflect -> Retry)
失败处理可能会在当前步骤卡住,或进行无效的重复尝试。将整个失败的“轨迹”作为学习材料,进行深入分析。
记忆通常是短期的“暂存器”(Scratchpad),记录当前任务的步骤。拥有一个长期、不断累积的“反思记忆库”(Reflexion Memory)。
学习方式主要依赖于 In-context Learning,受限于单次提示的长度和内容。通过“语言强化学习”,将反思(Verbal Feedback)作为内部奖励信号来指导后续行为。

Reflexion 的核心组件

一个完整的 Reflexion 流程包含三个关键角色,它们都可以由同一个大型语言模型(LLM)通过不同的 Prompt 来扮演:

  1. 行动者 (Actor):

    • 职责: 根据任务目标和当前的“反思记忆”,生成思考和具体行动指令。
    • 工作方式: 这是 Agent 的“手和脚”,负责与外部环境(如代码解释器、搜索引擎)交互。在后续的尝试中,Actor 的 Prompt 会包含之前失败后总结的反思,从而避免重蹈覆辙。
  2. 评估者 (Evaluator):

    • 职责: 判断行动者的输出结果是成功、失败还是部分成功。
    • 工作方式: 评估者检查 Actor 的行动轨迹(Trajectory)和最终结果。评估可以是简单的基于规则的检查(例如,代码是否成功运行),也可以是复杂的、基于 LLM 的语义判断(例如,生成的文章是否回答了问题)。
  3. 自我反思者 (Self-Reflector):

    • 职责: 这是 Reflexion 的核心。当评估者给出“失败”信号时,反思者被激活。它会分析整个失败的行动轨迹,并生成一段简洁、高度概括、具有指导意义的反思文本 (Reflection Text)
    • 工作方式: 反思者会被要求回答“为什么之前的尝试会失败?”以及“下一次应该如何做才能避免这个错误?”。生成的反思文本会被存储到“反思记忆库”中。

工作流程图

下面是 Reflexion Agent 的典型工作流程:


如何使用 Reflexion Prompt 开发 Agent

开发一个 Reflexion Agent 的本质,就是设计一套精巧的 Prompt 链,来分别驱动 Actor, Evaluator 和 Reflector 这三个角色,并管理好“反思记忆库”。

第1步:定义 Agent 的核心组件

你需要准备三个主要的 LLM 调用函数,或者说三个核心 Prompt。

1. Actor Prompt (行动者提示)

这是 Agent 执行任务的基础。与 ReAct 不同的是,你需要为它注入“反思记忆”。

  • 基础结构:

    你是一个{Agent角色,如AI程序员}。你需要解决以下任务。
    
    # 任务
    {task_description}
    
    # 思考过程
    你需要一步步思考,然后选择一个工具/行动。可用的工具有: {tool_list}。
    
    # 反思 (如果记忆库不为空)
    在之前的尝试中,你犯了一些错误。请参考以下从失败中总结的经验教训,避免重蹈覆覆:
    {reflection_memory}
    
    # 行动轨迹 (Scratchpad)
    {scratchpad}
  • {reflection_memory}: 这是一个变量,用于动态插入所有过去的反思文本。在第一次尝试时,这里是空的。
  • {scratchpad}: 用于记录当前尝试中的“Thought, Action, Observation”序列。

2. Evaluator Prompt (评估者提示)

评估可以是简单的代码检查,也可以是复杂的 LLM 判断。对于需要语义理解的评估,可以使用如下 Prompt:

  • 基础结构:

    # 角色
    你是一个严谨的评估机器人。
    
    # 原始任务
    {task_description}
    
    # Agent 的行动轨迹
    {agent_trajectory}
    
    # 评估标准
    请根据以下标准判断 Agent 是否成功完成了任务:
    1.  {criterion_1}
    2.  {criterion_2}
    
    # 你的判断
    请严格回答 "Success" 或 "Failure"。
  • {agent_trajectory}: 传入 Actor 在一次完整尝试中的所有记录。

3. Self-Reflector Prompt (自我反思提示)

这是整个 Reflexion 机制的灵魂。当 Evaluator 返回 "Failure" 时,调用此 Prompt。

  • 基础结构:

    # 角色
    你是一个善于反思和总结的 AI 导师。
    
    # 失败的尝试
    一个 Agent 在尝试解决以下任务时失败了。
    任务: {task_description}
    
    这是它失败的完整行动轨迹:
    {failed_trajectory}
    
    # 你的任务
    请仔细分析上述轨迹,找出导致失败的关键原因。然后,生成一条或几条简洁、通用、具有指导意义的反思。这条反思应该像一个警句或策略,帮助 Agent 在未来的尝试中避免同样的错误。
    
    # 输出要求
    - 直接输出反思文本。
    - 语言要精炼,不超过 50 个字。
    - 专注于策略层面,而不是具体的代码细节。
    
    # 你的反思:
  • 示例输出 (反思文本):
    • "如果一个库的某个函数不存在,应该先检查库的版本或者查阅官方文档,而不是猜测函数名。"
    • "在进行文件写入前,必须先确认目标目录是否存在,如果不存在则需要创建它。"
    • "当网页爬取不到预期内容时,应检查请求头(Headers)是否模拟了真实浏览器,以防被屏蔽。"

第2步:搭建 Agent 的主循环

有了这三个核心 Prompt,你就可以编写 Agent 的主控制逻辑了。

伪代码示例:

def run_reflexion_agent(task, max_trials=3):
    # 初始化反思记忆库
    reflection_memory = []

    for i in range(max_trials):
        print(f"--- 开始第 {i+1} 次尝试 ---")

        # 1. 执行一次完整的尝试 (Actor)
        # Actor 的 prompt 中会包含 reflection_memory
        current_trajectory = execute_trial(task, reflection_memory)

        # 2. 评估结果 (Evaluator)
        is_successful = evaluate_trial(task, current_trajectory)

        if is_successful:
            print("任务成功!")
            return current_trajectory
        else:
            print("尝试失败,开始反思...")
            # 3. 如果失败,进行反思 (Self-Reflector)
            new_reflection = generate_reflection(current_trajectory)
            print(f"新的反思: {new_reflection}")

            # 4. 更新记忆库
            reflection_memory.append(new_reflection)

    print("已达到最大尝试次数,任务失败。")
    return None

# --- Helper Functions ---
def execute_trial(task, reflections):
    # 调用 LLM (Actor Prompt) 来生成一系列的 thought-action-observation
    # ... 实现细节 ...
    return trajectory

def evaluate_trial(task, trajectory):
    # 调用 LLM (Evaluator Prompt) 或其他规则来判断成功与否
    # ... 实现细节 ...
    return True_or_False

def generate_reflection(failed_trajectory):
    # 调用 LLM (Self-Reflector Prompt) 来生成反思文本
    # ... 实现细节 ...
    return reflection_text

关键的实现细节与建议

  1. 管理记忆库和上下文窗口: 反思记忆会不断增长。如果记忆过多,可能会超出 LLM 的上下文窗口限制。你需要策略来管理它,例如:

    • 只保留最近的 N 条反思。
    • 对所有反思进行一次更高层次的总结。
    • 使用向量数据库,根据当前失败情境检索最相关的反思。
  2. 反思的质量至关重要: Self-Reflector Prompt 的设计直接决定了 Agent 的学习效率。一个好的反思应该是通用且可操作的,而不是简单地复述错误。

  3. 分层反思 (Hierarchical Reflection): 对于非常复杂的任务,可以设计两层反思。第一层针对短期策略,第二层在多次失败后进行更高层次、更长远的战略总结。

总结

Reflexion 是一种强大但实现起来也更复杂的 Agent 架构。它通过将失败转化为学习机会,极大地提升了 Agent 在需要多步推理、试错和规划的复杂任务上的鲁棒性和成功率。

要成功开发一个 Reflexion Agent,关键在于设计出能够精准驱动 Actor、Evaluator 和 Self-Reflector 这三大核心角色的 Prompt,并实现一个有效的主循环来调度它们和管理反思记忆。这不仅仅是技术实现,更是一门 Prompt Engineering 的艺术。

nuwa terminal 发布了新版本v0.1.1

nuwa-terminal 新版本发布说明

简单介绍

nuwa-terminal 是一个在终端中与大语言模型(LLM)聊天的程序,该工具基于LLM,旨在使终端更加智能。这个终端可以帮助用户使用自然语言
执行命令或任务,同时它还可以作为终端智能助手,你可以询问任何关于软件开发的任何问题。

帮助文档请参考README

目前该版本只支持安装到Linux环境上,对于windows 用户,可以安装到WSL上使用。

更改内容

新特性

  • 聊天模式流式输出:新增对聊天模式流式输出的支持。
  • 安装脚本:发布了 install.sh 并更新了安装指南。
  • 自然语言脚本支持
    • 新增了自然语言脚本系统提示。
    • 新增对脚本模式的处理支持。
    • 新增了系统服务检查的示例脚本。
    • 新增了用于收集 pod 信息的自然语言脚本。
  • 后端配置:新增了对 Google 和 Deepseek 的后端配置支持。
  • 文件路径建议:启动时支持 ./ 或 / 开头的文件路径建议。
  • 未来特性:新增对 Git 的未来特性支持。

改进

  • 代码重构
    • 重构了 setCurrentWorkMode。
    • 在主进程中使用了 NuwaCmd 对象。
    • 在主进程中使用了 NuwaModeManager。
    • 更新了 CheckDirChanged,使用了 getwd。
    • 将 GenerateContent 移至 llms 包。
    • 重构了命令解析代码。
  • 文档更新
    • 更新了支持特性的功能列表。
    • 更新了自然语言脚本相关文档。
    • 删除了 README.md 中的 bash 模式内容。
  • 错误处理:修复了错误格式,并新增了命令帮助。

Bug 修复

  • 键盘快捷键:修复了帮助信息和注释中的错误快捷键。

内部更改

  • Nuwa 包集成
    • 新增了 NuwaModeManager 接口及其实现。
    • 使用了来自 nuwa 包的 NuwaAgent、NuwaTask 和 NuwaChat。
    • 新增了以下实现:
    • 脚本模式。
    • Nuwa 代理模式。
    • Nuwa 任务模式。
    • Nuwa 命令模式。
    • Nuwa 聊天模式。
    • 删除了 main.go 中的 ParseScript。

详细更改

特性

  • 新增了 install.sh 脚本,简化了安装过程。
  • 新增了聊天模式流式输出支持。
  • 新增了 Google 和 Deepseek 的后端配置支持。
  • 新增了自然语言脚本示例和系统提示。
  • 为了更好的用户体验,新增了文件路径建议功能。

重构

  • 重构代码以使用 NuwaCmd、NuwaModeManager 和来自 nuwa 包的其他组件。
  • 改进了命令解析逻辑和错误处理。

文档

  • 更新了 README.md 以反映更改并删除过时信息。
  • 增加了自然语言脚本和未来特性的文档。

Bug 修复

  • 修复了帮助信息和注释中的错误快捷键。

本版本包含了代码结构的重大改进,新增了自然语言脚本功能,以及更好的用户体验,包括文件路径建议和流式输出。有关详细说明,请参阅更新后的文档。

如何安装

使用安装脚本(推荐)


# 下载并运行安装脚本
wget https://github.com/darmenliu/nuwa-terminal-chat/releases/latest/download/install.sh
chmod +x install.sh
sudo ./install.sh

# 配置你的 API 密钥
vim ~/.nuwa-terminal/envs.sh
source ~/.nuwa-terminal/envs.sh

# 启动 nuwa-terminal
nuwa-terminal

如何使用DeepSeek的API开发大模型应用

如何使用DeepSeek的API开发大模型应用

DeepSeek-v3 和 DeepSeek-r1

最近Deepseek因为连续发布了Deepseek-v3和Deepseek-r1两个模型而迅速出圈,在全球科技领域引起了很大的轰动。

Deepseek2024年12月底发布并开源了DeepSeek-V3模型,性能可比肩顶级闭源模型。

Deepseek2025年1月发布了推理模型DeepSeek-R1,在多项测试中超越了OpenAI的o1模型。

以下是它们的基本介绍:

DeepSeek-V3

DeepSeek-V3 是一种混合专家(MoE)模型,具有 6710 亿参数,同时激活 370 亿参数。它在知识基础任务、长文本处理、代码生成和数学推理方面表现出色。它在中文语言能力方面也颇具特色。DeepSeek-V3 结合了多头潜在注意力(MLA)、DeepSeekMoE 和多标记预测(MTP)等创新。

主要特性和亮点:

  • 性能:DeepSeek V3 在一些领域超越了其他开源模型,并在某些方面与顶尖闭源模型如 GPT-4o 和 Claude 竞争。它在 MMLU(EM)上达到了 88.5% 的准确率,在 MMLU-Redux(EM)上达到了 89.1% 的准确率。
  • 速度:其生成速度提高了三倍,从每秒 20 个标记增加到 60 个标记(TPS)。
  • 架构:DeepSeek-V3 采用了一种新的负载平衡策略,不依赖于辅助损失。它使用细粒度专家系统,动态调整专家路由,以确保负载平衡而不牺牲模型性能。
  • 训练:DeepSeek-V3 使用 FP8 混合精度训练框架,完成了对 14.8 万亿标记的预训练,使用了 2.664M H800 GPU 小时。它从 DeepSeek R1 等模型中提炼推理能力,以提高其推理性能。

DeepSeek R1

DeepSeek R1 是一个基于开源和强化学习(RL)的模型,以其推理能力而闻名。它几乎完全依赖于 RL 进行微调,最小化了对标记数据集的需求。

主要特性和亮点:

  • 推理:DeepSeek R1 在数学、代码和自然语言任务中表现出强大的推理能力。在 AIME 2024 数学竞赛中,它达到了 79.8% 的 pass@1 得分。在 Codeforces 上获得了 2029 Elo 评分,超过了 96.3% 的人类参与者。
  • 训练:DeepSeek R1 使用多阶段训练过程,在强化学习之前集成冷启动数据。它采用基于规则的方法,确保可扩展的强化学习,并将强大的推理能力推广到其他领域。
  • 性价比:与 OpenAI 的 o1 模型相比,DeepSeek R1 的训练成本更低。每百万个标记的输入成本便宜 90%,输出价格约低 27 倍。
  • 开源:DeepSeek R1 在 MIT 许可下开源,允许用户自由使用、修改、分发和商业化该模型。

申请DeepSeek的API Key

进入DeepSeek官网, 点击右上角的“API开放平台”按钮,进入API开放平台页面。
选择“API Key”,点击“创建API Key”按钮,创建一个API Key。将你的API Key保存到安全的地方,后续会用到。

使用API Key调用DeepSeek的API

使用curl调用DeepSeek的API


curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer " \
  -d '{
        "model": "deepseek-chat",
        "messages": [
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"}
        ],
        "stream": false
      }'

使用Python调用DeepSeek的API

DeepSeek的API与OpenAI的API兼容,因此完全可以使用OpenAI的SDK直接调用DeepSeek的API。
这也是官方文档推荐的方法。


# Please install OpenAI SDK first: pip3 install openai

from openai import OpenAI

client = OpenAI(api_key="", base_url="https://api.deepseek.com")

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "Hello"},
    ],
    stream=False
)

print(response.choices[0].message.content)

使用Langchain封装的接口调用DeepSeek的API

使用OpenAI的库是相对简单和直接的方法,但是OpenAI的库功能相对单一,如果需要更复杂
的功能,比如链式调用、内存管理、工具调用等,还是需要使用LangChain。

LangChain介绍

LangChain 是一个用于开发由大型语言模型(LLMs)驱动的应用程序的框架。简化了 LLM
应用程序生命周期的每个阶段,提供了一套工具、组件和接口,帮助开发者更高效地构建智
能应用。 LangChain 的主要功能包括:

  • 模型输入/输出(Model I/O):理大型语言模型的输入(Prompts)和输出格式化
    (Output Parsers)。
  • 数据连接(Data Connection):理向量数据存储(Vector Stores)、内容数据获取
    (Document Loaders)和转换(Transformers),以及向量数据查询(Retrievers)。
  • 记忆(Memory):于存储和获取对话历史记录的功能模块。
  • 链(Chains): Memory、Model I/O 和 Data Connection 串联起来,实现连续对话
    和推理流程。
  • 代理(Agents):于 Chains 进一步集成工具(Tools),将大语言模型的能力与本
    地或云服务结合。
  • 回调(Callbacks):供回调系统,可连接到 LLM 应用的各个阶段,便于日志记录和
    追踪。过这些功能,开发者可以创建各种应用程序,包括聊天机器人、智能问答工具、文档
    摘要生成等。

LangChain 还支持与外部数据源的连接,使语言模型能够与其环境进行交互,增强应用程序
的功能和灵活性。2022 年 10 月推出以来,LangChain 迅速获得了开发者的关注和支持,
成为构建 LLM 驱动应用程序的强大工具。

使用LangChain Python调用DeepSeek的API


# 安装必要库(如果未安装)
# pip install langchain-core langchain-openai

import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# 设置环境变量(替换为您的API Key)
os.environ["DEEPSEEK_API_KEY"] = "sk-your-api-key-here"

# 创建 DeepSeek 模型实例
# 假设 DeepSeek API 兼容 OpenAI 格式
model = ChatOpenAI(
    model="deepseek-chat",  # 指定模型名称
    base_url="https://api.deepseek.com/v1",  # DeepSeek API 地址
    api_key=os.environ["DEEPSEEK_API_KEY"],
    temperature=0.7,  # 控制生成随机性(0-1)
    max_tokens=512  # 最大输出长度
)

# 创建对话提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个乐于助人的AI助手"),
    ("user", "{input}")
])

# 创建简单对话链
chain = prompt | model

# 执行对话
response = chain.invoke({
    "input": "请用Python写一个快速排序算法,并解释其原理"
})

print("AI回复:\n", response.content)

另外一种选择是,最新的langchain库已经提供了deepseek的扩展库 langchain-deepseek
因此直接使用该库,也可以很方便的调用DeepSeek的API。


# 安装必要库(如果未安装)
# pip install -U langchain-deepseek
export DEEPSEEK_API_KEY="your-api-key"

from langchain_deepseek import ChatDeepSeek

llm = ChatDeepSeek(
    model="deepseek-chat",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
    # api_key="...",
    # other params...
)

messages = [
    ("system", "You are a helpful translator. Translate the user sentence to French."),
    ("human", "I love programming."),
]
response = llm.invoke(messages)
print(response)

# Stream response
response = llm.stream(messages)
for chunk in response:
    print(chunk)

使用LangChain Go调用DeepSeek的API

Golang 非常适合开发云原生后端应用,同时相比Python,Golang的性能更高,更适合开发高性能的应用。
LangchainGo is the Go Programming Language port/fork of LangChain.
以下提供一个使用LangchainGo调用DeepSeek的API的示例。


package main

import (
    "context"
    "fmt"
    "log"

    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/openai"
)

func main() {
    // Initialize the OpenAI client with Deepseek model
    llm, err := openai.New(
        openai.WithModel("deepseek-reasoner"),
    )
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // Create messages for the chat
    content := []llms.MessageContent{
        llms.TextParts(llms.ChatMessageTypeSystem, "You are a helpful assistant that explains complex topics step by step"),
        llms.TextParts(llms.ChatMessageTypeHuman, "Explain how quantum entanglement works and why it's important for quantum computing"),
    }

    // Generate content with streaming to see both reasoning and final answer in real-time
    completion, err := llm.GenerateContent(
        ctx,
        content,
        llms.WithMaxTokens(2000),
        llms.WithTemperature(0.7),
        llms.WithStreamingFunc(func(ctx context.Context, chunk []byte) error {
            fmt.Print(string(chunk))
            return nil
        }),
    )
    if err != nil {
        log.Fatal(err)
    }

    // Access the reasoning content and final answer separately
    if len(completion.Choices) > 0 {
        choice := completion.Choices[0]
        fmt.Printf("\n\nReasoning Process:\n%s\n", choice.ReasoningContent)
        fmt.Printf("\nFinal Answer:\n%s\n", choice.Content)
    }
}

使用DeepSeek模型开发智能应用的场景

DeepSeek 模型和其他大模型一样,在多个领域具有广泛的应用:

  • 城市治理:AI 可以处理公众请求,协助政府工作人员,并通过 AI 助手和公众关切问题的智能分析来支持决策制定。
  • 客户服务:通过集成 DeepSeek API,企业可以创建 24/7 全天候可用的 AI 助手,用于回答客户问题并提高响应速度。
  • 内容创作:DeepSeek 能够快速生成高质量的文本,例如新闻报道、博客文章和营销内容,提高内容创作效率。
  • 教育:DeepSeek 可用于开发智能教育平台,根据学生的表现个性化学习计划,识别知识盲点,并提供针对性的练习。
  • 医疗:DeepSeek 的智能诊断系统可以快速分析医学影像,提供精准的诊断建议,从而辅助诊断和药物研发。
  • 金融:它可以分析金融数据,提供投资建议、风险评估以及欺诈预防。

DeepSeek 模型还可应用于智能家居,实现语音交互和场景识别;在智能交通领域,用于优化交通流量和辅助驾驶。

此外,DeepSeek 模型适用于需要高推理能力的任务,例如解决数学问题、编写代码以及处理逻辑复杂的场景。
DeepSeek V3 模型兼容 OpenAI API,具有高性价比和优异性能,能够降低获取、部署和使用大模型的成本,
加速其在商业和消费场景中的应用。

我个人的开发案例

目前我正在探索使用AI大模型来提升Linux运维效率,以下是一些探索和实践。

基于DeepSeek 的 nuwa-terminal 智能终端助手

nuwa-terminal 是一个在终端中与大语言模型(LLM)聊天的程序,该工具基于LLM,旨在使终端更加智能。这个终端可以帮助用户使用自然语言 执行命令或任务,同时它还可以作为终端智能助手,你可以询问任何关于软件开发的任何问题。

该文章基于原生deepseek开发的智能终端工具nuwa-terminal 会有详细的介绍。

GitHub地址:nuwa-terminal

基于DeepSeek 的 Linux 系统监控程序

AI Agentic Monitor 是一个基于 AI 智能体技术的系统监控工具。它旨在监控Linux及Cloud系统的状态,并提供实时警报和系统优化建议。
它还非常智能,可以帮助您找到问题的根本原因并提供解决方案。目前该项目还在开发中,欢迎感兴趣的朋友一起参与。

GitHub地址:AI Agentic Monitor

基于原生deepseek开发的智能终端工具Nuwa Terminal

基于原生deepseek开发的智能终端工具Nuwa Terminal

基于生成式AI可以重构一切传统软件的思路,我产生了一种想法就是使用AI大模型,来开发一款更加智能的终端工具。于是Nuwa Terminal诞生了。

nuwa-terminal 是一个在终端中与大语言模型(LLM)聊天的程序,该工具基于LLM,旨在使终端更加智能。这个终端可以帮助用户使用自然语言
执行命令或任务,同时它还可以作为终端智能助手,你可以询问任何关于软件开发的任何问题。

为什么需要Nuwa Terminal智能终端

作为程序员,实际上我们只有少部分时间在写代码,大部分的时间在分析需求、阅读文档、调试代码、解决bug、沟通交流等。过程中有相当一部分
时间是在使用终端来完成一些任务,比如:

  • 使用git命令提交代码。
  • 使用docker或者K8S命令部署项目并进行测试。
  • 调试应用程序。
  • 使用Linux系统命令调查各种系统问题。

这些任务中,大部分都是重复性的工作,同时程序员需要查阅各种文档,Linux map page等等,这些都大大降低了我们的工作效率。
多个上下文的切换,降低了同一任务的专注度。尤其对于复杂的任务来说,如果是要编写shell脚本的话(shell 并不是每天都在使
用的编程语言,只有在需要的时候,尤其是测试的时候使用),并不是每个人都擅长。这需要花更多的时间学习来完成。

然而,大语言模型存储了大量的知识,有些模型尤其擅长软件开发,Linux及开源软件的知识。通过大语言模型,可以轻松的使用自然
语言来生成Linux命令行或者shell脚本。

因此使用AI大模型的能力来赋能终端,可以让程序员的工作更加容易,同时专注在当前任务上。

Nuwa terminal的架构

nuwa terminal 的架构非常简单,它使用langchaingo作为基础库和大模型进行交互,langchaingo是langchain的golang复刻版本,
nuwa terminal 是基于单个AI agent的架构,通过调用命令和脚本来完成任务。

Nuwa terminal 目前支持的功能特性

  • 基于终端的AI运维助力。
  • 使用自然语言生成shell命令并执行。
  • 使用自然语言生成shell脚本并执行。
  • 使用智能体模式执行复杂任务或者故障排查。
  • 支持执行自然语言编写的脚本。
  • 支持和bash之间进行自由切换。

如何使用 Nuwa Terminal

Nuwa Terminal 的使用文档可以参考这里

安装前准备

安装和使用

# 构建并安装 nuwa-terminal-chat
git clone https://github.com/darmenliu/nuwa-terminal-chat.git
cd nuwa-terminal-chat
make

# 使用 sed 将 LLM_API_KEY=apikey 替换为真实的 api key
sed -i 's/LLM_API_KEY=apikey/LLM_API_KEY=<你的 api key>/g' envs.sh
source envs.sh

# 运行 nuwa-terminal-chat
(base) $ ./nuwa-terminal
███    ██ ██    ██ ██     ██  █████      ████████ ███████ ██████  ███    ███ ██ ███    ██  █████  ██
████   ██ ██    ██ ██     ██ ██   ██        ██    ██      ██   ██ ████  ████ ██ ████   ██ ██   ██ ██
██ ██  ██ ██    ██ ██  █  ██ ███████        ██    █████   ██████  ██ ████ ██ ██ ██ ██  ██ ███████ ██
██  ██ ██ ██    ██ ██ ███ ██ ██   ██        ██    ██      ██   ██ ██  ██  ██ ██ ██  ██ ██ ██   ██ ██
██   ████  ██████   ███ ███  ██   ██        ██    ███████ ██   ██ ██      ██ ██ ██   ████ ██   ██ ███████

/home/bob>>> 你是谁?
你: 你是谁?
NUWA: 我是NUWA,一个终端聊天工具。我可以通过生成代码、执行命令和回答问题来帮助你进行软件开发。我有三种模式:

* **聊天模式:** 用于一般聊天和代码生成。
* **命令模式:** 用于执行Linux命令。
* **任务模式:** 用于生成shell脚本并执行Linux命令。

你可以使用以下命令在模式之间切换: chatmode, cmdmode, 和 taskmode。

今天我能为你做些什么?

/home/bob>>> 你能为我做什么?
你: 你能为我做什么?
NUWA: 我是NUWA,你友好的软件工程师聊天机器人。我可以帮助你完成各种任务,包括:

**聊天模式:**
* 回答你关于软件开发概念、最佳实践等问题。
* 根据你的指示生成各种编程语言的代码片段。

**命令模式:**
* 直接在我们的聊天中执行Linux命令。

**任务模式:**
* 创建根据你需求定制的shell脚本。
* 在任务上下文中执行Linux命令。

要开始,告诉我你想进入哪种模式:
* **chatmode** 用于一般软件开发聊天
* **cmdmode** 用于运行Linux命令
* **taskmode** 用于创建和运行shell脚本

今天你想做什么?

/home/bob>>>

Nuwa Terminal 的工作模式

Nuwa 有四种工作模式,分别是:

  • 聊天模式:用于一般聊天和代码生成。
  • 命令模式:用于执行Linux命令。
  • 任务模式:用于创建和运行shell脚本。
  • 智能体模式:用于执行复杂任务或者故障排查。

聊天模式相当于Nuwa是一个智能运维助手,你可以和它进行聊天,询问各种问题,它可以帮助你回答问题,并生成代码或者shell命令。
在命令模式下,你可以通过自然语言生成Linux命令,并执行。同样任务模式下,你可以通过自然语言生成shell脚本,并执行。智能体
模式还是一个实验性的功能,在智能体模式下,Nuwa可以执行更加复杂的任务,比如:寻找系统高负载的原因,并找出相应的进程。

以下可以提供一些使用示例:


# 使用聊天模式,生成一个查询所有指定namespace下k8s pods日志的脚本
nuwa-terminal-chat@ 帮我生成查询所有指定namespace下k8s pods日志的脚本,
You: 帮我生成查询所有指定namespace下k8s pods日志的脚本,
NUWA: 好的,我可以帮你生成一个查询指定 Kubernetes 命名空间下所有 Pods 日志的脚本。这个脚本将使用 kubectl 命令来获取日志。

@get_pods_logs.sh@
#!/bin/bash

# 检查是否提供了命名空间参数
if [ -z "$1" ]; then
  echo "Usage: $0 "
  exit 1
fi

NAMESPACE=$1

# 获取指定命名空间下的所有 Pods
PODS=$(kubectl get pods -n $NAMESPACE -o jsonpath='{.items[*].metadata.name}')

# 遍历每个 Pod 并获取日志
for POD in $PODS; do
  echo "Fetching logs for pod: $POD"
  kubectl logs $POD -n $NAMESPACE
done

### 使用方法:
1. 将上述脚本保存为 get_pods_logs.sh。
2. 赋予脚本执行权限:chmod +x get_pods_logs.sh。
3. 运行脚本并指定命名空间:./get_pods_logs.sh <namespace>。

这个脚本会输出指定命名空间下所有 Pods 的日志。如果你需要进一步处理这些日志,可以在脚本中添加相应的逻辑。
# 默认是聊天模式,切换到命令模式,执行命令时以自然语言描述
nuwa-terminal-chat@ cmdmode
You: cmdmode
2025-01-11 21:26:03 INFO  NUWA TERMINAL: Mode is cmdmode
nuwa-terminal-chat# 获取当前系统cpu占用较高的进程
You: 获取当前系统cpu占用较高的进程
NUWA: execute command: ps aux --sort=-%cpu | head -n 10
time=2025-01-11T21:26:47.635+08:00 level=INFO msg=Matched: "match content"="ps aux --sort=-%cpu | head -n 10"
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      245519  2.1  0.1 6258356 30852 pts/5   Sl+  21:25   0:01 ./nuwa-terminal
root           1  1.0  0.0 167020 12400 ?        Ss   11:33   6:03 /sbin/init
root         781  0.4  0.2  43388 36800 ?        S    11:33   2:37 python3 /snap/ubuntu-desktop-installer/1286/usr/bin/cloud-init status --wait
# 切换到任务模式,生成一个shell脚本,并执行
# taskmode
You: taskmode
2025-01-11 21:31:09 INFO  NUWA TERMINAL: Mode is taskmode
nuwa-terminal-chat> 查询当前内存使用情况,找出系统中占用内存较高的前5进程
You: 查询当前内存使用情况,找出系统中占用内存较高的前5进程
NUWA: 以下是一个用于查询当前内存使用情况并找出系统中占用内存较高的前5进程的Shell脚本:

#!/bin/bash

# 获取内存使用情况并排序,显示前5个进程
ps aux --sort=-%mem | head -n 6

### 解释:
- ps aux:显示所有进程的详细信息。
- --sort=-%mem:按照内存使用率(%MEM)降序排序。
- head -n 6:显示前6行(包括标题行),即前5个进程。

运行此脚本后,您将看到系统中占用内存最高的前5个进程及其详细信息。
time=2025-01-11T21:33:12.748+08:00 level=INFO msg="Adding file to source file dict" content="`` shell\n#!/bin/bash\n\n# 获取内存使用情况并排序,显示前5个进程\nps aux --sort=-%mem | head -n 6\n``"
time=2025-01-11T21:33:12.748+08:00 level=INFO msg=Matched: "match_content "="#!/bin/bash\n\n# 获取内存使用情况并排序,显示前5个进程\nps aux --sort=-%mem | head -n 6"
2025-01-11 21:33:12 INFO  NUWA TERMINAL: script file saved to
                      │   .nuwa-terminal/scripts/39ea4f03-79d9-4cc4-8ea4-1cb338ce9314.sh
2025-01-11 21:33:12 INFO  NUWA TERMINAL: script output
                      └ output: + ps aux --sort=-%mem
+ head -n 6
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

2025-01-11 21:33:12 INFO  NUWA TERMINAL: script file removed

未来的开发计划

  • 支持项目和解释代码
  • 支持分析日志和解释日志
  • 支持远程模式,通过ssh在远程主机上执行命令或者任务
  • 支持通过自然语言执行git 相关的操作

贡献者招募

Nuwa Terminal 是一个开源项目,是一个有趣的学习和尝试,通过AI大模型来重构终端工具,欢迎有兴趣的伙伴参与贡献,共同打造一个更加智能的终端工具。
如果感兴趣,可以联系我,一起交流。

如果你关注到这个项目,欢迎给个star,谢谢。

写在最后

我希望将Nuwa Terminal打造成一个更加智能的终端工具,也许它会成为程序员运维工作的好帮手。未来我会引进多智能体架构,使得该工具能够
更加智能和自主的完成任务,目前该工具还处于早期阶段,欢迎大家关注和使用,并提出宝贵的意见和建议。足够多的反馈,会让我
更有动力去完善它。

最后,感谢大家的关注和支持。

面向智能体编程-构建有效的智能体

面向智能体编程-创建有效的智能体

本文翻译自build effective agents

译者荐语

随着我对提示词工程及智能体编程有了更深的理解,我越来越肯定的是,智能体编程应该是一种新的编程模式。而哪些已有的框架,比如低代码平台Coze,dify,以及langchain,autogen,multi-agent框架掩盖了过多的细节,开发者无法触及智能体本身运作的细节。另外这些框架试图提供一种通用的解决方案,随着时间的推移,面对不同的需求,增加更多的自由和可定制后,框架本身会变得复杂和累赘。

作为开发者,就如本文得建议,我更愿意直接使用大模型的API开发智能应用,这样会给我更加灵活得自由度,同时在实践过程中,我能更好的学习和理解智能体的运作方式。

正文

在过去的一年中,我们与来自各行各业的数十个团队合作,开发基于大语言模型(LLM)的智能体。我们发现,最成功的实现并非依赖复杂的框架或特定的专业化库,而是基于简单、可组合的模式构建而成。

在本文中,我们将分享与客户合作以及自主开发智能体的经验,并为开发者提供构建高效智能体的实用建议。

什么是智能体?

“智能体”(Agent)有多种定义。一些客户将其定义为完全自主的系统,这些系统能够长时间独立运行,利用各种工具完成复杂任务。另一些客户则将“智能体”用于描述更具指导性的实现,这些实现遵循预定义的工作流。在 Anthropic,我们将所有这些变体统称为智能体系统(agentic systems),但在架构上对工作流和智能体做了重要的区分:

  • 工作流(Workflows) 是指通过预定义的代码路径来编排 LLM 和工具的系统。
  • 智能体(Agents) 则是指由 LLM 动态指导其自身流程和工具使用的系统,它们能够自主决定如何完成任务。

接下来,我们将详细探讨这两种智能体系统。在附录 1(“实践中的智能体”)中,我们还描述了客户在两个特定领域中使用这些系统的实际价值。

什么时候使用智能体?

在使用 LLM 构建应用时,我们建议尽可能找到最简单的解决方案,只有在必要时才增加复杂性。这可能意味着完全不构建智能体系统。智能体系统通常以更高的延迟和成本为代价来换取更好的任务性能,因此需要仔细考虑这种权衡何时是值得的。

当需要更复杂的系统时,工作流为定义明确的任务提供了可预测性和一致性,而智能体则适用于需要大规模灵活性和模型驱动决策的场景。然而,对于许多应用来说,通过检索和上下文示例优化单次 LLM 调用通常已经足够。

何时以及如何使用框架

有许多框架可以简化智能体系统的实现,包括:

  • LangChainLangGraph
  • 亚马逊 Bedrock 的 AI Agent 框架
  • Rivet,一种可视化拖放式 LLM 工作流构建工具;
  • Vellum,另一个用于构建和测试复杂工作流的可视化工具。

这些框架通过简化调用 LLM、定义和解析工具以及链接调用等标准底层任务,使开发者能够轻松上手。然而,它们往往会引入额外的抽象层,这可能掩盖底层的提示(prompts)和响应,增加调试的难度。此外,这些框架可能让开发者倾向于增加不必要的复杂性,而实际上更简单的设置可能已经足够。

我们建议开发者从直接使用 LLM API 开始:许多模式只需要几行代码即可实现。如果您决定使用框架,请确保理解其底层代码。对框架内部逻辑的误解是客户常见的错误来源之一。

更多示例实现,请参考我们的实践手册(Cookbook)

构建块、工作流和代理

在本节中,我们将探讨生产环境中常见的智能体系统模式。从最基础的构建模块——增强型 LLM(Augmented LLM)开始,逐步增加复杂性,涵盖从简单的组合式工作流到自主智能体的各个层级。

构建模块:增强型 LLM

智能体系统的基本构建模块是通过检索、工具和记忆等增强功能扩展的 LLM。当前的模型能够主动利用这些功能,例如生成自己的搜索查询、选择合适的工具以及决定需要保留哪些信息。

我们建议将实现重点放在以下两个关键方面:

  1. 根据您的具体用例定制这些增强功能。
  2. 确保它们为 LLM 提供一个简单且文档齐全的接口。

虽然实现这些增强功能的方法有很多,但其中一种方法是通过我们最近发布的 Model Context Protocol。该协议允许开发者通过简单的客户端实现,集成到一个不断扩展的第三方工具生态系统中。

在本文的剩余部分中,我们将假设每次 LLM 调用都能够访问这些增强功能。

工作流:提示链(Prompt Chaining)

提示链是一种将任务分解为一系列步骤的工作流,每次 LLM 调用都会处理前一步的输出。在每个中间步骤,可以添加程序化检查(见下图中的“gate”),以确保整个过程保持在正确轨道上。

何时使用此工作流

该工作流非常适合那些可以轻松且清晰地分解为固定子任务的情况。其主要目标是通过将每次 LLM 调用转化为更简单的任务,从而在提高准确性和降低延迟之间进行权衡。

提示链适用的示例:

  • 生成营销文案,然后将其翻译成另一种语言。
  • 撰写文档大纲,检查该大纲是否符合某些标准,然后根据大纲撰写文档。

工作流:路由(Routing)

路由是一种将输入分类并引导其进入专门后续任务的工作流。该工作流允许关注点的分离,从而构建更专业化的提示。如果没有这种工作流,针对某种输入进行优化可能会影响其他输入的性能。

路由工作流

何时使用此工作流:
路由适用于复杂任务,在这些任务中,存在不同类别,并且可以通过 LLM 或更传统的分类模型/算法准确处理分类。

路由适用的示例:

  • 将不同类型的客户服务查询(一般问题、退款请求、技术支持)引导到不同的下游流程、提示和工具中。
  • 将简单/常见问题路由到小型模型(如 Claude 3.5 Haiku),而将困难/不寻常的问题路由到更强大的模型(如 Claude 3.5 Sonnet),以优化成本和速度。

工作流:并行化(Parallelization)

LLM 有时可以同时处理任务,并以编程方式汇总它们的输出。这种工作流的并行化表现为两种主要变体:

  • 分段(Sectioning):将任务分解为独立的子任务,并行运行。
  • 投票(Voting):多次运行相同的任务,以获得多样化的输出。

并行化工作流

何时使用此工作流:
并行化在以下情况下效果良好:分割的子任务可以并行处理以提高速度,或者当需要多个视角或尝试以获得更高置信度的结果时。对于具有多个考虑因素的复杂任务,当每个考虑因素由单独的 LLM 调用处理时,LLM 通常表现更佳,这样可以集中注意力在每个特定方面。

并行化适用的示例:

  • 分段(Sectioning):

    • 实施保护机制,其中一个模型实例处理用户查询,而另一个模型实例筛查不当内容或请求。这种方式通常比让同一个 LLM 调用同时处理保护机制和核心响应更有效。
    • 自动化评估 LLM 性能的评估,其中每个 LLM 调用评估给定提示下模型性能的不同方面。
  • 投票(Voting):

    • 检查代码的漏洞,多个不同的提示对代码进行审查,并在发现问题时标记代码。
    • 评估给定内容是否不当,多个提示评估不同方面或要求不同的投票阈值,以平衡假阳性和假阴性。

工作流:协调者-工作者(Orchestrator-Workers)

在协调者-工作者工作流中,中央 LLM 动态地将任务分解,委派给工作者 LLM,并综合它们的结果。

协调者-工作者工作流

何时使用此工作流:
该工作流非常适合复杂任务,其中无法预测所需的子任务(例如,在编码中,需要更改的文件数量以及每个文件的更改性质可能取决于具体任务)。虽然从拓扑上看与并行化类似,但其关键区别在于灵活性——子任务并不是预先定义的,而是由协调者根据具体输入确定的。

协调者-工作者适用的示例:

  • 对每次涉及对多个文件进行复杂更改的编码产品。
  • 涉及从多个来源收集和分析信息以获取可能相关信息的搜索任务。

工作流:评估者-优化器(Evaluator-Optimizer)

在评估者-优化器工作流中,一个 LLM 调用生成响应,而另一个 LLM 在循环中提供评估和反馈。

评估者-优化器工作流

何时使用此工作流:
该工作流在有明确评估标准的情况下特别有效,并且当迭代优化能够提供可测量的价值时使用效果最佳。适合的两个标志是:首先,当人类表达反馈时,LLM 的响应可以明显改善;其次,LLM 能够提供这样的反馈。这类似于人类作家在撰写精炼文档时可能经历的迭代写作过程。

评估者-优化器适用的示例:

  • 文学翻译,其中翻译 LLM 可能最初无法捕捉到某些细微差别,但评估者 LLM 可以提供有用的批评。
  • 复杂的搜索任务,要求多轮搜索和分析以收集全面的信息,在这种情况下,评估者决定是否需要进一步的搜索。

智能体

随着 LLM 在理解复杂输入、进行推理和规划、可靠地使用工具以及从错误中恢复等关键能力上的成熟,智能体(Agents)在生产环境中逐渐崭露头角。智能体通常以来自人类用户的命令或互动讨论开始工作。一旦任务明确,智能体便能独立规划和操作,可能会在执行过程中返回人类获取进一步信息或判断。在执行过程中,智能体在每个步骤中获得环境的“真实情况”(如工具调用结果或代码执行)以评估其进展至关重要。智能体可以在检查点处或遇到阻碍时暂停以获取人类反馈。任务通常在完成时终止,但通常会设置停止条件(如最大迭代次数)以保持对过程的控制。

智能体能够处理复杂的任务,但其实现通常是简单的。它们通常仅仅是基于环境反馈在循环中使用工具的 LLM。因此,清晰且周到地设计工具集及其文档至关重要。我们在附录 2(“为您的工具进行提示工程”)中扩展了工具开发的最佳实践。

何时使用智能体

智能体可以用于开放性问题,在这些问题中,难以或不可能预测所需的步骤数量,并且无法硬编码固定路径。LLM 可能会进行多轮操作,因此必须对其决策能力有一定程度的信任。智能体的自主性使其非常适合在可信环境中扩展任务。

智能体的自主特性意味着更高的成本,以及可能导致错误累积的风险。因此,我们建议在沙盒环境中进行广泛测试,并设置适当的保护措施。

智能体适用的示例:

以下示例来自我们自己的实现:

  • 编码智能体,用于解决 SWE-bench 任务,这些任务涉及根据任务描述对多个文件进行编辑。
  • 我们的“计算机使用”参考实现,其中 Claude 使用计算机完成任务。

组合和定制这些模式

这些构建模块并不是固定不变的规范。它们是开发者可以根据不同用例进行塑造和组合的常见模式。成功的关键在于,和任何 LLM 特性一样,测量性能并对实现进行迭代。再次强调:您应该只在明显改善结果时考虑增加复杂性。

总结

在 LLM 领域,成功并不在于构建最复杂的系统,而在于为您的需求构建合适的系统。首先从简单的提示开始,通过全面评估进行优化,仅在更简单的解决方案无法满足需求时,才添加多步骤的智能体系统。

在实施智能体时,我们努力遵循三个核心原则:

  1. 保持智能体设计的简单性。
  2. 优先考虑透明性,明确显示智能体的规划步骤。
  3. 通过全面的工具文档和测试,仔细设计您的智能体-计算机接口(ACI)。

框架可以帮助您快速入门,但在进入生产阶段时,不要犹豫减少抽象层次,使用基本组件进行构建。遵循这些原则,您可以创建不仅强大而且可靠、可维护且受到用户信任的智能体。

致谢

撰写者:Erik Schluntz 和 Barry Zhang。本文基于我们在 Anthropic 构建智能体的经验,以及客户分享的宝贵见解,我们对此深表感激。

附录 1:智能体的实践

与客户的合作揭示了两个特别有前景的 AI 智能体应用,展示了上述模式的实际价值。这两个应用都说明了智能体在需要对话和行动的任务中如何增加价值,具有明确的成功标准,能够启用反馈循环,并集成有意义的人类监督。

A. 客户支持
客户支持结合了熟悉的聊天机器人界面与通过工具集成增强的功能。这是更开放的智能体的自然契合点,因为:

  • 支持交互自然遵循对话流程,同时需要访问外部信息和操作;
  • 可以集成工具来提取客户数据、订单历史和知识库文章;
  • 诸如处理退款或更新票务等操作可以以编程方式处理;
  • 成功可以通过用户定义的解决方案明确衡量。

一些公司通过基于使用的定价模型展示了这种方法的可行性,仅对成功的解决方案收费,显示出对其智能体有效性的信心。

B. 编码智能体
软件开发领域展现出 LLM 特性的显著潜力,能力从代码补全发展到自主问题解决。智能体特别有效,因为:

  • 代码解决方案可以通过自动化测试进行验证;
  • 智能体可以使用测试结果作为反馈对解决方案进行迭代;
  • 问题空间定义明确且结构化;
  • 输出质量可以客观衡量。

在我们自己的实现中,智能体现在可以仅根据拉取请求描述解决真实的 GitHub 问题,符合 SWE-bench Verified 基准。然而,尽管自动化测试有助于验证功能,但人类审核在确保解决方案与更广泛的系统要求一致方面仍然至关重要。

附录 2:为您的工具进行提示工程

无论您正在构建何种智能体系统,工具都可能是您智能体的重要组成部分。工具使 Claude 能够通过在我们的 API 中指定其确切结构和定义与外部服务和 API 进行交互。当 Claude 做出响应时,如果计划调用工具,它将包括一个工具使用块在 API 响应中。工具定义和规范应与整体提示一样,得到同样多的提示工程关注。在这个简短的附录中,我们描述了如何为您的工具进行提示工程。

指定同一操作通常有几种方法。例如,您可以通过编写差异(diff)来指定文件编辑,或者通过重写整个文件。对于结构化输出,您可以在 markdown 或 JSON 中返回代码。在软件工程中,这些差异在外观上是微不足道的,可以无损转换。然而,某些格式对于 LLM 来说比其他格式更难写。编写差异要求在编写新代码之前知道块头中有多少行在变化。将代码写在 JSON 中(相比于 markdown)需要额外转义换行符和引号。

我们对工具格式的建议如下:

  • 给模型足够的 tokens,以便在写作时能够“思考”,而不是写进死胡同。
  • 保持格式接近模型在互联网上自然出现的文本格式。
  • 确保没有格式“开销”,例如必须准确计算数千行代码或转义任何写的代码。

一个经验法则是考虑人机接口(HCI)投入多少精力,并计划在创建良好的智能体-计算机接口(ACI)上投入同样多的精力。以下是一些想法:

  • 设身处地为模型着想。根据描述和参数,使用这个工具是否显而易见,还是需要仔细思考?如果是这样,那么对于模型来说也可能是如此。良好的工具定义通常包括示例用法、边界情况、输入格式要求以及与其他工具的明确界限。
  • 如何改变参数名称或描述以使其更明显?将其视为为您团队中的初级开发人员撰写出色的文档字符串。这在使用许多相似工具时尤其重要。
  • 测试模型如何使用您的工具:在我们的工作台中运行多个示例输入,查看模型的错误,并进行迭代。
  • 采用防错机制(Poka-yoke)设计您的工具。改变参数,使其更难出错。

在为 SWE-bench 构建智能体时,我们实际上在优化工具上花费的时间比在整体提示上更多。例如,我们发现模型在智能体移动出根目录后使用相对文件路径的工具时会出错。为了解决这个问题,我们将工具更改为始终要求绝对文件路径——我们发现模型以这种方式使用毫无问题。

提示词工程-ReAct提示词(反应式)-让智能体像人一样思考和行动

文章会实时同步到我的公众号,有兴趣的童鞋扫码关注我的公众号噢:

提示词工程-ReAct

提示词工程的魅力就在于,让你可以变成现代版的祭师,能够让大模型言听计从,控制大模型做你想做的事情。

我不太确定超级智能会在未来的哪一天出现,但是从AI的快速迭代和进化来看,我们似乎可以预测,这一天不会遥远。一直以来,创造一个能够自主思考,自主学习和进化的智能体应该是AI发展的终极目标,而在这样的发展进程中,提示词工程也许只是这个进程中的一小段旅程,也许有一天,这项技术会成为历史,不过至少现在,它能够让我们对AI大模型有更加深入的了解,并且助力大模型变得更加聪明和务实。

起初,很难相信,生成模型会具有思考的能力,可当研究人员不断的探索出新的提示词技术时,这种怀疑逐渐得到了清晰的答案。

ReAct 提示词

ReAct 是 "Reasoning and Acting" 的缩写,旨在通过结合推理和行动来提高模型在复杂任务中的表现。

起初该框架由Yao 等人于2022年提出。

ReAct提示词实际上是one-shot或者few-shot提示词的一种(对于什么是one-shot,few-shot提示词,请阅读《提示词工程-少样本提示》)。
简单的说,就是给AI大模型一个思考-行动的例子,通过该例子,表明完成一件特殊任务时,思考和行动的基本框架和逻辑。ReAct本身是拟人化的,模拟人类思考和行动的基本方式,这里我可以举一个非常简单的例子,比如肚子饿了,非常想吃蛋糕:

问题:俺肚子饿了,非常想吃蛋糕。
思考:看看家里有没有买了蛋糕啊?
行动:去冰箱里看看,去厨房看看,发现没有。
思考:想吃自己做的蛋糕呢,还是去点外卖呢,哎,最近有点懒,不想动,还是外卖吧!
行动:打开手机APP,搜索蛋糕,得到种类繁多的蛋糕。
思考:我到底想吃哪一种呢,好像提拉米苏更加诱人一些。
行动:下单购买提拉米苏。
......

以上只是一个非常简单的例子,对人类来说,看起来是件非常普通和自然的事情,可是将思考方式分解,用来提示AI大模型时,会出现非常神奇的效果。

与链式思维推理类似,ReAct 是一种提示工程方法,使用少量样本学习来教模型解决问题。CoT 旨在模仿人类思考问题的方式,ReAct 也包含了这种推理元素,但更进一步地允许智能体通过文本操作与其环境进行交互。人类通过语言推理(说话或思考)来帮助制定策略和记忆事物,但我们也可以采取行动来获取更多信息并实现目标。这就是 ReAct 的基础。

ReAct 提示包括包含行动的示例,通过行动获得的观察,以及人类在过程中不同阶段的书面思考(推理策略)。LLM 学会模仿这种交替进行思考与行动的方法,使其成为环境中的智能代理。下方是 ReAct 智能体如何运作的示例,(按“思考 -> 行动 -> 观察 -> 思考”顺序)。

ReAct智能体的任务执行的大致过程:

  • 用户提出问题。
  • 思考,第一步应该做什么,决定执行动作和环境互动。
  • 行动,使用外部工具,从环境中获取需要的信息。
  • 观察,将行动的结果和收集的信息作为下一步思考的输入。
  • 思考,判断是否问题得到解决,基于上一步观察的结果,重新制定下一步需要执行的动作。
  • 重复以上循环,直到问题解决,或者得到了最终的答案,并结束。

ReAct 提示词是一种思考和行动的模版和范式,教AI大模型按照这种思维框架进行学习和解决问题,与其他提示工程不同的是,ReAct需用通过和环境的互动,获取信息,做动态的调整和规划。因此使用ReAct提示词时,同时需要实现智能体,或者智能代理,能够让智能体使用工具和外部环境进行交互。

更多ReAct提示词的例子

以下是一个来自论文的 ReAct 提示示例

你是知识问答机器人,你会帮助用户回答科学,地理等相关科普知识,给用户提供准确的答案,请以以下例子为参考,以思考-行动-观察 迭代的方式,确保你的答案是实时准确的,你可以通过搜索引擎获取外部知识。

问题:科罗拉多造山运动的东部区域延伸到的区域的海拔范围是多少? 
思考 1:我需要搜索“科罗拉多造山运动”,找出其东部区域延伸到的地方,然后找出该区域的海拔范围。 
行动 1:搜索[科罗拉多造山运动] 
观察 1:科罗拉多造山运动是科罗拉多及周边地区发生的造山事件。 
思考 2:资料中没有提到东部区域,因此我需要查找“东部区域”。 
行动 2:查找[东部区域] 
观察 2:(结果 1 / 1)东部区域延伸到大平原,被称为中央平原造山运动。 
思考 3:科罗拉多造山运动的东部区域延伸到大平原。因此,我需要搜索“大平原”的海拔范围。 
行动 3:搜索[大平原] 
观察 3:“大平原”指的是两种不同的土地区域之一。 
思考 4:我需要改为搜索“美国大平原”。 
行动 4:搜索[美国大平原] 
观察 4:大平原是大平原的一个子区域。从东到西,大平原的海拔从约 1,800 英尺(550 米)上升到 7,000 英尺(2,130 米)。 
思考 5:大平原的海拔范围是从约 1,800 英尺到 7,000 英尺,因此答案是 1,800 英尺到 7,000 英尺。 
行动 5:完成[1,800 英尺到 7,000 英尺]

通用ReAct智能体提示词模版

以下提供的提示词模版是对ReAct的抽象和总结,通过以下模版,开发人员可以定义 AI Agent的基本角色和用户场景,以及智能体能够和外界交互的可用工具集。同时指导智能体在执行特定任务时,需遵从“思考-》执行任务-》观察-》思考”的迭代过程。

以下的ReAct通用提示词可以使用在任何任务场景,程序员只要稍加调整和修改就可以应用在自己的工具和用例里。

TOOL_DESC = """{name_for_model}: Call this tool to interact with the {name_for_human} API. What is the {name_for_human} API useful for? {description_for_model} Parameters: {parameters} Format the arguments as a JSON object."""

REACT_PROMPT = """Answer the following questions as best you can. You have access to the following tools:

{tool_descs}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can be repeated zero or more times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {query}"""

以下是该提示词模板的中文翻译:

TOOL_DESC = """{name_for_model}:调用此工具以与{name_for_human} API 交互。{name_for_human} API 有什么用途?{description_for_model} 参数:{parameters} 将参数格式化为 JSON 对象。"""

REACT_PROMPT = """请尽可能准确地回答以下问题。你可以使用以下工具:

{tool_descs}

使用以下格式:

问题:你必须回答的输入问题
思考:你应该始终考虑要做什么
行动:要采取的行动,应为 [{tool_names}] 之一
行动输入:行动的输入
观察:行动的结果
...(此思考/行动/行动输入/观察可以重复零次或多次)
思考:我现在知道最终答案了
最终答案:对原始输入问题的最终答案

开始!

问题:{query}"""

写在最后

由于ReAct需要通过环境来获取信息,因此从环境中获取的信息的准确性会严重影响最终的输出结果。因此开发者需要考虑环境信息的准确和可靠,才能保证ReAct应用的性能和可靠性。

ReAct的推理并不完美,但仍然是一种强大的提示工程方法,它克服了链式推理中的幻觉问题,并使大型语言模型能够成为可以与环境互动的智能体。此外,这是一种非常可解释的方法,因为智能体在行动时会输出其思维过程。

ReAct提示词可以让智能体变的更加聪明,帮助我们解决更加复杂的问题,探索ReAct智能体是一件非常有趣的过程。

我相信你一定好奇,如何使用以上的提示词模版实现一个能够自主思考的智能体,接下来后续的文章我将分析如何通过不同的Agent框架,快速的构建智能体,希望持续关注我的博客文章。

参考文章:

智能体(LLM Agent) 资料汇总(持续更新)

文章会实时同步到我的公众号,有兴趣的童鞋扫码关注我的公众号噢:

智能体(LLM Agent)资料汇总

本文致力于收集整理所有LLM Agent相关的资料,共大家参考学习。

智能体概念

提示词工程

智能体概念

智能体编程框架

智能体编程实战

智能体低代码平台

智能体应用

智能体实战之autogen:智能体生成shell脚本并执行

使用智能体生成脚本并执行

智能体如何使用工具,是研究智能体非常重要的一部分。通过使用脚本,可以赋予智能体使用Linux系统的各式各样的命令行工具来执行特定任务,本文提供非常简单的例子,使用autogen生成脚本并执行用户指定的任务。

智能体介绍

参考文章:什么是智能体

Autogen

AutoGen是一个开源编程框架,用于构建AI智能体并促进多个智能体之间的合作以解决任务。AutoGen旨在提供一个易于使用且灵活的框架,以加速智能体AI的开发和研究,类似于深度学习中的PyTorch。它提供的功能包括能够与其他智能体对话的智能体、支持LLM和工具使用、自治和人机协作工作流程以及多智能体对话模式。

主要功能

  • AutoGen使得基于多智能体对话构建下一代LLM应用程序变得轻松便捷。它简化了复杂LLM工作流程的协调、自动化和优化,最大化LLM模型的性能,并克服其弱点。
  • 它支持多种对话模式以应对复杂工作流程。通过可定制且可对话的智能体,开发人员可以使用AutoGen构建与对话自主性、智能体数量和智能体对话拓扑相关的各种对话模式。
  • 它提供了一系列具有不同复杂性的工作系统。这些系统涵盖了来自各种领域和复杂性的广泛应用,展示了AutoGen如何轻松支持多样的对话模式。

环境准备

  • Linux or Windows WSL
  • python 3.10+
  • 安装 anaconda

本文使用anaconda构建python虚拟环境:


#创建autogen的虚拟环境
conda create --name autogen python=3.11

#进入该虚拟环境
conda activate autogen

# 安装autogen
pip install autogen-agentchat~=0.2

导入相关的依赖库

import os
import tempfile

from autogen import ConversableAgent
from autogen.coding import LocalCommandLineCodeExecutor

构建系统提示词

使用系统提示词定义智能体的角色,指导行为,提供一定的背景信息,同时也可以约束智能体,当用户行为超出智能体能力边界时,提示用户。

以下提示词指导智能体通过生成脚本,来收集Linux系统的一些信息。该提示词为one-shot提示词。提供代码块的样例给大模型。

以下系统提示词将传递给代码生成智能体,指导代码生成智能体生成脚本代码。


script_executor_message = """You are shell script assistant, a expert of linux and shell script, and you will generate shell script and get information according to user's prompt.
Gnerate a script according user's requirments with below format:

    #```bash  此处因为显示格式的原因加了注释,实际使用时请删除#
    #!/bin/bash

    # query all files information in current directory
    ls -la

    #``` 此处因为显示格式的原因加了注释,实际使用时请删除#
Always thinking step by step to about users questions, make sure your answer is correct and helpful.
If user did not ask question about Linux system, then please response like:

Please ask me question about Linux system, I only could help you on that.

"""

创建和脚本执行器

代码执行器是autogen智能体的一个组件,在创建autogen智能体实例之前需要先初始化代码执行器,并作为参数传递给autogen智能体的实例,代码执行器主要用来执行代码。

# Create a temporary directory to store the code files.
temp_dir = tempfile.TemporaryDirectory()

# Create a local command line code executor.
script_executor = LocalCommandLineCodeExecutor(
    timeout=10,  # Timeout for each code execution in seconds.
    work_dir=temp_dir.name,  # Use the temporary directory to store the code files.
)

创建代码生成智能体实例

ConversableAgent class 是对智能体的抽象,autogen中使用该类来创建智能体实例。通常你需要提供一些参数,max_consecutive_auto_reply=1 配置智能体只能回复一次,system_message用来配置系统提示词。llm_config 用来配置大模型作为后端,我选择使用deepseek-chat模型,国产模型性价比非常高,api调用也没有太多限制。代码生成方面,deepseek已经非常优秀了。code_execution_config=False 配置关闭代码执行功能。human_input_mode="NEVER"配置智能体自动回复,不需要人的介入。

以下代码创建了一个负责生成脚本代码的智能体实例。

script_generate_agent = ConversableAgent(
    "code_writer_agent",
    max_consecutive_auto_reply=1,
    system_message=script_executor_message,
    llm_config={"config_list": [{"model": "deepseek-chat", "api_key": os.environ["OPENAI_API_KEY"], "base_url":"https://api.deepseek.com"}]},
    code_execution_config=False,  # Turn off code execution for this agent.
    human_input_mode="NEVER",
)

创建代码执行智能体

以下代码创建了代码执行的智能体实例,只负责解析和执行代码,因此该智能体不需要接入大模型,配置llm_config=False。code_execution_config={"executor": script_executor} 用来配置代码执行器。

# Create an agent with code executor configuration.
code_executor_agent = ConversableAgent(
    "code_executor_agent",
    max_consecutive_auto_reply=1,
    system_message=script_executor_message,
    llm_config=False,
    code_execution_config={"executor": script_executor},  # Use the local command line code executor.
    human_input_mode="NEVER", 
)

初始化任务

以下代码最终将会启动两个智能体,首先脚本生成智能体将根据输入信息生成相应的脚步,代码执行智能体接受脚本生成智能体的输出作为输入,解析脚本,并执行。

chat_result = code_executor_agent.initiate_chat(
    script_generate_agent,
    message="Get Linux OS information",
)

执行结果如下:

$ python simple_script_executor.py
flaml.automl is not available. Please install flaml[automl] to enable AutoML functionalities.
code_executor_agent (to code_writer_agent):

Get Linux OS information

--------------------------------------------------------------------------------
[autogen.oai.client: 10-07 11:47:55] {349} WARNING - Model deepseek-chat is not found. The cost will be 0. In your config_list, add field {"price" : [prompt_price_per_1k, completion_token_price_per_1k]} for customized pricing.
code_writer_agent (to code_executor_agent):

    #```bash 此处因为显示格式的原因加了注释,实际使用时请删除#
    #!/bin/bash

    # Get Linux OS information

    # Display the Linux distribution information
    echo "Linux Distribution Information:"
    lsb_release -a 2>/dev/null || cat /etc/*release 2>/dev/null || cat /etc/issue 2>/dev/null
    echo ""

    # Display kernel version
    echo "Kernel Version:"
    uname -r
    echo ""

    # Display system architecture
    echo "System Architecture:"
    uname -m
    echo ""

    # Display CPU information
    echo "CPU Information:"
    lscpu
    echo ""

    # Display memory information
    echo "Memory Information:"
    free -h
    echo ""

    # Display disk usage
    echo "Disk Usage:"
    df -h
    echo ""

    # Display network interfaces
    echo "Network Interfaces:"
    ip a
    echo ""

    # Display hostname
    echo "Hostname:"
    hostname
    echo ""

    # Display uptime
    echo "Uptime:"
    uptime
    echo ""
    #``` 此处因为显示格式的原因加了注释,实际使用时请删除#

This script will provide a comprehensive overview of your Linux system, including distribution information, kernel version, system architecture, CPU information, memory usage, disk usage, network interfaces, hostname, and uptime.

--------------------------------------------------------------------------------

>>>>>>>> EXECUTING CODE BLOCK (inferred language is bash)...
code_executor_agent (to code_writer_agent):

exitcode: 0 (execution succeeded)
Code output: Linux Distribution Information:
Distributor ID: Ubuntu
Description:    Ubuntu 22.04.4 LTS
Release:        22.04
Codename:       jammy

Kernel Version:
5.15.153.1-microsoft-standard-WSL2

System Architecture:
x86_64

CPU Information:
Architecture:                       x86_64
CPU op-mode(s):                     32-bit, 64-bit
Address sizes:                      39 bits physical, 48 bits virtual
Byte Order:                         Little Endian
CPU(s):                             12
On-line CPU(s) list:                0-11
Vendor ID:                          GenuineIntel
Model name:                         12th Gen Intel(R) Core(TM) i5-12400
CPU family:                         6
Model:                              151
Thread(s) per core:                 2
Core(s) per socket:                 6
Socket(s):                          1
Stepping:                           2
BogoMIPS:                           4991.99
Flags:                              fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon rep_good nopl xtopology tsc_reliable nonstop_tsc cpuid pni pclmulqdq vmx ssse3 fma cx16 pdcm sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch ssbd ibrs ibpb stibp ibrs_enhanced tpr_shadow vnmi ept vpid ept_ad fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid rdseed adx smap clflushopt clwb sha_ni xsaveopt xsavec xgetbv1 xsaves avx_vnni umip waitpkg gfni vaes vpclmulqdq rdpid movdiri movdir64b fsrm md_clear serialize arch_lbr flush_l1d arch_capabilities
Virtualization:                     VT-x
Hypervisor vendor:                  Microsoft
Virtualization type:                full
L1d cache:                          288 KiB (6 instances)
L1i cache:                          192 KiB (6 instances)
L2 cache:                           7.5 MiB (6 instances)
L3 cache:                           18 MiB (1 instance)
Vulnerability Gather data sampling: Not affected
Vulnerability Itlb multihit:        Not affected
Vulnerability L1tf:                 Not affected
Vulnerability Mds:                  Not affected
Vulnerability Meltdown:             Not affected
Vulnerability Mmio stale data:      Not affected
Vulnerability Retbleed:             Mitigation; Enhanced IBRS
Vulnerability Spec rstack overflow: Not affected
Vulnerability Spec store bypass:    Mitigation; Speculative Store Bypass disabled via prctl and seccomp
Vulnerability Spectre v1:           Mitigation; usercopy/swapgs barriers and __user pointer sanitization
Vulnerability Spectre v2:           Mitigation; Enhanced IBRS, IBPB conditional, RSB filling, PBRSB-eIBRS SW sequence
Vulnerability Srbds:                Not affected
Vulnerability Tsx async abort:      Not affected

Memory Information:
               total        used        free      shared  buff/cache   available
Mem:            15Gi       695Mi        14Gi       3.0Mi       591Mi        14Gi
Swap:          4.0Gi          0B       4.0Gi

Disk Usage:
Filesystem      Size  Used Avail Use% Mounted on
none            7.8G     0  7.8G   0% /usr/lib/modules/5.15.153.1-microsoft-standard-WSL2
none            7.8G  4.0K  7.8G   1% /mnt/wsl
drivers         451G  282G  169G  63% /usr/lib/wsl/drivers
/dev/sdc        251G   24G  215G  10% /
none            7.8G   84K  7.8G   1% /mnt/wslg
none            7.8G     0  7.8G   0% /usr/lib/wsl/lib
rootfs          7.8G  2.2M  7.8G   1% /init
none            7.8G  780K  7.8G   1% /run
none            7.8G     0  7.8G   0% /run/lock
none            7.8G     0  7.8G   0% /run/shm
tmpfs           4.0M     0  4.0M   0% /sys/fs/cgroup
none            7.8G   76K  7.8G   1% /mnt/wslg/versions.txt
none            7.8G   76K  7.8G   1% /mnt/wslg/doc

Network Interfaces:
1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet 10.25.25.254/32 brd 10.25.25.254 scope global lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0:  mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:15:5d:dd:f0:b7 brd ff:ff:ff:ff:ff:ff
    inet 111.21.22.44/20 brd 111.21.22.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::215:5dff:fedd:f0b7/64 scope link
       valid_lft forever preferred_lft forever

Hostname:
PC-XXXXXXYY

Uptime:
 11:47:56 up 1 min,  1 user,  load average: 0.54, 0.16, 0.05

使用AI智能体重塑企业订单管理系统

基于AI智能体的订单管理系统应用与优势

随着人工智能技术的快速发展,各种行业都在探索如何利用AI来提升效率和改善用户体验。订单管理系统作为企业运营中的关键环节,也不例外。然而,传统订单管理系统存在诸多痛点,而引入AI LLM(大语言模型)Agent可以有效解决这些问题。本文将探讨如何利用AI LLM Agent重塑订单管理系统,提升整体效率和客户满意度,并强调数据隐私保护和本地部署的重要性。

传统订单管理系统的痛点

1. 手动操作繁琐

传统订单管理系统依赖大量的人工操作,包括订单录入、库存检查、发货安排等。这不仅耗时耗力,还容易出错,影响工作效率和客户满意度。

2. 响应速度慢

当客户查询订单状态或请求更改订单时,传统系统往往需要经过多个步骤和层级审批,导致响应速度慢,客户体验不佳。

3. 数据分析能力有限

传统系统的数据分析功能较为有限,难以从大量订单数据中提取有价值的信息,影响企业的决策能力和市场响应速度。

什么是AI LLM Agent?

AI LLM(大语言模型)Agent 是基于大语言模型(如GPT-4、Llama 3、Mixtral 8*7B等)构建的智能系统。它不仅能理解和生成自然语言,还能通过与各种工具和数据库的集成,执行复杂的任务。图中展示了一个典型的AI LLM Agent架构,包括系统提示、上下文记忆管理、用户界面、AI LLM、工具以及外部数据库的整合。

引入AI LLM Agent的优势

1. 提升用户体验

通过集成AI LLM Agent,用户可以通过自然语言与订单管理系统进行交互。例如,客户可以直接询问订单状态、预计交货时间等问题,系统会即时响应,提供准确的信息。这种方式不仅提高了响应速度,还使得用户体验更加人性化。

2. 自动化处理

AI LLM Agent 能够自动处理大量重复性工作,如订单录入、库存管理和发货安排等。这不仅减少了人工操作的错误率,还大大提高了工作效率。例如,当客户下单后,系统会自动检查库存、安排发货,并实时更新订单状态。

3. 数据分析与预测

AI LLM Agent 可以集成统计和查询工具,对历史订单数据进行分析,从中发现趋势和规律。通过与Tickets Info数据库的对接,系统可以生成详细的销售报告,帮助企业优化库存管理和销售策略。此外,AI还可以预测未来的订单需求,帮助企业提前做好准备。

基于数据隐私保护和本地部署的重要性

数据隐私保护

在使用AI LLM Agent时,数据隐私保护至关重要。系统应确保所有客户数据和订单信息在传输和存储过程中都经过加密处理,防止未经授权的访问和泄露。同时,企业应制定严格的数据管理政策,确保数据使用的透明度和合法性。

本地部署的重要性

为了更好地保护数据隐私和提高系统的响应速度,许多企业选择将AI LLM Agent本地部署。本地部署不仅能确保数据不离开企业内部网络,降低数据泄露风险,还能提高系统的响应速度和稳定性,尤其在处理大量订单请求时更为显著。

架构详解

用户界面(UI)

用户界面是用户与AI LLM Agent交互的入口。通过友好的UI设计,用户可以轻松下达指令或查询信息。无论是通过文字输入还是语音命令,UI都会将用户的请求传递给AI LLM。

系统提示(Sys Prompts)

系统提示模块用于初始化和指导AI LLM的行为和响应方式。它包含了一系列预定义的指令和模板,确保AI在处理用户请求时的准确性和一致性。

上下文记忆管理(Context Memory Management)

为了提供连续性和上下文相关的响应,AI LLM Agent 具有上下文记忆管理功能。它能记住用户之前的交互内容,确保在多轮对话中提供一致且相关的回答。

AI LLM 核心

AI LLM是整个系统的核心,它负责理解用户的请求,并调用合适的工具或数据库来完成任务。无论是处理自然语言还是进行复杂的数据查询,AI LLM都能胜任。它可以根据用户需求,灵活调用Llama 3和Mixtral 8*7B等不同的语言模型,确保高效处理各种任务。

工具与数据库集成

AI LLM Agent 集成了多个工具(如统计工具、查询工具)和外部数据库(如Tickets Info数据库)。当用户提出查询请求时,AI LLM 会调用相应的工具从数据库中提取所需信息,并生成易于理解的回复。

结语

通过引入AI LLM Agent,订单管理系统可以实现前所未有的自动化和智能化。它不仅提升了用户体验,还大幅提高了运营效率和数据分析能力。特别是在数据隐私保护和本地部署方面的重视,进一步确保了系统的安全性和稳定性。未来,随着AI技术的进一步发展,我们可以预见更多创新应用的出现,为各行各业带来更多的价值。

Coze 如何自定义插件-获取公众号文章列表

Coze 如何自定义插件-获取公众号文章列表

关于Coze

毫无疑问,2023年是大模型元年,那么2024年,将会是LLM Agent应用爆发的一年。通过LLM agent 模式,AI 大模型将会释放自己的能力,助力更多的应用智能化。

Coze 平台是字节跳动开发的一款能够低代码创建AI agent的平台,无论你是否有编程经验,Coze 平台都能让你轻松创建各种聊天机器人,并将它们部署到不同的社交平台和消息应用中。该平台通过提供友好的界面和强大的功能,使得用户可以快速上手,开发出具有个性化和智能交互功能的机器人。简而言之,Coze 平台为聊天机器人的开发和应用提供了一个简单、高效、多功能的环境。

关于如何使用Coze,及了解更多的信息,可以阅读Coze 操作文档

本篇文章将主要聚焦于如何自定义Coze的工具(插件)。

创建Coze的插件

进入 Coze 主页

  • 1 选择个人空间
  • 2 选择插件
  • 3 点击创建插件按钮,进入创建插件界面。

根据上图:

  • 填写插件命名,可以使用中文。
  • 填写插件描述,简单描述插件的用途。
  • 选择在Coze IDE 中创建
  • 有两种编程语言可选,Node.js 和 Python3, 本实例使用python,因此选择Python3
  • 点击 确认

点击按钮 在IDE中创建工具

命名工具,必须以字母数字下划线格式命名,跟函数命名一致。
描写工具的用途。点击 确认

此时,你可以通过编程实现handler函数,来实现你的插件功能。
如果该工具需要自定义输入输出参数,则可通过元数据标签页,添加输入参数和输出参数。

分别使用输入参数和输出参数的编辑按钮,编辑输入参数和输出参数。
由于获取公众号文章时,公众号API需要使用公众号的appid和secret来获取访问资源的token,因此在此定义输入参数为appid和secret。
同时输出为公众号文章的列表,因此输出是一个数组,并且数组的每个item是一个对象,该对象具有如下字段:title,author,digest,url,如下图所示。

编辑完成后记得点击保存。然后切换到代码标签页。
由于公众号的API依赖于requests, 因此需要使用添加依赖,添加依赖的库。
添加依赖以后,就可以编程实现相应的功能,以下是获取公众号文章的代码。


from runtime import Args
from typings.GetArticleList.GetArticleList import Input, Output

import json
import requests

def get_stable_access_token(appid, secret, force_refresh=False):
    """
    获取稳定的访问令牌

    参数:
    appid (str):微信小程序的 appid
    secret (str):微信小程序的 secret
    force_refresh (bool):是否强制刷新令牌,默认为 False

    返回:
    dict:访问令牌的 JSON 数据
    """
    url = "https://api.weixin.qq.com/cgi-bin/stable_token"
    payload = {
        "grant_type": "client_credential",
        "appid": appid,
        "secret": secret,
        "force_refresh": force_refresh
    }
    headers = {'Content-Type': 'application/json;charset=utf-8'}
    response = requests.post(url, headers=headers, data=bytes(json.dumps(payload), encoding='utf-8'))
    print(response)
    if response.status_code == 200:
        return response.json()
    else:
        response.raise_for_status()

def extract_info(articles):
    """
    提取文章列表中所有文章的信息

    Args:
        articles (dict):包含文章列表的 JSON 数据

    Returns:
        list:包含所有文章信息的列表,每个元素是一个字典
    """

    result = []
    if "item" in articles:
        for item in articles["item"]:
            if "content" in item and "news_item" in item["content"]:
                for news_item in item["content"]["news_item"]:
                    # 获取文章的标题、作者、摘要和 URL,如果没有则为空字符串
                    title = news_item.get("title", "")
                    author = news_item.get("author", "")
                    digest = news_item.get("digest", "")
                    url = news_item.get("url", "")
                    # 创建一个新的 JSON 对象来存储提取的信息
                    article = {
                        "title": title,
                        "author": author,
                        "digest": digest,
                        "url": url
                    }
                    result.append(article)
    return result

def get_published_articles(access_token, offset, count, no_content):
    """
    获取已发布的文章列表

    参数:
        access_token (str):调用接口的 access_token
        offset (int):要获取的文章列表的起始位置
        count (int):要获取的文章数量
        no_content (bool):是否返回文章内容

    返回:
        str:返回的文章列表的 JSON 字符串
    """
    url = f"https://api.weixin.qq.com/cgi-bin/freepublish/batchget?access_token={access_token}"
    payload = {
        "offset": offset,
        "count": count,
        "no_content": no_content
    }
    headers = {'Content-Type': 'application/json;charset=utf-8'}
    response = requests.post(url, headers=headers, data=json.dumps(payload))
    text = response.content.decode('utf-8')

    if response.status_code == 200:
        return text
    else:
        response.raise_for_status()

"""
Each file needs to export a function named <code>handler</code>. This function is the entrance to the Tool.

Parameters:
args: parameters of the entry function.
args.input - input parameters, you can get test input value by args.input.xxx.
args.logger - logger instance used to print logs, injected by runtime.

Remember to fill in input/output in Metadata, it helps LLM to recognize and use tool.

Return:
The return data of the function, which should match the declared output parameters.
"""
def handler(args: Args[Input])->Output:
    offset = 0
    count = 100
    no_content = 0

    appid = args.input.appid
    appsecret = args.input.appsecret

    access_token = get_stable_access_token(appid, appsecret)
    token = access_token['access_token']
    content = get_published_articles(token, offset, count, no_content)
    articles = json.loads(content)
    result = extract_info(articles)
    return result

运行测试时,输入以下参数,运行可以查看结果。

{
    "appid":"your appid",
    "appsecret":"your appsecret"
}

测试通过即可将你的插件进行发布

什么是AI智能体?

LLM 智能体

考虑一个旨在帮助金融分析师回答关于公司绩效的问题的大型语言模型(LLM)应用程序。通过一个设计良好的检索增强生成(RAG)管道,分析师可以回答类似于:“X公司2022财年的总收入是多少?”这样的问题。这些信息可以由经验丰富的分析师轻松地从财务报表中提取。

现在考虑一个问题,比如,“从2023财年第二季度的盈利电话会议中得出的三个要点是什么?重点关注公司正在构建的技术壁垒”。这是金融分析师想要回答以纳入其报告中的类型问题,但需要投入时间来回答。

我们如何开发一个解决方案来回答类似上述问题?很明显,这种信息需要更多的工作,而不仅仅是从盈利电话会议中查找。这种查询需要计划、定制焦点、记忆、使用不同工具,并将一个复杂问题分解为更简单的子部分。这些概念组合在一起基本上就是我们所谓的LLM智能体。

在这篇文章中,我介绍了由LLM提供动力的智能体,并讨论了智能体是什么以及企业应用的一些用例。有关更多信息,请参阅构建您的第一个智能体应用程序。在那篇文章中,我提供了一个生态系统概述,涵盖了构建AI智能体的可用框架以及一个入门指南,供任何尝试使用问答(Q&A)智能体的人使用。

什么是LLM智能体

虽然没有一个被广泛接受的LLM智能体的定义,但它们可以被描述为一个系统,可以使用LLM来推理问题,创建解决问题的计划,并在一组工具的帮助下执行计划。

简而言之,智能体是一个具有复杂推理能力、记忆和执行任务手段的系统。

这种能力最初是在项目中观察到的,比如AutoGPT或BabyAGI,在这些项目中,复杂的问题得到了解决,几乎没有干预。为了更详细地描述智能体,这里是一个LLM智能体应用程序的一般架构示意图(图1)。

一个智能体由以下关键组件组成(稍后会详细介绍):

  • 智能体核心
  • 记忆模块
  • 工具
  • 规划模块

智能体核心模块

智能体核心是管理智能体的核心逻辑和行为特征的中央协调模块。可以将其视为智能体的“关键决策模块”。在这里我们也定义了:

  • 智能体的总体目标:包含智能体的总体目标和目标。
  • 执行工具:基本上是智能体可以访问的所有工具的简要列表或“用户手册”。
  • 如何利用不同的规划模块:关于不同规划模块的效用以及在何种情况下使用哪个的详细说明。
  • 相关记忆:这是一个动态部分,在推理时填充与用户过去对话中最相关的记忆项。 “相关性”是根据用户提出的问题确定的。
  • 智能体的角色(可选):此角色描述通常用于偏好使用某些类型的工具或在智能体的最终响应中赋予典型的特殊性。

智能体的记忆模块

记忆模块在AI智能体中扮演着至关重要的角色。记忆模块基本上可以被看作是智能体的内部日志以及与用户的互动的存储库。

记忆模块有两种类型:

  • 短期记忆:智能体经历的行动和思考的记录,试图回答用户的单个问题:智能体的“思维线索”。
  • 长期记忆:关于用户和智能体之间发生的事件的行动和思考的记录。它是一个日志簿,包含了跨越数周或数月的对话历史。

记忆不仅需要基于语义相似性的检索。通常,复合分数由语义相似性、重要性、最近性和其他特定于应用程序的指标组成。它用于检索特定信息。

工具集

工具是经过明确定义的可执行工作流程,智能体可以使用它们来执行任务。通常情况下,它们可以被看作是专门的第三方API。

例如,智能体可以使用RAG管道生成上下文感知答案,使用代码解释器解决复杂的编程任务,使用API在互联网上搜索信息,甚至可以使用任何简单的API服务,比如天气API或即时消息应用程序的API。

规划模块

复杂问题,比如分析一组财务报告以回答一个分层业务问题,通常需要细致入微的方法。借助LLM动力智能体,可以通过以下两种技术的组合来处理这种复杂性:

  • 任务和问题分解
  • 反思或评论

问题分解

复合问题或推断信息需要某种形式的分解。举个例子,问题是:“NVIDIA最近的盈利电话会议中有哪三个要点?”

回答这个问题所需的信息不能直接从一个小时的会议记录中提取出来。然而,这个问题可以分解成多个问题主题:

  • “哪些技术转变被讨论得最多?”
  • “是否存在任何业务阻力?”
  • “财务结果如何?”

每个问题都可以进一步分解成子部分。也就是说,一个专业的AI智能体必须引导这种分解过程。

反思和评论

诸如ReAct、Reflexion、Chain of Thought和Graph of Thought之类的技术已经被用作基于评论或证据的提示框架。它们被广泛应用于改进LLM的推理能力和响应。这些技术也可以用于优化智能体生成的执行计划。

企业应用智能体

虽然智能体的应用几乎是无限的,但以下是一些可能对许多企业产生巨大影响的有趣案例:

  • “与您的数据交流”的智能体
  • 智能体群
  • 推荐和体验设计智能体
  • 定制的AI作者智能体
  • 多模式智能体

“与您的数据交流”的智能体

“与您的数据交流”并不是一个简单的问题。有很多挑战是一个直接的RAG管道无法解决的:

  • 源文档的语义相似性
  • 复杂的数据结构,比如表格
  • 缺乏明显的上下文(并非每个块都包含其来源的标记)
  • 用户提出的问题的复杂性

…等等

例如,回到之前的盈利电话会议记录示例(2023年第三季度 | 2024年第一季度)。你如何回答这个问题:“数据中心收入在2023年第三季度和2024年第一季度之间增长了多少?”为了回答这个问题,你基本上必须分别回答三个问题(即,我们需要一个规划模块):

  • 2023年第三季度数据中心收入是多少?
  • 2024年第一季度数据中心收入是多少?
  • 这两者之间有什么区别?

在这种情况下,你需要一个智能体,该智能体可以访问一个进行问题分解的规划模块(生成子问题并搜索答案,直到解决更大的问题),一个RAG管道(用作工具)来检索特定信息,以及记忆模块来准确处理子问题。在“LLM动力智能体:构建您的第一个智能体应用程序”一文中,我详细介绍了这种类型的案例。

智能体群

一群智能体可以被理解为一组智能体共同努力在单一环境中共存,并能相互合作解决问题。分散式的智能体生态系统非常类似于多个“智能”微服务协同解决问题。

像生成式智能体和ChatDev这样的多智能体环境在社区中非常受欢迎(图3)。为什么呢?像ChatDev这样的框架使您能够建立一个工程师、设计师、产品管理、首席执行官和智能体的团队,以低成本构建基本软件。像Brick Breaker或Flappy Bird这样的热门游戏甚至可以以50美分的低价进行原型设计!

通过一群智能体,您可以为数字公司、社区甚至整个城镇创建人口,用于行为模拟经济研究、企业营销活动、物理基础设施的用户体验等应用。

这些应用目前无法在没有大型语言模型的情况下进行模拟,并且在现实世界中运行非常昂贵。

推荐和体验设计的智能体

互联网运作依赖于推荐。由智能体驱动的对话推荐系统可用于打造个性化体验。

例如,考虑一个在电子商务网站上的人工智能智能体,它可以帮助您比较产品,并根据您的一般请求和选择提供建议。还可以构建完整的礼宾式体验,多个智能体协助最终用户在数字商店中导航。选择观看哪部电影或预订哪间酒店房间等体验可以构建为对话形式,而不仅仅是一系列决策树式的对话!

定制的AI作者智能体

另一个强大的工具是拥有一个个人AI作者,可以帮助您处理诸如共同撰写电子邮件或为您准备时间紧迫的会议和演示等任务。常规创作工具的问题在于不同类型的材料必须根据不同的受众进行定制。例如,投资者演讲必须与团队演示有所不同。

智能体可以利用您以前的工作。然后,您可以让智能体根据您的个人风格塑造智能体生成的演讲,并根据您的具体用例和需求定制工作。这个过程对于普通的LLM微调来说通常过于微妙。

多模态智能体

仅使用文本作为输入,您无法真正地“与数据交流”。通过构建能够处理各种输入的多模态智能体,例如图像和音频文件,可以增强所有提到的用例。

这只是解决企业挑战的几个方向的一些例子。数据整理、社交图和领域专业知识的智能体都是开发社区正在积极探索的企业应用领域。

请进一步学习

由LLM驱动的智能体与典型的聊天机器人应用有所不同,因为它们具有复杂的推理能力。智能体由一个智能体核心、记忆模块、工具集和规划模块组成,可以在各种企业环境中生成高度个性化的答案和内容,从数据整理到高级电子商务推荐系统。

要了解有关智能体周围技术生态系统的概述,如实现框架、必读论文、帖子和相关主题,请参阅《构建您的第一个智能体应用》。对问答智能体的无框架实现进行的步骤说明将帮助您更好地与您的数据交流。

要深入了解其他类型的LLM智能体,请参阅《构建一个LLM驱动的API智能体以执行任务》和《构建一个LLM驱动的数据智能体以进行数据分析》。

本位翻译自,感兴趣的话阅读原文:
https://developer.nvidia.com/blog/introduction-to-llm-agents/

本文系本站原创文章,著作版权属于作者,未经允许不得转载,如需转载或引用请注明出处或者联系作者。