【LangChain系列 3】LangChain核心模块简介(二)

原文链接：【LangChain系列 3】LangChain核心模块简介(二)

本文速读：

• Memory

• Agents

• Callbacks

04 Memory

简单来讲Memory就是对话的上下文，它记录着当前对话的内容、背景等相关信息。至少它应该可以访问到最近一段时间的Message；对于一个复杂的系统，它应该是像真实世界的模型一样，随着对话的不断进行，它应该不断地更新它所了解的实体以及它们互相关联的信息，这种能力就是Memory。

LangChain提供了很多模块，这样我们可以方便地将Memory增加到一个系统中去。Memory系统需要有两个基础的能力：读和写。

• 在收到用户初始输入之后，但在继续执行核心逻辑之前，Chain会先去读取Memory系统，然后将其读取到的信息也作为用户输入的一部分。

• 在执行完核心逻辑之后 ，但在返回结果之前，Chain会将用户输入和当前输出写到Momory系统。

任何一个Memory系统都需要考虑两个核心的设计：

• 状态怎么存储

• 状态怎么查询

在LangChain中，主要通过Chat Messages列表的方式来存储，其中Memory模块中有一个关键的部分就是集成Chat Messages存储。存储的方式已经确定，接下来的问题就是如何查询？

在Chat Messages之上，通过不同的数据结构和算法，LangChain定义了很多Memory类型，方便我们查询Messages，主要类型有：

• Conversation buffer memory

• Conversation buffer window memory

• Entity memory

• Conversation Knowledge Graph Memory

• Conversation summary memory

• ConversationSummaryBufferMemory

• ConversationTokenBufferMemory

• Vector store-backd memory

后面我们将详细介绍这些类型的使用，下面我们先看一个简单的例子：

from langchain.chat_models import ChatOpenAI
from langchain.prompts import (ChatPromptTemplate,
                               MessagesPlaceholder,
                               SystemMessagePromptTemplate,
                               HumanMessagePromptTemplate)
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory​​

llm = ChatOpenAI(openai_api_key="xxxxxxxx")
prompt = ChatPromptTemplate(messages=[
SystemMessagePromptTemplate.from_template(
        "You are a nice chatbot having a conversation with a human."),
        # The `variable_name` here is what must align with memory
        MessagesPlaceholder(variable_name="chat_history"),
        HumanMessagePromptTemplate.from_template("{question}")])
        # Notice that we `return_messages=True` to fit into the MessagesPlaceholder
        # Notice that `"chat_history"` aligns with the MessagesPlaceholder name.
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=True,
    memory=memory)

05 Agents

Agents在核心作用就是：使用LLM来选择一系列要执行的操作。在一个Chain中，它要执行的操作以及次序是代码中事先确定好了的；有了Agents，LLM可以动态选择要执行的操作和次序。

Agent本质就是一个决定下一步操作的类，由一个语言模型和一个prompt来驱动。prompt可以包括如下内容：

• agent的特性

• agent的背景、上下文

• 辅助推理执行下一步的prompt策略

Tools是agents调用的函数，它的作用主要是：

• 告诉agent可以访问哪些正确的工具

• 告诉agent正确的使用工具

LangChain提供了很多工具，同时我们也可以定义我们自己的工具。

• Defining Custom Tools

• Human-in-the-loop Tool Validation

• Multi-Input Tools

• Tool Input Schema

• Tools as OpenAI Functions

下面我们看一个Agent的例子：

1. 首先定义一个语言模型来控制agent

from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(temperature=0, openai_api_key="aaa")

2. 定义工具

from langchain.agents import tool​

@tool
def get_word_length(word: str) -> int:
    """Returns the length of a word."""
    return len(word)​

tools = [get_word_length]

3. 创建prompt

from langchain.schema import SystemMessage
from langchain.agents import OpenAIFunctionsAgent

system_message = SystemMessage(content="You are very powerful assistant, but bad at calculating lengths of words.")
prompt = OpenAIFunctionsAgent.create_prompt(system_message=system_message)

4. 创建agent

agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)

5. 创建AgentExecutor并执行

from langchain.agents import AgentExecutor

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)​
agent_executor.run("how many letters in the word educa?")

至此第一个agent就完成了，你可以在本地执行查看效果啦！

06 Callbacks

LangChain提供了一个callbacks系统，这样你就可以在LLM应用的不同阶段实现你的钩子函数，比如说日志、监控、流处理等其它任务。

我们可以通过callcacks的参数来订阅事件，这个参数就是handlers对象。CallbackHandlers是实现CallbackHandler接口的对象，接口中定义了很多不同函数来监控不同事件，如果你需要订阅某个事件，你只需要实现接口中对应的函数即可。

以下是一个最基本的CallbackHander：

class BaseCallbackHandler:
    """Base callback handler that can be used to handle callbacks from langchain."""

    def on_llm_start(
        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
    ) -> Any:
        """Run when LLM starts running."""

    def on_chat_model_start(
        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs: Any
    ) -> Any:
        """Run when Chat Model starts running."""

    def on_llm_new_token(self, token: str, **kwargs: Any) -> Any:
        """Run on new LLM token. Only available when streaming is enabled."""

    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> Any:
        """Run when LLM ends running."""

    def on_llm_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when LLM errors."""

    def on_chain_start(
        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
    ) -> Any:
        """Run when chain starts running."""

    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
        """Run when chain ends running."""

    def on_chain_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when chain errors."""

    def on_tool_start(
        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
    ) -> Any:
        """Run when tool starts running."""

    def on_tool_end(self, output: str, **kwargs: Any) -> Any:
        """Run when tool ends running."""

    def on_tool_error(
        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
    ) -> Any:
        """Run when tool errors."""

    def on_text(self, text: str, **kwargs: Any) -> Any:
        """Run on arbitrary text."""

    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
        """Run on agent action."""

    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
        """Run on agent end."""

以上就是Memory、Agents、Callbacks这三个模块的介绍，再加上【LangChain系列 2】LangChain核心模块简介(一)，LangChain的核心模块介绍就完成了，后面我将详细地介绍各个模块的使用与实践。