大模型应用开发（六）：基于LangChain+LLM的agent实战教学包含Memory（上下文记忆和记忆存储）记忆功能

最新推荐文章于 2025-05-12 16:04:04 发布
最新推荐文章于 2025-05-12 16:04:04 发布
阅读量1.4k 收藏
点赞数 43
文章标签： langchain python prompt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjl1234567sjl/article/details/143176535
版权

文章目录

概要

主要用于通过 LangChain 框架创建一个 ReAct 代理，用于查询 SQLite 数据库中的内容，并根据用户问题生成合适的 SQL 查询执行，最后返回查询结果。它整合了 LLM（大语言模型）和数据库查询能力。

整体架构流程

需要安装包

pip install redis

整体流程：

用户输入问题
    ↓
ReAct 代理 (create_react_agent)
    ↓
决定使用工具 -> 调用自定义工具 (SQLiteInfo)
    ↓
生成 SQL 查询 -> 查询数据库 (SQLDatabaseChain)
    ↓
返回数据库查询结果
    ↓
整理并返回最终答案给用户

另外包含的记忆功能分为 ConversationBufferMemory（上下文记忆）和 Redis（记忆存储功能）

技术名词解释

  • Agent（代理）： 是一种能够自主决策和行动的模块，通常用于处理复杂任务。代理通过与外部工具或数据源（如数据库、API等）的交互，来完成用户提出的问题或任务。
  • create_react_agent ：是 LangChain 中一个用于创建 ReAct agent（反应代理）的函数。ReAct 代表“Reasoning and Acting”（推理与行动），是一种代理架构，结合了逻辑推理与外部工具调用，适用于处理复杂任务和需要动态决策的场景。
  • create_structured_chat_agent ： Langchain 库中的一个函数，用于创建结构化的聊天代理（Structured Chat Agent）。这种代理可以处理用户输入并生成结构化的响应。它能够以更系统化的方式处理多步对话和任务，并且通常用于需要更严格的交互控制和跟踪的场景，比如工作流程自动化或复杂的任务管理。
  • Memory（记忆）：模块 用于存储和管理对话的上下文，从而使得代理在处理多轮对话或连续任务时，可以记住之前的对话内容和信息。

技术细节

我们分为两部分：

第一部分是使用create_react_agent函数的Agent功能

完整代码1：

import json

from langchain.agents import create_react_agent, AgentExecutor
from langchain_community.utilities import SQLDatabase
from langchain_core.tools import tool
from langchain_experimental.sql import SQLDatabaseChain
from llm.model_init.init import LLModel
from langchain.prompts import PromptTemplate

api_key = "sk-xxx"

llm_instance = LLModel(api_key=api_key)

llm = llm_instance.initialize_Tongyi_model()

template = """Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: {input}
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought:{agent_scratchpad}"""

# agent_scratchpad是代理使用过程展示
prompt = PromptTemplate(input_variables=["tools", "tool_names", "input", "agent_scratchpad"], template=template)


@tool(return_direct=True)
def SQLiteInfo(query: str):
    """数据库相关内容，胜率，别名"""
    db = SQLDatabase.from_uri(f"sqlite:///D:/sqlite/ai.db")
    # 数据库提示词
    template = ''' 给定一个输入问题，优先查询示例，很重要，根据{input}严格按照示例进行筛选输出,
                   按照示例进行查询,首先创建一个语法正确的{dialect}查询来运行，然后查看查询结果并返回答案，不要执行任何。
                   使用以下格式:
                   示例1：
                   Question:"盲僧2024年10月16日的胜率情况和场次和他的别名"
                   SQLQuery: SELECT 
                               OPGGGGGGGG.OPGG_WINNING_RATE RATE, 
                               OPGGGGGGGG.OPGG_SESSION SESSION, 
                               LOL_HERO_MSG.LOL_ALIAS  ALIAS
                             FROM 
                               OPGG_MSG OPGGGGGGGG
                             JOIN 
                                LOL_HERO_MSG 
                             ON 
                                OPGGGGGGGG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
                             WHERE 
                                OPGGGGGGGG.OPGG_UPDATE_TIME = '2024-10-16' 
                                AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
                   SQLResult:"SQLquery的查询结果"
                   Answer:"盲僧在2024年10月16日这一天的胜率为RATE%。出场次数为SESSION，他的别名叫做ALIAS。
                   仅使用以下的表:
                   {table_info}
                   问题:{input}'''

    prompt = PromptTemplate(
        input_variables=["dialect", "table_info", "input"],
        template=template
    )
    # 创建一个生成 SQL 查询的链
    db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, verbose=True)
    # 运行查询问题
    response = db_chain.invoke(query)
    response = response["result"]
    return response


tools = [SQLiteInfo]
agent = create_react_agent(
    llm,
    tools,
    prompt
)

agent_executor = AgentExecutor(agent=agent,
                               tools=tools,
                               verbose=True)


def agent_test(query: str):
    response = agent_executor.invoke({"input": query})
    result = response["output"]
    result = json.dumps(result, ensure_ascii=False)
    result = json.loads(result)
    return result


if __name__ == "__main__":
    print(agent_test("盲僧2024年10月16日的胜率情况和场次和他的别名"))

1.LLM 模型初始化：

这一部分在我之前的文章大模型应用开发（一）中实现，包含代码LLModel和initialize_Tongyi_model的代码。

api_key = "sk-xxx"

llm_instance = LLModel(api_key=api_key)

llm = llm_instance.initialize_Tongyi_model()

2.PromptTemplate（提示模板）定义

这个 template 是我通过 LangChain Hub 获取的。实际上，可以直接使用以下代码来加载模板：

prompt = hub.pull("hwchase17/structured-chat-agent")

不过，为了方便理解和便于后续修改提示词，我选择将其改写为更具可读性的代码形式：

"""请尽可能回答以下问题。您可以使用以下工具： 使用以下格式： 问题：您必须回答的输入问题 思考：您应该始终考虑要做什么 操作：要采取的行动，应该是[{tool_names}]之一 行动输入：{input} 观察：行动的结果...（这个 ThoughtActionAction InputObservation 可以重复 N 次）思考：我现在知道最终答案了 最终答案：原始输入问题的最终答案 Begin！问题：{input} 想法：{agent_scratchpad}"""

template = """Answer the following questions as best you can. You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: {input}
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought:{agent_scratchpad}"""

# agent_scratchpad是代理使用过程展示
prompt = PromptTemplate(input_variables=["tools", "tool_names", "input", "agent_scratchpad"], template=template)

可以看到其中的input_variables中的参数：
tools：SQLiteInfo
tool_names：tools的工具中的名称，提供给agent选择
input: 用户输入的问题
agent_scratchpad：可以理解为agent思考的过程

我们需要定义tools，输入input两个参数，agent_scratchpad并不需要实际定义。

3. SQLite 数据库查询工具 (SQLiteInfo)

@tool 装饰器 用来创建一个名为 SQLiteInfo 的工具，它封装了 SQLite 数据库的查询逻辑，并通过 SQL 查询来获取数据。该工具可以直接返回查询结果给用户。
这一块我们需要注意的内容
1.@tool装饰器
from langchain_core.tools import tool，源码中有很多参数，感兴趣的小伙伴可以自行查看。
这块内容除了@tool，都可以从之前的文章中查看大模型应用开发（三）

# return_direct=True代表是否直接从工具返回，而不是继续代理循环
@tool(return_direct=True)
def SQLiteInfo(query: str):
    """数据库相关内容，胜率，别名"""
    db = SQLDatabase.from_uri(f"sqlite:///D:/sqlite/ai.db")
    # 数据库提示词
    template = ''' 给定一个输入问题，优先查询示例，很重要，根据{input}严格按照示例进行筛选输出,
                   按照示例进行查询,首先创建一个语法正确的{dialect}查询来运行，然后查看查询结果并返回答案，不要执行任何。
                   使用以下格式:
                   示例1：
                   Question:"盲僧2024年10月16日的胜率情况和场次和他的别名"
                   SQLQuery: SELECT 
                               OPGGGGGGGG.OPGG_WINNING_RATE RATE, 
                               OPGGGGGGGG.OPGG_SESSION SESSION, 
                               LOL_HERO_MSG.LOL_ALIAS  ALIAS
                             FROM 
                               OPGG_MSG OPGGGGGGGG
                             JOIN 
                                LOL_HERO_MSG 
                             ON 
                                OPGGGGGGGG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
                             WHERE 
                                OPGGGGGGGG.OPGG_UPDATE_TIME = '2024-10-16' 
                                AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
                   SQLResult:"SQLquery的查询结果"
                   Answer:"盲僧在2024年10月16日这一天的胜率为RATE%。出场次数为SESSION，他的别名叫做ALIAS。
                   仅使用以下的表:
                   {table_info}
                   问题:{input}'''

    prompt = PromptTemplate(
        input_variables=["dialect", "table_info", "input"],
        template=template
    )
    # 创建一个生成 SQL 查询的链
    db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, verbose=True)
    # 运行查询问题
    response = db_chain.invoke(query)
    response = response["result"]
    return response
 
tools = [SQLiteInfo]

4. ReAct 代理的创建

使用 create_react_agent 函数创建 ReAct 代理，并调用之前定义的提示模板和 SQLiteInfo 工具。

agent = create_react_agent(
    llm,
    tools,
    prompt
)

5.AgentExecutor（代理执行器）

创建AgentExecutor,传参就是agen,tools,verbose(显示agent的执行过程)

agent_executor = AgentExecutor(agent=agent,
                               tools=tools,
                               verbose=True)

6.调用

创建agent_test函数，调用AgentExecutor输入传参input，接收答案，这里需要

 result = json.dumps(result, ensure_ascii=False)

否则会出现Unicode 编码的情况

def agent_test(query: str):
    response = agent_executor.invoke({"input": query})
    result = response["output"]
    result = json.dumps(result, ensure_ascii=False)
    result = json.loads(result)
    return result


if __name__ == "__main__":
    print(agent_test("盲僧2024年10月16日的胜率情况和场次和他的别名"))

接下来运行查看结果

D:\AI\conda\envs\aiAgent\python.exe D:\Pycharm\aiAgent\pythonProject\llm\agent_test\agent_easy.py 


> Entering new AgentExecutor chain...
我需要查询数据库来获取盲僧在2024年10月16日的胜率、比赛场次以及他的别名。
Action: SQLiteInfo
Action Input: 盲僧2024年10月16日的胜率情况和场次和他的别名

> Entering new SQLDatabaseChain chain...
盲僧2024年10月16日的胜率情况和场次和他的别名
SQLQuery:```sql
SELECT 
    OPGG_MSG.OPGG_WINNING_RATE AS RATE, 
    OPGG_MSG.OPGG_SESSION AS SESSION, 
    LOL_HERO_MSG.LOL_ALIAS AS ALIAS
FROM 
    OPGG_MSG
JOIN 
    LOL_HERO_MSG 
ON 
    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
WHERE 
    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' 
    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
SQLResult: [('49.32', 131374, '瞎子')]
Answer:盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。
> Finished chain.
盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。


> Finished chain.
盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。

Process finished with exit code 0

第二部分是使用create_react_agent函数的Agent功能

一、使用ConversationBufferMemory的部分

完整代码2：

import json

from langchain import hub
from langchain.agents import AgentExecutor, create_structured_chat_agent
from langchain.memory import ConversationBufferMemory
from langchain_community.utilities import SQLDatabase
from langchain_core.tools import tool
from langchain_experimental.sql import SQLDatabaseChain
from llm.model_init.init import LLModel
from langchain.prompts import PromptTemplate

api_key = "sk-xxx"

llm_instance = LLModel(api_key=api_key)

llm = llm_instance.initialize_Tongyi_model()

prompt = hub.pull("hwchase17/structured-chat-agent")


@tool(return_direct=True)
def SQLiteInfo(query: str):
    """数据库相关内容，胜率，别名"""
    db = SQLDatabase.from_uri(f"sqlite:///D:/sqlite/ai.db")
    # 数据库提示词
    template = ''' 给定一个输入问题，优先查询示例，很重要，根据{input}严格按照示例进行筛选输出,
                   按照示例进行查询,首先创建一个语法正确的{dialect}查询来运行，然后查看查询结果并返回答案，不要执行任何。
                   使用以下格式:
                   示例1：
                   Question:"盲僧2024年10月16日的胜率情况和场次和他的别名"
                   SQLQuery: SELECT 
                               OPGGGGGGGG.OPGG_WINNING_RATE RATE, 
                               OPGGGGGGGG.OPGG_SESSION SESSION, 
                               LOL_HERO_MSG.LOL_ALIAS  ALIAS
                             FROM 
                               OPGG_MSG OPGGGGGGGG
                             JOIN 
                                LOL_HERO_MSG 
                             ON 
                                OPGGGGGGGG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
                             WHERE 
                                OPGGGGGGGG.OPGG_UPDATE_TIME = '2024-10-16' 
                                AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
                   SQLResult:"SQLquery的查询结果"
                   Answer:"盲僧在2024年10月16日这一天的胜率为RATE%。出场次数为SESSION，他的别名叫做ALIAS。
                   仅使用以下的表:
                   {table_info}
                   问题:{input}'''

    prompt = PromptTemplate(
        input_variables=["dialect", "table_info", "input"],
        template=template
    )
    # 创建一个生成 SQL 查询的链
    db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, verbose=True)
    # 运行查询问题
    response = db_chain.invoke(query)
    response = response["result"]
    return response


tools = [SQLiteInfo]
agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)


# 使用Memory记录上下文
memory = ConversationBufferMemory(
    memory_key='chat_history',
    return_messages=True
)

# 定义AgentExecutor，必须使用AgentExecutor，才能执行代理定义的工具
agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent, tools=tools, memory=memory, verbose=True, handle_parsing_errors=True
)


def agent_test(query: str):
    response = agent_executor.invoke({"input": query})
    result = response["output"]
    result = json.dumps(result, ensure_ascii=False)
    result = json.loads(result)
    return result


if __name__ == "__main__":
    print(agent_test("盲僧2024年10月16日的胜率情况和场次和他的别名"))
    print(agent_test("刚刚回答的问题是什么"))

和没有记忆功能的区别是
1.更换prompt

prompt = hub.pull("hwchase17/structured-chat-agent")

2.修改agent使用create_structured_chat_agent函数

agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)

3.使用Memory记录上下文

# 使用Memory记录上下文
memory = ConversationBufferMemory(
    memory_key='chat_history',
    return_messages=True
)

4.# 定义AgentExecutor，包含memory参数

agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent, tools=tools, memory=memory, verbose=True, handle_parsing_errors=True
)

执行代码查看结果：

> Entering new AgentExecutor chain...
Thought: 需要查询盲僧在2024年10月16日的胜率、场次以及他的别名。

Action:

{
  "action": "SQLiteInfo",
  "action_input": {
    "query": "SELECT win_rate, matches_played, aliases FROM champions WHERE name = '盲僧' AND date = '2024-10-16'"
  }
}


> Entering new SQLDatabaseChain chain...
SELECT win_rate, matches_played, aliases FROM champions WHERE name = '盲僧' AND date = '2024-10-16'
SQLQuery:```sql
SELECT 
    OPGG_MSG.OPGG_WINNING_RATE AS win_rate, 
    OPGG_MSG.OPGG_SESSION AS matches_played, 
    LOL_HERO_MSG.LOL_ALIAS AS aliases
FROM 
    OPGG_MSG
JOIN 
    LOL_HERO_MSG 
ON 
    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
WHERE 
    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' 
    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';


**SQLResult:** "SQLquery的查询结果"

**Answer:** "盲僧在2024年10月16日这一天的胜率为win_rate%。出场次数为matches_played，他的别名叫做aliases。"
SQLResult: [('49.32', 131374, '瞎子')]
Answer:盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。
> Finished chain.
盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。


> Finished chain.
盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。


> Entering new AgentExecutor chain...
{
  "action": "Final Answer",
  "action_input": "您刚刚询问的是关于盲僧在2024年10月16日的胜率情况、出场次数和他的别名。"
}

> Finished chain.
您刚刚询问的是关于盲僧在2024年10月16日的胜率情况、出场次数和他的别名。

Process finished with exit code 0

可以看到两部分action": “SQLiteInfo”，“action”: “Final Answer”，如果存在记忆action会变成Final Answer。

二、使用redis+Memory的部分

我们需要先安装redis+redis可视化工具，这部分在我的资源中有，或者可以网上查找资料安装一下。

完整代码3：

import json

from langchain import hub
from langchain.agents import AgentExecutor, create_structured_chat_agent
from langchain.memory import ConversationBufferMemory
from langchain_community.chat_message_histories import RedisChatMessageHistory
from langchain_community.utilities import SQLDatabase
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_core.tools import tool
from langchain_experimental.sql import SQLDatabaseChain
from llm.model_init.init import LLModel
from langchain.prompts import PromptTemplate

api_key = "sk-xxx"

llm_instance = LLModel(api_key=api_key)

llm = llm_instance.initialize_Tongyi_model()

prompt = hub.pull("hwchase17/structured-chat-agent")


@tool(return_direct=True)
def SQLiteInfo(query: str):
    """数据库相关内容，胜率，别名"""
    db = SQLDatabase.from_uri(f"sqlite:///D:/sqlite/ai.db")
    # 数据库提示词
    template = ''' 给定一个输入问题，优先查询示例，很重要，根据{input}严格按照示例进行筛选输出,
                   按照示例进行查询,首先创建一个语法正确的{dialect}查询来运行，然后查看查询结果并返回答案，不要执行任何。
                   使用以下格式:
                   示例1：
                   Question:"盲僧2024年10月16日的胜率情况和场次和他的别名"
                   SQLQuery: SELECT 
                               OPGGGGGGGG.OPGG_WINNING_RATE RATE, 
                               OPGGGGGGGG.OPGG_SESSION SESSION, 
                               LOL_HERO_MSG.LOL_ALIAS  ALIAS
                             FROM 
                               OPGG_MSG OPGGGGGGGG
                             JOIN 
                                LOL_HERO_MSG 
                             ON 
                                OPGGGGGGGG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
                             WHERE 
                                OPGGGGGGGG.OPGG_UPDATE_TIME = '2024-10-16' 
                                AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
                   SQLResult:"SQLquery的查询结果"
                   Answer:"盲僧在2024年10月16日这一天的胜率为RATE%。出场次数为SESSION，他的别名叫做ALIAS。
                   仅使用以下的表:
                   {table_info}
                   问题:{input}'''

    prompt = PromptTemplate(
        input_variables=["dialect", "table_info", "input"],
        template=template
    )
    # 创建一个生成 SQL 查询的链
    db_chain = SQLDatabaseChain.from_llm(llm, db, prompt=prompt, verbose=True)
    # 运行查询问题
    response = db_chain.invoke(query)
    response = response["result"]
    return response


tools = [SQLiteInfo]
agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)

message_history = RedisChatMessageHistory(
    url="redis://127.0.0.1:6379/2", session_id="my-session"
)

# 定义AgentExecutor，必须使用AgentExecutor，才能执行代理定义的工具
agent_executor = AgentExecutor(agent=agent,
                               tools=tools,
                               verbose=True)

agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    # 必传参数,session_id 在大多数实际场景中，需要一个会话ID。它在这里并没有真正使用，
    # 因为我们使用的是一个简单的内存中的ChatMessageHistory
    lambda session_id: message_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

def agent_test(query: str):
    # 设置memory session_id
    response = agent_with_chat_history.invoke(
        {"input": query},
        config={"configurable": {"session_id": "123"}})

    result = response["output"]
    result = json.dumps(result, ensure_ascii=False)
    return result


if __name__ == "__main__":
    print(agent_test("盲僧2024年10月16日的胜率情况和场次和他的别名"))
    print(agent_test("刚刚回答的问题是什么"))

注意：使用redis需要修改langchain源码

D:\AI\conda\envs\aiAgent\Lib\site-packages\langchain_community\chat_message_histories\redis.py路径下
self.redis_client.lpush(self.key, json.dumps(message_to_dict(message)))修改为
self.redis_client.lpush(self.key, json.dumps(message_to_dict(message), ensure_ascii=False))
否则存入的中文会变成十六进制

这个部分内容
1.agent也需要是create_structured_chat_agent

agent = create_structured_chat_agent(
    llm,
    tools,
    prompt
)

2.定义redis

message_history = RedisChatMessageHistory(
    url="redis://127.0.0.1:6379/2", session_id="my-session"
)

3.使用AgentExecutor,并调用RunnableWithMessageHistory实现记忆存储

agent_executor = AgentExecutor(agent=agent,
                               tools=tools,
                               verbose=True)

agent_with_chat_history = RunnableWithMessageHistory(
    agent_executor,
    # 必传参数,session_id 在大多数实际场景中，需要一个会话ID。它在这里并没有真正使用，
    # 因为我们使用的是一个简单的内存中的ChatMessageHistory
    lambda session_id: message_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

4.调用方法
需要配置相同的session_id

def agent_test(query: str):
    # 设置memory session_id
    response = agent_with_chat_history.invoke(
        {"input": query},
        config={"configurable": {"session_id": "123"}})

    result = response["output"]
    result = json.dumps(result, ensure_ascii=False)
    return result


if __name__ == "__main__":
    print(agent_test("盲僧2024年10月16日的胜率情况和场次和他的别名"))
    print(agent_test("刚刚回答的问题是什么"))

查看结果：

> Entering new AgentExecutor chain...
Thought: 需要查询盲僧在2024年10月16日的胜率、场次以及他的别名。

Action:

{
  "action": "SQLiteInfo",
  "action_input": {
    "query": "SELECT win_rate, matches_played, aliases FROM champions WHERE champion_name = '盲僧' AND date = '2024-10-16'"
  }
}


> Entering new SQLDatabaseChain chain...
SELECT win_rate, matches_played, aliases FROM champions WHERE champion_name = '盲僧' AND date = '2024-10-16'
SQLQuery:```sql
SELECT 
    OPGG_MSG.OPGG_WINNING_RATE AS win_rate, 
    OPGG_MSG.OPGG_SESSION AS matches_played, 
    LOL_HERO_MSG.LOL_ALIAS AS aliases
FROM 
    OPGG_MSG
JOIN 
    LOL_HERO_MSG 
ON 
    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
WHERE 
    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' 
    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';
SQLResult: [('49.32', 131374, '瞎子')]
Answer:**示例1：**

**Question:** "盲僧2024年10月16日的胜率情况和场次和他的别名"

**SQLQuery:**
```sql
SELECT 
    OPGG_MSG.OPGG_WINNING_RATE AS win_rate, 
    OPGG_MSG.OPGG_SESSION AS matches_played, 
    LOL_HERO_MSG.LOL_ALIAS AS aliases
FROM 
    OPGG_MSG
JOIN 
    LOL_HERO_MSG 
ON 
    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
WHERE 
    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' 
    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';


**SQLResult:** [('49.32', 131374, '瞎子')]

**Answer:** "盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。"
> Finished chain.
**示例1：**

**Question:** "盲僧2024年10月16日的胜率情况和场次和他的别名"

**SQLQuery:**
```sql
SELECT 
    OPGG_MSG.OPGG_WINNING_RATE AS win_rate, 
    OPGG_MSG.OPGG_SESSION AS matches_played, 
    LOL_HERO_MSG.LOL_ALIAS AS aliases
FROM 
    OPGG_MSG
JOIN 
    LOL_HERO_MSG 
ON 
    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID 
WHERE 
    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' 
    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';


**SQLResult:** [('49.32', 131374, '瞎子')]

**Answer:** "盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。"


> Finished chain.
"**示例1：**\n\n**Question:** \"盲僧2024年10月16日的胜率情况和场次和他的别名\"\n\n**SQLQuery:**\n```sql\nSELECT \n    OPGG_MSG.OPGG_WINNING_RATE AS win_rate, \n    OPGG_MSG.OPGG_SESSION AS matches_played, \n    LOL_HERO_MSG.LOL_ALIAS AS aliases\nFROM \n    OPGG_MSG\nJOIN \n    LOL_HERO_MSG \nON \n    OPGG_MSG.OPGG_LOL_HERO_NAME_ID = LOL_HERO_MSG.ID \nWHERE \n    OPGG_MSG.OPGG_UPDATE_TIME = '2024-10-16' \n    AND LOL_HERO_MSG.LOL_HERO_NAME = '盲僧';\n```\n\n**SQLResult:** [('49.32', 131374, '瞎子')]\n\n**Answer:** \"盲僧在2024年10月16日这一天的胜率为49.32%。出场次数为131374，他的别名叫做瞎子。\""


> Entering new AgentExecutor chain...

{
  "action": "Final Answer",
  "action_input": "您刚刚询问的是关于盲僧在2024年10月16日的胜率情况、场次和他的别名。"
}


> Finished chain.
"您刚刚询问的是关于盲僧在2024年10月16日的胜率情况、场次和他的别名。"

redis可视化工具内容：
会把每个问题和回答都记录在其中
在这里插入图片描述

小结

这部分内容就到这里告一段落了，如果有任何疑问或意见，欢迎在评论区积极讨论和反馈！非常感谢大家的支持！

睡觉了i
关注
AI Agent的上下文理解：增强LLM的长期记忆
AI智能涌现深度研究
02-23 907
AI Agent，即人工智能代理，是能够自主执行任务并能在复杂环境中做出决策的计算机程序。它们在自然语言处理、游戏智能、自动驾驶等领域发挥着重要作用。随着AI技术的发展，如何提升AI Agent的上下文理解能力成为一个关键问题。AI Agent通过学习大量数据来获取知识，并利用这些知识进行推理和决策。然而，在处理长文本或复杂任务时，它们的上下文理解能力往往受到限制。AI Agent不仅仅局限于自然语言处理领域，还包括图像识别、语音识别等多模态智能。概念结构与核心要素组成：AI Agent接收外部信息。
一文彻底搞懂大模型 - Agent（智能体）
weixin_53880910的博客
08-15 1933
什么是LLM Agent？大模型Agent是一种构建于大型语言模型（LLM）之上的智能体，它具备环境感知能力、自主理解、决策制定及执行行动的能力。 Agent是能够模拟独立思考过程，灵活调用各类工具，逐步达成预设目标。在技术架构上，Agent从面向过程的架构转变为面向目标的架构，旨在通过感知、思考与行动的紧密结合，完成复杂任务。
使用 Ollama 本地运行各种 LLM
python123456_的博客
05-31 1211
今天看看另外一个产品Ollama。Ollama 的安装非常简单，只需从官网（https://ollama.com/download）下载后解压缩，并在 Terminal 中运行脚本即可完成环境设置。我尝试运行 Llama3，虽然在运行时占用了大量电脑资源，使得其他应用运行变慢，但整体体验尚可。Ollama 支持多种大型语言模型（https://ollama.com/library）。
LangChain 如何为 Agent 添加记忆
engchina的专栏
01-28 1948
LangChain 如何为 Agent 添加记忆
GPT - langchain
lonanx3的博客
02-02 557
可以让GPT生成工具执行的步骤和脚本，再本机调用工具执行步骤和脚本，再拿到返回提交给gpt生成答案。
主流 Agent 开发框架实战 ：LangChain 与 LlamaIndex
weixin_59191169的博客
04-24 951
在本章中，我们通过具体的代码示例，动手实践了如何使用两大主流框架——LangChain 和 LlamaIndex 来构建 AI Agent。我们学习了它们的核心 API 与概念，体验了如何定义工具、配置 Agent 并观察其运行逻辑，特别是在 LlamaIndex 中实践了将知识图谱索引作为工具的强大功能。我们还比较了它们的设计哲学和选型考量。
深度学习系列62：Agent入门
kittyzc的博客
03-13 1346
agent的核心是其代理协同工作的能力。每个代理都有其特定的能力和角色，你需要定义代理之间的互动行为，即当一个代理从另一个代理收到消息时该如何回复。agent目前大多使用openai标准接口调用LLM服务，说明如下。标准接口示例如下，其中role包括：system（设定了 AI 的行为和角色，和背景），user（我们输入的问题或请求），assistant（自动生成）
初识langchain：LLM大模型+Langchain实战[qwen2.1、GLM-4]+Prompt工程
lhx17673139267的博客
07-22 1790
模型编码：glm-4-0520、glm-4 、glm-4-air、glm-4-airx、 glm-4-flash，根据输入的自然语言指令完成多种语言类任务，推荐使用 SSE 或异步调用方式请求接口场景示例模型广场官网大模型开源 glm-4-9b 简单介绍GLM-4-9B 是智谱 AI 推出的最新一代预训练模型 GLM-4 系列中的开源版本。在语义、数学、推理、代码和知识等多方面的数据集测评中，GLM-4-9B 及其人类偏好对齐的版本 GLM-4-9B-Chat 均表现出较高的性能。
【AI大模型应用开发】以LangChain为例：从短期记忆实战，到如何让AI应用保持长期记忆的探索
同学小张的博客
03-30 4654
本文我们来系统看下实现大模型应用记忆的方法，包括短期记忆和长期记忆。还是以LangChain为例来进行实战。
AI大模型开发架构设计（1）——LLM大模型Agent剖析和应用案例实战
yangwei2048的博客
01-20 4919
LLM Agent 可以理解为一个以 LLM 为大脑的智能体(类比人)，集成了规划、记忆、工具使用等能力。当“记忆”非常多时，如何在大量“记忆”力快速找到最相关的那些“记忆”?Auto-GPT 的效果很大程度上归功于它复杂的。工具使用能力-function calling。工具使用能力-HuggingGPT。Auto-GPT 的主要框架设计。CoT任务拆解的缺陷是什么？LLM和传统规划方式结合。Auto-GPT 的输出。LLM + 向量数据库。LLM的记忆是什么？
大模型的实践应用41-天气预测与分析决策系统:Qwen3(32B)+langchain框架+MCP(大模型上下文协议)+RAG+传统算法
最新发布
微学AI的博客
05-12 456
大家好，我是微学AI，今天给大家介绍一下大模型的实践应用41-Qwen3(32B)+langchain框架+MCP(大模型上下文协议)+RAG+传统算法研发天气预测与分析决策系统。本项目构建一个基于大模型Qwen3(32B)、LangChain框架、MCP协议、RAG技术以及传统算法的天气预测与分析决策系统。该系统通过多源数据融合、混合推理模式和智能工具调用，实现从数据采集到决策输出的全流程智能化，解决传统天气预测系统数据碎片化、处理效率低、服务同质化和决策支持弱的痛点，为公众、农业、交通等不同行业提供精准
初识langchain[1]：Langchain实战教学，利用qwen2.1与GLM-4大模型构建智能解决方案[含Agent、tavily面向AI搜索]
丨汀、的博客
07-16 2088
初识langchain[1]：Langchain实战教学，利用qwen2.1与GLM-4大模型构建智能解决方案[含Agent]
LLM大模型：大模型应用（五）模型记忆力代码实战，memory最佳实践
2401_84204413的博客
09-05 1495
首先讲memory是很宽泛的概念，通常理解一个大模型的应用=思考力+行动力+记忆力+设定。通常意义上所谓的memory就是记忆力。我接触的memory代码，是langchain上看到的，它给了我很大启发，后来还在我们整个团队内部分享，间接促成了我们对于memory的专项化建设。一般来说总结应该是离线的，但我们也应该允许用户主动总结，同样来一个tool支持。//对tool的描述.description("用户主动总结")
LangChain agent以及create_structured_chat_agent的用法入门
我的博客
02-22 956
LangChain agent以及create_structured_chat_agent的用法入门
Agent 核心能力：工具使用详解，零基础入门到精通，收藏这一篇就够了
leah126的博客
09-10 2550
工具使用对智能体而言至关重要，它不仅显著扩展了智能体的能力范围，使其能够高效执行如实时信息获取、复杂数据分析等高级任务，还提升了任务精度和用户体验的丰富性；此外，工具的集成增强了智能体的适应性和可扩展性，使其能够在不断变化的环境中保持灵活更新，从而更好地满足多样化的用户需求。工具使用（也称函数调用）是指通过定义和调用外部工具或函数来扩展大模型的能力。我们可以让大模型访问一组预定义的工具，它可以在任何时候调用这些工具。工具允许我们编写代码，执行大模型无法完成的特定任务或计算。
【LangChain】在创建 Agent 时 initialize_agent 函数中 通过 agent 指定的 AgentType 有哪些？
彬彬侠的博客
05-01 772
AgentType 是一个枚举类，位于 langchain.agents 模块中，用于指定代理的行为模式。包括：ZERO_SHOT_REACT_DESCRIPTION，REACT_DOCSTORE，SELF_ASK_WITH_SEARCH，CONVERSATIONAL_REACT_DESCRIPTION，CHAT_ZERO_SHOT_REACT_DESCRIPTION，CHAT_CONVERSATIONAL_REACT_DESCRIPTION，STRUCTURED_CHAT_ZERO_SHOT_REACT_
2. langgraph中的react agent使用 (在react agent添加历史消息)
No trade is free, but my contents are.
11-16 890
我们定义一个获取天气信息的工具，该工具接受一个城市名称作为参数，并返回相应的天气信息。@toolelse:为了更好地展示对话过程，我们定义一个函数，用于打印流式输出的消息。
ReACT Agent 实战
weixin_34452850的博客
04-27 1231
ReACT 是 Agent 的理论基础，理解 ReACT 的原理对于开发 Agent 有非常大的帮助！
langchain agent实战
02-19
### LangChain Agent 实战示例项目教程 #### 了解LangChain Agent的工作原理 LangChain Agent是一种能够执行特定任务的人工智能实体，可以被设计成独立工作或与其他代理协同作业。这些代理通过一系列预定义的行为模式来完成复杂操作，比如查询数据库、解析文档以及调用API接口等[^1]。 #### 构建简单的问答机器人 为了展示如何创建一个基于LangChain Agent的应用程序实例，这里提供了一个简易版的Python代码片段用于构建一个能回答简单问题的知识型聊天机器人： ```python from langchain import LangChainAgent, KnowledgeBaseTool def create_qa_bot(): kb_tool = KnowledgeBaseTool() # 初始化知识库工具 qa_agent = LangChainAgent( tools=[kb_tool], # 添加所需使用的工具列表 llm=OpenAI(), # 使用指定的语言模型作为LLM引擎 verbose=True # 设置为True以便查看详细的运行日志 ) return qa_agent if __name__ == "__main__": bot = create_qa_bot() while True: query = input("请输入您的问题 (输入'exit'退出): ") if query.lower().strip() == 'exit': break response = bot.run(query) print(f"Bot的回答: {response}") ``` 此段代码展示了怎样利用`KnowledgeBaseTool`类从内部存储的数据集中检索信息，并借助于大型语言模型（如OpenAI API）来进行自然语言处理和生成回复。 #### 应用场景扩展——多代理协作机制下的任务分配 当面对更复杂的业务逻辑需求时，则可能涉及到多个不同类型的代理之间的交互合作。此时就需要引入像ReAct这样的框架来帮助管理各个代理间的通信流程与决策过程[^2]。例如，在上述例子基础上进一步增强功能，使其能够在必要时候自动切换至其他专门化的子代理以获取更加精准的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值