【方便 | 重要】#LLM入门 | Agent | langchain | RAG # 3.7_代理Agent，使用langchain自带agent完成任务

于 2024-04-19 11:16:55 发布
阅读量988 收藏 26
点赞数 12
分类专栏： RAG LLM入门教程笔记 AIGC 文章标签： langchain 自然语言处理 人工智能 python Agent AIGC LLM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45312236/article/details/137958323
版权
LLM入门教程笔记 同时被 3 个专栏收录
33 篇文章 2 订阅
订阅专栏
AIGC
21 篇文章 0 订阅
订阅专栏
RAG
16 篇文章 0 订阅
订阅专栏

大型语言模型（LLMs）虽强大，但在逻辑推理、计算和外部信息检索方面能力有限，不如基础计算机程序。例如，LLMs处理简单计算或最新事件查询时可能不准确，因为它们仅基于预训练数据。LangChain框架通过“代理”(Agent)概念来解决这一问题。
代理作为语言模型的外部模块，可提供计算、逻辑、检索等功能的支持，使语言模型获得异常强大的推理和获取信息的超能力。
本章将深入探讨代理机制、类型以及如何与LangChain中的语言模型结合，以构建更全面、智能的应用程序。代理显著扩展了语言模型的能力，是提升智能的关键方法。我们将学习如何通过代理充分发挥语言模型潜力。

一、使用LangChain内置工具llm-math和wikipedia

使用代理(Agents)需要三个要素：基本的大型语言模型(LLM)、交互工具(Tools)以及控制这些交互的代理(Agents)。

from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
from langchain.python import PythonREPL
from langchain.chat_models import ChatOpenAI

首先，新建一个基本的 LLM

# 参数temperature设置为0.0，从而减少生成答案的随机性。
llm = ChatOpenAI(temperature=0)

初始化工具(Tool)时，可创建自定义或加载预构建工具。工具是具有名称(name)和描述(description)的实用链。

  • llm-math 工具结合语言模型和计算器执行数学运算。
  • wikipedia工具通过API连接到wikipedia进行搜索查询。
tools = load_tools(
    ["llm-math","wikipedia"], 
    llm=llm #第一步初始化的模型
)

现在我们有了 LLM 和工具，最后让我们初始化一个简单的代理 (Agents) ：

# 初始化代理
agent= initialize_agent(
    tools, #第二步加载的工具
    llm, #第一步初始化的模型
    agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,  #代理类型
    handle_parsing_errors=True, #处理解析错误
    verbose = True #输出中间步骤
)
  • agent: 代理类型。这里使用的是AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION 指的是：
    • CHAT: 针对对话优化的代理模型。
    • Zero-shot: 代理仅在当前操作有效，无记忆功能。
    • REACT: 为REACT设计的提示模板。
  • DESCRIPTION 依据工具描述选择工具。本章不讨论 REACT 框架，但可视为LLM循环执行推理(Reasoning)和行动(Action)的多步骤过程，用于识别答案。
  • handle_parsing_errors: 决定是否处理解析错误，将错误信息反馈给大模型以纠正。
  • verbose: 是否输出中间步骤结果。

使用代理回答数学问题
agent(“计算300的25%”)

> Entering new AgentExecutor chain...
Question: 计算300的25%
Thought: I can use the calculator tool to calculate 25% of 300.
Action:
```json
{
  "action": "Calculator",
  "action_input": "300 * 0.25"
}

Observation: Answer: 75.0
Thought:The calculator tool returned the answer 75.0, which is 25% of 300.
Final Answer: 25% of 300 is 75.0.

Finished chain.

{‘input’: ‘计算300的25%’, ‘output’: ‘25% of 300 is 75.0.’}

**上面的过程可以总结为下**

1. 模型对于接下来需要做什么，给出思考**思考**：我可以使用计算工具来计算300的25%
2. 模型基于思考采取行动**行动**: 使用计算器（calculator），输入（action_input）300*0.25
3. 模型得到观察**观察**：答案: 75.0
4. 基于观察，模型对于接下来需要做什么，给出思考**思考**: 计算工具返回了300的25%，答案为75
5. 给出最终答案（Final Answer）**最终答案**: 300的25%等于75。
6. 以字典的形式给出最终答案。

Tom M. Mitchell的书

question = “Tom M. Mitchell是一位美国计算机科学家，
也是卡内基梅隆大学（CMU）的创始人大学教授。
他写了哪本书呢？”

agent(question)

Entering new AgentExecutor chain…
Thought: I can use Wikipedia to find information about Tom M. Mitchell and his books.
Action:

{
  "action": "Wikipedia",
  "action_input": "Tom M. Mitchell"
}

Observation: Page: Tom M. Mitchell
Summary: Tom Michael Mitchell (born August 9, 1951) is an American computer scientist and the Founders University Professor at Carnegie Mellon University (CMU). He is a founder and former Chair of the Machine Learning Department at CMU. Mitchell is known for his contributions to the advancement of machine learning, artificial intelligence, and cognitive neuroscience and is the author of the textbook Machine Learning. He is a member of the United States National Academy of Engineering since 2010. He is also a Fellow of the American Academy of Arts and Sciences, the American Association for the Advancement of Science and a Fellow and past President of the Association for the Advancement of Artificial Intelligence. In October 2018, Mitchell was appointed as the Interim Dean of the School of Computer Science at Carnegie Mellon.

Page: Tom Mitchell (Australian footballer)
Summary: Thomas Mitchell (born 31 May 1993) is a professional Australian rules footballer playing for the Collingwood Football Club in the Australian Football League (AFL). He previously played for the Adelaide Crows, Sydney Swans from 2012 to 2016, and the Hawthorn Football Club between 2017 and 2022. Mitchell won the Brownlow Medal as the league’s best and fairest player in 2018 and set the record for the most disposals in a VFL/AFL match, accruing 54 in a game against Collingwood during that season.
Thought:The book written by Tom M. Mitchell is “Machine Learning”.
Thought: I have found the answer.
Final Answer: The book written by Tom M. Mitchell is “Machine Learning”.

Finished chain.

{‘input’: ‘Tom M. Mitchell是一位美国计算机科学家，也是卡内基梅隆大学（CMU）的创始人大学教授。他写了哪本书呢？’,
‘output’: ‘The book written by Tom M. Mitchell is “Machine Learning”.’}

✅ **总结**

1. 模型对于接下来需要做什么，给出思考（Thought）**思考**：我应该使用维基百科去搜索。
2. 模型基于思考采取行动（Action）**行动**: 使用维基百科，输入Tom M. Mitchell
3. 模型得到观察（Observation）**观测**: 页面: Tom M. Mitchell，页面: Tom Mitchell (澳大利亚足球运动员)
4. 基于观察，模型对于接下来需要做什么，给出思考（Thought）**思考**: Tom M. Mitchell写的书是Machine Learning
5. 给出最终答案（Final Answer）**最终答案**: Machine Learning
6. 以字典的形式给出最终答案。

值得注意的是，模型每次运行推理的过程可能存在差异，但最终的结果一致。

示例代码：

```python
from langchain.agents import initialize_agent, AgentType, load_tools
from langchain.chat_models import ChatOpenAI

from app.pool.component_factory import LLMModelFactory
azure_config = {
    "azure_endpoint": "···",
    "openai_api_version": "···",
    'api_key': "···",
    "model": "gpt-35-turbo"
}
llm = LLMModelFactory().create('AzureChatOpenAI', **azure_config)
# 加载默认工具
tools = load_tools(["llm-math"], llm=llm)
# 创建代理，传入工具、模型、代理类型，开启调试
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
# 提问
rs = agent.run("Assume you are 12 years old now, what's your age raised to the 0.43 power?")
print(rs)

我的输出：
image.png

二、 使用LangChain内置工具PythonREPLTool

我们创建一个能将顾客名字转换为拼音的 python 代理，步骤与上一部分的一样：

from langchain.agents.agent_toolkits import create_python_agent
from langchain.tools.python.tool import PythonREPLTool

agent = create_python_agent(
    llm,  #使用前面一节已经加载的大语言模型
    tool=PythonREPLTool(), #使用Python交互式环境工具 REPLTool
    verbose=True #输出中间步骤
)
customer_list = ["小明","小黄","小红","小蓝","小橘","小绿",]

agent.run(f"将使用pinyin拼音库这些客户名字转换为拼音，并打印输出列表: {customer_list}。")  

> Entering new AgentExecutor chain...


Python REPL can execute arbitrary code. Use with caution.


I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.
Action: Python_REPL
Action Input: import pinyin
Observation: 
Thought:I have imported the pinyin library. Now I can use it to convert the names to pinyin.
Action: Python_REPL
Action Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']
pinyin_names = [pinyin.get(i, format='strip') for i in names]
print(pinyin_names)
Observation: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']

Thought:I have successfully converted the names to pinyin and printed out the list of converted names.
Final Answer: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']

> Finished chain.





"['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']"

在调试（debug）模式下再次运行，我们可以把上面的6步分别对应到下面的具体流程

  1. 模型对于接下来需要做什么，给出思考（Thought）
    • [chain/start] [1:chain:AgentExecutor] Entering Chain run with input
    • [chain/start] [1:chain:AgentExecutor > 2:chain:LLMChain] Entering Chain run with input
    • [llm/start] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:ChatOpenAI] Entering LLM run with input
    • [llm/end] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:ChatOpenAI] [1.91s] Exiting LLM run with output
    • [chain/end] [1:chain:AgentExecutor > 2:chain:LLMChain] [1.91s] Exiting Chain run with output
  2. 模型基于思考采取行动（Action), 因为使用的工具不同，Action的输出也和之前有所不同，这里输出的为python代码 import pinyin
    • [tool/start] [1:chain:AgentExecutor > 4:tool:Python REPL] Entering Tool run with input
    • [tool/end] [1:chain:AgentExecutor > 4:tool:Python_REPL] [1.28ms] Exiting Tool run with output
  3. 模型得到观察（Observation）
    • [chain/start] [1:chain:AgentExecutor > 5:chain:LLMChain] Entering Chain run with input
  4. 基于观察，模型对于接下来需要做什么，给出思考（Thought）
    • [llm/start] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:ChatOpenAI] Entering LLM run with input
    • [llm/end] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:ChatOpenAI] [3.48s] Exiting LLM run with output
  5. 给出最终答案（Final Answer）
    • [chain/end] [1:chain:AgentExecutor > 5:chain:LLMChain] [3.48s] Exiting Chain run with output
  6. 返回最终答案。
    • [chain/end] [1:chain:AgentExecutor] [19.20s] Exiting Chain run with output
import langchain
langchain.debug=True
agent.run(f"使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: {customer_list}") 
langchain.debug=False 

[chain/start] [1:chain:AgentExecutor] Entering Chain run with input:
{
  "input": "使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']"
}
[chain/start] [1:chain:AgentExecutor > 2:chain:LLMChain] Entering Chain run with input:
{
  "input": "使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']",
  "agent_scratchpad": "",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are an agent designed to write and execute python code to answer questions.\nYou have access to a python REPL, which you can use to execute python code.\nIf you get an error, debug your code and try again.\nOnly use the output of your code to answer the question. \nYou might know the answer without running any code, but you should still run the code to get the answer.\nIf it does not seem like you can write code to answer the question, just return \"I don't know\" as the answer.\n\n\nPython_REPL: A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with `print(...)`.\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [Python_REPL]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: 使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:ChatOpenAI] [2.32s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "prompt_tokens": 320,
      "completion_tokens": 39,
      "total_tokens": 359
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 2:chain:LLMChain] [2.33s] Exiting Chain run with output:
{
  "text": "I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin"
}
[tool/start] [1:chain:AgentExecutor > 4:tool:Python_REPL] Entering Tool run with input:
"import pinyin"
[tool/end] [1:chain:AgentExecutor > 4:tool:Python_REPL] [1.5659999999999998ms] Exiting Tool run with output:
""
[chain/start] [1:chain:AgentExecutor > 5:chain:LLMChain] Entering Chain run with input:
{
  "input": "使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']",
  "agent_scratchpad": "I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin\nObservation: \nThought:",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are an agent designed to write and execute python code to answer questions.\nYou have access to a python REPL, which you can use to execute python code.\nIf you get an error, debug your code and try again.\nOnly use the output of your code to answer the question. \nYou might know the answer without running any code, but you should still run the code to get the answer.\nIf it does not seem like you can write code to answer the question, just return \"I don't know\" as the answer.\n\n\nPython_REPL: A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with `print(...)`.\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [Python_REPL]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: 使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\nThought:I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin\nObservation: \nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:ChatOpenAI] [4.09s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "I have imported the pinyin library. Now I can use it to convert the names to pinyin.\nAction: Python_REPL\nAction Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\npinyin_names = [pinyin.get(i, format='strip') for i in names]\nprint(pinyin_names)",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "I have imported the pinyin library. Now I can use it to convert the names to pinyin.\nAction: Python_REPL\nAction Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\npinyin_names = [pinyin.get(i, format='strip') for i in names]\nprint(pinyin_names)",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "prompt_tokens": 365,
      "completion_tokens": 87,
      "total_tokens": 452
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 5:chain:LLMChain] [4.09s] Exiting Chain run with output:
{
  "text": "I have imported the pinyin library. Now I can use it to convert the names to pinyin.\nAction: Python_REPL\nAction Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\npinyin_names = [pinyin.get(i, format='strip') for i in names]\nprint(pinyin_names)"
}
[tool/start] [1:chain:AgentExecutor > 7:tool:Python_REPL] Entering Tool run with input:
"names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']
pinyin_names = [pinyin.get(i, format='strip') for i in names]
print(pinyin_names)"
[tool/end] [1:chain:AgentExecutor > 7:tool:Python_REPL] [0.8809999999999999ms] Exiting Tool run with output:
"['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']"
[chain/start] [1:chain:AgentExecutor > 8:chain:LLMChain] Entering Chain run with input:
{
  "input": "使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']",
  "agent_scratchpad": "I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin\nObservation: \nThought:I have imported the pinyin library. Now I can use it to convert the names to pinyin.\nAction: Python_REPL\nAction Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\npinyin_names = [pinyin.get(i, format='strip') for i in names]\nprint(pinyin_names)\nObservation: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']\n\nThought:",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 8:chain:LLMChain > 9:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: You are an agent designed to write and execute python code to answer questions.\nYou have access to a python REPL, which you can use to execute python code.\nIf you get an error, debug your code and try again.\nOnly use the output of your code to answer the question. \nYou might know the answer without running any code, but you should still run the code to get the answer.\nIf it does not seem like you can write code to answer the question, just return \"I don't know\" as the answer.\n\n\nPython_REPL: A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with `print(...)`.\n\nUse the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [Python_REPL]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n\nBegin!\n\nQuestion: 使用pinyin拼音库将这些客户名字转换为拼音，并打印输出列表: ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\nThought:I need to use the pinyin library to convert the names to pinyin. I can then print out the list of converted names.\nAction: Python_REPL\nAction Input: import pinyin\nObservation: \nThought:I have imported the pinyin library. Now I can use it to convert the names to pinyin.\nAction: Python_REPL\nAction Input: names = ['小明', '小黄', '小红', '小蓝', '小橘', '小绿']\npinyin_names = [pinyin.get(i, format='strip') for i in names]\nprint(pinyin_names)\nObservation: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']\n\nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 8:chain:LLMChain > 9:llm:ChatOpenAI] [2.05s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "I have successfully converted the names to pinyin and printed out the list of converted names.\nFinal Answer: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "I have successfully converted the names to pinyin and printed out the list of converted names.\nFinal Answer: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "prompt_tokens": 483,
      "completion_tokens": 48,
      "total_tokens": 531
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 8:chain:LLMChain] [2.05s] Exiting Chain run with output:
{
  "text": "I have successfully converted the names to pinyin and printed out the list of converted names.\nFinal Answer: ['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']"
}
[chain/end] [1:chain:AgentExecutor] [8.47s] Exiting Chain run with output:
{
  "output": "['xiaoming', 'xiaohuang', 'xiaohong', 'xiaolan', 'xiaoju', 'xiaolv']"
}

三、 定义自己的工具并在代理中使用

在本节，我们将创建和使用自定义时间工具。LangChian tool 函数装饰器可以应用用于任何函数，将函数转化为LangChain 工具，使其成为代理可调用的工具。我们需要给函数加上非常详细的文档字符串, 使得代理知道在什么情况下、如何使用该函数/工具。比如下面的函数time,我们加上了详细的文档字符串。

# 导入tool函数装饰器
from langchain.agents import tool
from datetime import date

@tool
def time(text: str) -> str:
    """
    返回今天的日期，用于任何需要知道今天日期的问题。\
    输入应该总是一个空字符串，\
    这个函数将总是返回今天的日期，任何日期计算应该在这个函数之外进行。
    """
    return str(date.today())

# 初始化代理
agent= initialize_agent(
    tools=[time], #将刚刚创建的时间工具加入代理
    llm=llm, #初始化的模型
    agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,  #代理类型
    handle_parsing_errors=True, #处理解析错误
    verbose = True #输出中间步骤
)

# 使用代理询问今天的日期. 
# 注: 代理有时候可能会出错（该功能正在开发中）。如果出现错误，请尝试再次运行它。
agent("今天的日期是？")  

> Entering new AgentExecutor chain...
根据提供的工具，我们可以使用`time`函数来获取今天的日期。

Thought: 使用`time`函数来获取今天的日期。

Action:

{
“action”: “time”,
“action_input”: “”
}



Observation: 2023-08-09
Thought:我现在知道了最终答案。
Final Answer: 今天的日期是2023-08-09。

> Finished chain.





{'input': '今天的日期是？', 'output': '今天的日期是2023-08-09。'}

上面的过程可以总结为下

  1. 模型对于接下来需要做什么，给出思考（Thought）思考：我需要使用 time 工具来获取今天的日期
  2. 模型基于思考采取行动（Action), 因为使用的工具不同，Action的输出也和之前有所不同，这里输出的为python代码行动: 使用time工具，输入为空字符串
  3. 模型得到观察（Observation）观测: 2023-07-04
  4. 基于观察，模型对于接下来需要做什么，给出思考（Thought）思考: 我已成功使用 time 工具检索到了今天的日期
  5. 给出最终答案（Final Answer）最终答案: 今天的日期是2023-08-09.
  6. 返回最终答案。
向日葵花籽儿
关注
  • 12
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大模型之最火Agent实战(打造你代理)教程
01-16
代理（Agent）指能自主感知环境并采取行动实现目标的智能体。基于大语言模型（LLM）的 AI Agent 利用 LLM 进行记忆检索、决策推理和行动顺序选择等，把Agent的智能程度提升到了新的高度。
langchain-Agent代理详解
weixin_45626120的博客
08-05 8247
Langchain Agent详解
LangChain Agent 执行过程解析 OpenAI
热门推荐
qq_35361412的博客
03-27 1万+
解析一下LangChain Agent代理是如何执行的
轻松上手 LangChain 开发框架之 Agent 技术 ！！
musicml的博客
03-24 736
▼最近直播超级多，预约保你有收获—1—Agent 技术剖析Agent 这一模块在 LangChain 的使用过程中也是十分重要的。官方文档是这样定义它的：“The core idea of agents is to use a language model to choose a sequence of actions to take. In chains, a sequence of acti...
Langchain-agent入门笔记（1）
weixin_41032724的博客
06-07 2949
自整理langchain-agent入门笔记
用通俗易懂的方式讲解大模型：LangChain Agent 原理解析
2301_78285120的博客
12-31 3276
在 LangChain 中，Agent 是一个代理，接收用户的输入，采取相应的行动然后返回行动的结果。Agent 可以看作是一个自带路由消费 Chains 的代理，基于 MRKL 和 ReAct 的基本原理，Agent 可以使用工具和自然语言处理问题。官方也提供了对应的 Agent，包括 OpenAI Functions Agent、Plan-and-execute Agent、Self Ask With Search 类 AutoGPT 的 Agent 等。
LangChain-Agents 入门指南
马超的博客
05-10 2450
其中 Agents 使用 LLMs 来确定采取哪些行动以及以何种顺序采取行动。操作可以是使用工具并观察其输出，也可以是返回给用户。如果使用得当，代理可以非常强大。本文章的目的是向您展示如何通过最简单、最高级别的 API 轻松使用 Agents 。
langchain-使用langchain构建LLMs应用实例.zip
02-23
langchain langchain_使用langchain构建LLMs应用实例
langchain简介及使用.pdf
02-22
LangChain是一个开源框架，旨在帮助开发人员使用大型语言模型（LLM）构建端到端的应用程序。它提供了一套工具、组件和接口，可简化创建由大型语言模型（LLM）和聊天模型提供支持的应用程序的过程。
使用langchain+千问72b+m3e-large+chroma的对话机器人源码python实现
02-19
2.使用langchain调用本地llm模型、embedding模型、数据库 3.使用langchain的LCEL 4.Retrieval-Augmented Generation，简称RAG的实现方式 5.文档分割、拆分 6.高级prompt的实现方法 7.从搭建知识库到高级检索在到形成...
JavaScript_独立的应用程序，方便RAG与本地LLM.zip
最新发布
05-20
JavaScript
怎么和Bing一样使用ChatGPT？如何让ChapGPT与外界世界交互结合？LangChain Agent模块帮你解决问题。LangChain Agent模块的使用案例和源码详解
赖赖的博客
03-23 6696
ChatGPT很火，但是对于这个模型我们怎么用呢？只是和他聊聊天，回答回答问题？如何基于这个模型进行二次开发呢？是否可以和new bing一样，可以搜索资料然后进行回复？甚至可以按照你的指令帮你操作机器人？LangChain的 Agent模块就可以帮大家做到这些，而Agent是如何使用LLM思考并与外部世界进行交互的呢？我们通过源码给大家进行讲解。以下源码是基于 LangChain的 0.0.117版本，也就是最近的最新版本。
langchain主要模块(五)：Agent以及Wandb
qq128252的博客
09-14 1560
Agent：这是一个类，负责决定下一步要采取什么行动。它由语言模型和提示驱动。提示可以包括agent的性格、背景上下文以及用于引发更好推理的提示策略等。 Tools：这些是agent调用的函数。这里有两个重要的考虑因素：给agent提供正确的工具，以及以最有帮助的方式描述这些工具。 Toolkits：这是一组工具，用于完成特定的目标。LangChain提供了一系列的toolkits。 AgentExecutor：这是agent的运行时环境。它实际上调用agent并执行其选择的动作。
LangChain大型语言模型(LLM)应用开发(六)：Agents
weixin_42608414的博客
07-15 3356
在LangChain中，代理是一个可以访问一套工具的组件，并且可以根据用户的输入决定使用哪个工具。
LLM之LangChain（二）| LangChain中的Agent
wshzd的博客
01-15 1839
定义了两个工具，“搜索”和“查找”，其中“搜索”工具搜索文档，“查找”工具执行术语查找。上述代码从LangChain库导入必要的模块，包括代理和语言模型，它设置了一个具有特定代理配置的会话代理，称为“self-ask-with-search”。此代理是为在会话设置中使用而设计的，它结合了React框架来确定使用哪个工具，并利用内存来记住以前的对话交互。LangChain是一种功能强大的自动化工具，可用于各种任务，它提供了可用于创建agent的各种工具。然后，代码提供两个提示来演示与代理的一次性交互。
LangChain与大型语言模型(LLMs)应用基础教程:神奇的Agent
weixin_42608414的博客
04-05 6094
今天我们学习了LangChain的agent功能，它可以通过语言指令的方式执行各种数据分析、汇总、统计以及预测等功能，如果你是一个不会编程的小白，那可以尝试一下agent。
大模型从入门到应用——LangChain：代理（Agents）-[代理执行器（Agent Executor）：处理解析错误、访问中间步骤和限制最大迭代次数]
冯·诺依曼
09-19 2374
我们也可以轻松自定义在解析错误时使用的错误信息。tools,Action:```{}```我们还可以将错误自定义为接受错误输入并输出字符串的函数。tools,
LangChain使用调研
benben044的专栏
05-24 3504
self-ask-with-search：此代理只使用一个工具: Intermediate Answer, 它会为问题寻找事实答案(指的非gpt生成的答案, 而是在网络中,文本中已存在的), 如 Google search API 工具。conversational-react-description：为会话设置而设计的代理, 它的prompt会被设计的具有会话性, 且还是会使用 ReAct框架来决定使用来个工具, 并且将过往的会话交互存入内存.包括所有LLMs的通用接口，以及常用的LLMs工具。
langchain 代理
01-26
LangChain代理是一种用于处理自然语言的工具，它可以执行一系列任务，例如回答问题、生成文本等。LangChain代理可以通过限制执行的步骤数量来确保代理不会执行过多的步骤。下面是一个使用LangChain代理的示例： ```python from langchain.agents import load_tools from langchain.agents import initialize_agent, Tool from langchain.agents import AgentType from langchain.llms import OpenAI # 加载LangChain代理工具 tools = [Tool(name="Jester", func=lambda x: "foo", description="useful for answering questions")] # 初始化LangChain代理 llm = OpenAI(temperature=0) agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True, max_iterations=2) # 运行LangChain代理 adversarial_prompt = "Can you tell me a joke?" agent.run(adversarial_prompt) ``` 在上述示例中，我们首先加载LangChain代理工具，并初始化LangChain代理。然后，我们使用LangChain代理来回答一个问题，即"Can you tell me a joke?"。LangChain代理会根据提供的工具和模型生成一个回答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值