LangChain 框架核心模块与使用指南

Few Shot Examples 是一组示例，可用于帮助语言模型生成更好的响应。要使用 few shot examples 生成提示，可以使用 FewShotPromptTemplate。这个类接受一个 PromptTemplate 和一个 few shot examples 列表。然后，它将用 few shot examples 格式化提示模板。

如果在构建 prompt 过程中，如果有很多 example 示例，可以使用 ExampleSelector 类进行 select_examples，该方法接受输入变量，然后返回一个示例列表。该方法根据示例 example 与输入的相似度等选择示例。它通过查找嵌入与输入的余弦相似度最大的示例来实现此目的。使用方法示例如下：

example_selector = SemanticSimilarityExampleSelector.from_examples(
    examples,
    OpenAIEmbeddings(),
    Chroma,
    k=1
)
similar_prompt = FewShotPromptTemplate(
    example_selector=example_selector,
    example_prompt=example_prompt,
    prefix="Give the antonym of every input",
    suffix="Input: {adjective}\nOutput:",
    input_variables=["adjective"],
)

输出解析器也是提示工程中的重要一环。一般来说 LLM 语言模型输出文本，但是很多时候需要获得比文本更结构化的信息。这就是输出解析器的作用。

输出解析器是帮助结构化语言模型响应的类。如逗号分隔列表：

['Vanilla', 'Chocolate', 'Strawberry', 'Mint Chocolate Chip', 'Cookies and Cream']

或者定义好我们想要接受的响应格式，并将模式作为参数传递给 prompt 模板，最终得到的大模型响应结果就可以按照预先定义的格式来。例如：

response_schemas = [
    ResponseSchema(name="answer", description="answer to the user's question"),
    ResponseSchema(name="source", description="source used to answer the user's question, should be a website.")
]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
# 进行调用后
parsed_output = output_parser.parse(output.content)
# 结果
# {'answer': 'Paris', 'source': 'https://en.wikipedia.org/wiki/Paris'}

序列化提示模板，可以将 PromptTemplate 保存到本地文件系统中。LangChain 会自动通过文件扩展名推断文件格式。当前，LangChain 支持将模板保存为 YAML 和 JSON 文件。

内存 (Memory)

底层的 LLMs 和聊天模型是无状态的，因此每个请求都是独立地处理。但在某些应用程序中（如聊天机器人），记住以前的交互非常重要，无论是在短期还是长期层面上。因此需要一定的 memory 来存储过程中的交互数据。Memory 中可以保存最近 n 个对话和以前对话的消息摘要。

• 缓存窗口内存：ConversationBufferWindowMemory 函数，保留了对话随时间推移的交互列表。它仅使用最后 K 个交互。这可以用于保持最近交互的滑动窗口，以便缓冲区不会过大。K 值作为参数可以自定义。
• 实体摘要内存/对话摘要内存：ConversationEntityMemory，通过该函数来总结并记住特定实体的信息。它使用 LLMs 提取实体的信息，并移逐渐建立对实体的了解（通过 LLMs 的能力)。ConversationSummaryMemory 这种记忆类型可以创建关于对话的摘要，有助于从对话中概括信息。概括能力仍然需要 LLM。
• 对话摘要缓存内存：ConversationSummaryBufferMemory 结合了前两个想法。它将最近的交互记录缓存在内存中，但不仅仅是完全清除旧的交互，而是将它们编译成一份摘要并同时使用。不过，与之前的实现不同，它使用 token 长度而不是交互数量 K 来确定何时清除交互。
• 对话缓冲内存：ConversationTokenBufferMemory 会在内存中保留最近的对话内容，并使用 token 长度而不是对话数量来决定何时刷新对话。可以将历史记录作为消息列表。
• 基于向量存储的记忆：VectorStoreRetrieverMemory 将记忆存储在 VectorDB 中，并在每次调用时查询最重要的 K 个文档。与大多数其他记忆类不同的是，它不明确跟踪交互的顺序。在这种情况下，'文档'是先前的对话片段。这可以用来提到 AI 在对话中早期被告知的相关信息。

索引 (Indexes)

主要关注于构建索引，目标是使用它们作为检索器。我们主要关注的检索器类型是 Vectorstore 检索器。它提供一系列能力将文件等非结构化数据存储起来并提供索引以供检索，更好的与大模型交互。

通过文件回答问题包括四个步骤：

1. 创建索引
2. 从该索引创建检索器
3. 创建一个问题回答链
4. 问问题！

首先可以使用 VectorstoreIndexCreator 创建索引，然后用它来询问数据问题，示例代码如下：

from langchain.indexes import VectorstoreIndexCreator
index = VectorstoreIndexCreator().from_loaders([loader])
query = "What did the president say about Ketanji Brown Jackson"
result = index.query(query)
# 下述方法可以返回查询的数据来源 sources 地址
sources = index.query_with_sources(query)

其中这个 VectorstoreIndexCreator 背后的主要功能如下： 加载文件后有三个主要步骤：

1. 将文档分割成块
2. 为每个文档创建嵌入
3. 在向量库中存储文档和嵌入

VectorstoreIndexCreator 只是所有这些逻辑的包装器。它可以在它使用的文本分割器、它使用的嵌入以及它使用的向量存储中进行配置。配置方法如下：

index_creator = VectorstoreIndexCreator(
    vectorstore_cls=Chroma,
    embedding=OpenAIEmbeddings(),
    text_splitter=CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
)

与向量存储相关的高级功能如下：

docsearch = Chroma.from_texts(texts, embeddings)
query = "What did the president say about Ketanji Brown Jackson"
# 搜索
docs = docsearch.similarity_search(query)
# 添加文本
docsearch.add_texts(["Ankush went to Princeton"])
# 从文档初始化向量存储。使用文本拆分器方法直接获取文档
documents = text_splitter.create_documents([state_of_the_union], metadatas=[{"source": "State of the Union"}])

向量存储完成后，需要使用检索器来进行下一步查询。LangChain 最支持的索引，因此也是最支持的检索器是 VectorStoreRetriever。正如其名称所示，此检索器主要由 VectorStore 支持。

# 从向量数据库 db 中初始化一个检索器
retriever = db.as_retriever()
# 默认情况下，vectorstore 检索器使用相似性搜索。如果底层的 vectorstore 支持最大边际相关性搜索，则可以指定该搜索类型。
retriever = db.as_retriever(search_type="mmr")
docs = retriever.get_relevant_documents("what did he say about ketanji brown jackson")

链 (Chains)

使用单独的 LLM 对于一些简单的应用程序来说是可以的，但许多更复杂的应用程序需要链接 LLM——无论是相互链接还是与其他专家链接。LangChain 为链提供了标准接口，以及一些常见的链实现，以便于使用。链允许我们将多个组件组合在一起，创建一个单一的、一致的应用程序。例如，我们可以创建一个链，该链接接受用户输入，使用 PromptTemplate 对其进行格式化，然后将格式化后的响应传递给 LLM。我们可以通过将多个链组合在一起，或者通过将链与其他组件组合在一起，来构建更复杂的链。

LLMChain 是一个简单的链，它接受一个大模型 + 一个提示模板（可以是自定义的 PromptTemplate），也可以使用 chatllm + ChatPromptTemplate；然后将信息发个大模型并得到返回。

调用 Chain 的方式： 可以将 chain 作为一个 function 集成在 Tool 中，从而构建代理。代码示例如下：

tools.append(
    Tool(
        name="Calculator",
        func=llm_math_chain.run,
        description="在需要回答数学问题时非常有用",
        args_schema=CalculatorInput
    )
)

向链中添加内存： Chain 支持将 BaseMemory 对象作为其内存参数，允许 Chain 对象跨多个调用持久存储数据。换句话说，它使 Chain 成为一个有状态对象。

调试链： 因为大多数 Chain 对象都涉及大量的输入提示预处理和 LLM 输出后处理，所以很难单独从它的输出调试 Chain 对象。如果详细设置为 True，将在 Chain 对象运行时打印出它的一些内部状态。

组合 Chain： 我们可以组合这两个 LLMChains，这样我们就可以在一个步骤中创建完成两个不同的任务，示例代码如下：

from langchain.chains import SimpleSequentialChain
overall_chain = SimpleSequentialChain(chains=[chain, chain_two], verbose=True)
# Run the chain specifying only the input variable for the first chain.
catchphrase = overall_chain.run("colorful socks")
print(catchphrase)

问答与来源： 如果我们想通过 chain 对一系列文档进行带来源的问答，首先，我们需要准备数据。在此示例中，我们在向量数据库上进行相似性搜索，但这些文档可以以任何方式获取（本教程的重点是强调在获取文档后要做什么)。可以使用如下代码思路：

# 准备问题
query = "What did the president say about Justice Breyer"
# 准备文档数据源&向量化存储
docsearch = Chroma.from_texts(texts, embeddings, metadatas=[{"source": str(i)} for i in range(len(texts))])
docs = docsearch.similarity_search(query)
# 使用链
chain = load_qa_with_sources_chain(OpenAI(temperature=0), chain_type="stuff")
chain({"input_documents": docs, "question": query}, return_only_outputs=True)

进一步的，可以使用向量数据进行索引对问题进行基于来源的问答。它通过使用 RetrievalQAWithSourcesChain 来完成从索引中查找文档的工作。代码如下：

docsearch = Chroma.from_texts(texts, embeddings, metadatas=[{"source": f"{i}-pl"} for i in range(len(texts))])
from langchain import OpenAI
chain = RetrievalQAWithSourcesChain.from_chain_type(OpenAI(temperature=0), chain_type="stuff", retriever=docsearch.as_retriever())
chain({"question": "What did the president say about Justice Breyer"}, return_only_outputs=True)

代理 (Agents)

Agent 也可以称为'智能体'或'智能业务助理'，在大模型技术驱动下，它通过'大模型 + 插件 + 执行流程 / 思维链'的方式，对应控制端 (Brain / 大脑)、感知端 (Perception)、执行端 (Action) 环节，实现了复杂的功能。一个代理 (Agent) 至少由三个部分组成：

1. LLM：作为 Agent 的大脑，用于核心控制器，例如规划，反馈，学习等。
2. 工具 (Tools)：代理可以使用的工具。工具是代理可以用来与世界互动的功能。这些工具可以是通用工具（例如搜索)，其他链，甚至是其他代理。
3. 代理执行器 (Executor)：这决定了采取哪些行动。

Agent 的核心在于让 LLM 自主决定调用哪个工具以及调用的顺序。常见的 Agent 类型包括：

• ReAct Agent：结合 Reasoning（推理）和 Acting（行动），通过思考 - 行动 - 观察的循环解决问题。
• Plan-and-Execute Agent：先制定计划，再逐步执行计划中的步骤。
• Multi-Agent Systems：多个 Agent 协作完成任务，例如一个负责搜索，一个负责写作。

构建一个简单的 Agent 示例：

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
tools = [
    Tool(
        name="Search",
        func=search_tool.run,
        description="Useful for when you need to answer questions about current events."
    ),
    Tool(
        name="Calculator",
        func=calculator_tool.run,
        description="Useful for when you need to answer questions about math."
    )
]

agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
agent.run("Who is the CEO of Tesla? What is his net worth?")

在实际应用中，Agent 可以极大地扩展 LLM 的能力边界，使其不仅能回答问题，还能执行操作、访问外部 API 或处理复杂的工作流。

总结

LangChain 提供了一个完整的生态系统，使得开发基于大语言模型的应用变得更加模块化、可扩展和易于维护。通过理解模型、提示、内存、索引、链和代理这六大核心模块，开发者可以根据具体需求灵活组合，构建出功能强大的 AI 应用。随着生态系统的不断演进，LangChain 将继续降低 AI 开发的门槛，推动更多创新场景的实现。