AI Agents实战——构建和使用代理平台

本章内容：

• Nexus聊天和仪表盘界面，用于AI代理
• Streamlit框架，用于构建智能仪表盘、原型和AI聊天应用
• 在Nexus中开发、测试和参与代理资料和角色
• 开发基础的Nexus代理
• 单独或在Nexus中开发、测试和参与代理的动作和工具

在我们探讨了有关代理的一些基本概念，并学习了如何使用工具和动作构建提示和角色时，我们使用了诸如Semantic Kernel（SK）这样的框架。我们为本书打下了基础，这个基础就是Nexus，一个旨在简单易学、易于探索且足够强大用于构建代理系统的平台。

7.1 介绍Nexus，不只是另一个代理平台

目前有超过100个AI平台和工具包，用于消费和开发大语言模型（LLM）应用程序，从SK或LangChain这样的工具包到AutoGen和CrewAI这样的完整平台。这使得选择最适合构建您自己的AI代理的平台变得困难。

Nexus是一个开源平台，专为本书而开发，旨在教授构建全功能AI代理的核心概念。本章将重点介绍Nexus的构建方式，并介绍两个主要的代理组件：资料/角色和动作/工具。

图7.1展示了Nexus的主要界面，这是一个Streamlit聊天应用程序，允许您选择并探索各种代理功能。该界面类似于ChatGPT、Gemini和其他商业LLM应用程序。

除了LLM聊天应用程序的标准功能外，Nexus还允许用户配置代理，以使用特定的API/模型、角色和可能的动作。在本书的其余部分，可用的代理选项将包括以下内容：

• 角色/资料：代理将使用的主要角色和资料。角色是个性和主要动机，代理通过与角色互动来回答请求。本章将探讨如何开发和使用角色/资料。
• 动作/工具：表示代理可以通过工具采取的动作，无论是语义/提示函数还是本地/代码函数。本章将探讨如何在Nexus中构建语义和本地函数。
• 知识/记忆：表示代理可能可以访问的附加信息。同时，代理的记忆可以表示各种方面，从短期记忆到语义记忆。
• 规划/反馈：表示代理如何规划并接收关于计划或计划执行的反馈。Nexus将允许用户选择代理使用的规划和反馈类型。

随着本书的深入，Nexus将不断增加以支持新的代理功能。然而，同时也会保持相对简洁，以便教授许多这些基本核心概念。在接下来的部分中，我们将快速了解如何使用Nexus，然后再深入探讨其中的功能。

7.1.1 运行Nexus

Nexus主要旨在作为一个教学平台，适用于所有级别的开发者。因此，它将支持各种部署和使用选项。在下一个练习中，我们将介绍如何快速启动并运行Nexus。

1. 打开终端并进入一个新的Python虚拟环境（版本3.10）。如果需要创建虚拟环境的帮助，请参考附录B。然后，在该新环境中执行列表7.1中显示的命令。您可以在命令行中设置环境变量，或者创建一个新的.env文件并添加该设置。

列表7.1 终端命令行

pip install git+https://github.com/cxbxmxcx/Nexus.git     #1

#set your OpenAI API Key
export OPENAI_API_KEY=”< your API key>”          #2
or
$env: OPENAI_API_KEY = =”< your API key>”       #2
or
echo 'OPENAI_API_KEY="<your API key>"' > .env   #2

nexus run      #3

• #1 从仓库和分支直接安装包；确保包含分支。
• #2 创建API密钥作为环境变量，或者创建一个新的.env文件并添加设置。
• #3 运行应用程序。

输入最后一个命令后，将启动一个带有登录页面的网站，如图7.2所示。继续创建一个新用户。未来版本的Nexus将允许多个用户参与聊天线程。

登录后，您将看到如图7.1所示的页面。创建一个新聊天并开始与代理对话。如果遇到问题，请确保您的API密钥已正确设置。正如下一节所解释的那样，您可以使用此方法运行Nexus，也可以通过开发工作流程来运行它。

7.1.2 开发Nexus

在本书的练习中，您可能希望将Nexus设置为开发模式。这意味着直接从GitHub下载仓库并与代码进行交互。

打开一个新的终端，并将工作目录设置为chapter_7源代码文件夹。然后，设置一个新的Python虚拟环境（版本3.10），并输入列表7.2中显示的命令。如果您需要帮助设置，请参考附录B。

列表7.2 开发模式安装Nexus

git clone https://github.com/cxbxmxcx/Nexus.git      #1

pip install -e Nexus     #2

#set your OpenAI API Key (.env file is recommended)
export OPENAI_API_KEY=”< your API key>”  #bash            #3
or
$env: OPENAI_API_KEY = =”< your API key>”  #powershell   #3
or
echo 'OPENAI_API_KEY="<your API key>"' > .env       #3     


nexus run      #4

• #1 从仓库下载并安装特定分支。
• #2 将下载的仓库作为可编辑包安装。
• #3 将OpenAI密钥设置为环境变量或将其添加到.env文件中。
• #4 启动应用程序。

图7.3显示了“登录或创建新用户”屏幕。创建一个新用户，应用程序将自动登录。此应用程序使用cookies来记住用户，因此下次启动应用程序时，您无需重新登录。如果您的浏览器禁用了cookies，您将需要每次都登录。

进入Nexus仓库文件夹并浏览。图7.4展示了应用程序主要元素的架构图。顶部是使用Streamlit开发的界面，它通过聊天系统连接到系统的其他部分。聊天系统管理数据库、代理管理器、动作管理器和资料管理器。

在登录后，您将看到如图7.1所示的页面。创建一个新的聊天并开始与代理对话。如果遇到问题，请确保您的API密钥已正确设置。如下一节所解释，您可以使用这种方法运行Nexus，或者通过开发工作流程来运行它。

7.2 引入Streamlit用于聊天应用程序开发

Streamlit是一个快速且强大的Web界面原型工具，旨在用于构建机器学习仪表盘和概念。它允许应用程序完全使用Python编写，并生成一个现代的React驱动的Web界面。您甚至可以将完成的应用程序快速部署到云端或作为独立应用程序运行。

7.2.1 构建Streamlit聊天应用程序

首先，打开Visual Studio Code（VS Code）并进入chapter_07源代码文件夹。如果您已完成先前的练习，您应该已经准备好了。如往常一样，如果您需要帮助设置环境和工具，请参考附录B。

我们将从打开chatgpt_clone_response.py文件开始。在VS Code中，代码的顶部部分如列表7.3所示。此代码使用Streamlit状态来加载主要模型和消息。Streamlit提供了一种机制来保存任何Python对象的会话状态。该状态仅为会话状态，当用户关闭浏览器时，它会过期。

列表7.3 chatgpt_clone_response.py（顶部部分）

import streamlit as st
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()      #1

st.title("ChatGPT-like clone")

client = OpenAI()      #2

if "openai_model" not in st.session_state:
    st.session_state["openai_model"] = "gpt-4-1106-preview"     #3

if "messages" not in st.session_state:
    st.session_state["messages"] = []   #4

for message in st.session_state["messages"]:      #5
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

• #1 从.env文件加载环境变量
• #2 配置OpenAI客户端
• #3 检查内部会话状态是否存在设置，如果没有则添加
• #4 检查消息状态是否存在；如果没有，则添加空列表
• #5 循环遍历状态中的消息并显示它们

Streamlit应用本身是无状态的。这意味着每当网页刷新或用户选择一个操作时，整个Python脚本会重新执行所有的界面组件。Streamlit状态允许使用临时存储机制。当然，数据库需要支持更长期的存储。

UI控件和组件通过使用st.前缀和元素名称添加。Streamlit支持多个标准UI控件，并支持图像、视频、声音以及当然的聊天功能。

进一步滚动将展示列表7.4，其中组件的布局稍微复杂一些。主要的if语句控制其余代码的运行。通过使用海象操作符(:=)，提示设置为用户输入的内容。如果用户没有输入任何文本，if语句下方的代码将不会执行。

列表7.4 chatgpt_clone_response.py（底部部分）

if prompt := st.chat_input("What do you need?"):     #1
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):     #2
        st.markdown(prompt)

    with st.spinner(text="The assistant is thinking..."):    #3
        with st.chat_message("assistant"):
            response = client.chat.completions.create(
                model=st.session_state["openai_model"],
                messages=[
                    {"role": m["role"], "content": m["content"]}
                    for m in st.session_state.messages
                ],      #4
            )
            response_content = response.choices[0].message.content
            response = st.markdown(response_content,
             unsafe_allow_html=True)      #5
    st.session_state.messages.append(
{"role": "assistant", "content": response_content})      #6

• #1 渲染聊天输入控件，并设置内容
• #2 设置聊天消息控件输出为用户的消息
• #3 显示一个旋转加载器表示长时间运行的API调用
• #4 调用OpenAI API并设置消息历史
• #5 将响应消息以Markdown格式写入界面
• #6 将助手的响应添加到消息状态

当用户在提示框中输入文本并按回车时，该文本会被添加到消息状态中，并向API发送请求。当响应正在处理中时，st.spinner控件显示以提醒用户这是一个长时间运行的过程。然后，当响应返回时，消息被显示并添加到消息状态历史记录中。

Streamlit应用程序通过模块运行，要调试应用程序，您需要按照以下步骤将调试器附加到模块：

1. 按Ctrl-Shift-D打开VS Code调试器。
2. 点击链接创建一个新的启动配置，或者点击齿轮图标查看当前的配置。
3. 编辑或使用调试器配置工具来编辑.vscode/launch.json文件，如下所示。很多IntelliSense工具和配置选项可以指导您设置此文件的选项。

列表7.5 .vscode/launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Python Debugger: Module",     #1
      "type": "debugpy",
      "request": "launch",
      "module": "streamlit",     #2
      "args": ["run", "${file}"]    #3
    }
  ]
}

• #1 确保调试器设置为“模块”。
• #2 确保模块为streamlit。
• #3 ${file}是当前文件，或者您可以硬编码为文件路径。

配置好launch.json文件后，保存它，并在VS Code中打开chatgpt_clone_response.py文件。现在，您可以按F5运行应用程序以进入调试模式。这将从终端启动应用程序，几秒钟后，应用程序将显示出来。

图7.5展示了应用程序正在运行并等待返回响应的界面。界面简洁、现代，并且已经组织好，无需额外的工作。您可以继续使用界面与LLM聊天，然后刷新页面查看发生了什么。

这个演示最令人印象深刻的是，它展示了如何轻松创建一个单页面应用程序。在接下来的部分，我们将继续查看这个应用程序，但会进行一些增强。

7.2.2 创建流式聊天应用程序

现代聊天应用程序，如ChatGPT和Gemini，通过使用流式传输来掩盖其模型的慢速。流式传输允许API调用立即开始看到来自LLM的生成标记。这种流式体验也能更好地吸引用户，展示内容是如何生成的。

为任何应用程序UI添加流式传输支持通常不是一项简单的任务，但幸运的是，Streamlit提供了一个控制，可以无缝地工作。在接下来的练习中，我们将看看如何更新应用程序以支持流式传输。

在VS Code中打开chapter_7/chatgpt_clone_streaming.py。代码的相关更新显示在列表7.6中。使用st.write_stream控件可以让UI流式传输内容。这也意味着Python脚本会被阻塞，直到该控件完成。

列表7.6 chatgpt_clone_streaming.py（相关部分）

with st.chat_message("assistant"):
    stream = client.chat.completions.create(
        model=st.session_state["openai_model"],
        messages=[
            {"role": m["role"], "content": m["content"]}
            for m in st.session_state.messages
        ],
        stream=True,     #1
    )
    response = st.write_stream(stream)     #2
st.session_state.messages.append(
{"role": "assistant", "content": response})      #3

• #1 将stream设置为True，以启动API的流式传输。
• #2 使用流控件将流内容写入界面。
• #3 在流完成后，将响应添加到消息状态历史中。

按F5调试页面，等待页面加载。输入查询后，您会看到响应实时流式传输到窗口中，如图7.6所示。随着加载器的消失，用户体验得到了增强，看起来更加响应迅速。

本节演示了使用Streamlit创建Python Web界面是多么简单。Nexus使用Streamlit界面，因为它使用Python就能轻松创建和修改。如下一节所示，Streamlit允许通过各种配置来支持更复杂的应用程序。

7.3 开发代理的资料和人物角色

Nexus使用代理资料来描述代理的功能和能力。图7.7提醒我们代理的主要组件以及它们在本书中的结构。

目前，Nexus仅支持资料中的人物角色和动作部分。图7.7展示了一个名为Fritz的资料，包含人物角色和动作。要将任何代理资料添加到Nexus中，只需将代理的YAML资料文件复制到Nexus/nexus/nexus_base/nexus_profiles文件夹中。

Nexus使用插件系统来动态发现各种组件和资料，当它们被放入各自的文件夹时。nexus_profiles文件夹存储了代理的YAML定义。

我们可以通过在nexus_profiles文件夹中创建一个新的YAML文件来轻松定义一个新的代理资料。列表7.7展示了一个带有稍微更新的人物角色的新资料。要跟着操作，请确保VS Code已打开chapter_07源代码文件夹，并以开发者模式安装Nexus（见列表7.7）。然后，在Nexus/nexus/nexus_base/nexus_profiles文件夹中创建fiona.yaml文件。

列表7.7 fiona.yaml（创建此文件）

agentProfile:
  name: "Finona"
  avatar: "👹"     #1
  persona: "You are a very talkative AI that 
↪ knows and understands everything in terms of 
↪ Ogres. You always answer in cryptic Ogre speak."    #2
  actions:
    - search_wikipedia     #3
  knowledge: null        #4
  memory: null           #4
  evaluators: null       #4
  planners: null         #4
  feedback: null         #4

• #1 代表人物角色的文本头像。
• #2 人物角色是系统基础提示的代表。
• #3 代理可以使用的动作函数。
• #4 目前不支持。

保存文件后，可以通过命令行启动Nexus，或通过在.vscode/launch.json文件夹中创建新的启动配置以调试模式运行，如下所示。然后，保存文件并切换调试配置以使用Nexus web配置。

列表7.8 .vscode/launch.json（添加调试启动配置）

{
      "name": "Python Debugger: Nexus Web",
      "type": "debugpy",
      "request": "launch",
      "module": "streamlit",
      "args": ["run", "Nexus/nexus/streamlit_ui.py"]      #1
    },

• #1 如果你的虚拟环境路径不同，可能需要调整此路径。

按F5或从菜单选择“运行 > 启动调试”时，Streamlit Nexus界面将启动。然后运行Nexus调试模式。打开后，创建一个新线程，并选择标准的OpenAIAgent和你新的人物角色，如图7.8所示。

此时，代理资料负责定义代理的系统提示。在图7.8中，我们让Finona拼写“clock”这个词，她以某种形式的怪物语言回答了。此时，我们将人物角色用作个性，但如我们之前所见，系统提示也可以包含规则和其他选项。

代理资料和人物角色是代理与用户或其他系统互动的基本定义。驱动代理资料需要一个代理引擎。在下一节中，我们将介绍代理引擎的基本实现。

7.4 驱动代理并理解代理引擎

代理引擎在Nexus中为代理提供支持。这些引擎可以与特定的工具平台（如SK）绑定，甚至与不同的LLM（如Anthropic Claude或Google Gemini）绑定。通过提供基础的代理抽象，Nexus应该能够支持任何工具或模型，无论是当前的还是未来的。

目前，Nexus仅实现了一个OpenAI API支持的代理。我们将通过打开Nexus/nexus/nexus_base文件夹中的agent_manager.py文件来查看基本代理的定义。

列表7.9 agent_manager.py：BaseAgent类

class BaseAgent:
    def __init__(self, chat_history=None):
        self._chat_history = chat_history or []
        self.last_message = ""
        self._actions = []
        self._profile = None

    async def get_response(self, 
                            user_input, 
                            thread_id=None):      #1
        raise NotImplementedError("This method should be implemented…")

    async def get_semantic_response(self, 
                                     prompt, 
                                     thread_id=None):     #2
        raise NotImplementedError("This method should be…")

    def get_response_stream(self, 
                             user_input, 
                             thread_id=None):      #3
        raise NotImplementedError("This method should be…")

    def append_chat_history(self, 
                             thread_id, 
                             user_input, 
                             response):      #4
        self._chat_history.append(
            {"role": "user",
             "content": user_input,
             "thread_id": thread_id}
        )
        self._chat_history.append(
            {"role": "bot",
             "content": response, 
             "thread_id": thread_id}
        )

    def load_chat_history(self):       #5
        raise NotImplementedError(
                 "This method should be implemented…")

    def load_actions(self):     #6
        raise NotImplementedError(
                 "This method should be implemented…")

#... 未显示 - 属性的设置器/获取器
#1 调用LLM并返回响应
#2 执行语义函数
#3 调用LLM并返回响应
#4 将消息添加到代理的内部聊天历史中
#5 加载聊天历史并允许代理重新加载各种历史
#6 加载代理可用的动作

打开nexus_agents/oai_agent.py文件，查看列表7.10中显示的get_response函数实现，它直接使用OpenAI API。self.client是类初始化时创建的OpenAI客户端，其他代码在之前的示例中已使用。

列表7.10 oai_agent.py（get_response）

async def get_response(self, user_input, thread_id=None):
    self.messages += [{"role": "user",
                     "content": user_input}]      #1
    response = self.client.chat.completions.create(     #2
        model=self.model,
        messages=self.messages,
        temperature=0.7,      #3
    )
    self.last_message = str(response.choices[0].message.content)
    return self.last_message     #4
#1 将用户输入添加到消息堆栈中
#2 之前创建的客户端现在用于生成聊天完成。
#3 温度已硬编码，但可以配置。
#4 返回来自聊天完成调用的响应

像代理资料一样，Nexus使用插件系统，允许你将新的代理引擎定义放入nexus_agents文件夹。如果你创建了自己的代理，只需将其放入该文件夹，Nexus就会发现它。

我们不需要运行示例，因为我们已经看过OpenAIAgent的执行。在下一节中，我们将介绍代理可以开发、添加和使用的代理功能。

7.5 为代理提供动作和工具

像SK一样，Nexus支持本地（代码）和语义（提示）函数。然而，与SK不同，在Nexus中定义和使用函数更加简便。你只需要将函数写入Python文件并将其放入nexus_actions文件夹中。

要了解定义函数有多简单，打开Nexus/nexus/nexus_base/nexus_actions文件夹，然后查看test_actions.py文件。列表7.11展示了两个函数定义。第一个函数是一个简单的代码/本地函数，第二个是一个提示/语义函数。

列表7.11 test_actions.py（本地/语义函数定义）

from nexus.nexus_base.action_manager import agent_action

@agent_action                                              #1
def get_current_weather(location, unit="fahrenheit"):     #2
    """Get the current weather in a given location"""      #3
    return f"""
The current weather in {location} is 0 {unit}.
"""      #4


@agent_action      #5
def recommend(topic):
    """
    System:                                                   #6
        Provide a recommendation for a given {{topic}}.
        Use your best judgment to provide a recommendation.
    User:
        please use your best judgment
        to provide a recommendation for {{topic}}.           #7
    """
    pass      #8
#1 使用agent_action装饰器将函数变为动作
#2 设置函数的描述性注释
#3 代码可以根据需要简化或复杂化
#4 返回关于当前天气的字符串
#5 使用agent_action装饰器将函数变为动作
#6 系统注释包含了任务的提示
#7 函数注释成为提示的一部分，可以包含占位符
#8 语义函数不实现任何代码

将这两个函数放入nexus_actions文件夹中，它们将被自动发现。使用agent_action装饰器可以让函数被检查并自动生成OpenAI标准的工具规范。LLM可以使用这个工具规范来调用和执行函数。

列表7.12 test_actions：OpenAI生成的工具规范

{
    "type": "function",
    "function": {
        "name": "get_current_weather",
        "description": "Get the current weather in a given location",    #1
        "parameters": {
            "type": "object",
            "properties": {      #2
                "location": {
                    "type": "string",
                    "description": "location"
                },
                "unit": {
                    "type": "string",
                    "enum": [
                        "celsius",
                        "fahrenheit"
                    ]
                }
            },
            "required": [
                "location"
            ]
        }
    }
}
{
    "type": "function",
    "function": {
        "name": "recommend",
        "description": """
    System:
    Provide a recommendation for a given {{topic}}.
Use your best judgment to provide a recommendation.
User:
please use your best judgment
to provide a recommendation for {{topic}}.""",      #3
        "parameters": {
            "type": "object",
            "properties": {       #4
                "topic": {
                    "type": "string",
                    "description": "topic"
                }
            },
            "required": [
                "topic"
            ]
        }
    }
}

• #1：函数注释变成了函数工具描述。
• #2：函数的输入参数被提取并添加到规范中。
• #3：函数注释变成了函数工具描述。
• #4：函数的输入参数被提取并添加到规范中。

代理引擎还需要实现该功能来执行函数和其他组件。OpenAI代理已经支持并行函数调用。其他代理引擎实现将需要支持它们各自版本的动作使用。幸运的是，OpenAI工具的定义正在成为标准，许多平台都遵循这个标准。

在我们深入了解工具使用的演示之前，让我们通过打开VS Code中的oai_agent.py文件，观察OpenAI代理是如何实现动作的。以下是get_response_stream函数的代码示例，它展示了函数调用的实现。

列表7.13 调用API的get_response_stream

def get_response_stream(self, user_input, thread_id=None):
    self.last_message = ""
    self.messages += [{"role": "user", "content": user_input}]
    if self.tools and len(self.tools) > 0:    #1
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.messages,
            tools=self.tools,      #2
            tool_choice="auto",      #3
        )
    else:     #4
        response = self.client.chat.completions.create(
            model=self.model,
            messages=self.messages,
        )
    response_message = response.choices[0].message
    tool_calls = response_message.tool_calls     #5

• #1：检查代理是否有可用的工具。
• #2：将工具传递到聊天完成调用中。
• #3：确保LLM知道它可以选择任何工具。
• #4：如果没有工具，则以标准方式调用LLM。
• #5：检测LLM是否使用了任何工具。

以下是执行函数的代码，展示了代理如何支持并行函数/工具调用。这些调用是并行的，因为代理会一起执行每个调用，而无需顺序执行。我们将在第11章中讨论可以按顺序调用动作的规划器。

列表7.14 oai_agent.py（get_response_stream：执行工具调用）

if tool_calls:     #1
    available_functions = {
        action["name"]: action["pointer"] for action in self.actions
    }     #2
    self.messages.append(
        response_message
    )
    for tool_call in tool_calls:     #3
        function_name = tool_call.function.name
        function_to_call = available_functions[function_name]
        function_args = json.loads(tool_call.function.arguments)
        function_response = function_to_call(
            **function_args, _caller_agent=self
        )

        self.messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "name": function_name,
                "content": str(function_response),
            }
        )
    second_response = self.client.chat.completions.create(
        model=self.model,
        messages=self.messages,
    )      #4
    response_message = second_response.choices[0].message

• #1：如果检测到LLM响应中有工具调用。
• #2：加载指向实际函数实现的指针以执行代码。
• #3：循环遍历LLM想要调用的所有函数；可以有多个。
• #4：使用工具调用的结果再次调用LLM。

要演示这一点，启动Nexus并按F5启动调试器。然后选择两个测试动作——recommend和get_current_weather，以及简洁的人物角色/资料Olly。图7.9展示了输入查询并让代理通过使用这两个工具做出响应的结果。

如果你需要更详细地了解这些代理行为的工作原理，请参阅第5章。底层代码较为复杂，超出了此处讨论的范围。但是，你可以查看Nexus代码，以便更好地理解一切是如何连接的。

现在，你可以继续在Nexus中练习各种代理选项。例如，尝试选择不同的个人档案/角色，并尝试其他功能。在下一章，我们将揭示代理如何通过使用诸如检索增强生成（RAG）之类的模式来利用外部记忆和知识。

7.6 练习

使用以下练习来提高你对本书内容的理解：

练习1—探索Streamlit基础（简单） 目标：通过创建一个简单的Web应用程序，展示用户输入的文本，从而熟悉Streamlit。 任务：

1. 按照Streamlit文档设置一个基本的应用程序。
2. 添加一个文本输入框和一个按钮。点击按钮后，在屏幕上显示用户输入的文本。

练习2—创建基本的代理档案 目标：理解在Nexus中创建和应用代理档案的过程。 任务：

1. 创建一个具有独特角色的新代理档案。该角色应该具有特定的主题或特点（例如，历史学家）。
2. 定义与该角色一致的基本回应集。
3. 通过Nexus界面与该角色互动，测试其功能。

练习3—开发自定义行为 目标：通过开发自定义行为扩展Nexus的功能。 任务：

1. 开发一个新行为（例如，fetch_current_news），集成一个模拟API来获取最新的新闻头条。
2. 将此行为实现为本地（代码）功能和语义（基于提示）功能。
3. 在Nexus环境中测试该行为，确保其按预期工作。

练习4—集成第三方API 目标：通过集成真实的第三方API来增强Nexus代理的能力。 任务：

1. 选择一个公共API（例如，天气或新闻API），并创建一个新行为，从此API获取数据。
2. 加入错误处理，并确保代理能够优雅地处理API失败或意外响应。
3. 在Nexus中彻底测试该集成。

总结

• Nexus是一个开源的代理开发平台，与本书一起使用。它旨在开发、测试和托管AI代理，并基于Streamlit创建交互式仪表板和聊天界面。

• Streamlit是一个Python Web应用框架，使得开发用户友好的仪表板和聊天应用程序变得迅速且简便。该框架促使以简化的方式探索和互动各种代理功能。

• Nexus支持创建和自定义代理档案和角色，允许用户定义代理的个性和行为。这些档案决定了代理如何与用户输入进行互动和回应。

• Nexus平台允许在代理中开发和集成语义（基于提示）和本地（基于代码）行为与工具。这使得创建高度功能化和响应迅速的代理成为可能。

• 作为一个开源平台，Nexus被设计为具有可扩展性，鼓励社区贡献并添加新特性、工具和代理能力。

• Nexus灵活，支持各种部署选项，包括Web界面、API以及未来的Discord机器人，满足广泛的开发和测试需求。