在这篇文章中，我深入研究了人工智能领域最热门的趋势：AI代理。这项技术有望推动人工智能领域的巨大进步，甚至可能比下一代基础模型更加关键。让我们一起来探讨为什么AI代理会引起如此大的关注。

安德鲁·Ng最近撰写了一系列关于代理模式（Agentic Patterns）的博客，强调了这一趋势的重要性和影响。

“亲爱的朋友们，我认为今年AI的进步将会非常巨大，甚至可能超过下一代基础模型带来的进步。这是一个重要的趋势，我希望大家都能关注。” —— 吴恩达

本质上，AI代理是由大型语言模型（LLMs）驱动的实体，旨在自主完成任务。代理能够规划、推理并采取行动来实现特定目标。它们就像是超级版的数字助手，能够将复杂任务拆分成可管理的小步骤，使用各种工具来完成这些步骤，并从经验中学习进步。

人们对AI代理的热情源于它们有可能改变我们与AI系统互动的方式，并自动化复杂任务。想象一下，你有一个虚拟团队成员，不仅能理解你的需求，还能制定策略满足这些需求，适应新变化，甚至还能和其他AI一起解决复杂问题。

出处:https://ai.gopubby.com/why-we-all-should-learn-get-serious-about-ai-agents-this-year-dd452b625b9d

我们从只能提供信息的基本语言模型，就像“我可以告诉你关于纽约旅行的计划”这样的功能，发展到了如今能够采取行动的AI助手——例如“我可以为您预订航班，预定酒店，并将细节添加到您的日历中”。未来更加令人期待：AI将了解您的偏好，并在没有指示的情况下采取主动行动。这种从提供信息到采取行动再到预测的变化，标志着AI融入我们生活的根本性转变，从被动的辅助工具转变为积极的个性化助手。

从自动化业务流程到提升客户服务，再到加速科学研究和激发创意，人工智能代理的应用广泛而多样。它们有可能大幅提升生产力，促进创新，并在各个行业中打开新的可能性。

本文旨在为想利用AI代理技术优势的开发者、探索其应用的企业领导以及对AI未来感兴趣的个人提供有价值的见解。

1. AI代理的解剖：对构成AI代理的关键组件进行探讨，从其LLM核心模型到其规划和行动能力。
2. 构建你的第一个AI代理：使用Langgraph逐步创建基本AI代理的教程，重点介绍基本的搜索功能。
3. 高级代理技术：探索提升AI能力的代理模式和多代理系统。
4. 构建多代理系统：使用Langgraph逐步创建具有状态的多代理AI系统的教程，重点介绍系统设计和实现。
5. 多代理系统如何提升性能：深入探讨Andrew NG和他的团队构建的代理，以提高代码评测性能。
6. 挑战与未来方向：讨论AI代理开发面临的障碍以及该领域的未来发展趋势。

原文来自: https://langfuse.com/blog/2024-07-ai-agent-observability-with-langfuse

AI代理是由多个关键组件构成的复杂系统，这些组件协同工作，使AI代理能够自主完成任务。AI代理通常包含五个主要组成部分。

每个AI代理的核心是大规模语言模型（LLM）。这就像代理的大脑，提供基本的智能和语言理解功能。LLM使代理能够处理和生成类似人类的文本信息，理解上下文环境，并在大量训练数据的基础上做出决策。

一个AI代理的关键能力之一就是它的规划能力。这个模块让代理能够将复杂的任务目标分解成一系列可管理的小任务。

• 分析给定的任务
• 确定实现任务所需的步骤
• 按逻辑顺序排列这些步骤
• 根据新信息调整计划

有效的规划对于解决复杂的多步骤问题是至关重要的。在这个模块中，智能代理使用LLM进行推理。这纯粹是一个生成式的人工智能任务，也可以视为有效的输出（请参阅下文）

{
  "任务": "生成一条使用AI代理的Twitter推文",
  "规划": {
    "输入项": {
      "用户偏好": [
        "主题",
        "关键词",
        "语气"
      ],
      "趋势数据": "获取热门话题和标签"
    },
    "工作流程": [
      {
        "步骤": "收集输入",
        "描述": "收集用户的偏好和趋势信息",
        "动作": [
          "请求用户输入（例如，主题、关键词、语气）",
          "从Twitter API获取热门话题和标签"
        ]
      },
      {
        "步骤": "生成推文",
        "描述": "基于输入和趋势创建推文",
        "动作": [
          "使用AI模型生成不超过280个字符的推文",
          "将用户偏好和趋势数据融入其中以增加相关性"
        ]
      },
      {
        "步骤": "优化互动",
        "描述": "让推文更具互动性",
        "动作": [
          "添加相关的标签和提及",
          "调整语气和内容以实现最大互动"
        ]
      },
      {
        "步骤": "验证推文",
        "描述": "确保推文符合规则",
        "动作": [
          "检查字符长度和格式",
          "确保内容符合Twitter的规定和社区准则"
        ]
      },
      {
        "步骤": "发布推文",
        "描述": "代表用户发布推文",
        "动作": [
          "使用Twitter API发布推文",
          "确认推文已成功发布"
        ]
      },
      {
        "步骤": "反馈循环",
        "描述": "收集反馈以进行改进",
        "动作": [
          "监控推文互动（点赞、转发、评论）",
          "根据性能数据和用户反馈来调整AI模型"
        ]
      }
    ]
  }
}

行动部分是AI代理与其环境交互以完成任务的地方。这通常涉及利用各种工具和API。一些例子包括：AI代理可能采取的一些动作示例有：

• 进行网页搜索
• 运行代码
• 访问数据库
• 与其他软件系统互动

有效地使用工具可以大大扩展AI代理可以执行的任务范围。这是因为范式从生成转向了纯粹的确定性执行。 例如，简单来说，如果一个代理想要执行某个函数（例如所有可以调用的API），那么大型语言模型的任务是识别需要执行的函数及其参数。例如，比如，如果一个代理想执行某个函数（例如所有可以调用的API），这里有两个例子。

    ## 发布推文的API
    {  
      "endpoint": "/api/post-tweet",  
      "method": "POST",  
      "description": "将生成的推文发布到Twitter上。",  
      "request": {  
        "body": {  
          "tweet_id": "string",  
          "user_id": "string",  
          "oauth_token": "string"  
        }  
      },  
      "response": {  
        "status": 200,  
        "body": {  
          "message": "发布成功",  
          "twitter_post_id": "twitter_post_id"  
        }  
      }  
    }  

    ## 获取Twitter上的热门话题和标签的API
    {  
      "endpoint": "/api/fetch-trending",  
      "method": "GET",  
      "description": "从Twitter获取热门话题和标签。",  
      "request": {  
        "query_parameters": {  
          "location": "string",  
          "limit": "number"  
        }  
      },  
      "response": {  
        "status": 200,  
        "body": {  
          "trending_topics": [  
            {  
              "hashtag": "#example",  
              "tweet_volume": "推文量"  
            }  
          ]  
        }  
      }  
    }

现在如果我向一个代理人提出以下问题

看看Twitter上有哪些热门的体育话题，  
同时将这条推文发布到Twitter上：  
“AI智能是自切片面包以来最伟大的创新”，  

注意："自从切片面包以来" 改为 "有切片面包以来"，并用逗号连接句子，使其更符合中文口语表达习惯。

大型语言模型将识别如下函数调用

    ## 调用带有参数的FETCH API请求
    {  
      "endpoint": "/api/fetch-trending",  
      "method": "GET",  
      "parameters": {  
        "location": "global",  // 或指定位置，如 "United States" ，以缩小检索范围  
        "limit": 10  // 要检索的热门话题数量  
      },  
      "response": {  
        "status": 200,  
        "body": {  
          "trending_topics": [  
            {  
              "hashtag": "#SportsExample1",  
              "tweet_volume": 25000  
            },  
            {  
              "hashtag": "#FootballExample2",  
              "tweet_volume": 18000  
            }  
            // 更多热门话题...  
          ]  
        }  
      }  
    }  

    ## 使用带参数的POST Tweet API发起调用  
    {  
      "endpoint": "/api/post-tweet",  
      "method": "POST",  
      "body": {  
        "tweet_text": "AI 代理是自切片面包以来最好的事情",  
        "user_id": "your_user_id",  // 用户或应用的唯一ID  
        "oauth_token": "your_oauth_token"  // 用于验证Twitter API的OAuth令牌，如"your_oauth_token"  
      },  
      "response": {  
        "status": 200,  
        "body": {  
          "message": "推文已成功发布。",  
          "twitter_post_id": "123456789"  
        }  
      }  
    }

一旦你从这些大语言模型（LLM）中得到了结果，你就可以用这些结果在实际运行环境中执行API。

AI代理的配置定义了其行为模式、个性特征和特定技能。这可能包括以下内容：

• 代理的角色或专长（例如，客服代表，数据分析师）
• 说话的语气和沟通方式
• 道德准则和限制
• 具体的专业知识领域

该资料有助于确保智能代理的回应和行为与其预期角色一致且合适。

    系统提示：你是一名Twitter内容助理。  
    你的工作是搜集热门体育话题，  
    根据用户输入制作吸引人的推文，  
    并发布它们，以最大限度地提高互动。

记忆组件允许AI代理存储和调取过去交互中的信息，这非常重要，例如：

• 保持对话中的上下文连贯
• 从之前的经历中学习
• 随着时间的推移提高性能
• 根据用户历史提供个性化的回复

记忆可以是短期的（只持续一次对话的时间）或长期的（在多次互动中持续存在）。

下面是一步一步的指导，教你如何在Langgraph（https://www.langchain.com/langgraph）构建你第一个简单的AI代理。
这个代理会根据你的需要，使用Tavily（https://tavily.com/）来搜索网络。

1. 安装依赖

接下来安装一些必要的库：

!pip install -U langchain-community langgraph langchain-anthropic tavily-python langgraph-checkpoint-sqlite
!pip install -qU langchain-openai

2. 安装和配置 Tavily 以及 Open AI，并了解工具绑定的概念。

```python
    import getpass  
    import os  

    os.environ["TAVILY_API_KEY"] = ""  ##请在这里插入Key  

    from langchain_community.tools.tavily_search import TavilySearchResults  

    search = TavilySearchResults(max_results=2)  
    search_results = search.invoke("旧金山的天气怎么样")  
    print(search_results)  
    # 如果需要，我们可以创建其他工具。  
    # 一旦有了所有想要的工具，我们可以把它们放在一个列表中，稍后引用。  
    tools = [search]  

    import getpass  
    import os  

    os.environ["OPENAI_API_KEY"] = ""  

    from langchain_openai import ChatOpenAI  

    model = ChatOpenAI(model="gpt-4")  

    from langchain_core.messages import HumanMessage  

    response = model.invoke([HumanMessage(content="嘿!")])  
    response.content  

    model_with_tools = model.bind_tools(tools)  ##在这里将搜索工具绑定到LLM  

    response = model_with_tools.invoke([HumanMessage(content="嘿!")])  

    print(f"内容字符串: {response.content}")  
    print(f"工具调用结果: {response.tool_calls}")  

    response = model_with_tools.invoke([HumanMessage(content="旧金山的天气怎么样？")])  

    print(f"内容字符串: {response.content}")  
    print(f"工具调用结果: {response.tool_calls}")  

3. 设置一个简单的代理服务器

from langgraph.prebuilt 导入 create_react_agent  

agent_executor = create_react_agent(model, tools)  

response = agent_executor.invoke({"messages": [HumanMessage(content="嗨！")]})  

response["messages"]  

response = agent_executor.invoke({"messages": [HumanMessage(content="蒲那的天气怎么样？")]})  
response["messages"]

4. 增加内存

    从langgraph.checkpoint.memory模块导入MemorySaver类  

    memory = MemorySaver()  

    agent_executor = create_react_agent(model, tools, checkpointer=memory)  

    config = {"configurable": {"thread_id": "123"}}  

    for chunk in agent_executor.stream(  
        {"messages": [HumanMessage(content="hi, 我是Bob!")]}, config  
    ):  
        打印(chunk)  
        打印("--------------------")  

    agent_executor = create_react_agent(model, tools, checkpointer=memory)  

    config = {"configurable": {"thread_id": "123"}}  

    for chunk in agent_executor.stream(  
        {"messages": [HumanMessage(content="hi, 我是Bob!")]}, config  
    ):  
        打印(chunk)  
        打印("--------------------")

目前，在AI研究中发现的关键模式（代理行为模式）包括：

1. 思考
2. 使用工具
3. 规划
4. 团队协作

让我们来探讨一下这些，以理解它们在人工智能发展过程中的重要性。

反思涉及AI代理分析和批判其自身输出的能力。这一模式对于提高AI生成内容的质量和可靠性至关重要。例如，在编码任务中，一个AI代理可能会生成代码，然后检查代码的正确性、风格和效率，并提供有助于改进的建设性反馈。

AI代理越来越擅长使用外部工具来提升他们的能力。这种模式包括：

- 网络搜索：AI代理现在可以利用互联网搜索功能来访问超出其训练数据的信息，极大地扩展了它们的知识库。
- 代码执行：高级AI代理不仅可以理解和推理代码，还可以编写和执行代码，从而让它们的产出可以在现实世界中被测试和使用。

大型语言模型现在能够将复杂的任务拆分为可管理的步骤。这种规划能力让AI可以有条不紊地解决问题，在采取行动前，会先考虑实现目标所需的步骤。

可能最令人激动的发展是多个专门的代理能共同完成复杂的任务。这种合作就像人类团队合作一样，不同的代理承担了类似于专业环境中角色的任务，比如软件工程师、产品经理、设计师和质量保证工程师。

来源:2024年7月AI代理可观测性文章

为了说明这些代理模式（agency patterns）如何在实际应用场景中结合在一起，来看一个例子：自动化内容生成流水线。

https://towardsdatascience.com/ai-agents-from-concepts-to-practical-implementation-in-python-fb26789b1560

1Agent 1：视频分析与转录
— 任务：根据给定话题查找相关视频并制作转录。
— 工具：YouTube频道查找、视频分析算法、转录软件。

2. 任务2：写博客文章
— 任务：根据视频的文字稿内容撰写一篇博客文章草稿。

3. 任务3：写 LinkedIn 帖子
— 任务：撰写一篇总结博客草稿关键点的 LinkedIn 帖子。

4. 第四特工：写推文
— 任务：把内容进一步提炼，写出简洁的推文。

这个多代理系统展示了各个专门的AI代理如何协同作业，每个代理专注于特定的任务，同时为更大的目标做出贡献。过程始于用户感兴趣的特定主题，并最终在多个平台上实现协调一致的内容策略规划。

下面是一个Langchain实现的常见应用场景的标准实现方式。

这个多代理系统通过一系列专门的代理来处理用户的请求：一个 研究员 收集数据，一个 路由器 管理信息流，一个 图表生成器 生成可视化图表，一个 呼叫工具 促进代理间的互动。系统根据条件逻辑循环这些代理，直到生成并返回给用户的最终图表。

来源：Langchain（一个特定领域的术语或品牌）

第一步：安装依赖

     pip install -U langchain langchain_openai langsmith pandas langchain_experimental matplotlib langgraph langchain_core

步骤2：创建生成代理的函数

    from langchain_core.messages import (  
        BaseMessage,  
        HumanMessage,  
        ToolMessage,  
    )  
    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder  

    from langgraph.graph import END, StateGraph, START  

    def create_agent(llm, tools, system_message: str):  
        """创建一个代理角色。"""  
        prompt = ChatPromptTemplate.from_messages(  
            [  
                (  
                    "system",  
                    "你是一个乐于助人的AI助手，与其他助手合作。"  
                    "使用提供的工具来逐步推进回答问题。"  
                    "如果你无法完全回答，也没关系，另一个拥有不同工具的助手会继续你的未完成部分。"  
                    "尽力推进进程。"  
                    "如果你或其他助手得到了最终答案，"  
                    "在你的回复前加上'最终答案'，这样团队就知道可以停止了。"  
                    "你可以使用以下工具：{tool_names}。\n{system_message}",  
                ),  
                MessagesPlaceholder(variable_name="messages"),  
            ]  
        )  
        prompt = prompt.partial(system_message=system_message)  
        prompt = prompt.partial(tool_names=", ".join([tool.name for tool in tools]))  
        return prompt | llm.bind_tools(tools)

这个功能可以创建上述所有代理。但是我们并不需要将代理的创建限制在单一功能上。它们可以有自己的工具和特定的指令。上述功能通过一组绑定到llm的工具和系统描述来创建一个代理。

第三步：添加工具

from typing import Annotated  

from langchain_community.tools.tavily_search import TavilySearchResults  
from langchain_core.tools import tool  
from langchain_experimental.utilities import PythonREPL  

tavily_tool = TavilySearchResults(max_results=5)  

# 此代码在本地执行，若无沙箱环境则可能存在安全隐患  

repl = PythonREPL()  

@tool  
def python_repl(  
    code: Annotated[str, "要执行的Python代码"],  
):  
    """使用此工具来执行Python代码。如果您希望显示某个值的输出，请使用`print(...)`进行打印。此内容对用户可见。"""  
    try:  
        result = repl.run(code)  
    except BaseException as e:  
        return f"执行失败。错误：{repr(e)}"  
    result_str = f"执行成功：\n```python\n{code}\n```\n标准输出：{result}"  
    return (  
        result_str + "\n\n如果您已完成所有任务，请回复最终答案。")

上面我们有两个工具。

1. Tavily（例如）用于搜索功能。
2. 第二个工具是一个Python运行时的函数，用于生成代码——该函数接收一段Python代码并执行。

第4步：创建代理的状态

当我们提到这些代理时，指的是那些有状态的代理。

具有状态的AI代理使用持久化的内存结构来保留和更新跨交互过程的上下文信息，从而能够动态调整其决策过程。这种架构支持复杂的推理，支持序列任务中的长期依赖，并允许在从对话界面到多步骤问题解决的应用中进行更复杂的模式识别并提供个性化的响应。

下面，我们创建一个状态结构体，这个状态结构体将在整个循环过程中不断维护和更新。

import operator  
from typing import Annotated, Sequence, TypedDict  

from langchain_openai import ChatOpenAI  

# 以下定义了在图中的每个节点之间传递的对象
# 一个代理的状态，包括消息和发送者信息
class AgentState(TypedDict):  
    messages: Annotated[Sequence[BaseMessage], operator.add]  
    sender: str

消息变量会不断添加新的消息，而发送者变量会被更新（这能让当前的代理知道谁是之前的代理）。

步骤五：定义代理人

我们在图中创建了3个代理或节点，具体如下：

1. research_agent：负责在网络上搜索信息，并为chart_agent提供支持
2. chart_agent：负责生成和执行Python代码，同时创建图表
3. Tool_node：负责执行各种工具任务

    import functools

    from langchain_core.messages import AIMessage

    # 一个辅助函数，用于为给定代理创建节点
    def agent_node(state, agent, name):
        result = agent.invoke(state)
        # 我们将代理输出转换为适合追加到全局状态的格式
        if isinstance(result, ToolMessage):
            pass
        else:
            result = AIMessage(**result.dict(exclude={"type", "name"}), name=name)
        return {
            "messages": [result],
            # 由于我们有一个严格的工作流程，我们可以跟踪发送者，以明确下一步应该传递给谁。
            "sender": name,
        }

    llm = ChatOpenAI(model="gpt-4o-mini")

    # 研究代理和节点
    research_agent = create_agent(
        llm,
        [tavily_tool],
        system_message="你需要提供准确的数据给图表生成器。",
    )
    research_node = functools.partial(agent_node, agent=research_agent, name="Researcher")

    # 图表生成器
    chart_agent = create_agent(
        llm,
        [python_repl],
        system_message="你生成的任何图表都将对用户可见。",
    )
    chart_node = functools.partial(agent_node, agent=chart_agent, name="chart_generator")

    from langgraph.prebuilt import ToolNode

    tools = [tavily_tool, python_repl]
    tool_node = ToolNode(tools)

第六步：定义条件边及其逻辑规则

    # 任一方代理都可以决定结束
    from typing import Literal

    def router(state) -> Literal["call_tool", "__end__", "continue"]:
        # 这是路由器
        messages = state["messages"]
        last_message = messages[-1]
        if last_message.tool_calls:
            # 前一个代理正在调用一个工具
            return "call_tool"
        if "FINAL ANSWER" in last_message.content:
            # 任一方代理认为工作已经完成
            return "__end__"
        return "continue"

这个功能主要来说意味着吧

1. 如果之前的代理正在调用一个工具（即与代理的LLM绑定），那么状态将更新为 工具调用
2. 如果之前的代理没有调用工具，而是表示任务已完成且最终答案已准备好，则状态将更新为 结束
3. 否则，状态将更新为继续

第七步：我们来定义这个图形

    workflow = StateGraph(AgentState)

    workflow.add_node("Researcher", research_node)
    workflow.add_node("chart_generator", chart_node)
    workflow.add_node("call_tool", tool_node)

    workflow.add_conditional_edges(
        "Researcher",
        router,
        {"continue": "chart_generator", "call_tool": "call_tool", "__end__": END},
    )
    workflow.add_conditional_edges(
        "chart_generator",
        router,
        {"continue": "Researcher", "call_tool": "call_tool", "__end__": END},
    )

    workflow.add_conditional_edges(
        "call_tool",
        # 每个代理节点都会更新‘sender’字段
        # 调用工具的节点不会更新，这意味着
        # 这条边会回到最初调用工具的代理节点
        lambda x: x["sender"],
        {
            "Researcher": "Researcher",
            "chart_generator": "chart_generator",
        },
    )
    workflow.add_edge(START, "Researcher")
    graph = workflow.compile()

现在这是核心部分——我们创建一个图（图形），并添加3个节点（代理节点）。接着我们添加带有条件的边，根据在步骤6中定义的路由函数，这样一来，我们根据在步骤6中定义的路由函数来添加边。

1. 从研究节点添加的边：
   — 如果路由器在第六步说状态需要更新为继续，则会继续执行至chart_generator。
   — 如果路由器说状态需要更新为调用工具，则会继续执行至工具代理节点。
   — 如果路由器说状态需要更新为结束，整个执行过程将停止。

2. 从chart_generator节点添加的边：
   — 如果路由器说状态需要更新为继续，则会继续执行至研究节点。
   — 如果路由器说状态需要更新为调用工具，则会继续执行至工具代理节点。
   — 如果路由器说状态需要更新为结束，整个执行过程将停止。

3. 从工具节点添加的边：它将基于状态中的发送者变量返回到发送者（执行工具节点前的状态）。

我们从研究员开始，然后继续。

    workflow.add_edge(START, '研究人员')  
    graph = workflow.compile() # 图 = workflow.compile() # 编译工作流

你也可以这样理解图的构建过程可以这样可视化如下

    from IPython.display import Image, display  

    尝试:  
        display(Image(graph.get_graph(xray=True).draw_mermaid_png()))  
    除了异常:  
        # 不过这需要一些额外的依赖，所以可以跳过这一步  
        pass

第八步：运行代理程序

events = graph.stream(  
    {  
        "messages": [  
            HumanMessage(  
                content="获取印度过去5年的GDP数据，并绘制一个图表"  
            )  
        ],  
    },  
    # 最大递归限制  
    {"recursion_limit": 150},  
)  
for s in events,:  
    print(s)  
    print("----")

这是输出结果

以下是印度过去五年GDP的数据：

• 2023年：3549.92亿美元
• 2022年：3416.65亿美元
• 2021年：3150.31亿美元
• 2020年：2671.60亿美元
• 2019年：2835.61亿美元

接下来，我会使用这些数据来制作一个图表。

由于直接生成图表的工具不可用，这里可以指导你如何使用在线图表生成器来创建图表。以下是使用GDP数据创建图表的简单步骤：

1. 访问一个图表生成网站，例如 ApexCharts 或 LiveGap Charts。
2. 选择你想要创建的图表类型（例如，柱状图、折线图）。
3. 输入如下数据：
   • 年份：2019年、2020年、2021年、2022年、2023年
   • GDP（以10亿为单位）：2835.61、2671.60、3150.31、3416.65、3549.92
4. 自定义图表（如标题、颜色等）。
5. 保存或分享这个图表。

如果你需要进一步的帮助或具体的指导，随时告诉我。

    {'call_tool': {'messages': [ToolMessage(content="成功执行了以下操作:\n```python\nimport matplotlib.pyplot as plt\n\n# 印度过去5年的GDP数据\n年份 = [2019, 2020, 2021, 2022, 2023]\nGDP值 = [2835.61, 2671.60, 3150.31, 3416.65, 3549.92]\n\n# 创建图表\nplt.figure(figsize=(10, 5))\nplt.plot(年份, GDP值, marker='o')\nplt.title('印度过去5年的GDP图表')\nplt.xlabel('年份')\nplt.ylabel('GDP (以亿元计)')\nplt.grid(True)\nplt.xticks(年份)\nplt.yticks(range(2600, 3600, 100))\nplt.axhline(0, color='black', linewidth=0.5, ls='--')\nplt.show()\n```\n程序输出:\n\n如果完成了所有任务，请回复‘最终答案’.", name='python_repl', tool_call_id='call_7geCBD9wUbblBXvpTK3d5gK2')]}}  
    ----  
    {'chart_generator': {'messages': [AIMessage(content="最终答案\n\n以下是印度过去五年GDP的数据:\n\n![印度过去5年的GDP图表](attachment://plot.png)\n\nGDP数据如下:\n- **2019**: 2,835.61亿元\n- **2020**: 2,671.60亿元\n- **2021**: 3,150.31亿元\n- **2022**: 3,416.65亿元\n- **2023**: 3,549.92亿元\n\n如果您需要更多信息或帮助，请随时提问。", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 124, 'prompt_tokens': 7524, 'total_tokens': 7648}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_507c9469a1', 'finish_reason': 'stop', 'logprobs': None}, name='chart_generator', id='run-b9a37890-83d0-4cba-b9f7-541098a26075-0', usage_metadata={'input_tokens': 7524, 'output_tokens': 124, 'total_tokens': 7648})], 'sender': 'chart_generator'}}  
    ----

在多代理系统中，这种互动过程展示了共同解决问题的方法：

用户最初想了解的是过去五年印度的GDP数据。

2. 研究员通过代理进行多次搜索，以收集各年从2019年至2023年的GDP数据。

3. 第一次尝试绘制图表：研究员试图使用一个名为‘chart_generator’的函数来绘制图表，但结果却出现错误，因为‘chart_generator’并不是一个有效的工具，而是一个代理程序.

4. 寻找替代方案：研究员接着搜索“用于生成GDP数据图表的工具”来找到替代方案。

5. 手动图表制作建议：根据搜索结果，研究者建议使用在线图表制作工具，并提供了一些手动创建图表的步骤。

6. 过渡到基于代码的模式：图表生成器代理接管，决定用 Python 代码生成图表。

1. Python代码生成：chart_generator 使用 matplotlib 生成一个用于绘制GDP图表的Python脚本。

8. 代码执行步骤：call_tool 工具运行 Python 代码并确认其成功执行。

9. 最终答案汇总：图表生成器汇总最终答案，包括生成的图表和 GDP 数据的总结。

10. 结果展示：最终答案已经准备好了，可以展示给用户了。

代码库地址：https://github.com/vinitgela/gen-ai-meetup-pune

附注：请查看如下链接来监控这样的系统_ https://langfuse.com/docs/integrations/langchain/example-python-langgraph _

Andrew NG和他的团队证明了Agentic模式对HumanEval编码测试基准的影响。

[深度学习人工智能团队的博客文章] 介绍了代理如何提升大型语言模型的表现。原文章链接为：https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance/

比较了多种不同的代理模式与多代理架构，与针对 GPT-3.5 和 GPT-4 的零样本方法。

如你所见，基础的GPT-3.5（零样本模型）正确率为48.1%。GPT-4（零样本）的正确率为67.0%，表现更好。然而，从GPT-3.5到GPT-4的提升幅度较小，而引入迭代代理工作流后，提升幅度较大。在代理循环中，GPT-3.5的正确率可达到95.1%，而GPT-4则达到97%，相比之下。

来自：Prosus（一家公司）

如上图所示，对于GPT-4，使用工具时，性能从67%提升至约83%，而使用规划代理时，性能则飙升至97%。这显示了代理模式或策略和多代理架构带来的影响。

最好的一点——LLM还是原来的。不需要新的基础模型、微调或其他形式的训练。

作者

AI代理的挑战（特别是多代理系统）

1. 可扩展性：随着AI代理变得越来越复杂并被部署到更大的系统中，确保它们能够高效扩展非常重要。这包括优化计算资源、管理分布式系统以及在不影响性能的前提下处理更大规模的数据。如果你有4到5个代理来执行以前由单一LLM调用的任务，尽管性能有所提高，但你的TPMs和RPMs会增加到原来的4到5倍。特别是当输入提示非常长时，这个问题会更加复杂。
   性能和规模之间存在着巨大的权衡。

2. 集成: 让AI代理真正实现端到端，你还需要把这些AI代理无缝地融入现有的软件生态系统、API和数据源中。这通常是一个相当复杂的步骤，并且还没有完全享受到生成式AI带来的加速好处。

3. 确定性与随机性行为：在AI代理中平衡确定性（可预测）和随机性（概率性）行为是关键。AI代理在结果可预测且可以一致重复的确定性环境中表现非常有效。确定性行为确保了一致性和可靠性，使这些代理非常适合需要精确结果的任务，例如自动化交易系统或质量控制流程。这种可靠性在必须符合特定标准的情况下至关重要。此外，确定性行为有助于通过遵循预定义的规则和算法来减少错误，从而最小化意外结果。此外，这种可预测性提高了效率，使AI代理能够快速且低成本地完成重复任务。它还使开发人员能够微调系统以达到精确的性能标准。在确定性环境中，AI代理能够更好地控制其行为，这对于需要精确行为的复杂系统来说至关重要。通过专注于确定性过程，，AI系统可以提供高效且精确的性能，确保任务按照预期参数可靠地完成。

4. 短期记忆的局限：当前的AI模型在长时间互动中经常难以保持上下文理解。开发高效的方法来短期记忆的保存和检索对于创建更加连贯和上下文理解的代理来说至关重要。

5. 安全：保护AI代理免受恶意攻击，保护数据隐私，并维护信息的伦理应用至关重要。在不影响功能的情况下实施强有力的安全措施是一项重要的技术难题。

6. 端到端代理操作管理：在复杂的多代理系统中，管理越来越多的代理和步骤使得识别故障和发现表现不佳的代理变得越来越困难。随着系统规模的扩大，由于交互和依赖关系的数量庞大，追踪单个代理的表现变得更加复杂。随着涉及的代理数量增多，隔离特定故障点变得更加复杂。理解哪个代理失败或表现不佳需要复杂的监控和诊断工具。复杂性增加是因为故障可能通过间接的方式影响系统。找出根本原因需要细致的分析，使得诊断和解决性能问题变得更加复杂。最终，管理并分析多代理系统中的性能复杂性随着代理数量和步骤的增加而增加，需要高级工具和方法来准确地检测和有效解决这些问题。

人工智能代理的未来非常有前景，有望通过让技术更直观、高效和主动来改变我们的互动方式。然而，这种演变也带来了一系列重大挑战。确保这些代理能够可靠运行、遵守伦理规范、保持透明度对于赢得用户信任及广泛采用至关重要。技术上的挑战包括提升决策能力、管理复杂多代理系统，以及解决偏见和隐私问题，这些领域需要重点关注。随着我们不断前进，我们需要克服这些挑战，并充分利用这些代理的全部潜力，以实现其变革性影响，并让它们无缝融入我们的生活中。

绝对不能错过的几篇文章

1. Prosus 关于 Agent Ops — https://www.prosus.com/news-insights/group-updates/2024/ai-agentops-landscape（链接）
2. Lang-fuse 与 Langgraphs 的集成 — https://langfuse.com/docs/integrations/langchain/example-python-langgraph（链接）
3. 安德鲁·吴的文章
   — https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance/（链接）
   — https://www.deeplearning.ai/the-batch/agentic-design-patterns-part-2-reflection/?ref=dl-staging-website.ghost.io（链接）
   — https://www.deeplearning.ai/the-batch/agentic-design-patterns-part-3-tool-use/?ref=dl-staging-website.ghost.io（链接）
   — https://www.deeplearning.ai/the-batch/agentic-design-patterns-part-4-planning/?ref=dl-staging-website.ghost.io（链接）
   — https://www.deeplearning.ai/the-batch/agentic-design-patterns-part-5-multi-agent-collaboration/?ref=dl-staging-website.ghost.io（链接）