AI 大模型应用进阶系列（七）：LangChain 核心 API

• LangChain 官方文档：python.langchain.com.cn
• LangChain 中文社区：langchain.com.cn

LangChain 是一个用于开发由大型语言模型 (LLMs) 驱动的应用程序的框架。通过模块化组件和灵活的链路编排，帮助开发者快速构建从简单对话到复杂多模型协作的全流程系统

生态

• langgraph

  langgraph是 langchain 的一个扩展，旨在 通过将步骤建模为图中的边和节点，构建强大且有状态的多参与者应用程序。提供了用于创建常见类型代理的高级接口，以及用于组合自定义流程的低级 API。

• langserve

  一个将 LangChain 链部署为 REST API 的包。使得快速搭建生产就绪的 API 变得简单。

• LangSmith

  一个开发者平台，让你能够调试、测试、评估和监控 LLM 应用程序。

核心概念

LangChain 的核心概念围绕着构建大语言模型（LLM）应用的关键组件展开，这些组件通过模块化设计实现灵活组合，形成处理复杂任务的 "链" 或 "智能代理"

• 模型 I/O：

  • models
    • 基础语言模型
    • 对话模型
    • 嵌入模型
  • 提示词模版
    • 提示词模板有助于将用户输入和参数转换为语言模型的指令。 这可以用于指导模型的响应，帮助其理解上下文并生成相关且连贯的基于语言的输出
  • 输出解析器
    • 输出解析器是帮助结构化语言模型响应的类

• 链：

  • 是连接不同组件（如模型、提示、工具、检索器等）的核心机制，它将单一组件的能力串联成一个完整的工作流，以解决复杂任务。链的本质是 “流程编排”，通过定义组件的执行顺序和数据传递方式，实现从输入到输出的自动化处理

• 记忆机制

  • 是用于存储和管理对话历史或中间状态的核心组件，它让语言模型具备 “上下文感知” 能力，能够像人类一样记住之前的交互内容，从而实现连贯的多轮对话或复杂任务的分步处理

• 代理 （Agent）

  • Agent 是 LangChain 中具备自主决策能力的组件，它能根据用户目标拆解任务、选择工具、执行操作，并根据结果动态调整策略。简单来说，Agent 像一个 “决策者”，会思考 “需要做什么→该用什么工具→如何用工具→是否需要进一步操作”

• 工具(Tools)

  • Tools 是 Agent 可调用的外部功能或服务，用于弥补 LLM 自身的局限性（如无法获取实时数据、不能执行计算、无法操作外部系统等）。工具本质是 “函数”，Agent 通过调用这些函数与外部世界交互。

• 回调

  • 回调是通过 “钩子函数（Hook）” 实现的事件响应机制。当 LangChain 组件（如 LLM、链、Agent）执行到特定阶段时，会自动触发对应的钩子函数，开发者可以在这些函数中编写自定义代码（如记录日志、修改输出、收集指标等）

• 数据增强（RAG）

  • 是一种结合 “外部知识检索” 与 “大语言模型生成” 的技术框架，核心是让模型在生成回答时，先从外部知识库中检索相关信息作为 “上下文”，再基于这些信息生成准确、可靠的结果

提示词模版

在 LangChain 0.3 版本中，from_template 是提示词模板（Prompt Template）中非常实用的静态方法，用于快速从字符串模板创建提示词模板对象。它简化了模板的初始化流程，尤其适合快速定义包含变量的提示词结构

类型

• 字符串提示词模板

  • 示例

  from langchain_core.prompts import PromptTemplate
  
  # 用 from_template 创建模板（自动识别变量）
  prompt = PromptTemplate.from_template("请用一句话描述{concept}的核心功能。")
  
  # 查看自动解析的变量
  print("提取的变量：", prompt.input_variables)  # 输出：['concept']
  
  # 填充变量生成提示词
  final_prompt = prompt.format(concept="LangChain")
  print(final_prompt)
  # 输出：请用一句话描述LangChain的核心功能
  

  • 与 Partial结合使用

  from langchain_core.prompts import PromptTemplate
  
  # 用 from_template 创建含多个变量的模板
  prompt = PromptTemplate.from_template(
     "用户问的是关于{category}的{question}，请用{style}风格回答。"
  )
  
  # 部分填充：先固定category和style
  partial_prompt = prompt.partial(
     category="机器学习",
     style="通俗易懂"
  )
  
  # 后续补充剩余变量question
  final_prompt = partial_prompt.format(question="什么是过拟合？")
  print(final_prompt)
  # 输出：用户问的是关于机器学习的什么是过拟合？，请用通俗易懂风格回答。
  

• 聊天提示词模板

  • SystemMessagePromptTemplate：定义系统消息（如角色设定、行为准则）。
  • HumanMessagePromptTemplate：定义用户消息（如用户的问题）。
  • AIMessagePromptTemplate：定义助手消息（如历史回复，用于多轮对话）。

• 少量样本模版

  • FewShotPromptTemplate

• 消息占位符

  • MessagesPlaceholder：占位符，用于动态插入历史对话记录。

与大模型结合使用

• 示例

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI  # 需安装 langchain-openai

# 1. 定义聊天模板
chat_prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("你是翻译助手，将{source_lang}翻译成{target_lang}。"),
    HumanMessagePromptTemplate.from_template("{text}")
])

# 2. 初始化模型和输出解析器
model = ChatOpenAI(api_key="your-api-key")  # 替换为实际API密钥
output_parser = StrOutputParser()  # 将模型输出转为字符串

# 3. 构建链（模板 → 模型 → 解析器）
chain = chat_prompt | model | output_parser

# 4. 运行链，翻译文本
result = chain.invoke({
    "source_lang": "中文",
    "target_lang": "英文",
    "text": "LangChain 0.3 版本的聊天模板非常灵活。"
})

print(result)  # 输出：The chat templates in LangChain version 0.3 are very flexible.

样例选择器 Example Selector

样例选择器（Example Selectors）是少样本学习（Few-Shot Learning）的核心组件，用于从样例集中动态选择与当前输入最相关的样例，而非固定使用所有样例。这一机制能显著提升提示词的效率和相关性，尤其适用于样例数量多、输入场景多变的任务（如文本分类、问答、情感分析等）

• LengthBasedExampleSelector 长度选择样例
• SemanticSimilarityExampleSelector：语义相似度选择样例
• MaxMarginalRelevanceExampleSelector 最大边际相关性选择器

输出解析器 Output Parsers

输出解析器（Output Parsers） 是连接大语言模型（LLM）输出与下游应用的关键组件，负责将模型返回的原始文本转换为结构化数据（如字典、列表、自定义对象等），以便后续代码直接处理。这一机制解决了 “模型输出是自然语言文本，而程序需要结构化数据” 的核心矛盾。

• StrOutputParser

  • 作用：将模型输出直接转换为字符串（去除多余空格和换行），是最基础的解析器。
  • 适用场景：生成文本、摘要、翻译结果、开放式回答等无需结构化的场景。
  • 示例

  from langchain_core.output_parsers import StrOutputParser
  from langchain_core.prompts import PromptTemplate
  from langchain_openai import ChatOpenAI
  
  prompt = PromptTemplate.from_template("用一句话描述{topic}")
  model = ChatOpenAI(api_key="your-api-key")
  parser = StrOutputParser()
  
  chain = prompt | model | parser
  result = chain.invoke({"topic": "人工智能"})
  print(type(result))  # <class 'str'>
  print(result)        # 示例：人工智能是模拟人类智能的计算机系统。
  

• BytesOutputParser

  • 作用：将模型输出转换为字节流（bytes），适用于需要二进制数据的场景（如加密、文件存储）。
  • 适用场景：处理需二进制编码的输出（如特定格式的加密文本）。
  • 示例：

  from langchain_core.output_parsers import BytesOutputParser
  
  parser = BytesOutputParser(encoding="utf-8")  # 指定编码
  result = parser.parse("hello world")
  print(type(result))  # <class 'bytes'>
  print(result)        # b'hello world'
  

• JsonOutputParser

  • 作用：将模型输出解析为 JSON 字典或列表，支持通过 Pydantic 模型定义输出结构（字段名、类型、描述），并自动校验格式。
  • 适用场景：提取实体（如人物、时间、地点）、分类结果（如情感分析、主题标签）、多字段信息（如产品属性）等。
  • 示例：

  from langchain_core.output_parsers import JsonOutputParser
  from langchain_core.pydantic_v1 import BaseModel, Field
  from langchain_core.prompts import PromptTemplate
  
  # 定义输出结构（Pydantic模型）
  class Person(BaseModel):
      name: str = Field(description="姓名")
      age: int = Field(description="年龄")
  
  parser = JsonOutputParser(pydantic_object=Person)  # 关联模型
  prompt = PromptTemplate.from_template(
      "解析文本中的人物信息：{text}\n{format_instructions}",
      partial_instructions=parser.get_format_instructions()  # 注入格式约束
  )
  
  chain = prompt | model | parser
  result = chain.invoke({"text": "小明今年25岁，是一名工程师。"})
  print(result)  # {'name': '小明', 'age': 25}（或 Person 对象）
  

• PydanticOutputParser

  • 作用：通过 Pydantic 模型定义输出的字段、类型和验证规则，用于 自动校验 、类型检查等
  • 示例

  from langchain_core.output_parsers import PydanticOutputParser
  from langchain_core.prompts import PromptTemplate
  from langchain_openai import ChatOpenAI
  
  # 初始化解析器，关联Pydantic模型
  parser = PydanticOutputParser(pydantic_object=UserInfo)
  
  prompt = PromptTemplate.from_template(
      """
      请以下文本提取用户信息，按照严格按照格式要求输出：
      {text}
  
      格式要求：
      {format_instructions}
      """,
      partial_variables={"format_instructions": parser.get_format_instructions()}
  )
  
  
  # 初始化模型
  model = ChatOpenAI(api_key="your-api-key")
  
  # 构建链：提示词 → 模型 → 解析器
  chain = prompt | model | parser
  
  # 运行链（输入文本）
  result = chain.invoke({
      "text": "我叫张三，25岁，不是学生，邮箱是zhangsan@example.com。"
  })
  
  # 输出结果（Pydantic对象）
  print(type(result))  # <class '__main__.UserInfo'>
  print(result.name)   # 张三
  print(result.age)    # 25
  print(result.email)  # zhangsan@example.com
  print(result.is_student)  # False
  

• CommaSeparatedListOutputParser

  • 作用：将模型输出的逗号分隔文本转换为 Python 列表（如 "a,b,c" → ["a", "b", "c"]）。
  • 适用场景：生成关键词列表、选项列举、步骤拆分等。
  • 示例：

  from langchain_core.output_parsers import CommaSeparatedListOutputParser
  from langchain_openai import ChatOpenAI
  
  parser = CommaSeparatedListOutputParser()
  prompt = PromptTemplate.from_template(
      "列出3个{topic}相关的关键词：{format_instructions}",
      format_instructions=parser.get_format_instructions()
  )
  
  # 初始化模型
  model = ChatOpenAI(api_key="your-api-key")
  
  chain = prompt | model | parser
  result = chain.invoke({"topic": "机器学习"})
  print(result)  # ['监督学习', '神经网络', '特征工程']
  

• LineListOutputParser

  • 作用：将模型输出的换行分隔文本转换为 Python 列表（如 “a\nb\nc” → ["a", "b", "c"]）。
  • 适用场景：生成带序号的列表（如 “1. 第一步 \n2. 第二步”）、多行文本拆分。
  • 示例：

  from langchain_core.output_parsers import LineListOutputParser
  from langchain_openai import ChatOpenAI
  
  parser = LineListOutputParser()
  prompt = PromptTemplate.from_template(
      "分点列出{topic}的优势（每行一个）：{format_instructions}",
      format_instructions=parser.get_format_instructions()
  )
  # 初始化模型
  model = ChatOpenAI(api_key="your-api-key")
  
  chain = prompt | model | parser
  result = chain.invoke({"topic": "LangChain"})
  print(result)  # ['简化LLM应用开发', '支持多模型集成', '丰富的工具链']
  

• DatetimeOutputParser

  • 作用：从模型输出中提取并格式化日期时间格式（如将 “2024 年 8 月” 转换为 datetime 对象或指定字符串格式）。
  • 适用场景：提取会议时间、截止日期、事件发生时间等。
  • 关键特性：支持自定义输出格式（如 %Y-%m-%d 表示 “年 - 月 - 日”）。
  • 示例：

  from langchain_core.output_parsers import DatetimeOutputParser
  from langchain_openai import ChatOpenAI
  
  # 定义输出格式为"年-月-日 时:分"
  parser = DatetimeOutputParser(format="%Y-%m-%d %H:%M")
  prompt = PromptTemplate.from_template(
      "提取文本中的时间：{text}\n{format_instructions}",
      format_instructions=parser.get_format_instructions()
  )
  
  chain = prompt | model | parser
  result = chain.invoke({"text": "会议将于2024年9月1日上午10点开始。"})
  print(result)  # 2024-09-01 10:00（datetime对象或字符串）
  

• RegexParser

  • 作用：通过自定义正则表达式从模型输出中提取符合特定模式的内容（如邮箱、电话、URL、身份证号等）。
  • 适用场景：提取结构化格式严格的信息（如 “邮箱：xxx@xxx.com” 中的邮箱地址）。
  • 示例

  from langchain_core.output_parsers import RegexParser
  from langchain_openai import ChatOpenAI
  
  # 正则表达式：匹配邮箱格式（捕获组名为"email"）
  parser = RegexParser(
      regex=r"邮箱：(\S+@\S+)",  # 模式："邮箱："后跟邮箱地址
      output_keys=["email"],     # 提取的字段名
      default_output_key="email"
  )
  
  prompt = PromptTemplate.from_template("从文本中提取邮箱：{text}（格式：邮箱：xxx@xxx.com）")
  model = ChatOpenAI(api_key="your-api-key") # 替换为实际API密钥
  chain = prompt | model | parser
  result = chain.invoke({"text": "联系我请发邮件至support@langchain.com"})
  print(result)  # {'email': 'support@langchain.com'}
  

• MarkdownParser

  • 作用：解析 Markdown 格式的输出，提取标题、列表、表格等结构（需结合 markdown 库）。

  • 适用场景：处理模型生成的 Markdown 文档（如带标题的报告、表格数据）。

  • 示例：

  from langchain_core.output_parsers import MarkdownParser
  import markdown
  
  parser = MarkdownParser()
  # 模型输出的Markdown文本
  md_text = "# 报告\n- 要点1\n- 要点2"
  result = parser.parse(md_text)
  print(result)  # 解析后的HTML（或原始Markdown结构，取决于配置）
  

• OutputFixingParser

  • 作用：当模型输出格式错误（如 JSON 缺少括号、字段不完整）时，自动调用 LLM 修复格式后再解析。

  • 适用场景：对格式要求严格但模型偶尔输出错误的场景（如 JSON 解析）。

  • 示例：

  from langchain_core.output_parsers import OutputFixingParser, JsonOutputParser
  from langchain_openai import ChatOpenAI
  
  # 基础JSON解析器
  json_parser = JsonOutputParser(pydantic_object=Person)
  # 包装为带修复功能的解析器
  parser = OutputFixingParser.from_llm(
      llm=ChatOpenAI(api_key="your-api-key"),  # 用于修复的模型
      parser=json_parser  # 基础解析器
  )
  
  # 模拟格式错误的输出（缺少右括号）
  bad_output = '{"name": "小明", "age": 25'
  result = parser.parse(bad_output)  # 自动修复为完整JSON后解析
  print(result)  # {'name': '小明', 'age': 25}
  

• RetryOutputParser

  • 作用：当解析失败时，通过重试机制重新调用模型生成符合格式的输出（需配合提示词模板动态调整指令）。
  • 适用场景：格式错误可通过重新生成解决的场景（比 OutputFixingParser 更主动）。

• CombinedOutputParser

  • 作用：组合多个解析器，同时处理模型输出中的多种结构（如同时提取 JSON 和列表）。
  • 适用场景：复杂输出（如一段文本中同时包含键值对和列表）。

• StreamingJsonOutputParser

  • 作用：实时解析模型的流式 JSON 输出（边生成边解析），无需等待完整输出。
  • 适用场景：流式聊天中需要实时提取结构化信息（如实时情感分析）。

• StreamingStrOutputParser

  • 作用：实时解析流式文本输出，逐段返回字符串（如聊天机器人的打字机效果）。

• PandasDataFrameOutputParser

  • 作用：将模型输出的表格类文本（如 CSV、Markdown 表格）解析为 Pandas DataFrame。
  • 适用场景：处理结构化数据（如统计结果、列表信息）并进行数据分析。

• 自定义输出解析器

  • 作用： 如果内置解析器无法满足需求，可通过继承 BaseOutputParser 自定义解析逻辑：
  • 示例

  from langchain_core.output_parsers import BaseOutputParser
  from typing import List
  
  class NumberListParser(BaseOutputParser[List[int]]):
      """提取文本中的所有数字并返回整数列表"""
      def parse(self, text: str) -> List[int]:
          import re
          return [int(num) for num in re.findall(r"\d+", text)]
  
      def get_format_instructions(self) -> str:
          return "请在文本中包含数字，无需特殊格式。"
  
  # 使用自定义解析器
  parser = NumberListParser()
  result = parser.parse("样本1的得分是90，样本2是85，样本3是95。")
  print(result)  # [90, 85, 95]
  

加载器

本地文档加载器（Local Document Loaders）

• 纯文本 TextLoader
• PDF PyPDFLoader
• Word 文档 Docx2txtLoader
• 多格式文件 UnstructuredFileLoader
• 图片 ImageLoader
• Markdown UnstructuredMarkdownLoader
• JSON JSONLoader

 网络数据加载器（Web Data Loaders）

• HTML 加载器 WebBaseLoader
• 在线文件 URLLoader

结构化 / 半结构化数据加载器

• CSV表格文件 CSVLoader
• Excel 文件 ExcelLoader
• 关系型数据库 SQLDatabaseLoader
• MongoDB 数据库 MongoDBLoader

自定义加载器

文本分割器

在 LangChain 中，文本分割器（Text Splitters）是处理长文本的核心工具。由于大语言模型（LLMs）存在上下文窗口长度限制，无法直接处理超出长度的文本，文本分割器的作用是将长文本合理拆分为符合模型输入要求的 “小块”（chunks），同时尽可能保留文本的语义完整性，为后续的检索、问答等任务奠定基础。

• 递归分割文本 RecursiveCharacterTextSplitter
• 简单字符分割 CharacterTextSplitter
• token分割 TokenTextSplitter
• 语义感知分割 SentenceTransformersTokenTextSplitter
• markdown标题分割 MarkdownTextSplitter

检索器

在 LangChain 中，检索器（Retrievers）  是连接外部知识库与大语言模型（LLMs）的核心组件，负责根据用户查询（query）从文档集合中精准筛选出最相关的文档片段，为 LLM 生成回答提供可靠的上下文依据。它是 “检索增强生成（RAG）” 流程的核心环节，直接影响 LLM 回答的准确性和相关性。

• 向量存储检索器 VectorstoreRetriever
• BM25 检索器 BM25Retriever
• 多查询检索器 MultiQueryRetriever
• 上下文压缩检索器 LLMChainExtractor
• 自查询检索器 SelfQueryRetriever
• 合并检索器结果 EnsembleRetriever
• 混合检索器 HybridRetriever

缓存 MemorCache

• 内存缓存 InMemoryCache
• SQLite 缓存SQLiteCache
• 文件缓存FileCache
• Redis 缓存RedisCache

Runnerble

在 LangChain 中，Runnable 是自 0.1 版本起引入的核心抽象接口，旨在统一各类组件（如 LLM、提示模板、检索器、工具、链等）的交互方式，实现更灵活的组件组合与工作流构建。它解决了早期版本中Chain接口灵活性不足、组合复杂的问题，成为 LangChain 构建高级应用的基础。

Runnable 的核心接口

方法	作用	适用场景
invoke(input)	同步调用，接收输入并返回单个结果	简单场景，需要立即获取结果
ainvoke(input)	异步调用，异步接收输入并返回单个结果	异步工作流（如 FastAPI、异步任务）
stream(input)	同步流式输出，返回结果的迭代器	实时展示（如聊天机器人打字效果）
astream(input)	异步流式输出，返回异步迭代器	异步场景下的实时展示
batch(inputs)	同步批处理，接收输入列表并返回结果列表	批量处理多个相似请求（提高效率）
abatch(inputs)	异步批处理，异步处理输入列表	异步场景下的批量处理
transform(iterator)	处理输入迭代器，返回输出迭代器	流处理管道（如持续输入的数据流）

Runnable 的主要类型

1. 基础组件 Runnable

指单独的功能组件，直接实现Runnable接口，是构建工作流的 “原子单元”。

组件类型	示例	功能说明
LLM / 聊天模型	ChatOpenAI()、LlamaCpp()	接收提示（Prompt），返回模型生成的文本
提示模板	ChatPromptTemplate	接收变量，返回格式化的提示文本
检索器	VectorstoreRetriever	接收查询（Query），返回相关文档列表
工具	Tool、FunctionCall	接收工具调用参数，返回工具执行结果
输出解析器	StrOutputParser	接收模型输出，返回解析后的结构化结果
自定义函数	用@runnable装饰的函数	接收输入，返回自定义处理结果（如数据清洗）

2. 复合组件 Runnable

通过组合多个Runnable形成的 “组合组件”，支持复杂的执行逻辑（顺序、并行、条件等），是构建工作流的核心。

复合组件	功能说明	适用场景
RunnableSequence	按顺序执行多个 Runnable（前一个的输出作为后一个的输入）	流水线工作流（如 “提示模板→LLM→输出解析器”）
RunnableParallel	并行执行多个 Runnable，聚合结果（键值对形式）	同时处理多个独立任务（如 “检索文档 + 获取当前时间”）
RunnableBranch	按条件选择不同的 Runnable 执行（类似if-elif-else）	条件分支逻辑（如 “根据查询类型选择不同检索策略”）
RunnableLambda	将普通函数包装为 Runnable，支持自定义逻辑	嵌入简单处理逻辑（如数据转换、过滤）

Function Calling

在 LangChain 中，Function Calling（函数调用）  是指大语言模型（LLM）通过结构化特定格式调用外部函数（工具、API 或自定义逻辑）的能力。它是 Agent 与外部世界交互的核心机制，让 LLM 从 “纯文本生成” 升级为 “可执行动作”，从而解决需要实时数据、复杂计算或外部系统交互的任务。

Function Calling 的工作原理

LangChain 的 Function Calling 流程可概括为 “定义函数→模型生成调用指令→执行函数→处理结果” 四步：

1. 定义函数（工具）
   开发者预先定义需要 LLM 调用的函数（如get_weather(city: str, date: str)），并提供描述（包括函数作用、参数类型和含义），供 LLM 判断何时调用。
2. 模型生成调用指令
   LLM 接收用户查询后，分析是否需要调用函数。若需要，会按约定格式（如包含function_name和parameters的 JSON）生成调用指令，确保参数正确。
3. 执行函数
   LangChain 的执行器（如AgentExecutor）解析 LLM 生成的调用指令，调用对应的函数并传入参数，获取执行结果。
4. 处理结果并生成回答
   LLM 接收函数返回的结果，判断是否需要进一步调用其他函数（如信息不足时），或直接整理结果生成自然语言回答。

Tools

在 LangChain 中，工具（Tools）  是 Agent（智能体）能够调用的功能模块，是连接大语言模型（LLM）与外部世界的 “桥梁”。通过工具，LLM 可以突破自身知识局限性（如实时信息获取、复杂计算、数据库交互等），实现 “思考 + 行动” 的闭环，完成更复杂的任务。

Agent

在 LangChain 中，Agent（智能体）  是一类能够通过自主决策和工具调用解决复杂任务的组件。与固定流程的链（Chain）不同，Agent 具备 “思考能力”—— 它能根据用户输入分析问题、规划步骤、选择工具，并根据工具返回的结果调整策略，直到完成任务。这种灵活性使其特别适合处理需要多步推理、依赖外部信息或动态决策的场景（如复杂问答、数据分析、自动化办公等）。

类型

AgentType 类型	核心逻辑	特点	适用场景
ZERO_SHOT_REACT_DESCRIPTION	基于 React 框架（Reason+Act），仅通过工具描述决策，无记忆能力	轻量、通用，无需上下文依赖	单轮工具调用（如查天气、查景点）、独立简单任务
CHAT_ZERO_SHOT_REACT_DESCRIPTION	优化适配聊天模型（如 gpt-3.5-turbo），支持对话格式输入	符合自然对话习惯，交互更友好	对话式工具调用（如 “查天气后推荐景点”）、多轮交互任务
REACT_DOCSTORE	结合文档存储（如 VectorDB），通过工具检索文档片段并推理	依赖文档上下文，专注知识密集型任务	知识库问答（如 “根据年报查营收”）、特定文档解析
SELF_ASK_WITH_SEARCH	通过 “自问自答” 分解复杂问题，生成中间问题引导工具调用	擅长多步骤推理，逻辑链清晰	复杂推理任务（如 “计算高铁到达时间”）、需分步验证的问题
SQL_DATABASE	将自然语言转换为 SQL 查询，执行并解析数据库结果	专为 SQL 数据库设计，自动处理语法交互	数据库查询（如 “查询各地区销售额排序”）、结构化数据统计
JSON_AGENT	解析 JSON 结构并提取指定信息，无需 SQL 知识	轻量处理 JSON 数据，无需复杂配置	JSON 数据查询（如 “从接口结果提取邮箱”）、简单 JSON 解析任务
PYTHON_REPL	通过 Python 解释器执行代码，解决计算或数据处理问题	支持复杂计算和编程任务	数学建模（如 “计算质数和”）、数据可视化脚本生成、编程问题求解
STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION	增强型聊天 Agent，支持结构化工具输入（如指定参数格式）	适合严格参数校验的工具调用	调用有明确参数要求的 API（如 “查询指定日期航班”）、结构化数据交互
OPENAI_FUNCTIONS	适配 OpenAI 函数调用 API，直接通过 LLM 生成工具调用格式	依赖 OpenAI 原生函数调用能力，无需手动解析	与 OpenAI 生态集成的工具调用（如 gpt-4 的函数调用）
AZURE_OPENAI_FUNCTIONS	类似OPENAI_FUNCTIONS，专为 Azure OpenAI 服务优化	适配 Azure 环境，兼容其 API 特性

流程图

回调 Callbacks

LangChain提供了一个回调系统，允许您在LLM应用程序的各个阶段进行挂钩。这对于日志记录、监控、流式处理和其他任务非常有用。

一、通用核心事件（适用于所有组件）

这些事件是所有实现Runnable接口的组件（LLM、Chain、Agent 等）共有的基础事件，用于追踪整体执行流程：

事件名称	触发时机	核心参数（event 对象）	说明
on_chain_start	任何组件（LLM、Chain、Agent 等）开始执行时	name（组件名称）、inputs（输入数据）、run_id（唯一执行 ID）、tags（标签）	标记组件执行的起点，可用于初始化监控
on_chain_end	任何组件执行成功结束时	name、outputs（输出结果）、run_id、metadata（如执行时间）	标记组件执行的终点，可用于记录结果
on_chain_error	任何组件执行出错时	name、error（错误对象，含堆栈信息）、run_id、inputs	捕获执行异常，用于错误排查和告警

二、LLM 与聊天模型事件

针对大语言模型（LLM）和聊天模型（ChatModel）的专属事件，细化了文本生成过程的追踪：

事件名称	触发时机	核心参数	适用组件
on_llm_start	基础 LLM（如OpenAI）开始生成文本时	prompts（输入提示列表）、model_name（模型名）、run_id	非聊天类 LLM（如TextDavinci）
on_llm_end	基础 LLM 生成文本完成时	responses（模型输出）、model_name、run_id	非聊天类 LLM
on_llm_error	基础 LLM 执行出错时	error、model_name、run_id	非聊天类 LLM
on_llm_new_token	LLM 流式输出新 token 时（逐字生成）	token（新生成的 token）、run_id、model_name	支持流式输出的 LLM
on_chat_model_start	聊天模型（如ChatOpenAI）开始处理消息时	messages（输入消息列表）、model_name、run_id	聊天类模型（ChatModel）
on_chat_model_end	聊天模型生成响应完成时	responses（聊天响应）、model_name、run_id	聊天类模型
on_chat_model_error	聊天模型执行出错时	error、model_name、run_id	聊天类模型
on_chat_model_stream	聊天模型流式输出时（逐段生成）	chunk（流式片段）、run_id、model_name	支持流式的聊天模型

三、链（Chain）专属事件

针对 Chain 组件的事件，用于追踪链的执行步骤和子组件交互：

事件名称	触发时机	核心参数	说明
on_chain_stream	链（如SequentialChain）流式输出时	chunk（流式片段）、run_id、name	用于实时展示链的中间结果
on_chain_iterator	链处理迭代器输入时（如批量处理）	input（当前输入项）、run_id	适用于处理迭代器输入的链

四、智能体（Agent）事件

针对 Agent 的事件，覆盖决策、工具调用、结果处理等核心流程：

事件名称	触发时机	核心参数	说明
on_agent_action	Agent 决定执行工具调用时	action（工具调用信息，含tool名称和tool_input参数）、run_id	记录 Agent 的决策动作
on_agent_finish	Agent 完成所有工具调用并生成最终结果时	return_values（最终输出）、run_id	标记 Agent 任务完成
on_agent_step	Agent 完成单步推理（思考或工具调用）时	step（步骤信息）、run_id、name	用于追踪多步推理过程

五、工具（Tool）与函数调用事件

针对工具调用和函数调用的事件，追踪外部交互过程：

事件名称	触发时机	核心参数	说明
on_tool_start	工具（Tool）开始执行时	tool_name（工具名称）、input（工具输入）、run_id	标记工具调用的起点
on_tool_end	工具执行成功结束时	output（工具输出结果）、tool_name、run_id	记录工具调用的结果
on_tool_error	工具执行出错时	error、tool_name、run_id	捕获工具调用异常（如 API 超时）
on_function_call	执行函数调用（Function Calling）时	function（函数名）、arguments（参数）、run_id	追踪 LLM 调用函数的过程
on_function_end	函数调用成功返回结果时	result（函数返回值）、function、run_id	记录函数调用的返回值

六、检索（Retriever）事件

针对检索器（Retriever）的事件，用于追踪文档检索过程：

事件名称	触发时机	核心参数	说明
on_retriever_start	检索器开始检索文档时	query（检索查询词）、run_id、retriever_name	标记检索开始
on_retriever_end	检索器完成文档检索时	documents（检索到的文档列表）、run_id	记录检索结果（文档内容和元数据）
on_retriever_error	检索器执行出错时	error、query、run_id	捕获检索异常（如向量库连接失败）