本文详细介绍了 LangChain 框架的核心组件及其在 LLM 应用开发中的实践。涵盖了 Models、Indexes、Chains、Memory 和 Agent 五大模块的工作原理与代码示例。重点讲解了如何通过 Document Loaders 加载数据、Text Splitters 分割文本、Vectorstore 存储向量以及 Retriever 检索信息。同时深入分析了 LLMChain、Sequential Chain、Router Chain 及各类 Document Chain 的用法，并结合 Memory 实现多轮对话。文章还提供了文档总结与基于外部文档问答的完整落地案例，并展望了低代码编排与高级 Agent 系统的未来发展方向。
LangChain 是一个框架，用于开发由大语言模型（LLM）驱动的应用程序。可以简单认为是 LLM 领域的 Spring，以及开源版的 ChatGPT 插件系统。其核心功能包括：
LangChain 提供了各种不同的组件帮助使用 LLM，核心组件有 Models、Indexes、Chains、Memory 以及 Agent。
LangChain 本身不提供 LLM，提供通用的接口访问 LLM，可以很方便的更换底层的 LLM 以及自定义自己的 LLM。主要有 2 大类的 Models：
与模型交互的，基本上是通过给与 Prompt 的方式，LangChain 通过 PromptTemplate 的方式方便我们构建以及复用 Prompt。
from langchain import PromptTemplate
prompt_template = '''作为一个资深编辑，请针对 >>> 和 <<< 中间的文本写一段摘要。
>>> {text} <<<
'''
prompt = PromptTemplate(template=prompt_template, input_variables=["text"])
print(prompt.format_prompt(text="我爱北京天安门"))
索引和外部数据进行集成，用于从外部数据获取答案。主要的步骤有：
LangChain 通过 Loader 加载外部的文档，转化为标准的 Document 类型。Document 类型主要包含两个属性：page_content 包含该文档的内容，meta_data 为文档相关的描述性数据，类似文档所在的路径等。
LLM 一般都会限制上下文窗口的大小，有 4k、16k、32k 等。针对大文本就需要进行文本分割，常用的文本分割器为 RecursiveCharacterTextSplitter，可以通过 separators 指定分隔符。其先通过第一个分隔符进行分割，不满足大小的情况下迭代分割。
文本分割主要有 2 个考虑：
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
model_name="gpt-3.5-turbo",
allowed_special="all",
separators=["\n\n", "\n", "。", "，"],
chunk_size=7000,
chunk_overlap=0
)
docs = text_splitter.create_documents(["文本在这里"])
print(docs)
通过 Text Embedding models，将文本转为向量，可以进行语义搜索，在向量空间中找到最相似的文本片段。目前支持常用的向量存储有 Faiss、Chroma 等。
Embedding 模型支持 OpenAIEmbeddings、HuggingFaceEmbeddings 等。通过 HuggingFaceEmbeddings 加载本地模型可以节省 embedding 的调用费用。
# 通过 cache_folder 加载本地模型
embeddings = HuggingFaceEmbeddings(model_name="text2vec-base-chinese", cache_folder="local_model_path")
embeddings = embeddings.embed_documents([
"我爱北京天安门!",
"Hello world!"
])
Retriever 接口用于根据非结构化的查询获取文档，一般情况下是文档存储在向量数据库中。可以调用 get_relevant_documents 方法来检索与查询相关的文档。
from langchain import FAISS
from langchain.document_loaders import WebBaseLoader
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
loader = WebBaseLoader("https://in.m.jd.com/help/app/register_info.html")
data = loader.load()
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
model_name="gpt-3.5-turbo",
allowed_special="all",
separators=["\n\n", "\n", "。", "，"],
chunk_size=800,
chunk_overlap=0
)
docs = text_splitter.split_documents(data)
# 通过 cache_folder 设置自己的本地模型路径
embeddings = HuggingFaceEmbeddings(model_name="text2vec-base-chinese", cache_folder="models")
vectorstore = FAISS.from_documents(docs, embeddings)
result = vectorstore.as_retriever().get_relevant_documents("用户注册资格")
print(result)
print(len(result))
LangChain 通过 chain 将各个组件进行链接，以及 chain 之间进行链接，用于简化复杂应用程序的实现。其中主要有 LLMChain、Sequential Chain 以及 Route Chain。
最基本的链为 LLMChain，由 PromptTemplate、LLM 和 OutputParser 组成。LLM 的输出一般为文本，OutputParser 用于让 LLM 结构化输出并进行结果解析，方便后续的调用。
类似下面的示例，给评论进行关键词提取以及情绪分析，通过 LLMChain 组合 PromptTemplate、LLM 以及 OutputParser，可以很简单的实现一个之前通过依赖小模型不断需要调优的事情。
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.output_parsers import ResponseSchema, StructuredOutputParser
# llm = ChatOpenAI(...) # 需配置实际 LLM
# output parser
keyword_schema = ResponseSchema(name="keyword", description="评论的关键词列表")
emotion_schema = ResponseSchema(name="emotion", description="评论的情绪，正向为 1，中性为 0，负向为 -1")
response_schemas = [keyword_schema, emotion_schema]
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
# prompt template
prompt_template_txt = '''
作为资深客服，请针对 >>> 和 <<< 中间的文本识别其中的关键词，以及包含的情绪是正向、负向还是中性。
>>> {text} <<<
RESPONSE:
{format_instructions}
'''
prompt = PromptTemplate(template=prompt_template_txt, input_variables=["text"],
partial_variables={"format_instructions": format_instructions})
# llmchain
llm_chain = LLMChain(prompt=prompt, llm=llm)
comment = "京东物流没的说，速度态度都是杠杠滴！这款路由器颜值贼高，怎么说呢，就是泰裤辣！这线条，这质感，这速度，嘎嘎快！以后妈妈再也不用担心家里的网速了！"
result = llm_chain.run(comment)
data = output_parser.parse(result)
print(f"type={type(data)}, keyword={data['keyword']}, emotion={data['emotion']}")
输出结果展示结构化数据解析效果。
SequentialChains 是按预定义顺序执行的链。SimpleSequentialChain 为顺序链的最简单形式，其中每个步骤都有一个单一的输入/输出，一个步骤的输出是下一个步骤的输入。SequentialChain 为顺序链更通用的形式，允许多个输入/输出。
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.chains import SimpleSequentialChain
first_prompt = PromptTemplate.from_template(
"翻译下面的内容到中文:"
"\n\n{content}"
)
# chain 1: 输入：Review 输出：英文的 Review
chain_trans = LLMChain(llm=llm, prompt=first_prompt, output_key="content_zh")
second_prompt = PromptTemplate.from_template(
"一句话总结下面的内容:"
"\n\n{content_zh}"
)
chain_summary = LLMChain(llm=llm, prompt=second_prompt)
overall_simple_chain = SimpleSequentialChain(chains=[chain_trans, chain_summary], verbose=True)
content = '''In a blog post authored back in 2011, Marc Andreessen warned that, 'Software is eating the world.' Over a decade later, we are witnessing the emergence of a new type of technology that's consuming the world with even greater voracity: generative artificial intelligence (AI). This innovative AI includes a unique class of large language models (LLM), derived from a decade of groundbreaking research, that are capable of out-performing humans at certain tasks. And you don't have to have a PhD in machine learning to build with LLMs—developers are already building software with LLMs with basic HTTP requests and natural language prompts.
In this article, we'll tell the story of GitHub's work with LLMs to help other developers learn how to best make use of this technology. This post consists of two main sections: the first will describe at a high level how LLMs function and how to build LLM-based applications. The second will dig into an important example of an LLM-based application: GitHub Copilot code completions.
Others have done an impressive job of cataloging our work from the outside. Now, we're excited to share some of the thought processes that have led to the ongoing success of GitHub Copilot.
'''
result = overall_simple_chain.run(content)
print(f'result={result}')
RouterChain 是根据输入动态的选择下一个链，每条链处理特定类型的输入。
RouterChain 由两个组件组成：
初始化 RouterChain 以及 destination_chains 完成后，通过 MultiPromptChain 将两者结合起来使用。
下面的 4 种 Chain 主要用于 Document 的处理，在基于文档生成摘要、基于文档的问答等场景中经常会用到，在后续的落地实践里也会有所体现。
StuffDocumentsChain 这种链最简单直接，是将所有获取到的文档作为 context 放入到 Prompt 中，传递到 LLM 获取答案。
这种方式可以完整的保留上下文，调用 LLM 的次数也比较少，建议能使用 stuff 的就使用这种方式。其适合文档拆分的比较小，一次获取文档比较少的场景，不然容易超过 token 的限制。
RefineDocumentsChain 是通过迭代更新的方式获取答案。先处理第一个文档，作为 context 传递给 llm，获取中间结果 intermediate answer。然后将第一个文档的中间结果以及第二个文档发给 llm 进行处理，后续的文档类似处理。
Refine 这种方式能部分保留上下文，以及 token 的使用能控制在一定范围。
MapReduceDocumentsChain 先通过 LLM 对每个 document 进行处理，然后将所有文档的答案在通过 LLM 进行合并处理，得到最终的结果。
MapReduce 的方式将每个 document 单独处理，可以并发进行调用。但是每个文档之间缺少上下文。
MapRerankDocumentsChain 和 MapReduceDocumentsChain 类似，先通过 LLM 对每个 document 进行处理，每个答案都会返回一个 score，最后选择 score 最高的答案。
MapRerank 和 MapReduce 类似，会大批量的调用 LLM，每个 document 之间是独立处理。
正常情况下 Chain 无状态的，每次交互都是独立的，无法知道之前历史交互的信息。LangChain 使用 Memory 组件保存和管理历史消息，这样可以跨多轮进行对话，在当前会话中保留历史会话的上下文。Memory 组件支持多种存储介质，可以与 MongoDB、Redis、SQLite 等进行集成，以及简单直接形式就是 Buffer Memory。常用的 Buffer Memory 有：
通过查看 chain 的 prompt，可以发现 {history} 变量传递了从 memory 获取的会话上下文。下面的示例演示了 Memory 的使用方式，可以看到答案是从之前的问题里获取的。
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
# llm = ChatOpenAI(...)
memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory, verbose=True)
print(conversation.prompt)
print(conversation.predict(input="我的姓名是 tiger"))
print(conversation.predict(input="1+1=?"))
print(conversation.predict(input="我的姓名是什么"))
输出展示了上下文记忆的保持。
Agent 字面含义就是代理，如果说 LLM 是大脑，Agent 就是代理大脑使用 Tools。目前的大模型一般都存在知识过时、逻辑计算能力低等问题，通过 Agent 访问工具，可以去解决这些问题。目前这个领域特别活跃，诞生了类似 AutoGPT、BabyAGI、AgentGPT 等一堆优秀的项目。传统使用 LLM，需要给定 Prompt 一步一步的达成目标，通过 Agent 是给定目标，其会自动规划并达到目标。
一般通过 initialize_agent 函数进行 Agent 的初始化，除了 llm、tools 等参数，还需要指定 AgentType。
agent = initialize_agent(agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
tools=tools,
llm=llm,
verbose=True)
print(agent.agent.llm_chain.prompt.template)
该 Agent 为一个 zero-shot-react-description 类型的 Agent，其中 zero-shot 表明只考虑当前的操作，不会记录以及参考之前的操作。react 表明通过 ReAct 框架进行推理，description 表明通过工具的 description 进行是否使用的决策。
其他的类型还有 chat-conversational-react-description、conversational-react-description、react-docstore、self-ask-with-search 等，类似 chat-conversational-react-description 通过 memory 记录之前的对话，应答会参考之前的操作。
可以通过 agent.agent.llm_chain.prompt.template 方法，获取其推理决策所使用的模板。
有多种方式可以自定义 Tool，最简单的方式是通过 @tool 装饰器，将一个函数转为 Tool。注意函数必须得有 docString，其为 Tool 的描述。
from langchain.agents import load_tools, initialize_agent, tool
from langchain.agents.agent_types import AgentType
from datetime import date
# llm = ChatOpenAI(...)
@tool
def time(text: str) -> str:
"""
返回今天的日期。
"""
return str(date.today())
tools = load_tools(['llm-math'], llm=llm)
tools.append(time)
agent_math = initialize_agent(agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
tools=tools,
llm=llm,
verbose=True)
print(agent_math("计算 45 * 54"))
print(agent_math("今天是哪天？"))
输出展示了工具调用的结果。
from langchain.prompts import PromptTemplate
from langchain.document_loaders import PlaywrightURLLoader
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import RecursiveCharacterTextSplitter
# llm = ChatOpenAI(...)
loader = PlaywrightURLLoader(urls=["https://content.jr.jd.com/article/index.html?pageId=708258989"])
data = loader.load()
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
model_name="gpt-3.5-turbo",
allowed_special="all",
separators=["\n\n", "\n", "。", "，"],
chunk_size=7000,
chunk_overlap=0
)
prompt_template = '''
作为一个资深编辑，请针对 >>> 和 <<< 中间的文本写一段摘要。
>>> {text} <<<
'''
refine_template = '''
作为一个资深编辑，基于已有的一段摘要：{existing_answer}，针对 >>> 和 <<< 中间的文本完善现有的摘要。
>>> {text} <<<
'''
PROMPT = PromptTemplate(template=prompt_template, input_variables=["text"])
REFINE_PROMPT = PromptTemplate(
template=refine_template, input_variables=["existing_answer", "text"]
)
chain = load_summarize_chain(llm, chain_type="refine", question_prompt=PROMPT, refine_prompt=REFINE_PROMPT, verbose=False)
docs = text_splitter.split_documents(data)
result = chain.run(docs)
print(result)
from langchain.chains import RetrievalQA
from langchain.document_loaders import WebBaseLoader
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from langchain.prompts import PromptTemplate
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS
# llm = ChatOpenAI(...)
loader = WebBaseLoader("https://in.m.jd.com/help/app/register_info.html")
data = loader.load()
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
model_name="gpt-3.5-turbo",
allowed_special="all",
separators=["\n\n", "\n", "。", "，"],
chunk_size=800,
chunk_overlap=0
)
docs = text_splitter.split_documents(data)
# 设置自己的模型路径
embeddings = HuggingFaceEmbeddings(model_name="text2vec-base-chinese", cache_folder="model")
vectorstore = FAISS.from_documents(docs, embeddings)
template = """请使用下面提供的背景信息来回答最后的问题。如果你不知道答案，请直接说不知道，不要试图凭空编造答案。
回答时最多使用三个句子，保持回答尽可能简洁。回答结束时，请一定要说"谢谢你的提问！"
{context}
问题：{question}
有用的回答:"""
QA_CHAIN_PROMPT = PromptTemplate(input_variables=["context", "question"], template=template)
qa_chain = RetrievalQA.from_chain_type(llm, retriever=vectorstore.as_retriever(),
return_source_documents=True,
chain_type_kwargs={"prompt": QA_CHAIN_PROMPT})
result = qa_chain({"query": "用户注册资格"})
print(result["result"])
print(len(result['source_documents']))
随着大模型的发展，LangChain 应该是目前最火的 LLM 开发框架，能和外部数据源交互、能集成各种常用的组件等等，大大降低了 LLM 应用开发的门槛。其创始人 Harrison Chase 也和 Andrew Ng 联合开发了 2 门短课程，帮助大家快速掌握 LangChain 的使用。
目前大模型的迭代升级特别快，作为一个框架，LangChain 也得保持特别快的迭代速度。其开发特别拼，每天都会提交大量的 commit，基本隔几天就会发布一个新版本，其 Contributor 也达到了 1200 多人，特别活跃。
个人认为，除了和业务结合落地 LLM 应用外，还有 2 个大的方向可以进一步去探索：
此外，评估体系（Evaluation） 也是关键方向。如何量化 LLM 输出的质量、幻觉率以及安全性，建立标准化的 Benchmark 将是企业级应用落地的前提。同时，私有化部署与成本优化 也将持续受到关注，通过量化、蒸馏等技术降低推理成本，结合本地向量数据库保障数据安全。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online