Langchain是一个用于开发由语言模型驱动的应用程序的框架，它提供了一系列标准化的接口和模块，帮助开发者更轻松、高效地构建LLM应用。通过连接外部数据、赋予LLM使用工具的能力、维护对话状态等，Langchain简化了LLM应用的构建，并提供了一个结构化的、模块化的框架，让开发者专注于业务逻辑，而不是底层细节。本文介绍了Langchain的核心概念，并演示了如何使用Langchain构建一个简单的问答机器人。

💡Langchain 框架的核心在于其模块化设计，开发者可以像搭积木一样组合各种组件。

🔑Langchain 提供了与不同 LLM 提供商交互的标准化接口，如DeepSeek、OpenAI等，简化了模型调用。

📝通过 PromptTemplates，Langchain 能够帮助开发者轻松构建和优化提示词模板，提高提示词的可维护性和复用性。

🔗Chains是Langchain的核心抽象，它将多个组件组合成一个端到端的工作流，使构建多步骤的、复杂的 LLM 应用变得直观和模块化。

🛠️Agents赋予了LLM规划和执行动作的能力，使其从被动的文本生成器转变为主动的问题解决者。

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

简单来说，Langchain 是一个用于开发由语言模型驱动的应用程序的框架。它不是一个模型本身，而是一个工具集，一套库，旨在帮助开发者更轻松、更高效地构建那些以大语言模型为核心的应用。

你可以把 Langchain 想象成一个“编排者”或者“连接器”。它提供了一系列标准化的接口和模块，让你能够方便地将强大的 LLM 能力，与外部数据（比如你的文档、数据库、网页信息）、计算工具（比如计算器、搜索引擎、API 服务）以及用户输入、对话历史等各种元素连接起来，形成一个完整、流畅的工作流程。

为什么我们需要这样一个框架呢？正如我们在前面中提到的，直接调用 LLM API 有其局限性。构建一个实用的 LLM 应用，往往需要处理以下这些问题：

管理复杂的提示词（Prompt）：  随着应用逻辑的复杂化，给 LLM 的提示词会变得越来越长、越来越结构化。手动拼接和管理这些提示词既繁琐又容易出错。连接外部数据：  LLM 的知识是基于训练数据的，无法获取实时信息或访问私有数据。我们需要一种方式，让 LLM 能够查询外部数据源，并将查询结果纳入其生成的内容中（这通常被称为 RAG - Retrieval Augmented Generation 模式）。赋予 LLM 使用工具的能力：  LLM 本身只能处理文本，它不能执行计算、搜索网页或调用外部 API。但很多任务需要这些能力。我们需要一个机制，让 LLM 能够根据需要，自主决定使用哪些工具来完成任务。维护对话状态（记忆）：  对于聊天机器人等应用，LLM 需要记住之前的对话内容，以便进行连贯的多轮交流。这需要一个有效的记忆管理机制。构建多步骤的工作流：  很多复杂的任务需要 LLM 执行一系列操作，比如先搜索信息，然后总结信息，最后根据总结回答用户问题。这需要将多个 LLM 调用和外部操作串联起来，形成一个“链式”的工作流。

正是为了解决这些问题，Langchain 应运而生。它提供了一系列抽象和组件，极大地简化了上述复杂性的处理：

它提供了标准化的接口来与不同的 LLM 提供商（如 DeepSeek, OpenAI 等）交互。它提供了强大的提示词管理工具，让你轻松构建和优化提示词模板。它提供了文档加载器、文本分割器、向量存储等工具，方便你处理和索引外部数据，实现 RAG。它引入了“代理”（Agents）的概念，让 LLM 能够像一个智能体一样，根据任务目标自主选择并使用外部工具。它提供了记忆模块，帮助你在多轮对话中维护上下文。最核心的是，它提供了“链”（Chains）的概念，让你能够将上述各种组件像积木一样组合起来，构建出复杂的、端到端的工作流程。

总而言之，Langchain 的价值在于，它提供了一个结构化的、模块化的框架，将 LLM 的能力从一个简单的文本输入输出接口，扩展为一个能够与外部世界交互、执行复杂任务的强大引擎。它让开发者能够专注于构建应用的业务逻辑，而不是纠缠于底层 LLM 调用和外部集成的细节。

Langchain 的核心概念

Langchain 框架并非一个单一的黑箱，而是由一系列精心设计的模块组成的。理解这些核心模块，是快速掌握 Langchain 并构建复杂应用的关键。你可以把它们想象成一个工具箱里的各种工具，或者一套乐高积木，你可以根据需要自由组合它们。

下面，我们来逐一介绍 Langchain 中最重要的几个核心概念：

Models (模型):  这是 Langchain 与各种大语言模型交互的接口。Langchain 支持市面上绝大多数主流的 LLM 提供商，比如 DeepSeek、OpenAI、Hugging Face Hub 等等。它将不同模型的 API 调用进行了封装，为你提供统一的接口。 在 Langchain 中，模型接口主要分为两类：

LLMs: 传统的文本补全模型接口，输入一段文本，输出一段补全的文本。ChatModels: 针对聊天场景优化的模型接口，输入是消息列表（包含角色如 System, Human, AI），输出是 AI 的回复消息。 理解这两者的区别很重要，因为它们适用于不同的应用场景。

Prompts (提示):  给大模型的输入，也就是我们常说的“提示词”（Prompt），其质量直接影响输出结果。Langchain 提供了强大的提示词管理工具。

PromptTemplates (提示模板):  这是最常用的工具。它允许你创建带有变量的提示词模板，然后根据用户的输入或其他信息动态地填充这些变量，生成最终发送给 LLM 的提示词。这极大地提高了提示词的可维护性和复用性。Output Parsers (输出解析器):  有时你需要 LLM 的输出具有特定的结构（比如 JSON 格式）。输出解析器可以帮助你解析 LLM 的原始文本输出，并将其转换为结构化的数据格式。

Chains (链):  Langchain 的核心抽象之一就是“链”（Chain）。链是将多个组件（比如一个 PromptTemplate 和一个 LLM）组合成一个端到端的工作流的方式。 最简单的链可能只是将用户的输入通过一个提示模板格式化后发送给 LLM。更复杂的链可以包含多个步骤，比如先调用一个 LLM 生成一个问题，然后用这个问题去查询一个数据库，再将查询结果和原始问题一起发送给另一个 LLM 进行总结。 链的概念让构建多步骤的、复杂的 LLM 应用变得非常直观和模块化。

Indexes (索引):  当我们需要让大模型与外部数据（比如你的文档库、网页内容、数据库记录）交互时，“索引”（Indexes）模块就派上用场了。这个模块主要用于结构化文档，以便 LLM 可以有效地与之交互，尤其是在实现 RAG (Retrieval Augmented Generation) 模式时。 它包含几个关键子模块：

Document Loaders (文档加载器):  从各种来源（文件、网页、数据库等）加载文档。Text Splitters (文本分割器):  将长文档分割成更小的、适合模型处理的文本块（chunks）。Vector Stores (向量存储):  将文本块转换为向量嵌入，并存储起来，通常使用向量数据库。Retrievers (检索器):  根据用户的查询，从向量存储中检索出最相关的文本块。 这些组件协同工作，使得 LLM 能够“查阅”外部信息来回答问题。

Agents (代理):  “代理”（Agents）是 Langchain 中一个非常强大且富有想象力的概念。它赋予了 LLM 规划和执行动作的能力。一个 Agent 会根据用户的输入，决定需要采取哪些步骤来完成任务，包括决定使用哪些“工具”（Tools）。 工具可以是任何外部功能，比如：

搜索引擎（用于获取实时信息）计算器（用于执行数学计算）数据库查询工具自定义的 API 调用 Agent 的工作流程通常是：接收输入 -> LLM 思考并决定下一步行动（使用哪个工具，输入是什么）-> 执行工具 -> 观察工具输出 -> LLM 再次思考并决定下一步，直到任务完成。这让 LLM 从一个被动的文本生成器变成了一个主动的问题解决者。

Memory (记忆):  对于需要多轮对话的应用，比如聊天机器人，让模型记住之前的交流内容至关重要，这样它才能理解上下文并进行连贯的回复。Memory 模块就是用来在链或 Agent 的多次调用之间持久化状态（通常是对话历史）的。Langchain 提供了多种类型的 Memory 实现，以适应不同的需求。

这些核心模块是构建 Langchain 应用的基石。在接下来的部分，我们将通过实际的代码示例，看看如何将这些模块组合起来，构建一个简单的应用。

快速上手：安装与基本配置

理论讲得再多，不如动手实践。要开始使用 Langchain 构建应用，我们首先需要搭建好开发环境。这里，我们将采用一些现代化的工具，而不是完全依赖传统的 pip。我们将使用 uv 作为包管理器，它以其惊人的速度著称，是 pip 和 venv 的有力替代者。同时，我们将选择 DeepSeek 作为我们的 LLM 提供商，并使用 python-dotenv 来安全地管理 API 密钥。

1. 安装 uv

首先，确保你的系统安装了 Python 3.12 或更高版本。然后，我们需要安装 uv。最推荐的方式是使用其官方提供的独立安装脚本，这样可以避免依赖系统已有的 pip：

curl -LsSf https://astral.sh/uv/install.sh | sh

或者，如果你已经有 pip 并且不介意用它来安装 uv 本身：

pip install uv

安装完成后，验证一下 uv 是否可用：

uv --version

2. 初始化项目

接下来，我们使用 uv 来初始化一个新的项目目录。假设我们要构建一个简单的问答机器人，我们可以这样初始化：

uv init qa_bot

这个命令会创建一个名为 qa_bot 的新目录，并在其中生成一个标准的 pyproject.toml 文件。pyproject.toml 是现代 Python 项目的标准配置文件，用于管理依赖、项目元数据等。

现在，进入项目目录：

cd qa_bot

初始化 venv 环境

uv venv

通过 uv venv 我们自动初始化 .venv 环境，然后激活这环境

source .venv/bin/activate``**3. 添加必要的依赖**我们需要安装 Langchain 核心库、DeepSeek 的 Langchain 集成库以及用于加载环境变量的 `python-dotenv`。使用 `uv add` 命令来添加这些依赖：```bashuv add langchain langchain-deepseek python-dotenv

uv 会读取 pyproject.toml，解析依赖关系，并快速地将这些库安装到项目关联的虚拟环境中。同时，它会生成或更新一个 uv.lock文件，精确锁定所有依赖的版本，确保环境的可复现性。

4. 配置 LLM 提供商 (DeepSeek) 和 API 密钥

要使用 DeepSeek 的服务，你需要一个 API 密钥。请前往 DeepSeek 官方网站注册并获取你的 API Key。

非常重要的一点：  永远不要将你的 API 密钥直接写在代码里！这不仅不安全，也不便于管理。我们应该使用环境变量来存储敏感信息。dotenv 这个库就是用来帮助我们加载 .env 文件中的环境变量的。

在你的项目根目录（qa_bot 目录下），创建一个名为 .env 的新文件：

touch .env

注意： 不要将 .env 提交到代码仓库，可以使用 .gitignore 过滤掉这个文件。

然后用文本编辑器打开 .env 文件，添加你的 DeepSeek API 密钥，格式如下：

DEEPSEEK_API_KEY=你的DeepSeek_API_密钥

请务必将 你的DeepSeek_API_密钥 替换成你实际获取到的 DeepSeek API 密钥。注意等号两边不要有空格。

在 Python 代码中，我们将使用 dotenv 来加载这个文件中的变量。

5. 验证环境配置

为了确认一切设置正确，我们创建一个简单的 Python 文件来测试。在 qa_bot 目录下创建一个 main.py 文件：

touch main.py

编辑 main.py，添加以下内容：

import osfrom dotenv import load_dotenvfrom langchain_deepseek import DeepseekChat # 导入 DeepSeek 的 Chat 模型接口# 加载 .env 文件中的环境变量load_dotenv()# 尝试获取 DeepSeek API Keydeepseek_api_key = os.getenv("DEEPSEEK_API_KEY")if deepseek_api_key:    # 尝试初始化 DeepseekChat 对象 (这步不会实际调用API，只是检查库是否可用)    try:        chat_model = DeepseekChat(model="deepseek-chat") # 使用一个 DeepSeek 支持的模型名称        print(f"Langchain DeepseekChat 模型对象创建成功，使用的模型是: {chat_model.model_name}")    except Exception as e:        print(f"创建 DeepseekChat 模型对象时出错: {e}")else:    print("错误：无法加载 DeepSeek API Key。请检查 .env 文件是否存在且格式正确，以及是否设置了 DEEPSEEK_API_KEY。")print("\n环境配置初步验证完成。")

保存文件后，在 qa_bot 目录下运行这个脚本：

uv run main.py

uv run 会在当前项目的虚拟环境中执行指定的命令。如果一切顺利，你应该会看到类似这样的输出：

DeepSeek API Key 加载成功！Langchain DeepseekChat 模型对象创建成功，使用的模型是: deepseek-chat环境配置初步验证完成。

如果出现错误，请仔细检查前面的步骤，特别是 .env 文件名、文件内容、API 密钥是否正确，以及是否在 qa_bot 目录下运行的命令。

至此，我们已经成功搭建了使用 uv 管理依赖、通过 dotenv 配置 API 密钥、并准备好使用 Langchain 和 DeepSeek 的开发环境。接下来，我们将利用这些基础，开始构建我们的第一个 Langchain 应用。

构建你的第一个 Langchain 应用：一个简单的问答机器人

理论知识的学习固然重要，但最好的学习方式还是通过实践。现在，让我们利用前面搭建好的环境，构建一个最简单的 Langchain 应用：一个能够回答你提出问题的机器人。

我们将从最基础的 LLM 调用开始，逐步引入 Langchain 的核心组件，看看它们如何让开发变得更简单、更灵活。

在你的 qa_bot 项目目录下，打开或创建 main.py 文件。

步骤一：最基础的 LLM 调用

首先，我们尝试直接调用 DeepSeek 模型来回答一个固定的问题。这就像直接使用 API，不涉及 Langchain 的高级功能。

python

import osfrom dotenv import load_dotenvfrom langchain_deepseek import DeepseekChat# 注意：这里我们暂时不导入 PromptTemplate 和 Chain，先看最原始的方式# 加载 .env 文件中的环境变量load_dotenv()# 获取 DeepSeek API Keydeepseek_api_key = os.getenv("DEEPSEEK_API_KEY")if not deepseek_api_key:    print("错误：无法加载 DeepSeek API Key。请检查 .env 文件。")    exit() # 如果没有 Key，直接退出# 初始化 DeepSeek Chat 模型# 使用 DeepSeek 支持的聊天模型名称，例如 "deepseek-chat"chat_model = DeepseekChat(model="deepseek-chat", api_key=deepseek_api_key)# 定义一个固定的问题question = "Python 语言有什么特点？"print(f"提问：{question}")# 直接调用模型来获取回答# 对于 ChatModel，我们通常传入一个消息列表# Langchain 的 ChatModel 接口可以直接接受一个字符串作为人类消息response = chat_model.invoke(question)# 打印模型的回复内容print("\n回答：")print(response.content) # ChatModel 的输出是一个消息对象，内容在 .content 属性里

保存 main.py 文件。在终端中，确保你在 qa_bot 目录下，然后运行：

uv run python main.py

你应该会看到 DeepSeek 模型对“Python 语言有什么特点？”这个问题的回答。

这段代码非常直观：加载配置，初始化模型，然后把问题直接扔给模型。这确实能工作，但问题在于，如果我想问别的问题，我就得修改代码中的 question 变量。这显然不够灵活，也无法处理用户动态输入。

步骤二：引入 Prompt Template 让输入更灵活

为了让我们的问答机器人能够回答用户提出的任何问题，我们需要一个机制来动态地构建发送给 LLM 的提示词。这就是 PromptTemplate的作用。

修改 main.py 文件，引入 PromptTemplate：

python

import osfrom dotenv import load_dotenvfrom langchain_deepseek import DeepseekChatfrom langchain_core.prompts import PromptTemplate # 导入 PromptTemplate# ... (加载环境变量和初始化 chat_model 的代码保持不变) ...load_dotenv()deepseek_api_key = os.getenv("DEEPSEEK_API_KEY")if not deepseek_api_key:    print("错误：无法加载 DeepSeek API Key。请检查 .env 文件。")    exit()chat_model = DeepseekChat(model="deepseek-chat", api_key=deepseek_api_key)# ... (以上代码不变) ...# 定义一个带有变量的提示词模板# 模板中使用花括号 {} 包围变量名template = """你是一个乐于助人的AI助手。请根据用户的问题提供简洁明了的回答。用户的问题：{question}回答："""# 创建 PromptTemplate 对象# input_variables 参数指定了模板中包含哪些变量prompt = PromptTemplate(    input_variables=["question"],    template=template,)# 假设用户输入的问题user_question = "地球的周长是多少？"# 使用模板格式化用户输入，生成最终的提示词# format 方法接收一个字典，键是变量名，值是变量的值formatted_prompt = prompt.format(question=user_question)print(f"用户提问：{user_question}")print(f"发送给模型的完整提示词：\n---\n{formatted_prompt}\n---")# 将格式化后的提示词发送给模型response = chat_model.invoke(formatted_prompt)# 打印模型的回复内容print("\n回答：")print(response.content)

再次运行 uv run python main.py。这次，虽然我们仍然在代码中指定了 user_question，但我们使用了 PromptTemplate 来构建发送给模型的完整提示词。你可以轻松修改 user_question 的值，而无需改变提示词的整体结构。

PromptTemplate 让我们能够将提示词的结构与具体输入内容分离，这对于构建可复用和易于管理的提示词非常有用。

步骤三：构建一个简单的 Chain

现在我们有了动态生成提示词的能力，以及调用 LLM 的能力。Langchain 的“链”（Chain）概念就是用来将这些独立的步骤连接起来，形成一个流畅的工作流。

在 Langchain 的新版本中，推荐使用 LangChain Expression Language (LCEL) 来构建链，它非常灵活且易于组合。一个简单的链可以表示为 PromptTemplate | ChatModel，意思是“先执行 PromptTemplate，然后将其输出作为输入发送给 ChatModel”。

让我们修改 main.py，使用 LCEL 构建这个简单的问答链：

python

import osfrom dotenv import load_dotenvfrom langchain_deepseek import DeepseekChat# 导入 ChatPromptTemplate，LCEL 通常与 ChatPromptTemplate 配合使用from langchain_core.prompts import ChatPromptTemplate# 导入 Runnable 相关的类型提示，虽然不是必须的，但有助于理解 LCELfrom langchain_core.runnables import Runnable# ... (加载环境变量和初始化 chat_model 的代码保持不变) ...load_dotenv()deepseek_api_key = os.getenv("DEEPSEEK_API_KEY")if not deepseek_api_key:    print("错误：无法加载 DeepSeek API Key。请检查 .env 文件。")    exit()chat_model = DeepseekChat(model="deepseek-chat", api_key=deepseek_api_key)# ... (以上代码不变) ...# 使用 ChatPromptTemplate 定义提示词模板# from_template 方法更简洁chat_template = ChatPromptTemplate.from_template(    """你是一个乐于助人的AI助手。请根据用户的问题提供简洁明了的回答。用户的问题：{question}回答：""")# 使用 LCEL 构建链：将 chat_template 的输出通过管道 | 发送给 chat_model# 链的输入是 chat_template 需要的变量 (这里是 "question")# 链的输出是 chat_model 的输出 (一个 AIMessage 对象)qa_chain: Runnable = chat_template | chat_model# 现在，我们可以直接调用这个链，并传入用户的问题user_question = "光速是多少？"print(f"用户提问：{user_question}")# 调用链，传入一个字典，键是模板变量名response = qa_chain.invoke({"question": user_question})# 打印链的输出内容print("\n回答：")print(response.content)# 你可以轻松地问另一个问题user_question_2 = "水的化学式是什么？"print(f"\n用户提问：{user_question_2}")response_2 = qa_chain.invoke({"question": user_question_2})print("\n回答：")print(response_2.content)

再次运行 uv run python main.py。你会看到程序依次回答了两个问题。

这段代码展示了 Langchain 的核心魅力：通过链（Chain），我们将提示词模板和语言模型这两个独立的组件连接起来，形成了一个可执行的工作流。我们不再需要手动调用 prompt.format() 然后再调用 chat_model.invoke()。我们只需要调用 qa_chain.invoke()，并传入模板所需的输入变量（一个字典），链会自动处理中间的步骤。

这个简单的 chat_template | chat_model 链，就是我们第一个 Langchain 应用的核心。它接收一个问题，通过模板构建提示词，然后将提示词发送给 DeepSeek 模型，最后返回模型的回答。

通过这三个步骤，我们从最原始的模型调用，逐步过渡到使用 PromptTemplate 管理输入，最终利用 Chain 将它们优雅地组合起来。这正是 Langchain 简化 LLM 应用开发的方式。

进阶一瞥：连接外部数据 (RAG 模式简介)

到目前为止，我们的问答机器人只能回答那些 DeepSeek 模型在其训练数据中已经学到的知识。比如“Python 有什么特点”、“光速是多少”这类通用问题。但如果我问它：“我的电脑里，那个叫做 '项目报告.pdf' 的文件里写了什么？”或者“我们公司最新的财报数据是多少？”——它就无能为力了。因为这些信息不在它的训练数据里，或者信息是私有的、实时的。

如何让强大的 LLM 能够“阅读”并利用我们自己的、外部的、甚至是实时的信息来回答问题呢？这就是 检索增强生成（Retrieval Augmented Generation, RAG）  模式的核心思想。

RAG 的基本流程是这样的：

检索 (Retrieval):  当用户提出一个问题时，我们首先不是直接问 LLM，而是根据这个问题，去我们的外部数据源（比如文档库、数据库、网页）中“检索”出最相关的、最有可能包含答案的信息片段。增强 (Augmentation):  将用户的问题和检索到的相关信息片段一起，构建一个新的、更丰富的提示词。生成 (Generation):  将这个增强后的提示词发送给 LLM，让 LLM 利用这些提供的上下文信息来生成最终的回答。

你可以把这想象成：用户问你一个问题，你不是凭空回答，而是先快速翻阅一下手头的相关资料（检索），找到关键段落，然后结合这些段落和用户的问题，组织出你的回答（增强和生成）。

Langchain 为实现 RAG 模式提供了强大的支持，它将整个流程分解为几个模块化的步骤，这些步骤主要体现在我们前面提到的“Indexes”模块中：

文档加载 (Document Loading):  Langchain 提供了各种 DocumentLoader，可以从多种来源加载数据，比如 PDF 文件、网页、CSV 文件、数据库等等，将它们转换为 Langchain 内部的 Document 对象格式。文本分割 (Text Splitting):  加载进来的文档可能很长，而 LLM 的上下文窗口是有限的。我们需要将长文档分割成更小的、有意义的文本块（chunks）。TextSplitter 负责这项工作，它会尽量在句子或段落边界进行分割，同时保留一定的上下文重叠。文本嵌入 (Text Embedding):  为了能够根据用户的问题“检索”到相关的文本块，我们需要将文本块和用户的问题都转换成数值向量。这些向量能够捕捉文本的语义信息，使得语义相似的文本在向量空间中距离较近。Langchain 提供了各种 Embeddings 模型接口。向量存储 (Vector Stores):  将分割后的文本块及其对应的向量嵌入存储到向量数据库中。向量数据库专门优化了向量的存储和相似性搜索。Langchain 集成了多种向量数据库，如 Chroma、FAISS、Pinecone、Weaviate 等。检索器 (Retrievers):  Retriever 是一个接口，它接收用户的查询（问题），将其转换为向量，然后在向量存储中执行相似性搜索，找出与用户问题最相关的文本块，并将这些文本块返回。

RAG 模式在 Langchain 中的概念流程 (使用 LCEL 视角):

虽然构建一个完整的 RAG 系统涉及数据准备（加载、分割、嵌入、存储）和查询两个阶段，查询阶段的链式结构在 Langchain 中可以概念化为：

text

用户问题 -> Retriever (检索相关文档块) -> PromptTemplate (将问题和文档块组合成提示词) -> LLM (根据提示词生成回答)

用 LCEL 的管道符号表示，一个简化的 RAG 查询链可能看起来像这样：

python

# 这是一个概念性的链结构，实际代码会更复杂一些from langchain_core.runnables import RunnablePassthroughfrom langchain_core.output_parsers import StrOutputParser# 假设你已经初始化了一个 retriever 对象 (它知道如何去你的向量库里找东西)# retriever = your_vector_store.as_retriever()# 定义一个 RAG 模式的提示词模板，它需要两个输入：context 和 questionrag_template = """你是一个乐于助人的AI助手。请根据提供的上下文信息来回答用户的问题。如果上下文没有提供足够的信息，请说明你无法回答。上下文信息：{context}用户的问题：{question}回答："""rag_prompt = ChatPromptTemplate.from_template(rag_template)# 构建 RAG 链# RunnablePassthrough() 允许将输入直接传递下去# {"context": retriever, "question": RunnablePassthrough()} 这部分是 LCEL 的一个技巧# 它构建了一个字典作为 prompt 的输入。# "context" 的值来自 retriever 的输出# "question" 的值来自链的原始输入 (用户的 question)# 然后将这个字典传递给 rag_prompt# 最后将 rag_prompt 的输出传递给 chat_modelrag_chain = (    {"context": retriever, "question": RunnablePassthrough()}    | rag_prompt    | chat_model    | StrOutputParser() # 将 ChatModel 的输出转换为字符串)# 调用链，传入用户问题# response = rag_chain.invoke("关于项目报告，最新的进展是什么？")# print(response)

（注：上面这段代码是概念性的展示 RAG 链的结构，要实际运行需要先完成文档加载、分割、嵌入和向量存储的准备工作，并初始化 retriever 对象，这部分内容超出了本文“快速上手”的范围，通常需要额外的代码和依赖。 ）

通过 RAG 模式，我们极大地扩展了 LLM 的能力边界，让它能够利用我们自己的数据，回答那些它原本无法回答的特定领域或实时性问题。Langchain 提供的模块化工具，使得实现这一复杂模式变得更加可行和高效。虽然完整的 RAG 实现比简单的问答链要复杂得多，但 Langchain 已经为我们铺好了路，提供了所有必要的组件。

Langchain 的挑战与思考

通过前面的介绍和简单的实践，我们已经看到了 Langchain 如何通过模块化和链式结构，极大地简化了基于大模型的应用开发。它提供了一套清晰的抽象，让开发者能够更专注于业务逻辑的实现。

然而，就像任何强大的工具一样，Langchain 也并非没有挑战，我们在使用它时需要保持清醒的认识和深入的思考。

框架本身的复杂性与学习曲线：  虽然 Langchain 的目标是简化 LLM 应用开发，但它本身是一个包含众多模块和概念的框架。Models, Prompts, Chains, Agents, Indexes, Memory……每个模块下又有多种实现和配置选项。理解这些组件如何协同工作，以及在特定场景下选择最合适的组件，需要投入时间和精力去学习和实践。对于初学者来说，刚开始接触时可能会感到信息量巨大，存在一定的学习曲线。它提供的是一个工具箱，你需要学习如何使用里面的各种工具。对底层 LLM 的依赖与局限性：  Langchain 是一个“编排”和“连接” LLM 的框架，它本身并不解决 LLM 固有的问题。大模型可能出现幻觉（Hallucination，即生成看似合理但实际错误的信息）、偏见、对实时信息感知不足等问题。使用 Langchain 构建的应用，其最终表现很大程度上取决于所使用的底层 LLM 的能力和局限性。如果底层模型不够好，再精巧的 Langchain 链也无法变魔术。同时，每次调用 LLM 都涉及成本（按 token 计费）和延迟，复杂的链或 Agent 可能会导致更高的成本和更长的响应时间。Prompt Engineering 的重要性依然存在：  Langchain 提供了 PromptTemplate 等工具来管理提示词，但这并不意味着你可以忽视提示词本身的设计。如何向 LLM 提问、如何组织上下文、如何引导模型生成期望的输出，这些“提示词工程”（Prompt Engineering）的技巧依然至关重要。Langchain 帮助你更方便地构建和使用提示词，但提示词的内容和质量仍然需要开发者精心设计和优化。一个糟糕的提示词，即使通过 Langchain 发送，也难以获得好的结果。选择合适的组件与模式：  Langchain 提供了多种实现同一目标的途径。例如，构建一个问答系统，你可以使用简单的 LLMChain，也可以使用基于 RAG 的复杂链，甚至构建一个 Agent 来决定是否需要检索信息。面对众多的 Chain 类型、Agent 类型、Retriever 实现、Memory 方案，如何根据具体的应用场景、数据特点和性能要求，选择最合适、最高效的组件组合，是开发者需要不断实践和积累经验才能掌握的能力。快速发展的生态系统：  LLM 领域和 Langchain 本身都在飞速发展。新的模型不断涌现，Langchain 库的功能也在快速迭代和更新。这意味着你需要持续关注社区动态和官方文档，才能跟上最新的进展和最佳实践。有时，昨天还能用的代码，今天可能就需要调整以适应新的版本或推荐用法（比如 LCEL 的推广）。

总而言之，Langchain 是一个强大的赋能者，它为构建复杂的 LLM 应用提供了结构和便利。但它不是一个“黑箱”或“银弹”，不能解决所有问题。开发者仍然需要深入理解 LLM 的工作原理和局限性，掌握提示词设计的艺术，并学习如何在 Langchain 提供的丰富工具箱中做出明智的选择。只有这样，才能真正发挥 Langchain 的潜力，构建出稳定、高效、智能的 LLM 应用。

接下来该做什么

探索官方文档：  Langchain 的官方文档非常详尽，是深入学习的最佳资源。去看看不同类型的 Chains、Agents 和 Memory 是如何工作的。尝试更复杂的例子：  尝试实现一个简单的 RAG 应用，加载你自己的文档（比如几篇博客文章），构建向量存储，然后尝试提问。或者尝试构建一个简单的 Agent，让它能够使用搜索引擎来回答问题。

Langchain 为我们打开了一扇门，通往构建更强大、更智能、更实用的 LLM 应用的世界。希望本文能帮助你快速迈出第一步，在这个激动人心的领域中探索和创造。