LangChain学习：通过Agents自动查询天气

最新推荐文章于 2025-06-17 09:33:58 发布
最新推荐文章于 2025-06-17 09:33:58 发布
阅读量1.2k 收藏 7
点赞数 8
CC 4.0 BY-SA版权
文章标签： langchain 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjz0422/article/details/135178557

文章目录
1. LangChain tools
2. Python Agent
3. 自定义工具
3.1 查询日期
3.2 查询天气
learn from https://learn.deeplearning.ai/langchain

1. LangChain tools

from config import api_type, api_key, api_base, api_version, model_name
from langchain.chat_models import AzureChatOpenAI
from langchain.agents.agent_toolkits import create_python_agent
from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
from langchain.tools.python.tool import PythonREPLTool
from langchain.python import PythonREPL
from langchain.chat_models import ChatOpenAI

llm = AzureChatOpenAI(
    openai_api_base=api_base,
    openai_api_version=api_version,
    deployment_name=model_name,
    openai_api_key=api_key,
    openai_api_type=api_type,
    temperature=0.5,
)

tools = load_tools(["llm-math", "wikipedia", "terminal"], llm=llm)
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    handle_parsing_errors=True,
    verbose=True)

agent("300的四分之一是多少？")

给定了一些内置的工具，让模型自行选择使用哪个

问了个简单的除法，输出：

数学工具

> Entering new AgentExecutor chain...
Question: 300的四分之一是多少？
Thought: We can easily solve this problem using a calculator.
Action:
``
{
  "action": "Calculator",
  "action_input": "300/4"
}
``

Observation: Answer: 75.0
Thought:The calculator tool was able to solve the problem easily and gave us the answer.
Final Answer: 300的四分之一是75。

> Finished chain.
terminal工具

question = "列出当前目录下的所有文件，应该使用什么命令？"
result = agent(question)
print(result)
问了命令行的问题，输出

> Entering new AgentExecutor chain...
Question: 列出当前目录下的所有文件，应该使用什么命令？
Thought: 我需要使用一个能够列出当前目录下所有文件的命令。
Action:
``
{
  "action": "terminal",
  "action_input": "ls"
}
``
/opt/envs/rasa/lib/python3.8/site-packages/langchain/tools/shell/tool.py:33: UserWarning: The shell tool has no safeguards by default. Use at your own risk.
  warnings.warn(

Observation: chains.py
config.py
demo.py
goods.csv
langchain1.py
langchain2.py
langchain3.py
langchain4.py
langchain5.py
people.csv
__pycache__

Thought:我已经成功列出了当前目录下的所有文件。
Final Answer: 可以使用"ls"命令来列出当前目录下的所有文件。

> Finished chain.
{'input': '列出当前目录下的所有文件，应该使用什么命令？', 'output': '可以使用"ls"命令来列出当前目录下的所有文件。'}
2. Python Agent

agent = create_python_agent(
    llm,
    tool=PythonREPLTool(),
    verbose=True
)
import langchain
langchain.debug=True

customer_list = [["Harrison", "Chase"],
                 ["Lang", "Chain"],
                 ["Dolly", "Too"],
                 ["Elle", "Elem"],
                 ["Geoff","Fusion"],
                 ["Trance","Former"],
                 ["Jen","Ayai"]
                ]
res = agent.run(f"""对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：{customer_list}""")
print(res)
输出：

/opt/bdp/data01/anaconda3/envs/rasa/bin/python /opt/bdp/data01/chenmingming/gpt/langchain5.py 
[chain/start] [1:chain:AgentExecutor] Entering Chain run with input:
{
  "input": "对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]"
}
[chain/start] [1:chain:AgentExecutor > 2:chain:LLMChain] Entering Chain run with input:
{
  "input": "对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]",
  "agent_scratchpad": "",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:AzureChatOpenAI] 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: 对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]\nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 2:chain:LLMChain > 3:llm:AzureChatOpenAI] [5.13s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 110,
      "prompt_tokens": 344,
      "total_tokens": 454
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 2:chain:LLMChain] [5.13s] Exiting Chain run with output:
{
  "text": "I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))"
}
[tool/start] [1:chain:AgentExecutor > 4:tool:Python_REPL] Entering Tool run with input:
"sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))"
[tool/end] [1:chain:AgentExecutor > 4:tool:Python_REPL] [1.4369999999999998ms] Exiting Tool run with output:
""
[chain/start] [1:chain:AgentExecutor > 5:chain:LLMChain] Entering Chain run with input:
{
  "input": "对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]",
  "agent_scratchpad": "I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))\nObservation: \nThought:",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:AzureChatOpenAI] 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: 对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]\nThought:I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))\nObservation: \nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 5:chain:LLMChain > 6:llm:AzureChatOpenAI] [2.84s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "The sorted() function sorted the list of names by last name first, then by first name. I need to print the final sorted list.\nAction: Python_REPL\nAction Input: print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "The sorted() function sorted the list of names by last name first, then by first name. I need to print the final sorted list.\nAction: Python_REPL\nAction Input: print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 104,
      "prompt_tokens": 459,
      "total_tokens": 563
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 5:chain:LLMChain] [2.85s] Exiting Chain run with output:
{
  "text": "The sorted() function sorted the list of names by last name first, then by first name. I need to print the final sorted list.\nAction: Python_REPL\nAction Input: print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))"
}
[tool/start] [1:chain:AgentExecutor > 7:tool:Python_REPL] Entering Tool run with input:
"print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))"
[tool/end] [1:chain:AgentExecutor > 7:tool:Python_REPL] [0.641ms] Exiting Tool run with output:
"[['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]"
[chain/start] [1:chain:AgentExecutor > 8:chain:LLMChain] Entering Chain run with input:
{
  "input": "对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]",
  "agent_scratchpad": "I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))\nObservation: \nThought:The sorted() function sorted the list of names by last name first, then by first name. I need to print the final sorted list.\nAction: Python_REPL\nAction Input: print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))\nObservation: [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]\n\nThought:",
  "stop": [
    "\nObservation:",
    "\n\tObservation:"
  ]
}
[llm/start] [1:chain:AgentExecutor > 8:chain:LLMChain > 9:llm:AzureChatOpenAI] 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: 对这些顾客的姓名进行排序：先是姓，再是名字，并打印最终排序结果：[['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']]\nThought:I need to sort the list of names by last name first, then by first name. I can use the sorted() function with a key parameter to specify the sorting order.\nAction: Python_REPL\nAction Input: sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1]))\nObservation: \nThought:The sorted() function sorted the list of names by last name first, then by first name. I need to print the final sorted list.\nAction: Python_REPL\nAction Input: print(sorted([['Harrison', 'Chase'], ['Lang', 'Chain'], ['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Trance', 'Former'], ['Jen', 'Ayai']], key=lambda x: (x[0], x[1])))\nObservation: [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]\n\nThought:"
  ]
}
[llm/end] [1:chain:AgentExecutor > 8:chain:LLMChain > 9:llm:AzureChatOpenAI] [3.69s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "The final sorted list is [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]\nFinal Answer: [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]",
        "generation_info": {
          "finish_reason": "stop"
        },
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "The final sorted list is [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]\nFinal Answer: [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 110,
      "prompt_tokens": 619,
      "total_tokens": 729
    },
    "model_name": "gpt-3.5-turbo"
  },
  "run": null
}
[chain/end] [1:chain:AgentExecutor > 8:chain:LLMChain] [3.69s] Exiting Chain run with output:
{
  "text": "The final sorted list is [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]\nFinal Answer: [['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]"
}
[chain/end] [1:chain:AgentExecutor] [11.67s] Exiting Chain run with output:
{
  "output": "[['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]"
}
[['Dolly', 'Too'], ['Elle', 'Elem'], ['Geoff', 'Fusion'], ['Harrison', 'Chase'], ['Jen', 'Ayai'], ['Lang', 'Chain'], ['Trance', 'Former']]
3. 自定义工具
3.1 查询日期

from langchain.agents import tool
from datetime import date


@tool
def time(text: str) -> str:
    """返回今天的日期，将其用于与今天的日期相关的任何问题。
    输入应始终为空字符串, 此函数将始终返回今天的date,任何日期的数学运算都应在此函数之外发生"""
    return str(date.today())


agent1 = initialize_agent(
    tools + [time],
    llm,
    agent=AgentTyp

最低0.47元/天 解锁文章

200万优质内容无限畅学
cjz0422
关注
【LangChain编程：从入门到实践】LangChain中的代理
AI天才研究院
08-06 769
【LangChain编程：从入门到实践】LangChain中的代理 作者：禅与计算机程序设计艺术 1. 背景介绍 1.1 LangChain的兴起 LangChain作为一个新兴的自
【LangChain编程：从入门到实践】对话场景
AI天才研究院
05-30 1039
【LangChain编程：从入门到实践】对话场景 作者：禅与计算机程序设计艺术 1.背景介绍 1.1 对话式AI的兴起 近年来,随着自然语言处理(NLP)和机器学习(ML)技术的快速发展,对话式AI系统越来越受
大模型从入门到应用——LangChain：代理（Agents）-[代理执行器（Agent Executor）：处理解析错误、访问中间步骤和限制最大迭代次数]
冯·诺依曼
09-19 3254
我们也可以轻松自定义在解析错误时使用的错误信息。tools,Action:```{}```我们还可以将错误自定义为接受错误输入并输出字符串的函数。tools,
LangChain agent 以及tools 入门代码以及搜索实时天气
我的博客
02-07 807
LangChain agent 以及tools 入门代码
Qwen-7B-Chat 通过 Agent 获取外部天气
最新发布
王大呀呀的博客
06-17 544
本文使用 Qwen-7B-Chat 大模型，通过 Agent 调用自定义工具 weathercheck 来获取实时天气状况，还能给出出行穿戴的建议哦。
Langchain中使用Ollama提供的Qwen大模型进行Function Call实现天气查询、网络搜索
python1234567_的博客
06-17 4669
Function Call，或者叫函数调用、工具调用，是大语言模型中比较重要的一项能力，对于扩展大语言模型的能力，或者构建AI Agent，至关重要。
《AIGC学习之 LangChain获取天气预报》
qq_22576071的博客
05-09 854
LangChain获取天气
基于langchain的Agent(实现实时查询天气)
Mooczx的博客
12-19 600
智能体
LangChain入门：24.通过Baby AGI实现自动生成和执行任务
Hugo的博客
04-25 2066
随着 ChatGPT 的崭露头角，我们迎来了一种新型的代理——Autonomous Agents（自治代理或自主代理）。这些代理的设计初衷就是能够独立地执行任务，并持续地追求长期目标。在 LangChain 的代理、工具和记忆这些组件的支持下，它们能够在无需外部干预的情况下自主运行，这在真实世界的应用中具有巨大的价值。目前，GitHub 上已有好几个备受关注的“网红”项目，如 AutoGPT、BabyAGI 和 HuggingGPT，它们都代表了自治代理的初步尝试。
LangChain系列：LangChain基础入门教程
neweastsun的专栏
02-12 1250
LangChain 是一个开源框架，旨在简化使用大型语言模型（LLM）创建应用程序的过程。它为链提供了标准接口，与许多其他工具进行了集成，并为常见应用提供了端到端的链。LangChain 让 AI 开发人员能够基于大型语言模型（如 GPT-4, DeepSeek）与外部计算和数据源相结合来开发应用程序。该框架提供了 Python 和 JavaScript 的包。
GPT实战系列-LangChain + ChatGLM3构建天气查询助手
Alex_StarSky的博客
01-07 1880
用ChatGLM的工具可以实现很多查询接口和执行命令，而LangChain是很热的大模型应用框架。如何联合它们实现大模型查询助手功能？例如调用工具实现网络天气查询助手功能。
LLMs之ToolAgent之ChatGLM-3：基于LangChain框架采用ChatGLM3通过调用自定义的工具实现ToolAgent的功能(arxiv论文查询、天气查询、数值计算等单工具调用或者
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
03-23 1080
​ LLMs之ToolAgent：基于LangChain框架采用ChatGLM3通过调用自定义的工具实现ToolAgent的功能(arxiv论文查询、天气查询、数值计算等单工具调用或者多工具调用)输出详解实战 目录 基于LangChain框架采用ChatGLM3通过调用自定义的工具实现ToolAgent的功能(arxiv论文查询、天气查询、数值计算等单工具调用或者多工具调用)代码实战详解 基于LangChain框架采用ChatGLM3通过调用自定义的工具实现ToolAgent的功能(arx
基于langchain和gradio实现天气查询智能体，本地ollama大模型调实时天气api，前端输入即可自动返回天气
qq_38773993的博客
11-22 515
使用本地ollama大模型调实时天气api接口的方式，大模型识别和理解你要查询的请求，然后调第三方天气api接口返回实时天气
【基于 LangChain 的异步天气查询3】OpenWeather实现实时天气查询
qq_62223405的博客
05-10 872
该项目是一个智能天气查询助手，结合了LangChain、Deepseek-r1和天气API，支持通过中文城市名获取实时天气数据，并提供AI生成的简洁自然建议。主要功能包括：1. 使用GeoNames API识别城市并获取经纬度信息；2. 通过OpenWeather API获取天气数据，如温度、湿度和风速；3. 利用Deepseek-r1模型分析天气并生成生活建议；4. 支持异步运行，使用asyncio.run()；5. 通过.env文件隔离配置，保护API密钥安全。项目结构清晰，包含.env、main.py
LangChain 23 Agents中的Tools用于增强和扩展智能代理agent的功能
AI架构师易筋
12-08 2410
定义tools在Langchain中指的是可以被智能代理用来执行特定操作或任务的功能模块或服务。作用：这些工具使得代理不仅限于其内置的语言处理能力，还可以执行更复杂的任务，如数据分析、图像处理、网络搜索等。
langchain 的 agent + tool 使用
热门推荐
木下瞳的博客
05-19 1万+
langchain 中提供了内置工具的，但是基本不能用，除了一个计算器和一个执行 python 代码的，其他的都要 apiTool 模块相当于是使用外部工具，或者自定义工具。
LangChain入门(八)-自定义agent中所使用的工具
Good Luck
05-05 3516
比如 Calculator 在描述里面写到，如果你问关于数学的问题就用他这个工具。我们就可以在上面的执行过程中看到，他在我们请求的 prompt 中数学的部分，就选用了Calculator 这个工具进行计算。自定义工具里面有个比较有意思的地方，使用哪个工具的权重是靠。来实现的，和我们之前编程靠数值来控制权重完全不同。
解释一下langchain
03-19
<think>嗯，用户之前问过关于大语言模型生成PPT的实现，现在他们又想知道LangChain是什么。看起来他们可能是在探索如何将大语言模型应用到实际项目中，比如自动化生成PPT或者其他工作流程。我需要先回忆一下之前的回答，确保这次的内容和之前的一致，同时补充新的信息。 首先，用户可能对LangChain不太了解，需要从基础开始解释。LangChain是一个用于构建大语言模型应用的框架，对吧？它主要帮助开发者将LLM与其他工具或数据源连接起来。我需要说明它的核心功能，比如模型集成、数据连接、链式调用、记忆管理和智能体这些部分。 然后，用户可能想知道LangChain的工作原理。这时候需要分步骤解释，比如输入处理、链式处理、工具调用和输出生成。可能需要举一些例子，比如用户查询天气，系统调用天气API，然后用LLM生成回答。 接下来，用户可能对关键技术点感兴趣，比如链（Chains）、智能体（Agents）、记忆（Memory）和索引（Indexes）。需要详细说明每个部分的作用，比如链如何组合多个步骤，智能体如何自主调用工具，记忆如何保存上下文，索引如何处理外部数据。 用户可能还想知道有哪些应用场景，比如问答系统、文档分析、自动化流程和聊天机器人。这时候需要结合实际例子，比如客服机器人结合知识库，或者用LangChain生成PPT的流程。 开源库方面，需要提到LangChain本身是开源的，还有相关的工具比如LlamaIndex、Hugging Face Transformers和FAISS。这些库如何与LangChain配合使用，比如LlamaIndex用于数据索引，Hugging Face提供模型支持。 可能用户还会有疑问，比如LangChain和直接使用API有什么区别，这时候需要强调LangChain的模块化和扩展性，方便开发者构建复杂应用。另外，需要注意LangChain的学习曲线，以及处理复杂逻辑时的挑战。 最后，确保回答结构清晰，分点说明，避免技术术语过于复杂，用用户容易理解的语言。可能还需要检查是否有遗漏的重要点，比如安装方法或者代码示例，但根据用户的问题，可能不需要太深入，保持概述即可。</think>以下是关于 **LangChain** 的详细介绍，涵盖其定义、核心功能、工作原理、关键技术及实际应用场景： --- ### **1. LangChain 是什么？** **LangChain** 是一个用于构建**大语言模型（LLM）应用**的开源框架（Python/JS），其核心目标是简化 LLM 与外部工具、数据源及业务流程的集成。 - **定位**：充当 LLM 与真实世界的“桥梁”，解决纯 LLM 的局限性（如无法直接访问实时数据、文件、API 等）。 - **特点**：模块化设计，支持灵活扩展，适用于问答系统、自动化流程、数据分析等场景。 --- ### **2. 核心功能** #### **2.1 模型（Models）** - **统一接口**：支持多种 LLM 的调用（如 OpenAI GPT、Anthropic Claude、本地 Hugging Face 模型等）。 - **多模态扩展**：集成文本生成、图像理解（如 GPT-4V）等能力。 #### **2.2 数据连接（Data Connections）** - **外部数据加载**：从数据库、文档（PDF、Markdown）、网页等获取信息。 - **检索增强生成（RAG）**：将外部数据与 LLM 知识结合，生成更准确的回答（例如：基于企业内部文档的问答）。 #### **2.3 链（Chains）** - **复杂任务拆分**：将多步骤任务组合为“链”（如“查询天气 → 生成出行建议 → 翻译成中文”）。 - **预定义链**：提供通用链（如 `LLMChain`、`SequentialChain`），支持自定义链。 #### **2.4 记忆（Memory）** - **上下文管理**：保存对话历史或任务状态，实现多轮交互（如聊天机器人）。 - **存储方式**：短期记忆（单次会话）与长期记忆（数据库存储）。 #### **2.5 智能体（Agents）** - **自主决策**：根据用户输入动态选择工具（如调用搜索引擎、计算器、API）。 - **示例**： ```python from langchain.agents import load_tools agent.run("北京今天的温度是多少？如果高于30度，推荐一个室内景点。") # 步骤：调用天气API → 判断温度 → 调用旅游数据库API → 生成回答 ``` --- ### **3. 工作原理** LangChain 的核心思想是**“编排”**，通过模块化组件控制 LLM 的行为。典型流程如下： 1. **输入处理**：解析用户请求，提取意图（如“需要外部数据”或“需调用工具”）。 2. **链式处理**：按预设流程调用 LLM、工具或数据源。 3. **工具调用**：执行具体操作（如搜索、计算、读写文件）。 4. **输出生成**：整合结果并返回给用户。 #### **示例：基于文档的问答系统** 1. 用户提问：“公司2023年的营收目标是什么？” 2. LangChain 从企业财务文档中检索相关内容。 3. LLM 根据检索结果生成总结性回答。 --- ### **4. 关键技术** #### **4.1 链（Chains）** - **组合模式**：将多个 LLM 调用或工具操作串联，例如： ```python chain = LLMChain(llm=model, prompt=prompt) → ToolChain(tool=calculator) → OutputParser() ``` #### **4.2 智能体（Agents）** - **工具集**：预定义工具（如 `WikipediaQueryRun`、`PythonREPLTool`）或自定义工具。 - **决策逻辑**：通过 LLM 生成 JSON 格式的“思维步骤”（如 ReAct 框架）。 #### **4.3 检索增强生成（RAG）** - **步骤**： 1. 文档切分与向量化（使用 `Embeddings` 模型）。 2. 相似度检索（如使用 `FAISS` 向量数据库）。 3. 将检索结果注入 LLM 的上下文生成回答。 #### **4.4 记忆管理** - **会话状态**：通过 `ConversationBufferMemory` 保存对话历史。 - **长期记忆**：结合数据库（如 Redis）存储用户偏好或历史记录。 --- ### **5. 应用场景** 1. **问答系统**： - 结合内部知识库的客服机器人。 - 基于技术文档的开发者助手。 2. **文档分析**： - 自动总结长报告、生成会议纪要。 3. **自动化流程**： - 根据邮件内容自动创建任务工单。 - 生成数据分析报告并发送邮件。 4. **聊天机器人**： - 支持多轮对话的个性化交互（如医疗咨询）。 --- ### **6. 开源生态** - **GitHub 仓库**：https://github.com/langchain-ai/langchain - **核心库**： - `langchain-core`：基础模块（链、智能体、记忆）。 - `langchain-community`：第三方工具集成（如 Notion、Discord）。 - `langchain-experimental`：前沿功能测试（如多模态交互）。 - **依赖工具**： - `LlamaIndex`：高效数据索引与检索。 - `Hugging Face Transformers`：本地模型支持。 - `FAISS`：向量相似度搜索。 --- ### **7. 示例代码** #### **基础问答链** ```python from langchain_community.llms import OpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate template = "用一句话解释什么是{concept}" prompt = PromptTemplate(template=template, input_variables=["concept"]) llm = OpenAI(api_key="YOUR_KEY") chain = LLMChain(llm=llm, prompt=prompt) print(chain.run("量子计算")) # 输出：量子计算是利用量子力学原理进行信息处理的新型计算模式。 ``` #### **智能体调用工具** ```python from langchain.agents import load_tools, AgentType, initialize_agent tools = load_tools(["serpapi", "llm-math"], llm=llm) # 加载搜索引擎和计算器 agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION) agent.run("特斯拉当前股价是多少？如果我持有100股，总价值是多少美元？") ``` --- ### **8. 优势与挑战** - **优势**： - 模块化设计，快速搭建 LLM 应用。 - 支持复杂任务编排（如循环、条件分支）。 - **挑战**： - 学习曲线较陡（需理解链、智能体等概念）。 - 复杂逻辑可能导致执行效率下降。 --- ### **总结** LangChain 的核心价值在于**降低 LLM 应用开发门槛**，通过标准化接口和预置组件，开发者无需从零实现数据连接、记忆管理等功能。其“链式”和“智能体”设计模式，尤其适合需要多步骤推理或外部工具调用的场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值