文本摘要
信息
本教程演示如何使用内置链和 LangGraph 进行文本摘要。
此页面的 先前版本 展示了遗留链 StuffDocumentsChain、MapReduceDocumentsChain 和 RefineDocumentsChain。有关如何使用这些抽象以及本教程中演示的方法的比较，请参见 此处。
假设您有一组文档（PDF、Notion 页面、客户问题等），并希望总结其内容。
LLMs 是进行此项工作的绝佳工具，因为它们擅长理解和综合文本。
在检索增强生成的上下文中，对文本进行摘要有助于从大量检索到的文档中提炼信息，从而为大型语言模型提供上下文。
在本教程中，我们将介绍如何使用大型语言模型（LLM）对多个文档的内容进行摘要。
概念
我们将涵盖的概念包括：
-
使用 语言模型。
-
使用 文档加载器，特别是 WebBaseLoader 来从 HTML 网页加载内容。
-
两种总结或以其他方式组合文档的方法。
- Stuff，它只是将文档拼接成提示词；
- Map-reduce，适用于更大的文档集。该方法将文档拆分为批次，先对每个批次进行摘要，再对这些摘要进行汇总。
关于这些策略以及其他策略（包括 迭代优化）的简短、针对性指南，可在 操操作指南 中找到。
设置
Jupyter Notebook
本指南（以及文档中的大多数其他指南）使用 Jupyter notebooks，并假设读者也是如此。Jupyter notebooks 非常适合学习如何与 LLM 系统协作，因为很多时候可能会出现问题（输出意外、API 不可用等），而在交互式环境中逐步完成指南是更好地理解它们的绝佳方式。
此教程及其他教程最方便在 Jupyter notebook 中运行。有关如何安装的说明，请参见 此处。
安装
安装 LangChain 请运行：
- Pip
- Conda
pip install langchain
conda install langchain -c conda-forge
有关更多详细信息，请参阅我们的 安装指南。
LangSmith
您使用 LangChain 构建的许多应用程序将包含多个步骤以及多次 LLM 调用。 随着这些应用程序变得越来越复杂，能够检查您的链或代理内部究竟发生了什么变得至关重要。 实现这一点的最佳方式是使用 LangSmith。
在通过上述链接注册后，请确保设置您的环境变量以开始记录追踪：
export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="..."
或者，如果在笔记本中，您可以这样设置：
import getpass
import os
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = getpass.getpass()
概览
构建摘要器的一个核心问题是如何将文档传递到 LLM 的上下文窗口中。为此有两种常见方法：
-
Stuff: 只需将所有文档“塞入”单个提示中。这是最简单的方法（有关用于此方法的create_stuff_documents_chain构造函数的更多信息，请参见 此处）。 -
Map-reduce: 在“映射”步骤中分别总结每份文档，然后将这些摘要“归约”为最终摘要（有关用于此方法的MapReduceDocumentsChain的更多信息，请参见此处）。
请注意，当对子文档的理解不依赖于前文上下文时，map-reduce 方法尤其有效。例如，在总结大量较短文档的语料库时。在其他情况下，如总结具有固有顺序的小说或文本体时，迭代细化可能更为有效。
设置
首先设置环境变量并安装软件包：
%pip install --upgrade --quiet tiktoken langchain langgraph beautifulsoup4 langchain-community
# Set env var OPENAI_API_KEY or load from a .env file
# import dotenv
# dotenv.load_dotenv()
import os
os.environ["LANGSMITH_TRACING"] = "true"
首先我们加载我们的文档。我们将使用 WebBaseLoader 来加载一篇博客文章：
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://lilianweng.github.io/posts/2023-06-23-agent/")
docs = loader.load()
API 参考:WebBaseLoader
让我们接下来选择一个大语言模型：
选择 聊天模型:
pip install -qU "langchain[openai]"
import getpass
import os
if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")
from langchain.chat_models import init_chat_model
llm = init_chat_model("gpt-4o-mini", model_provider="openai")
内容：在单次 LLM 调用中总结
我们可以使用 create_stuff_documents_chain，特别是当使用具有更大上下文窗口的大型模型时，例如：
- 128k token OpenAI
gpt-4o - 20万 token Anthropic
claude-3-5-sonnet-20240620
该链将接收一个文档列表，将它们全部插入到提示词中，然后将该提示词传递给大语言模型（LLM）：
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains.llm import LLMChain
from langchain_core.prompts import ChatPromptTemplate
# Define prompt
prompt = ChatPromptTemplate.from_messages(
[("system", "Write a concise summary of the following:\\n\\n{context}")]
)
# Instantiate chain
chain = create_stuff_documents_chain(llm, prompt)
# Invoke chain
result = chain.invoke({"context": docs})
print(result)
The article "LLM Powered Autonomous Agents" by Lilian Weng discusses the development and capabilities of autonomous agents powered by large language models (LLMs). It outlines a system architecture that includes three main components: Planning, Memory, and Tool Use.
1. **Planning** involves task decomposition, where complex tasks are broken down into manageable subgoals, and self-reflection, allowing agents to learn from past actions to improve future performance. Techniques like Chain of Thought (CoT) and Tree of Thoughts (ToT) are highlighted for enhancing reasoning and planning.
2. **Memory** is categorized into short-term and long-term memory, with mechanisms for fast retrieval using Maximum Inner Product Search (MIPS) algorithms. This allows agents to retain and recall information effectively.
3. **Tool Use** enables agents to interact with external APIs and tools, enhancing their capabilities beyond the limitations of their training data. Examples include MRKL systems and frameworks like HuggingGPT, which facilitate task planning and execution.
The article also addresses challenges such as finite context length, difficulties in long-term planning, and the reliability of natural language interfaces. It concludes with case studies demonstrating the practical applications of these concepts in scientific discovery and interactive simulations. Overall, the article emphasizes the potential of LLMs as powerful problem solvers in autonomous agent systems.
流式传输
请注意，我们也可以逐 token 流式传输结果：
for token in chain.stream({"context": docs}):
print(token, end="|")
|The| article| "|LL|M| Powered| Autonomous| Agents|"| by| Lil|ian| W|eng| discusses| the| development| and| capabilities| of| autonomous| agents| powered| by| large| language| models| (|LL|Ms|).| It| outlines| a| system| architecture| that| includes| three| main| components|:| Planning|,| Memory|,| and| Tool| Use|.|
|1|.| **|Planning|**| involves| task| decomposition|,| where| complex| tasks| are| broken| down| into| manageable| sub|go|als|,| and| self|-ref|lection|,| allowing| agents| to| learn| from| past| actions| to| improve| future| performance|.| Techniques| like| Chain| of| Thought| (|Co|T|)| and| Tree| of| Thoughts| (|To|T|)| are| highlighted| for| enhancing| reasoning| and| planning|.
|2|.| **|Memory|**| is| categorized| into| short|-term| and| long|-term| memory|,| with| mechanisms| for| fast| retrieval| using| Maximum| Inner| Product| Search| (|M|IPS|)| algorithms|.| This| allows| agents| to| retain| and| recall| information| effectively|.
|3|.| **|Tool| Use|**| emphasizes| the| integration| of| external| APIs| and| tools| to| extend| the| capabilities| of| L|LM|s|,| enabling| them| to| perform| tasks| beyond| their| inherent| limitations|.| Examples| include| MR|KL| systems| and| frameworks| like| Hug|ging|GPT|,| which| facilitate| task| planning| and| execution|.
|The| article| also| addresses| challenges| such| as| finite| context| length|,| difficulties| in| long|-term| planning|,| and| the| reliability| of| natural| language| interfaces|.| It| concludes| with| case| studies| demonstrating| the| practical| applications| of| L|LM|-powered| agents| in| scientific| discovery| and| interactive| simulations|.| Overall|,| the| piece| illustrates| the| potential| of| L|LM|s| as| general| problem| sol|vers| and| their| evolving| role| in| autonomous| systems|.||
深入探索
- 您可以轻松自定义提示词。
- 您可以通过
llm参数轻松尝试不同的 LLM（例如，Claude）。
Map-Reduce：通过并行化总结长文本
让我们来剖析一下 MapReduce（映射-归约）方法。首先，我们将使用大语言模型（LLM）将每个文档映射为独立的摘要。然后，我们将这些摘要进行归约或整合，形成一个全局摘要。
请注意，map 步骤通常会对输入文档进行并行化处理。
LangGraph，构建在 langchain-core 之上，支持 map-reduce 工作流，非常适合解决此问题：
- LangGraph 允许将各个步骤（例如连续的摘要生成）进行流式传输，从而实现对执行过程的更精细控制；
- LangGraph 的 检查点（checkpointing） 支持错误恢复、扩展人机协作工作流，以及更便捷地集成到对话应用中。
- LangGraph 的实现修改和扩展都非常直接，如下所示。
Map
让我们首先定义与 map 步骤相关联的提示。我们可以使用上面 stuff 方法中相同的总结提示：
from langchain_core.prompts import ChatPromptTemplate
map_prompt = ChatPromptTemplate.from_messages(
[("system", "Write a concise summary of the following:\\n\\n{context}")]
)
API 参考:ChatPromptTemplate
我们还可以使用 Prompt Hub 来存储和获取提示词。
这将与您的 LangSmith API 密钥 配合使用。
例如，请查看地图提示 这里。
from langchain import hub
map_prompt = hub.pull("rlm/map-prompt")
API 参考:中心枢纽
减少
我们还定义了一个提示，该提示接收文档映射结果并将其缩减为单个输出。
# Also available via the hub: `hub.pull("rlm/reduce-prompt")`
reduce_template = """
The following is a set of summaries:
{docs}
Take these and distill it into a final, consolidated summary
of the main themes.
"""
reduce_prompt = ChatPromptTemplate([("human", reduce_template)])
通过 LangGraph 进行编排
下面我们实现一个简单的应用程序，该程序首先对文档列表执行摘要步骤，然后使用上述提示将它们进行缩减。
Map-reduce 流程在文本长度超过大语言模型上下文窗口时特别有用。对于长文本，我们需要一种机制，确保在 reduce 步骤中需要总结的上下文不会超过模型的上下文窗口大小。在这里，我们实现了一种递归的“折叠”总结方法：根据令牌限制对输入进行分区，并生成各分区的摘要。此步骤会重复执行，直到所有摘要的总长度满足预期限制，从而能够总结任意长度的文本。
首先，我们将博客文章分割成更小的“子文档”以便进行映射：
from langchain_text_splitters import CharacterTextSplitter
text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
chunk_size=1000, chunk_overlap=0
)
split_docs = text_splitter.split_documents(docs)
print(f"Generated {len(split_docs)} documents.")
API 参考:CharacterTextSplitter
Created a chunk of size 1003, which is longer than the specified 1000
``````output
Generated 14 documents.
接下来，我们定义我们的图。注意，我们将最大令牌长度人为地设置为较低的1,000个令牌，以说明“折叠”步骤。
import operator
from typing import Annotated, List, Literal, TypedDict
from langchain.chains.combine_documents.reduce import (
acollapse_docs,
split_list_of_docs,
)
from langchain_core.documents import Document
from langgraph.constants import Send
from langgraph.graph import END, START, StateGraph
token_max = 1000
def length_function(documents: List[Document]) -> int:
"""Get number of tokens for input contents."""
return sum(llm.get_num_tokens(doc.page_content) for doc in documents)
# This will be the overall state of the main graph.
# It will contain the input document contents, corresponding
# summaries, and a final summary.
class OverallState(TypedDict):
# Notice here we use the operator.add
# This is because we want combine all the summaries we generate
# from individual nodes back into one list - this is essentially
# the "reduce" part
contents: List[str]
summaries: Annotated[list, operator.add]
collapsed_summaries: List[Document]
final_summary: str
# This will be the state of the node that we will "map" all
# documents to in order to generate summaries
class SummaryState(TypedDict):
content: str
# Here we generate a summary, given a document
async def generate_summary(state: SummaryState):
prompt = map_prompt.invoke(state["content"])
response = await llm.ainvoke(prompt)
return {"summaries": [response.content]}
# Here we define the logic to map out over the documents
# We will use this an edge in the graph
def map_summaries(state: OverallState):
# We will return a list of `Send` objects
# Each `Send` object consists of the name of a node in the graph
# as well as the state to send to that node
return [
Send("generate_summary", {"content": content}) for content in state["contents"]
]
def collect_summaries(state: OverallState):
return {
"collapsed_summaries": [Document(summary) for summary in state["summaries"]]
}
async def _reduce(input: dict) -> str:
prompt = reduce_prompt.invoke(input)
response = await llm.ainvoke(prompt)
return response.content
# Add node to collapse summaries
async def collapse_summaries(state: OverallState):
doc_lists = split_list_of_docs(
state["collapsed_summaries"], length_function, token_max
)
results = []
for doc_list in doc_lists:
results.append(await acollapse_docs(doc_list, _reduce))
return {"collapsed_summaries": results}
# This represents a conditional edge in the graph that determines
# if we should collapse the summaries or not
def should_collapse(
state: OverallState,
) -> Literal["collapse_summaries", "generate_final_summary"]:
num_tokens = length_function(state["collapsed_summaries"])
if num_tokens > token_max:
return "collapse_summaries"
else:
return "generate_final_summary"
# Here we will generate the final summary
async def generate_final_summary(state: OverallState):
response = await _reduce(state["collapsed_summaries"])
return {"final_summary": response}
# Construct the graph
# Nodes:
graph = StateGraph(OverallState)
graph.add_node("generate_summary", generate_summary) # same as before
graph.add_node("collect_summaries", collect_summaries)
graph.add_node("collapse_summaries", collapse_summaries)
graph.add_node("generate_final_summary", generate_final_summary)
# Edges:
graph.add_conditional_edges(START, map_summaries, ["generate_summary"])
graph.add_edge("generate_summary", "collect_summaries")
graph.add_conditional_edges("collect_summaries", should_collapse)
graph.add_conditional_edges("collapse_summaries", should_collapse)
graph.add_edge("generate_final_summary", END)
app = graph.compile()
LangGraph 允许将图结构绘制出来，以帮助可视化其功能：
from IPython.display import Image
Image(app.get_graph().draw_mermaid_png())
在运行应用程序时，我们可以流式传输图以观察其步骤序列。下面，我们将简单地打印出每个步骤的名称。
请注意，由于我们的图中存在循环，在运行时指定 recursion_limit 可能会很有帮助。当超过指定的限制时，这将引发特定错误。
async for step in app.astream(
{"contents": [doc.page_content for doc in split_docs]},
{"recursion_limit": 10},
):
print(list(step.keys()))
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['generate_summary']
['collect_summaries']
['collapse_summaries']
['collapse_summaries']
['generate_final_summary']
print(step)
{'generate_final_summary': {'final_summary': 'The consolidated summary of the main themes from the provided documents is as follows:\n\n1. **Integration of Large Language Models (LLMs) in Autonomous Agents**: The documents explore the evolving role of LLMs in autonomous systems, emphasizing their enhanced reasoning and acting capabilities through methodologies that incorporate structured planning, memory systems, and tool use.\n\n2. **Core Components of Autonomous Agents**:\n - **Planning**: Techniques like task decomposition (e.g., Chain of Thought) and external classical planners are utilized to facilitate long-term planning by breaking down complex tasks.\n - **Memory**: The memory system is divided into short-term (in-context learning) and long-term memory, with parallels drawn between human memory and machine learning to improve agent performance.\n - **Tool Use**: Agents utilize external APIs and algorithms to enhance problem-solving abilities, exemplified by frameworks like HuggingGPT that manage task workflows.\n\n3. **Neuro-Symbolic Architectures**: The integration of MRKL (Modular Reasoning, Knowledge, and Language) systems combines neural and symbolic expert modules with LLMs, addressing challenges in tasks such as verbal math problem-solving.\n\n4. **Specialized Applications**: Case studies, such as ChemCrow and projects in anticancer drug discovery, demonstrate the advantages of LLMs augmented with expert tools in specialized domains.\n\n5. **Challenges and Limitations**: The documents highlight challenges such as hallucination in model outputs and the finite context length of LLMs, which affects their ability to incorporate historical information and perform self-reflection. Techniques like Chain of Hindsight and Algorithm Distillation are discussed to enhance model performance through iterative learning.\n\n6. **Structured Software Development**: A systematic approach to creating Python software projects is emphasized, focusing on defining core components, managing dependencies, and adhering to best practices for documentation.\n\nOverall, the integration of structured planning, memory systems, and advanced tool use aims to enhance the capabilities of LLM-powered autonomous agents while addressing the challenges and limitations these technologies face in real-world applications.'}}
在相应的 LangSmith 追踪 中，我们可以看到各个 LLM 调用，并按其各自的节点进行分组。
深入探索
自定义
- 如上所示，您可以为 map 和 reduce 阶段自定义 LLM 和提示词。
实际应用场景
- 查看 这篇博客文章 的案例研究，内容涉及分析用户互动（关于 LangChain 文档的提问）！
- 该博客文章及相关的仓库还介绍了将聚类作为摘要的一种手段。
- 这开辟了另一条超越
stuff或map-reduce方法的路径，值得考虑。
下一步
我们鼓励您查看 操操作指南，以获取更多关于以下内容的详细信息：
和其他概念。