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

多智能体系统的协同基础

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

多智能体系统(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)

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

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

提示词工程-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

大语言模型时代,聊聊自然语言编程

大语言模型时代,聊聊自然语言编程

计算机及编程语言的发展历史,其实就是从机器语言发展到接近人的自然语言编程的发展过程,这种发展,从来没有停歇。可是过去所有从低级到高级的编程语言,都不是真正的自然语言编程,直到今天,大语言模型横空出世,使得达到这一目标,向前迈了一大步。

在计算机的早期阶段,人们主要通过机器语言与计算机进行沟通。最初的计算机如ENIAC,只能通过插拔电线和设置开关来进行编程。随着时间的推移,汇编语言出现了,它用一些简短的符号(助记符)代表机器指令,这在一定程度上简化了编程工作,人们可以通过简单的指令来控制计算机执行流程,按照人类预想的流程执行。可以汇编还是接近计算机的机器指令,需要编程人员对硬件,指令集有良好的掌握,汇编语言非常难以理解,普通人很难阅读。

到了1950年代,高级编程语言如FORTRAN、COBOL和LISP开始出现。与纯粹的机器代码相比,这些语言更接近人类的思维方式,但仍然是程序员们为计算机量身定制的“新语言”,需要学习和掌握特定的语法和逻辑结构。相比于汇编,这些编程语言容易学习,屏蔽了底层计算指令,程序员只需要关注到编程本身的任务。

进入1970年代,C语言的诞生进一步推动了编程的普及。C语言不仅功能强大,还因其可移植性成为编程世界中的“通用语言”。此后,Python、Java等更高层次的编程语言相继出现,随着它们语法的简化和功能的增强,编程的门槛逐渐降低,更多的人能够参与到编程世界中来。

然而,这些语言尽管更加简洁和直观,仍然要求使用者具备一定的编程思维和逻辑能力,离我们平常使用的自然语言还有相当的距离。

自然语言编程的概念由来已久,但真正的实现却受限于技术的发展。20世纪末和21世纪初,随着计算能力的提升和人工智能的进步,基于自然语言的编程逐渐成为可能。

早期的尝试主要集中在有限领域的自然语言处理(NLP)上,比如通过简单的命令行工具让计算机理解基本的语句。此时的自然语言编程更多是一种“增强”的脚本编程,依然要求使用者遵循特定的语言结构。

随着深度学习技术的发展,特别是大语言模型(如GPT系列)的出现,自然语言编程迎来了质的飞跃。这些模型能够处理复杂的语言任务,理解并生成符合人类表达习惯的语句。这意味着,人们可以用更接近自然语言的方式与计算机互动,甚至可以通过简单的描述生成完整的代码段。

今天,开发者已经可以通过像ChatGPT这样的模型,将自然语言直接转化为代码。这不仅降低了编程的难度,也打开了非程序员进入编程世界的大门。比如,你可以直接描述你想要实现的功能,AI会自动生成相关代码,极大地提升了开发效率。

未来,自然语言编程有望彻底改变我们与计算机的互动方式。编程可能不再是少数人的专利,而是人人都能掌握的一种技能。我们可能只需要用自然语言描述问题或需求,计算机就能自动生成解决方案。这种技术不仅能够简化编程过程,还能推动跨学科的创新,让更多领域的人士能够利用编程工具解决他们领域中的问题。

自然语言编程的发展不仅是技术的进步,更是人类对语言和思维方式的探索与重塑。随着大语言模型的不断进化,编程将变得更加普及和智能,最终实现人人皆能编程的愿景。

什么是自然语言编程?

自然语言编程的定义:

自然语言编程(Natural Language Programming, NLP)是一种编程范式,允许程序员使用自然语言(如英语,甚至是其他各种人类语言)编写代码,而不是使用传统的编程语言语法。这种方法旨在使编程更加直观和易于理解,从而降低编程的学习曲线。

自然语言编程的核心思想是让计算机能够理解和执行用自然语言表达的指令。这需要自然语言处理(NLP)技术来分析和解释人类语言,并将其转换为计算机可执行的形式。

自然语言编程的一些特点包括:

  • 使用接近人类语言的语法和词汇,而不是传统编程语言的严格语法规则
  • 允许使用更多的上下文和隐含信息,而不是显式指定每个细节
  • 支持更自然的交互方式,如问答、对话式编程等
  • 提供更人性化的错误提示和反馈

自然语言编程的实现方式:

  • 代码自动生成:用户通过自然语言描述想要实现的功能,编程工具或系统会自动生成相应的代码。例如,在描述一个计算任务时,系统会将描述转换为Python、JavaScript或其他语言的代码。

  • 编程辅助:自然语言编程也可以作为一种编程辅助工具,帮助程序员快速编写代码段或调试代码。例如,开发者可以用自然语言描述要实现的逻辑,系统提供相应的代码建议或直接生成代码。

  • 多语言支持:自然语言编程不局限于单一的自然语言,它可以支持多种语言,用户可以使用自己熟悉的语言与计算机互动。

  • 人机语音交互:自然语言编程的终极目标就是通过自然语言交互,实现计算机自主理解及执行相应的任务,在可见的未来,人类不需要额外的输入,就可以通过自然语言的交互,实现计算机自主执行任何任务。

大模型时代的自然语言编程技术

在大模型技术出现之前,编程始终是程序员的技术活,每一种语言都存在一定的学习曲线,尤其像C++这种成熟的面向对象语言,灵活的语法,以及非常复杂的规范和标准,成为C++语言的熟练工,可真不是件容易的事,这需要数年甚至数十年的积累和经验。据不完全统计,目前至少有超过700种编程语言,而这个数字还在不断增长。但是接近纯自然语言的编程语言至今还未出现。

如今,大语言模型的出现,可以预见的是正在改变计算机编程的游戏规则,大模型时代的自然语言编程技术代表着计算机与人类互动方式的一次重大变革。在大规模预训练语言模型(如GPT系列、BERT等)的推动下,计算机能够以更加智能和自然的方式理解和处理人类的自然语言描述。这一技术的发展极大地简化了编程过程,使得更多的人能够以自然语言的方式进行编程,降低了技术门槛,提升了开发效率。

大语言模型的核心优势在于:

  • 强大的理解能力:大语言模型可以理解复杂的自然语言描述,包括上下文、隐含意义和复杂的逻辑结构。这使得用户可以用接近日常交流的语言与计算机互动,而不需要掌握传统编程语言的语法和规则。
  • 多领域知识:这些模型不仅懂得编程语言,还拥有广泛的背景知识,涵盖多个领域。这使得它们能够生成与特定领域相关的代码,并且在复杂应用中提供有价值的帮助。
  • 记忆:大模型具有一定的记忆,能够根据交互的上下文背景和人进行交互,这和人类的交谈是相似的,因此大模型在编程领域可以模拟人的行为。

基于大语言模型进行自然语言编程的不同方法

提示词工程

提示词工程无疑是和大语言模型交互的重要技术,这种技术完全可以应用到编程领域。

  • 描述: 用户通过自然语言描述要执行的任务,并将该描述(prompt)传递给大语言模型。模型会根据提示生成相应的代码或直接执行操作。Prompt的设计至关重要,它需要足够明确和具体,以便模型理解用户的意图。
  • 应用场景: 代码生成(如自动生成Python脚本)、任务执行(如数据库查询)、问题回答等。
使用提示词生成代码

目前市面上几乎所有的通用大模型都支持prompt生成代码,比如ChatGPT,Claude, Gemini等,也包括一些开源大模型,例如llama, qianwen等等,另外还有一些专业模型专门针对编程领域,例如llama coder,deepseek coder等等。

使用这些大模型,你可以通过自然语言描述特定的需求,直接使用大模型生成期望的代码。

例如我使用以下提示词生成了一个检查密码强度的工具:

请扮演软件工程师的角色,您擅长分析需求、设计软件和编码,您能否帮助我按照以下步骤一步一步设计和实现密码强度检查器:
步骤 1:列出密码强度检查器的可能功能和要求。
步骤 2:设计此密码强度检查器的软件。
步骤 3:根据您的设计实现功能和要求。
请帮助一步一步完成。请使用Golang,生成命令行应用程序
请用中文书写。

讲该prompt输入至ChatGPT时,GPT可以帮我做简单的分析和设计,并生成相应的代码:


package main

import (
    "fmt"
    "unicode"
)

func main() {
    var password string
    fmt.Print("请输入密码: ")
    fmt.Scanln(&password)

    strength := checkPasswordStrength(password)
    fmt.Printf("密码强度评分: %d/10\n", strength)

    if strength < 7 {
        fmt.Println("建议:请使用更复杂的密码,包括大小写字母、数字和特殊字符。")
    } else {
        fmt.Println("密码强度良好。")
    }
}

func checkPasswordStrength(password string) int {
    score := 0

    // 长度检查
    if len(password) >= 8 {
        score += 2
    } else {
        fmt.Println("密码长度应至少为8个字符。")
    }

    // 字符种类检查
    var hasUpper, hasLower, hasDigit, hasSpecial bool
    for _, char := range password {
        switch {
        case unicode.IsUpper(char):
            hasUpper = true
        case unicode.IsLower(char):
            hasLower = true
        case unicode.IsDigit(char):
            hasDigit = true
        case unicode.IsPunct(char) || unicode.IsSymbol(char):
            hasSpecial = true
        }
    }

    if hasUpper {
        score += 2
    }
    if hasLower {
        score += 2
    }
    if hasDigit {
        score += 2
    }
    if hasSpecial {
        score += 2
    }

    return score
}
大模型智能体应用

基于提示词工程,不仅仅可以通过自然语言生成代码。大模型时代的应用,将基于智能体编程模式,开启智能应用时代。基于智能体模式,相比传统应用程序,智能应用的交互模式发生了革命性的变化,应用程序完全可以理解人的自然语言输入,智能应用程序将通过理解人的语言进行思考,并以一定的自主能力来执行复杂的任务。

因此,自然语言编程的范畴并不仅仅是通过自然语言来生成代码,广义含义也包含了使用自然语言直接执行任务。

同时智能体应用本身的程序也将不再完全由程序代码来构建的,程序的核心部分将基于提示词工程的自然语言部分,比如react提示词模式,和COT(chain-of-thought)模式。剩余的部分包括大模型的API,数据库交互,记忆模块,以及工具的使用,将使用传统的编程模式。基于prompt的编程将是自然语言编程的重要组成部分。

通过智能体应用,应用程序将会更加智能化,人机交互方式将会发生革命性的转变,任务和指令将通过自然语言的方式进行输入,程序的反馈也将更加人性,更符合人与人的交流方式。

辅助编程

辅助编程技术,实际上是编程IDE诞生以来,一直在发展的技术,在生成式模型出现之前,传统的辅助编程工具可以帮助程序员建立代码索引,通过联想,自动补全等功能帮助程序员更加快速的找到已有函数,接口,变量等,提示编程效率。

辅助编程技术通过生成模型技术,已经发生了革命性的转变。用户可以通过自然语言与大模型进行互动,逐步引导模型生成代码。用户可以实时修正或者调整模型生成的代码,以确保最终结果符合预期。

辅助编程工具一般都是基于编程IDE来实现的,比如当下著名的编程助手 Github Copilot,Cursor 等,程序员仅仅通过自然语言提示,就可以生成代码,测试及文档,大大的提高了编程效率。这些工具除了可以编程外,还可以帮助重构,调试代码。

代码翻译

由于专业的大模型熟悉不同编程语言的语法和语义,因此程序员可以用自然语言描述现有代码段的逻辑或意图,指示大模型将一种语言的代码片段,翻译成其他语言的代码片段,这种特性将在跨语言的代码迁移、旧代码重构、多语言项目的代码管理等领域得到重要的应用。

写在最后

自然语言编程将是我未来的一个主要研究方向,我相信未来,越来越多的人会使用自然语言方式进行编程,未来的应用程序也将更加智能,编程将不在是程序员的专利,更多的人将参与到数字化世界的构筑,使得这个世界更加丰富多彩。

参考文章:

https://arxiv.org/html/2405.06907v1
https://arxiv.org/abs/2405.06907
https://juejin.cn/post/7348648095015567412
https://www.yunwei37.com/2023/06/14/natual-language-program/

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/

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