学习Langchain：最全入门指南与实战案例

引言：大模型时代的开发利器

大型语言模型（LLMs）如 OpenAI 的 GPT 系列、Google 的 Gemini、Meta 的 LLaMA 等，凭借其强大的文本生成、理解、推理能力，正在以前所未有的速度改变着我们与计算机交互的方式。然而，直接通过 API 调用 LLMs，虽然能实现基本的问答、文本生成等功能，但要构建一个真正强大、实用、能与外部世界互动（如联网搜索、访问文档、调用 API）、具有记忆和连续性的复杂应用，仅仅依赖简单的 API 调用是远远不够的。

这就引出了一个问题：如何有效地组织和协调这些强大的语言模型，使其能够连接到外部数据源、与其他工具集成，并处理复杂的任务流程？

答案之一，便是 Langchain。

Langchain 是一个用于开发由语言模型驱动的应用程序的框架。它的核心理念是将大型语言模型的能力与其他计算或知识源结合起来，以构建更强大的应用。简单来说，Langchain 提供了一套标准化的接口、集成和链式结构，帮助开发者将 LLM 调用、外部数据、业务逻辑、内存、代理等组件“链接”起来，从而构建出复杂的、智能的应用程序。

本文将带你系统学习 Langchain 的核心概念、关键模块，并通过实战案例深入理解其用法，助你成为 LLM 应用开发的“链”金术士。

第一章：初识 Langchain – 核心概念与安装

1.1 Langchain 是什么？为什么需要它？

Langchain 不是一个语言模型本身，而是一个编排框架（Orchestration Framework）。它就像一个“中枢”，负责协调不同组件（如 LLM、文档加载器、向量数据库、工具等）的工作流程。

我们为什么需要 Langchain？
* 简化复杂流程： 构建一个基于 LLM 的应用往往涉及多个步骤，例如：加载数据 -> 分割文本 -> 生成嵌入 -> 存储到向量数据库 -> 用户提问 -> 检索相关文档 -> 将问题和文档发送给 LLM -> LLM 生成答案。Langchain 提供抽象和标准接口，将这些步骤连接成“链（Chain）”，大大简化开发过程。
* 连接外部数据和工具： LLMs 的知识是有限且有截止日期的。真实应用需要访问实时信息（如天气）、公司文档、数据库等。Langchain 提供了丰富的集成，让 LLMs 能够与这些外部资源互动（通过 Agents 和 Tools）。
* 提供记忆能力： 对于需要多轮对话的应用，LLMs 本身是无状态的。Langchain 提供了记忆模块，使应用能够记住之前的交互历史。
* 模块化与可扩展性： Langchain 的设计是高度模块化的，每个组件（如不同的 LLM、不同的向量数据库、不同的加载器）都可以轻松替换，方便实验和迭代。
* 快速原型开发： 框架提供了许多常用的链和代理模板，可以快速构建原型。

1.2 Langchain 的核心模块

Langchain 的强大之处在于其模块化的设计。框架主要围绕以下六个核心组件构建：

Models (模型): 与各种语言模型的接口。包括传统的 LLMs（文本补全）和 Chat Models（基于消息的对话模型），以及 Embeddings 模型（将文本转换为向量）。
Prompts (提示): 管理和优化给语言模型的输入提示词。包括 Prompt Templates（提示词模板）和 Chat Prompt Templates（对话提示词模板）。
Indexes (索引): 处理用户自己的数据（非模型训练数据）。包括 Document Loaders（文档加载器）、Text Splitters（文本分割器）、Vector Stores（向量存储）、Retrievers（检索器）。这是实现基于文档问答（RAG – Retrieval Augmented Generation）的关键。
Chains (链): 将多个组件（如模型、提示词、解析器等）串联起来执行特定任务的工作流程。例如，一个简单的链可能是：用户输入 -> Prompt Template -> LLM -> Output Parser -> 最终输出。
Agents (代理): 利用 LLM 作为“推理引擎”，根据用户输入决定调用哪些“工具（Tools）”以及调用顺序来完成任务。这使得应用能够执行搜索、计算、调用 API 等复杂操作。
Memory (记忆): 在链或代理执行过程中保持状态，通常用于存储聊天历史， enabling conversational applications.

理解这六个核心模块的功能及其相互关系，是掌握 Langchain 的关键。

1.3 安装与环境准备

Langchain 主要使用 Python 语言。安装非常简单，通过 pip 包管理器即可：

bash pip install langchain

Langchain 是一个框架，它需要依赖具体的模型、向量数据库、文档加载库等。因此，你需要根据你的需求安装额外的库。

例如，如果你使用 OpenAI 模型：

bash pip install openai # 或者 langchain-openai (新版本推荐)

如果你使用 Chroma 作为向量数据库：

bash pip install chromadb

如果你需要加载 PDF 文件：

bash pip install pypdf

API Key 设置：
大多数 LLM 提供商（如 OpenAI, Anthropic 等）需要 API Key 进行身份验证和计费。通常推荐将 API Key 设置为环境变量。

“`python
import os

假设使用 OpenAI

os.environ[“OPENAI_API_KEY”] = “你的OpenAI API Key”

或者使用 .env 文件管理敏感信息（更推荐）

安装 python-dotenv: pip install python-dotenv

在项目根目录创建 .env 文件，内容如：

OPENAI_API_KEY=”你的OpenAI API Key”

ANTHROPIC_API_KEY=”你的Anthropic API Key”

…

在代码中加载环境变量

from dotenv import load_dotenv

load_dotenv()

os.environ[“OPENAI_API_KEY”] # 现在可以直接访问了

“`

第二章：Langchain 核心模块详解与简单示例

本章将深入讲解 Langchain 的六个核心模块，并提供简单的代码示例帮助理解。

2.1 Models (模型)

Langchain 提供了与多种 LLM 接口的统一抽象。

LLMs: 接收一个字符串作为输入，返回一个字符串作为输出（通常用于文本补全或单轮问答）。
“`python
from langchain_openai import OpenAI # 导入具体模型实现

llm = OpenAI(temperature=0.7) # temperature控制随机性，0为确定性最高
text = “请帮我写一句关于秋天的诗句：”
print(llm.invoke(text)) # 使用invoke方法调用模型
“`
Chat Models: 接收一个消息列表作为输入，返回一个消息作为输出（适用于多轮对话）。消息可以是SystemMessage, HumanMessage, AIMessage 等类型。
“`python
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI # 导入Chat模型实现

chat_model = ChatOpenAI(temperature=0.7)
messages = [
SystemMessage(content=”你是一个乐于助人的AI助手。”),
HumanMessage(content=”请问北京今天天气如何？”)
]
print(chat_model.invoke(messages))
“`
Embeddings: 将文本转换为固定维度的数值向量，用于衡量文本之间的语义相似度。这是向量数据库和 RAG 的基础。
“`python
from langchain_openai import OpenAIEmbeddings

embeddings_model = OpenAIEmbeddings()
text = “这是一个测试文档。”
query = “测试查询”
doc_embedding = embeddings_model.embed_query(text)
query_embedding = embeddings_model.embed_query(query)

print(f”文档向量维度: {len(doc_embedding)}”)

在实际应用中，会计算 doc_embedding 和 query_embedding 之间的相似度

“`

2.2 Prompts (提示)

管理和构造输入给模型（尤其是 LLMs 和 Chat Models）的提示词。

Prompt Templates: 用于生成 LLMs 的字符串提示。
“`python
from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template(
“请告诉我关于{topic}的三个最重要的事实。”
)

使用 format 方法填充变量

formatted_prompt = prompt.format(topic=”人工智能”)
print(formatted_prompt)

可以与LLM结合使用

from langchain.chains import LLMChain

chain = LLMChain(llm=llm, prompt=prompt)

print(chain.run(“气候变化”)) # 新版本推荐使用 Runnable 接口

“`
Chat Prompt Templates: 用于生成 Chat Models 的消息列表。
“`python
from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate

chat_template = ChatPromptTemplate.from_messages([
SystemMessagePromptTemplate.from_template(“你是一个翻译专家，负责将用户输入的文本从{source_language}翻译成{target_language}。”),
HumanMessagePromptTemplate.from_template(“{text}”)
])

messages = chat_template.format_messages(
source_language=”英文”,
target_language=”中文”,
text=”Hello, how are you?”
)
print(messages)

可以与Chat Model结合使用

print(chat_model.invoke(messages))

“`

2.3 Indexes (索引)

处理和组织非结构化数据，使其易于被 LLM 使用，特别是用于检索增强生成（RAG）。

Document Loaders: 从各种来源加载文档（PDF, TXT, 网页, 数据库等）。
“`python
# 示例：从本地txt文件加载
from langchain_community.document_loaders import TextLoader

假设有一个 example.txt 文件

loader = TextLoader(“example.txt”)

documents = loader.load()

print(documents[0].page_content[:100]) # 打印前100个字符

print(documents[0].metadata) # 查看元数据 (如文件名)

`` Langchain 支持非常多的加载器，需要安装对应的库（如pip install unstructured或pip install pypdf` 等）。
Text Splitters: 将大型文档分割成小块（chunks），因为 LLM 的上下文窗口是有限的。分割策略很重要，要尽量保持语义完整性。
“`python
from langchain.text_splitter import RecursiveCharacterTextSplitter

text = “这是一个很长的文本，包含多段内容。我们需要将其分割成适合LLM处理的小块。分割时要考虑保留上下文信息，例如句子或段落的边界。这样可以确保每个小块都能提供有意义的信息。”

text_splitter = RecursiveCharacterTextSplitter(
chunk_size=100, # 每个块的最大字符数
chunk_overlap=20 # 块之间的重叠部分，用于保留上下文
)

chunks = text_splitter.split_text(text)

print(chunks)

`` 常用的分割器有CharacterTextSplitter,RecursiveCharacterTextSplitter` 等。
Vector Stores: 存储文本的嵌入向量，并能快速进行相似度搜索。
“`python
# 示例：使用 Chroma 向量数据库 (需要先生成嵌入)
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings # 使用OpenAI的嵌入模型

documents 是经过 Document Loaders 和 Text Splitters 处理后的文档块列表

例如：documents = text_splitter.split_documents(loader.load())

将文档块和嵌入模型添加到向量存储

vectorstore = Chroma.from_documents(documents, OpenAIEmbeddings())

可以保存到本地

vectorstore = Chroma.from_documents(documents, OpenAIEmbeddings(), persist_directory=”./chroma_db”)

加载本地存储

persisted_vectorstore = Chroma(persist_directory=”./chroma_db”, embedding_function=OpenAIEmbeddings())

进行相似度搜索

query = “关于分割文本有什么重要的？”

relevant_docs = vectorstore.similarity_search(query, k=2) # 搜索最相似的k个文档

print(relevant_docs)

“`
Langchain 支持许多向量数据库，如 FAISS, Pinecone, Weaviate, Qdrant, ChromaDB 等。
Retrievers: 提供了从存储中检索相关文档的抽象接口。向量存储通常会提供一个 as_retriever() 方法。
python # retriever = vectorstore.as_retriever() # query = "关于分割文本有什么重要的？" # retrieved_docs = retriever.invoke(query) # 使用invoke方法检索 # print(retrieved_docs)
Retriever 是连接 Vector Store 和 Chains/Agents 的桥梁。

2.4 Chains (链)

将多个 Langchain 组件（如 Prompt + Model，或 Retriever + Model + Prompt）链接在一起形成一个工作流程。

基本链： LLMChain (Prompt + LLM)， StuffDocumentsChain (将文档填充到单个提示中)。
高级链：
- SequentialChain: 按顺序运行多个链。
- RetrievalQA: 最常用的 RAG 链，结合 Retriever 和 LLM 进行基于文档的问答。
- 不同的 RAG 链类型（load_qa_chain 的 chain_type 参数）：
  - stuff: 将所有检索到的文档“填充”到单个提示中。简单，但受限于 LLM 上下文窗口。
  - map_reduce: 对每个文档独立提问并获得答案，然后将所有答案汇总给 LLM 进行最终总结。适合处理大量文档，但调用 LLM 次数多。
  - refine: 先处理第一个文档，得到初步答案，然后依次将后续文档和当前答案一起提交给 LLM 进行细化。适合需要逐步细化答案的场景，但速度慢。
  - map_rerank: 对每个文档独立提问并获得带得分的答案，然后根据得分排序选择最佳答案。
“`python

示例：一个简单的 LLMChain (在新版本中，使用 Runnable 接口是推荐方式)

from langchain_core.runnables import RunnablePassthrough, RunnableParallel
from langchain_core.output_parsers import StrOutputParser

定义 Prompt, Model, Output Parser

prompt = ChatPromptTemplate.from_template(“请告诉我关于{topic}的三个最重要的事实。”)
model = ChatOpenAI()
output_parser = StrOutputParser()

构建 Runnable 链

| 操作符用于连接不同的组件

chain = (
{“topic”: RunnablePassthrough()} # 输入直接作为topic变量
| prompt
| model
| output_parser
)

调用链

print(chain.invoke(“太阳系”))

示例：一个简单的 RetrievalQA 链 (后续在实战案例中详细展开)

from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(

llm=llm,

chain_type=”stuff”, # 或者 “map_reduce”, “refine”

retriever=retriever

)

query = “你的文档主要讲了什么？”

print(qa_chain.run(query))

“`

2.5 Agents (代理)

代理是 Langchain 中最强大的概念之一。它允许 LLM 根据输入动态地决定执行哪些操作（调用哪些工具）以及执行顺序。

Tools (工具): 代理可以调用的外部功能。Langchain 提供了大量的预定义工具（如搜索、计算器、数据库查询等），也支持自定义工具。
“`python
# 示例：搜索工具 (需要安装并配置搜索引擎API，如 SerpAPI 或 Tavily)
# pip install google-search-results # for SerpAPI
# pip install tavily-python # for Tavily

from langchain_community.tools import DuckDuckGoSearchRun # 免费的搜索工具

search_tool = DuckDuckGoSearchRun()

print(search_tool.invoke(“今天纽约天气如何？”))

“`
Agent Types: 不同的代理类型有不同的决策逻辑。常见的有：
- zero-shot-react-description: 使用 ReAct（Reasoning and Acting）框架，LLM 根据工具的描述进行推理（思考-行动-观察循环）。
- openai-functions: 利用 OpenAI 函数调用能力来决定调用哪个工具。
Agent Executor: 运行代理的引擎。它负责循环调用 LLM 和工具，直到任务完成或达到停止条件。
“`python
# 示例：一个简单的带有搜索工具的代理
# from langchain import hub # 从Langchain hub加载预设的提示词模板
# from langchain.agents import create_react_agent, AgentExecutor
# from langchain_community.tools import DuckDuckGoSearchRun
# from langchain_openai import ChatOpenAI

tools = [DuckDuckGoSearchRun()]

llm = ChatOpenAI(temperature=0)

# 获取 ReAct 代理的提示模板

prompt = hub.pull(“hwchase17/react”)

# 创建 ReAct 代理

agent = create_react_agent(llm, tools, prompt)

# 创建 Agent 执行器

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # verbose=True可以查看代理的思考过程

# 运行代理

agent_executor.invoke({“input”: “今天中国国家主席是谁？”})

``verbose=True` 会打印代理的思考过程 (Thought, Action, Observation)，这对于理解和调试代理非常有用。

2.6 Memory (记忆)

为链或代理提供记住先前交互的能力。

ConversationBufferMemory: 存储完整的聊天历史。
ConversationBufferWindowMemory: 存储最近 K 轮的聊天历史，避免历史过长超出上下文窗口。
ConversationSummaryMemory: 随着对话进行，总结之前的聊天历史。
ConversationSummaryBufferMemory: 结合窗口和总结，先使用窗口，超过窗口大小后开始总结。

“`python
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain_openai import OpenAI # ConversationChain默认使用LLM

创建一个带有记忆的 ConversationChain

memory = ConversationBufferMemory()
llm = OpenAI(temperature=0)
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True # 可以看到prompt中包含了聊天历史
)

进行对话

print(conversation.invoke(“你好！”))

print(conversation.invoke(“我叫小明。”))

print(conversation.invoke(“我的名字是什么？”)) # 模型应该能记住名字

“`
在代理中添加记忆也很常见，通常是将记忆对象传递给 Agent Executor 或 Agent 的构造函数。

第三章：实战案例 – 构建更复杂的 LLM 应用

理解了核心模块后，我们来看两个更贴近实际应用的实战案例。

案例一：基于本地文档的问答系统 (RAG)

需求： 构建一个应用，用户可以上传一个文本文件，然后向应用提问关于文件内容的问题。

技术栈： Document Loader, Text Splitter, Embeddings, Vector Store, Retriever, RetrievalQA Chain.

步骤：

加载文档： 使用 Document Loader 读取本地文件。
分割文本： 将文档分割成适当大小的块。
创建嵌入并存储： 使用 Embeddings 模型生成文本块的向量，并存储到向量数据库中。
创建检索器： 从向量数据库创建检索器。
构建 QA 链： 使用 RetrievalQA Chain 结合检索器和 LLM 来回答问题。
进行问答。

“`python

导入所需库

import os
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA

设置 OpenAI API Key

os.environ[“OPENAI_API_KEY”] = “YOUR_OPENAI_API_KEY” # 替换为你的Key或使用dotenv

假设有一个名为 “my_document.txt” 的文件，内容如下：

——————–

这是一篇关于人工智能（AI）的文档。

人工智能是计算机科学的一个领域，旨在创建能够执行需要人类智能的任务的机器。

这些任务包括学习、问题解决、模式识别和语言理解。

AI 的应用非常广泛，包括自动驾驶汽车、医疗诊断、自然语言处理等。

目前，大型语言模型（LLMs）是AI领域的热点之一。

LLMs 在处理和生成文本方面表现出色，是许多现代AI应用的核心。

Langchain 是一个用于开发由语言模型驱动的应用程序的框架。

它通过链接不同的组件来构建更强大的应用。

——————–

请确保你创建了这个文件

1. 加载文档

loader = TextLoader(“my_document.txt”)
documents = loader.load()
print(f”加载了 {len(documents)} 个文档。”)

2. 分割文本

text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=20)
texts = text_splitter.split_documents(documents)
print(f”分割成 {len(texts)} 个文本块。”)

print(texts[0]) # 打印第一个文本块看看

3. 创建嵌入并存储到向量数据库

使用 OpenAI 的嵌入模型

embeddings = OpenAIEmbeddings()

使用 Chroma 作为向量数据库，将文本块和嵌入模型传入

可以选择持久化到本地目录

persist_directory = “./chroma_db”
vectorstore = Chroma.from_documents(texts, embeddings, persist_directory=persist_directory)

如果已经持久化过，可以直接加载

vectorstore = Chroma(persist_directory=persist_directory, embedding_function=embeddings)

print(“文本嵌入并存储到向量数据库完成。”)

4. 创建检索器

retriever = vectorstore.as_retriever(search_kwargs={“k”: 2}) # 检索最相关的2个文档块

5. 构建 QA 链

使用 ChatOpenAI 作为问答模型

llm = ChatOpenAI(temperature=0)

使用 RetrievalQA 链，链类型为 “stuff”

qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type=”stuff”, # 将所有检索到的文档填充到一个prompt中
retriever=retriever,
return_source_documents=True # 返回检索到的源文档
)

print(“QA 链构建完成。”)

6. 进行问答

query = “请问文档主要讲了什么？AI有哪些应用？”
result = qa_chain.invoke({“query”: query})

print(“\n— 查询结果 —“)
print(f”问题: {query}”)
print(f”回答: {result[‘result’]}”)
print(“\n— 参考文档 —“)
for doc in result[‘source_documents’]:
print(f”- {doc.page_content[:100]}…”) # 打印文档块的前100个字符

另一个问题

query = “Langchain是什么？”
result = qa_chain.invoke({“query”: query})

这个案例演示了如何将非结构化文档转化为可供 LLM 检索和理解的知识库，这是构建智能客服、文档分析等应用的基础。

案例二：一个具有搜索和计算能力的对话代理

需求： 构建一个能够进行多轮对话，并且在需要时能够使用搜索引擎查找信息或进行简单计算的助手。

技术栈： Chat Model, Tools (Search, Calculator), Memory, Agent, Agent Executor.

步骤：

加载模型： 使用 Chat Model。
定义工具： 定义搜索工具和计算器工具。
配置记忆： 添加记忆功能以支持多轮对话。
创建代理： 使用 Chat Model、工具和提示词创建代理。
创建 Agent 执行器： 将代理和工具传入 Agent Executor。
进行多轮对话。

“`python

导入所需库

import os
from langchain_openai import ChatOpenAI

导入常用的工具

from langchain_community.tools import DuckDuckGoSearchRun # 免费搜索工具
from langchain_community.tools.utility import ArxivSearch # 查询Arxiv论文
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub # 用于获取标准prompt
from langchain.memory import ConversationBufferMemory # 对话记忆

设置 OpenAI API Key

os.environ[“OPENAI_API_KEY”] = “YOUR_OPENAI_API_KEY” # 替换为你的Key或使用dotenv

1. 加载 Chat Model

llm = ChatOpenAI(temperature=0, model=”gpt-4o-mini”) # 可以选择更便宜的模型进行测试

2. 定义工具

免费搜索工具

search_tool = DuckDuckGoSearchRun()

Arxiv 论文搜索工具

arxiv_tool = ArxivSearch()

tools = [search_tool, arxiv_tool]

3. 配置记忆

使用 ConversationBufferMemory 来存储完整的对话历史

memory = ConversationBufferMemory(memory_key=”chat_history”, return_messages=True)

4. 获取 Agent 提示模板

使用 Langchain Hub 中预设的 ReAct agent prompt

这个prompt包含了如何让LLM进行思考（Thought）和行动（Action）的指令

prompt = hub.pull(“hwchase17/react-chat”) # 注意这里是react-chat，包含了对chat_history的处理

5. 创建 ReAct 代理

create_react_agent 函数会根据prompt、llm和tools创建一个代理

agent = create_react_agent(llm, tools, prompt)

6. 创建 Agent 执行器

AgentExecutor 是实际运行代理的引擎

verbose=True 会打印出代理的思考过程和每一步的行动及观察

memory=memory 将记忆添加到执行器中

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

print(“对话代理已启动，输入 ‘退出’ 结束对话。”)

7. 进行多轮对话

while True:
user_input = input(“你: “)
if user_input.lower() == ‘退出’:
break

try:
    # agent_executor.invoke 接收一个字典作为输入，包含了用户输入和聊天历史
    response = agent_executor.invoke({"input": user_input})
    print(f"AI: {response['output']}")
except Exception as e:
    print(f"AI: 抱歉，处理请求时出错：{e}")
    # 在实际应用中，你可能需要更健壮的错误处理

`` 这个案例展示了代理如何通过调用工具来扩展 LLM 的能力，使其能够执行更复杂的任务，并利用记忆保持对话的连贯性。当你提问需要外部知识（如“奥巴马总统任期是多久？”）或计算（如果你添加了计算器工具并修改prompt/agent类型），代理会利用搜索工具来获取信息。verbose=True` 输出将清晰地展示代理是如何分析问题、选择工具、执行工具并根据观察结果生成最终回答的。

第四章：进阶与展望

学习 Langchain 不止于此，框架还有许多更高级的特性和相关的生态工具：

LangGraph: 基于图结构构建更复杂、更灵活的代理和流程。
Langserve: 部署 Langchain 应用为 REST API。
Langsmith: 用于调试、测试、评估和监控 Langchain 应用的平台。
Customizing Components: 构建自己的 Document Loader, Tool, Chain 等。
Streaming: 实现模型输出的流式传输，提升用户体验。
Callbacks: 在链或代理执行的各个阶段触发自定义操作（如日志记录、进度显示）。
Integrating with other models/services: 除了 OpenAI，Langchain 支持几乎所有主流的 LLM 供应商和各种数据库、API 等。

Langchain 生态发展迅速，API 变化较快，保持关注官方文档和社区是持续学习的关键。同时，LlamaIndex 等其他类似的框架也在发展，了解它们的长处和异同也很有价值。

第五章：总结与建议

Langchain 是当前构建由大型语言模型驱动的复杂应用的强大且流行的框架。它通过提供一套标准的接口和模块，极大地简化了将 LLM 与外部数据、工具和记忆结合起来的过程。

通过本文的学习，你应该对 Langchain 的核心概念（Models, Prompts, Indexes, Chains, Agents, Memory）有了深入理解，并通过 RAG 和代理案例掌握了如何将这些模块组合起来构建实际应用。

学习建议：

动手实践： 最好的学习方式是写代码。运行本文的示例，并尝试修改它们。
阅读文档： Langchain 的官方文档是学习的宝库，虽然内容庞大且更新频繁，但它是最权威的参考资料。
探索更多集成： 尝试将 Langchain 与你熟悉的数据库、API 或其他服务结合。
研究 Langchain Hub： 学习社区贡献的各种链和代理模板。
关注社区： 参与 Langchain 的 Discord 频道、GitHub 仓库，了解最新动态和常见问题。
从简单开始： 不要一开始就尝试构建过于复杂的系统，先掌握基本模块和简单链，再逐步深入代理和 LangGraph。

Langchain 为开发者打开了构建下一代智能应用的大门。掌握它，你就能更高效、更灵活地利用 LLM 的强大能力，创造出更多可能性。现在，就开始你的 Langchain “链”金之旅吧！

学习Langchain：最全入门指南与实战案例

引言：大模型时代的开发利器

第一章：初识 Langchain – 核心概念与安装

1.1 Langchain 是什么？为什么需要它？

1.2 Langchain 的核心模块

1.3 安装与环境准备

假设使用 OpenAI

或者使用 .env 文件管理敏感信息（更推荐）

安装 python-dotenv: pip install python-dotenv

在项目根目录创建 .env 文件，内容如：

OPENAI_API_KEY=”你的OpenAI API Key”

ANTHROPIC_API_KEY=”你的Anthropic API Key”

…

在代码中加载环境变量

from dotenv import load_dotenv

load_dotenv()

os.environ[“OPENAI_API_KEY”] # 现在可以直接访问了

第二章：Langchain 核心模块详解与简单示例

2.1 Models (模型)

在实际应用中，会计算 doc_embedding 和 query_embedding 之间的相似度

2.2 Prompts (提示)

使用 format 方法填充变量

可以与LLM结合使用

from langchain.chains import LLMChain

chain = LLMChain(llm=llm, prompt=prompt)

print(chain.run(“气候变化”)) # 新版本推荐使用 Runnable 接口

可以与Chat Model结合使用

print(chat_model.invoke(messages))

2.3 Indexes (索引)

假设有一个 example.txt 文件

loader = TextLoader(“example.txt”)

documents = loader.load()

print(documents[0].page_content[:100]) # 打印前100个字符

print(documents[0].metadata) # 查看元数据 (如文件名)

print(chunks)

documents 是经过 Document Loaders 和 Text Splitters 处理后的文档块列表

例如：documents = text_splitter.split_documents(loader.load())

将文档块和嵌入模型添加到向量存储

vectorstore = Chroma.from_documents(documents, OpenAIEmbeddings())

可以保存到本地

vectorstore = Chroma.from_documents(documents, OpenAIEmbeddings(), persist_directory=”./chroma_db”)

加载本地存储

persisted_vectorstore = Chroma(persist_directory=”./chroma_db”, embedding_function=OpenAIEmbeddings())

进行相似度搜索

query = “关于分割文本有什么重要的？”

relevant_docs = vectorstore.similarity_search(query, k=2) # 搜索最相似的k个文档

print(relevant_docs)

2.4 Chains (链)

示例：一个简单的 LLMChain (在新版本中，使用 Runnable 接口是推荐方式)

定义 Prompt, Model, Output Parser

构建 Runnable 链

| 操作符用于连接不同的组件

调用链

print(chain.invoke(“太阳系”))

示例：一个简单的 RetrievalQA 链 (后续在实战案例中详细展开)

from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(

llm=llm,

chain_type=”stuff”, # 或者 “map_reduce”, “refine”

retriever=retriever

)

query = “你的文档主要讲了什么？”

print(qa_chain.run(query))

2.5 Agents (代理)

from langchain_community.tools import DuckDuckGoSearchRun # 免费的搜索工具

search_tool = DuckDuckGoSearchRun()

print(search_tool.invoke(“今天纽约天气如何？”))

tools = [DuckDuckGoSearchRun()]

llm = ChatOpenAI(temperature=0)

# 获取 ReAct 代理的提示模板

prompt = hub.pull(“hwchase17/react”)

# 创建 ReAct 代理

agent = create_react_agent(llm, tools, prompt)

# 创建 Agent 执行器

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # verbose=True可以查看代理的思考过程

# 运行代理

agent_executor.invoke({“input”: “今天中国国家主席是谁？”})

2.6 Memory (记忆)

创建一个带有记忆的 ConversationChain

进行对话

发表评论取消回复