Meta开源的Llama官方Agent：Llama-Agentic-System深度解析

TLDR

• • Meta 推出的 Llama as a System 将 Llama 3.1 模型转变为一个可以或许自主完成使命的智能代理，通过多步推理、工具使用和系统级安全机制，为构建更智能、更安全的 AI 应用开辟了新的可能性。
  
• • Llama-Agentic-System 具备强大的功能，包括多步推理、工具使用（内置和零样本学习）以及系统级安全保障，可以或许处理惩罚更复杂的使命，并加强安全性。
  
• • 本文将深入探讨 Llama as a System 的概念、架构、功能和应用场景，并提供具体的代码示例和使用指南。
  

引言

大型语言模型（LLM）的迅猛发展为人工智能领域带来了革命性的变革。从最初的文本生成工具，LLM 渐渐展现出理解复杂指令、执行多步使命的潜力。然而，如何将 LLM 安全、高效地应用于实际使命仍然是一个挑衅。Meta 推出的 Llama 3.1 为解决这个问题提供了新的思路：将 Llama 作为一个系统，使其可以或许完成更复杂的使命，并加强其安全性。本文将具体先容 Llama as a System 的概念、功能以及如何使用它构建 AI 应用。
Llama Agentic System 的核心功能

Llama Agentic System 的核心在于将 Llama 模型从一个简朴的文本生成工具转变为一个可以或许自主完成使命的智能代理。它具备以下关键能力：

• • 多步推理: 将复杂使命分解成多个步调，并按照逻辑顺序执行。例如，要预订航班，模型必要先搜索航班信息，然后选择符合的航班，最后填写乘客信息并完成支付。
  
• • 工具使用: 可以或许调用各种工具来完成使命，包括：
  
  
  
  • • 内置工具：如搜索引擎、代码解释器等。这些工具预先集成到系统中，模型可以直接调用。
    
  • • 零样本学习工具：可以通过上下文信息学习使用新的工具。这意味着即使模型之前没有见过某个工具，只要提供工具的使用阐明，它就可以学会使用。
    
  
  
• • 系统级安全: 将安全评估从模型级别提拔到整个系统级别，通过 Llama Guard 等安全机制，确保系统在各种场景下的安全性。这包括对用户输入、模型输出以及工具调用举行安全查抄和过滤，防止恶意攻击和不当内容的产生。
  

Llama Agentic System 架构解析

为了更好地理解 Llama Agentic System 的工作原理，让我们深入相识其架构。下图展示了 Llama Agentic System 的核心组件及其交互方式：

1. [/code] [b]组件阐明：[/b]
3. [list]
4. [*] • [b]User（用户）[/b]: 与 Llama Agentic System 举行交互的用户，发起使命指令并接收终极效果。
5. [*] • [b]Executor（执行器）[/b]: Llama Agentic System 的核心控制单元，负责接收用户输入，调用安全机制，并将使命分发给 LLM 或工具，终极将效果返回给用户。
6. [*] • [b]LLM（大型语言模型）[/b]: Llama 模型，负责理解使命、生成文本、选择符合的工具来执利用命，是系统的智能核心。
7. [*] • [b]Tools（工具）[/b]: 外部工具，如搜索引擎、代码解释器等，用于扩展 LLM 的功能，执行 LLM 无法直接完成的使命。
8. [*] • [b]Shields（安全机制）[/b]: 负责对用户输入、模型输出以及工具调用举行安全查抄和过滤，确保系统安全可靠地运行。
9. [/list] [b]工作流程：[/b]
10. [list=1]
11. [*] 1. 用户将使命指令和相关信息发送给 Executor。
12. [*] 2. Executor 调用安全机制对用户输入举行查抄，确保输入内容安全无害。
13. [*] 3. Executor 将使命指令发送给 LLM，LLM 分析指令并选择符合的工具（如果必要）。
14. [*] 4. LLM 根据使命指令选择符合的工具，并将调用请求发送给 Executor。
15. [*] 5. Executor 调用安全机制对工具调用举行查抄，防止潜在的安全风险。
16. [*] 6. Executor 调用相应的工具，并将工具返回的效果发送给 LLM，LLM 继续处理惩罚使命。
17. [*] 7. LLM 整合工具返回的效果，生成终极的回复，并发送给 Executor。
18. [*] 8. Executor 调用安全机制对模型输出举行查抄，确保输出内容安全可靠。
19. [*] 9. Executor 将终极的回复发送给用户，完成使命。
20. [/list] [size=4]Llama Agentic System 代码实现细节[/size]
22. Llama Agentic System 的核心代码位于 llama_agentic_system/agentic_system.py 文件中。以下是一些关键代码片段和解释：
23. [size=3]1. AgentInstance 类[/size]
25. [code]class AgentInstance(ShieldRunnerMixin):
26. def__init__(
27.         self,
28.         system_id:int,
29.         instance_config:AgenticSystemInstanceConfig,
30.         model:InstructModel,
31.         inference_api:Inference,
32.         builtin_tools:List[SingleMessageBuiltinTool],
33.         custom_tool_definitions:List[ToolDefinition],
34.         input_shields:List[ShieldBase],
35.         output_shields:List[ShieldBase],
36.         max_infer_iters:int=10,
37.         prefix_messages:Optional[List[Message]]=None,
38.     ):
39. # ... 初始化代码 ...
41. # 初始化内置工具字典
42.         self.tools_dict ={t.get_name(): t for t in builtin_tools}
43. # 初始化会话字典
44.         self.sessions ={}
45. # 初始化安全机制
46. ShieldRunnerMixin.__init__(
47.             self,
48.             input_shields=input_shields,
49.             output_shields=output_shields,
50. )
52. defcreate_session(self, name: str)->Session:
53.         # ... 创建会话代码 ...

复制代码

AgentInstance 类表示一个 Llama Agentic System 实例，负责管分析话、执行推理、调用工具和安全机制等。它是 Llama Agentic System 的核心控制单元，和谐各个组件协同工作。

• • 它维护一个 tools_dict 字典，存储所有可用的内置工具，键为工具名，值为工具实例。
  
• • 它维护一个 sessions 字典，存储所有会话，键为会话 ID，值为会话实例。
  
• • 它使用 ShieldRunnerMixin 来管理输入和输出安全机制。
  

2. create_and_execute_turn 方法

1.     async defcreate_and_execute_turn(
2.         self, request: AgenticSystemTurnCreateRequest
3.     )->AsyncGenerator:
4. # ... 获取会话，构建历史消息 ...
6. # ... 创建轮次 ID，初始化参数 ...
8. # 发送轮次开始事件
9. yieldAgenticSystemTurnResponseStreamChunk(
10.             event=AgenticSystemTurnResponseEvent(
11.                 payload=AgenticSystemTurnResponseTurnStartPayload(
12.                     turn_id=turn_id,
13. )
14. )
15. )
17.         steps =[]
18.         output_message =None
19. asyncfor chunk in self.run(
20.             turn_id=turn_id,
21.             input_messages=messages,
22.             temperature=params.temperature,
23.             top_p=params.top_p,
24.             stream=request.stream,
25.             max_gen_len=params.max_tokens,
26. ):
27. # 处理推理过程中的事件流
28. # ...
30. # ... 断言 output_message 不为空 ...
32. # 创建轮次实例
33.         turn =Turn(
34.             turn_id=turn_id,
35.             session_id=request.session_id,
36.             input_messages=request.messages,
37.             output_message=output_message,
38.             started_at=start_time,
39.             completed_at=datetime.now(),
40.             steps=steps,
41. )
42. # 将轮次添加到会话中
43.         session.turns.append(turn)
44. # 发送轮次结束事件
45. yieldAgenticSystemTurnResponseStreamChunk(
46.             event=AgenticSystemTurnResponseEvent(
47.                 payload=AgenticSystemTurnResponseTurnCompletePayload(
48.                     turn=turn,
49. )
50. )
51.         )

复制代码

该方法负责创建一个新的会话轮次，并执行用户请求。它会根据用户输入调用 LLM 举行推理，并根据 LLM 的回复调用相应的工具。这个方法实现了 Llama Agentic System 的交互逻辑，处理惩罚用户输入并生成相应的输出。

• • 它首先获取对应的会话，并构建包罗历史消息的消息列表。
  
• • 然后，它调用 self.run() 方法执行推理，并处理惩罚推理过程中产生的事件流。
  
• • 最后，它创建 Turn 实例表示当前轮次，并发送轮次结束事件。
  

3. run 方法

1.     async defrun(
2.         self,
3.         turn_id:str,
4.         input_messages:List[Message],
5.         temperature:float,
6.         top_p:float,
7.         stream:bool=False,
8.         max_gen_len:Optional[int]=None,
9.     )->AsyncGenerator:
10. # 对用户输入调用安全机制
11. asyncfor res in self.run_shields_wrapper(
12.             turn_id, input_messages, self.input_shields,"user-input"
13. ):
14. ifisinstance(res,bool):
15. return
16. else:
17. yield res
19. # 调用 _run 方法执行推理
20. asyncfor res in self._run(
21.             turn_id, input_messages, temperature, top_p, stream, max_gen_len
22. ):
23. ifisinstance(res,bool):
24. return
25. elifisinstance(res,CompletionMessage):
26.                 final_response = res
27. break
28. else:
29. yield res
31. # ... 断言 final_response 不为空 ...
33. # 对模型输出调用安全机制
34.         messages = input_messages +[final_response]
35. asyncfor res in self.run_shields_wrapper(
36.             turn_id, messages, self.output_shields,"assistant-output"
37. ):
38. ifisinstance(res,bool):
39. return
40. else:
41. yield res
43. yield final_response

复制代码

run 方法是 create_and_execute_turn 方法的核心，它实现了 Llama Agentic System 的推理逻辑，包括调用 LLM、执行工具、处理惩罚安全机制等。该方法是 Llama Agentic System 智能的核心，实现了多步推理、工具使用和安全保障等关键功能。

• • 它首先对用户输入调用 run_shields_wrapper 方法举行安全查抄。
  
• • 然后，它调用 _run 方法执行实际的推理过程，并处理惩罚推理过程中产生的事件流。
  
• • 最后，它对模型输出再次调用 run_shields_wrapper 方法举行安全查抄。
  

4. _run 方法

1.     async def_run(
2.         self,
3.         turn_id:str,
4.         input_messages:List[Message],
5.         temperature:float,
6.         top_p:float,
7.         stream:bool=False,
8.         max_gen_len:Optional[int]=None,
9.     )->AsyncGenerator:
10. # 预处理消息，添加系统提示信息
11.         input_messages = preprocess_dialog(input_messages, self.prefix_messages)
13.         attachments =[]
14.         n_iter =0
15. whileTrue:
16. # ... 获取最后一条消息，打印消息内容 ...
18.             step_id =str(uuid.uuid4())
19. # 发送推理步骤开始事件
20. yieldAgenticSystemTurnResponseStreamChunk(
21.                 event=AgenticSystemTurnResponseEvent(
22.                     payload=AgenticSystemTurnResponseStepStartPayload(
23.                         step_type=StepType.inference.value,
24.                         step_id=step_id,
25. )
26. )
27. )
29. # 构建推理请求
30.             req =ChatCompletionRequest(
31.                 model=self.model,
32.                 messages=input_messages,
33.                 available_tools=self.instance_config.available_tools,
34.                 stream=True,
35.                 sampling_params=SamplingParams(
36.                     temperature=temperature,
37.                     top_p=top_p,
38.                     max_tokens=max_gen_len,
39. ),
40. )
42.             tool_calls =[]
43.             content =""
44.             stop_reason =None
45. # 调用推理接口，处理推理结果
46. asyncfor chunk in self.inference_api.chat_completion(req):
47. # ... 处理推理结果 ...
49. # ... 处理推理结束原因 ...
51. # 创建 CompletionMessage 实例
52.             message =CompletionMessage(
53.                 content=content,
54.                 stop_reason=stop_reason,
55.                 tool_calls=tool_calls,
56. )
58. # 发送推理步骤结束事件
59. yieldAgenticSystemTurnResponseStreamChunk(
60.                 event=AgenticSystemTurnResponseEvent(
61.                     payload=AgenticSystemTurnResponseStepCompletePayload(
62.                         step_type=StepType.inference.value,
63.                         step_id=step_id,
64.                         step_details=InferenceStep(
65.                             step_id=step_id, turn_id=turn_id, model_response=message
66. ),
67. )
68. )
69. )
71. # ... 处理推理结束条件 ...
73. # ... 处理模型调用工具 ...
75.             n_iter += 1

复制代码

_run 方法是 run 方法的核心，它实现了 Llama Agentic System 的推理逻辑，包括调用 LLM、执行工具、处理惩罚安全机制等。

• • 它首先预处理惩罚消息，添加系统提示信息。
  
• • 然后，它进入一个循环，每次循环执行一次推理步调，直到满意结束条件。
  
• • 在每个推理步调中，它首先构建推理请求，然后调用 self.inference_api.chat_completion() 方法执行推理，并处理惩罚推理效果。
  
• • 如果模型必要调用工具，它会调用相应的工具，并将工具返回的效果添加到消息列表中。
  

Llama Agentic System Demo 示例

Llama Agentic System 提供了一些 Demo 示例，展示了如何使用它来完成实际使命。以下是一些示例：
1. 通货膨胀分析

• • 代码路径: examples/scripts/inflation.py
  
• • 功能描述: 该示例展示了如何使用 Llama Agentic System 来分析通货膨胀数据。它首先加载一个 CSV 文件，然后使用 LLM 往返答有关通货膨胀的问题，例如“哪一年以最高的通货膨胀结束？”、“是什么宏观经济形势导致了该时期如此高的通货膨胀？”等等。这个示例展示了 Llama Agentic System 如何处理惩罚结构化数据，并使用工具举行数据分析。
  

1. import asyncio
2. import fire
3. from llama_models.llama3_1.api.datatypes import*# noqa: F403
4. from custom_tools.ticker_data importTickerDataTool
5. from multi_turn import prompt_to_message, run_main
7. # 定义主函数
8. defmain(host: str, port: int, disable_safety: bool = False):
9. # 使用 asyncio 运行异步主函数
10.     asyncio.run(
11.         run_main(
12. [
13. UserMessage(
14.                     content=[
15. "Here is a csv, can you describe it ?",
16. Attachment(
17.                             url=URL(uri="file://examples/resources/inflation.csv"),
18.                             mime_type="text/csv",
19. ),
20. ],
21. ),
22.                 prompt_to_message("Which year ended with the highest inflation ?"),
23.                 prompt_to_message(
24. "What macro economic situations that led to such high inflation in that period?"
25. ),
26.                 prompt_to_message("Plot average yearly inflation as a time series"),
27.                 prompt_to_message(
28. "Using provided functions, get ticker data for META for the past 10 years ? plot percentage year over year growth"
29. ),
30.                 prompt_to_message(
31. "Can you take Meta's year over year growth data and put it in the same inflation timeseries as above ?"
32. ),
33. ],
34.             host=host,
35.             port=port,
36.             disable_safety=disable_safety,
37.             custom_tools=[TickerDataTool()],
38. )
39. )
42. if __name__ =="__main__":
43.     fire.Fire(main)

复制代码

代码解读:

• • 导入须要的库，包括 asyncio 用于异步利用，fire 用于下令行参数解析，llama_models 用于 Llama 模型相关功能，custom_tools 用于自定义工具，以及 multi_turn 用于多轮对话。
  
• • 定义 main 函数，它是步伐的入口点。
  
  
  
  • • 它使用 asyncio.run 运行异步函数 run_main。
    
  • • run_main 函数接收一系列用户消息和参数，包括主机地址、端口号、是否禁用安全机制以及自定义工具列表。
    
  • • 用户消息使用 UserMessage 类表示，可以包罗文本、附件等内容。
    
  • • prompt_to_message 函数用于将文本提示转换为用户消息。
    
  • • TickerDataTool 是一个自定义工具，用于获取股票数据。
    
  
  
• • 使用 fire.Fire(main) 将 main 函数绑定到下令行接口，方便用户使用下令行参数运行步伐。
  

2. 旅行筹划

• • 代码路径: examples/scripts/vacation.py
  
• • 功能描述: 该示例展示了如何使用 Llama Agentic System 来筹划旅行。用户可以向系统提供一些旅行信息，例如目标地、时间等，系统会根据这些信息生成具体的旅行筹划，包括景点推荐、路线规划、留宿发起等。这个示例展示了 Llama Agentic System 如何与用户举行多轮对话，并调用外部工具获取信息，终极完成复杂的使命。
  

1. import asyncio
2. import fire
3. from multi_turn import prompt_to_message, run_main
5. # 定义主函数
6. defmain(host: str, port: int, disable_safety: bool = False):
7.     asyncio.run(
8.         run_main(
9. [
10.                 prompt_to_message(
11. "I am planning a trip to Switzerland, what are the top 3 places to visit?"
12. ),
13.                 prompt_to_message("What is so special about #1?"),
14.                 prompt_to_message("What other countries should I consider to club?"),
15.                 prompt_to_message("How many days should I plan for in each country?"),
16. ],
17.             host=host,
18.             port=port,
19.             disable_safety=disable_safety,
20. )
21. )
23. # 当脚本作为主程序运行时，使用 fire 库执行 main 函数
24. if __name__ =="__main__":
25.     fire.Fire(main)

复制代码

代码解读:

• • 导入须要的库，包括 asyncio 用于异步利用，fire 用于下令行参数解析，以及 multi_turn 用于多轮对话。
  
• • 定义 main 函数，它是步伐的入口点。
  
  
  
  • • 它使用 asyncio.run 运行异步函数 run_main。
    
  • • run_main 函数接收一系列用户消息和参数，包括主机地址、端口号以及是否禁用安全机制。
    
  • • 用户消息使用 prompt_to_message 函数将文本提示转换为用户消息。
    
  
  
• • 使用 fire.Fire(main) 将 main 函数绑定到下令行接口，方便用户使用下令行参数运行步伐。
  

Llama Agentic System 安装与配置

如果您对 Llama as a System 感兴趣，并想尝试使用它，可以按照以下步调举行安装和配置：

1. # 创建并激活虚拟环境
2. ENV=agentic_env
3. with-proxy conda create -n $ENV python=3.10
4. cd<path-to-llama-agentic-system-repo>
5. conda activate $ENV
7. # 安装所需包
8. pip install -r requirements.txt
9. pip install llama-agentic-system
11. # 安装 bubblewrap 
12. # ... 根据您的操作系统安装 bubblewrap ...
14. # 测试安装
15. llama --help
17. # 下载模型检查点
18. llama download meta-llama/Meta-Llama-3.1-8B-Instruct
19. llama download meta-llama/Meta-Llama-3.1-70B-Instruct
20. llama download meta-llama/Prompt-Guard-86M--ignore-patterns original
21. llama download meta-llama/Llama-Guard-3-8B--ignore-patterns original
23. # 配置推理服务器
24. llama inference configure
26. # 运行推理服务器
27. llama inference start
29. # 配置 Agentic System
30. llama agentic_system configure
32. # 运行应用程序
33. mesop app/main.py
35. # 脚本交互
36. cd<path-to-llama-agentic-system>
37. conda activate $ENV
38. llama inference start
40. python examples/scripts/vacation.py localhost 5000

复制代码

结论

Llama as a System 为构建更智能、更安全的 AI 应用提供了强大的工具。通过将 Llama 模型与工具、安全机制相结合，我们可以构建可以或许解决更复杂问题的 AI 代理，并将其应用于更广泛的领域。

相关链接

• • Llama 官方网站: https://ai.meta.com/llama/
  
• • Llama Agentic System GitHub 仓库: https://github.com/facebookresearch/llama-agentic-system
  
• 来源 | 子非AI
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。