1 重点梳理：

langchain官网：Introduction | 🦜️🔗 LangChain

模板链接：LangSmith

storage：存储，翻译

chain = final_prompt | llm：在 LangChain 的上下文中，| 符号通常用于表示管道（Pipeline）操作，即将一个对象的输出传递给另一个对象的输入。这种用法类似于 Linux 中的管道操作，可以将多个处理步骤串联起来，形成一个完整的处理流程。

CommaSeparatedListOutputParser() 是 LangChain 中的一个实用工具，用于将语言模型生成的文本输出解析为一个由逗号分隔的列表。

LangChain概述：（overview）LangChain是一个开源框架，专为简化大语言模型（如GPT）应用的开发而设计。它通过模块化组件（如链式流程、智能代理）整合数据检索、模型调用与结果解析，帮助开发者高效构建问答系统、自动化工具等复杂应用，降低开发门槛并提升扩展性。

Prompt Template：（提示模板）提示模板用于规范模型输入格式，通过预设模板动态插入变量（如用户问题、上下文）。例如，将“问题”和“背景”嵌入固定句式，生成结构化的提示文本，确保输入一致性，减少重复代码，同时支持灵活的场景适配。

Models and Output Parsers（模型与输出解析器）

• Models：支持多种模型类型，如通用大语言模型（LLMs）和对话模型（Chat Models），开发者可自由调用或切换不同模型（如GPT-3、Claude），满足多样化需求。

• Output Parsers：将模型的非结构化文本输出（如回答、长文本）转换为结构化数据（如JSON、列表），便于提取关键信息（如日期、实体）并传递给下游程序，增强结果的可操作性。

Langchain的核心组件：

1. 模型 I/O 封装：负责 标准化模型的输入输出流程，包括调用大语言模型（如GPT）、设计提示词模板（Prompt Template）规范化输入，以及解析模型输出（Output parser）为结构化数据，确保交互的灵活性和一致性。

2. Retrieval（检索）：支持 文档的加载、分割、向量化与存储，通过Embedding模型将文本转为向量，结合向量数据库实现高效语义检索，适用于知识库问答或信息增强场景。

3. Chain（链式流程）：将多个功能模块串联成自动化流程，例如“检索→生成提示→调用模型→解析结果”，简化复杂任务的编排与执行。

4. Agent（智能代理）：基于用户指令和可用工具（如搜索、计算），自主规划执行步骤（如先调用A工具，再处理结果），实现端到端 任务自动化，类似“AI调度员”。

5. 记忆管理：通过 缓存对话历史或任务上下文，维持模型对长期交互的连贯性，例如记住用户偏好或前序步骤的中间结果。

---

2 什么是langchain

LangChain 是一个用于开发由大型语言模型（LLM）驱动的应用程序的开源框架。它提供了一套工具、组件和接口，简化了创建由 LLM 和聊天模型支持的应用程序的过程。LangChain 的核心目标是让开发者能够轻松地将 LLM 与外部数据源、API 和其他工具集成，从而构建出更智能、更实用的应用。

为什么需要 LangChain？

一个项目可能会包括：

• 调用多个不同的大模型（gpt4, 视频生成...)
• 向量数据库
• 数据类型（读取，trunk的切分...)

langchain功能：

• 连接数据源：让 LLM 能够访问和处理外部数据，解决其知识固定和数据局限性的问题。

• 增强交互：通过记忆功能让 AI 记住对话上下文，实现更连贯的交互。

• 调用工具：允许 LLM 动态调用外部工具（如搜索引擎、API 等），执行更复杂的任务。

• 简化开发：提供了一套工具和接口，让开发者更容易构建基于 LLM 的应用程序。

3 langchain 学习路径

1. Langchain的overview（概述），模型I/O封装
2. Retrieval组件, Chain组件，Agent组件，记忆里模块
3. 进阶RAG+langchain
4. Agent
5. 经典Agent开源项目剖析
6. Agent的经典案例分享

2.1 概述与模型 I/O 封装

LangChain 的核心目标是通过模型 I/O 封装简化大语言模型开发流程：输入侧利用提示模板动态整合用户问题、上下文等变量生成标准化指令，输出侧通过解析器将模型返回的文本转化为 JSON 等结构化数据，降低程序调用复杂度。

2.2 核心组件

框架包含四大核心模块：检索组件实现文档加载、分块、向量化存储及语义搜索功能；链式流程通过串联多步骤（如“检索→生成→调用”）构建自动化任务流；智能代理支持基于工具（API、数据库）动态规划执行路径；记忆模块则管理对话历史与上下文，保障交互连贯性。

2.3 进阶：RAG + LangChain

结合检索增强生成（RAG）技术，LangChain 通过优化文本分块粒度、重排序策略提升检索精度，并将结果动态注入模型提示词，显著增强知识密集型任务（如专业问答、依赖外部知识的场景）的生成准确性与信息可靠性。

2.4 Agent 进阶功能

智能代理支持动态规划工具调用路径（如根据任务自动选择API或数据库），执行失败时切换路径重试，并通过记忆模块跟踪多轮任务状态，实现复杂场景下的自我纠错与持续任务推进。

2.5 经典开源 Agent 项目

AutoGPT、BabyAGI 等开源项目展示了 Agent 的典型设计：将目标拆解为子任务（如编码→测试→调试）、调用多样化工具（文件读写、Git 操作），并利用长期记忆模块存储任务历史，实现跨周期任务管理。

2.6 Agent 实际应用案例

典型场景包括：客服助手自动检索知识库完成多轮问题解答；数据分析代理解析需求后生成 SQL 并可视化结果；办公自动化场景中根据邮件内容生成回复草稿或触发审批流程，体现 LangChain 在真实场景中的灵活性与扩展性。

---

一 Langchain的overview（概述）

在这里，我们快速体验一下langchain的各个组件。 请保证相应的library已经安装完毕。

两种模型：

• non-chat model: 用于text completion, 给定一句话，补全剩下的内容
• chat model: 用于chat, 可以流畅得进行对话的对话模型

我们主要关注chat model

1.1 安装包

# 相应library的安装， 我们默认安装最新版本
#!pip install langchain
#!pip install openai
#!pip install langchain-openai

# 安装完之后，可以查看一下版本号
# import openai
# print (openai.__version__)
# !python -m pip install python-dotenv

加载环境变量，配置.env 文件，model对应的keys:

# 导入openai api key
import os
from dotenv import load_dotenv, find_dotenv

# .env 存储api_key
load_dotenv()

1.2 接入模型

调用 llm.invoke，langchain已经封装好各类模型（开源、闭源）

from langchain_openai import ChatOpenAI

llm = ChatOpenAI()
#llm = ChatOpenAI(model_name="gpt-4")

llm.model_name  # 'gpt-3.5-turbo'

# 直接提供问题，并调用llm
llm.invoke("What is the Sora model?")

"""
AIMessage(content='The Sora model is a framework developed by Richard Culatta that focuses on personalized learning and the integration 
of technology in education. It stands for Social learning, Ownership of learning, Reflection, and Authentic learning experiences. This 
model emphasizes the importance of students taking ownership of their learning, engaging in social interactions with peers and experts,
reflecting on their learning experiences, and participating in authentic, real-world tasks. The Sora model aims to create a more 
student-centered and engaging learning environment.')"""

1.3 格式化输入prompt

prompt template（提示模板）的使用，prompt中可以加入变量，让prompt的构造更加灵活

# 我们也可以创建prompt template, 并引入一些变量到prompt template中，这样在应用的时候更加灵活
from langchain_core.prompts import ChatPromptTemplate

# 需要注意的一点是，这里需要指明具体的role，在这里是system和用户
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are the technical writer"),
    ("user", "{input}")  # {input}为变量
])

# 我们可以把prompt和具体llm的调用和在一起（通过chain，chain可以理解为sequence of calls to take）
chain = prompt | llm 
chain.invoke({"input": "What is the Sora model?"})

from langchain_core.output_parsers import StrOutputParser

output_parser = StrOutputParser()  # 输出string
chain = prompt | llm | output_parser
chain.invoke({"input": "What is the Sora model?"})

问题: 大模型对Sora理解不到位，为什么？ 如何解决？

使用RAG： 去网上获取最新的关于Sora的内容

1.4  RAG+Langchain

1.4.1 搜索相关知识

基于外部知识，增强大模型回复

# !pip install beautifulsoup4
#  结合关于Sora的technical report来生成更好地答案，分几步：
#  第一步： 寻找关于Sora的一些文库，并抓取内容
#  第二步： 把文库切块（trunks)并存放到向量数据库中
#  第三步： 对于新的问题，我们首选从vector store中提取trunks, 并融合到llm的prompt里

from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://openai.com/research/video-generation-models-as-world-simulators")
docs = loader.load()

1.4.2 拆分文档，写入向量数据库

#  使用openai embedding
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()

#!pip install faiss-cpu
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 使用 recursiveCharacterTextSplitter, 在春节前的课程中讲过其算法
text_splitter = RecursiveCharacterTextSplitter()

# 把docs切分成trunks，在这里只有一个doc，因为我们只抓取了一个页面；
documents = text_splitter.split_documents(docs)

# 存放在向量数据库中。把trunk转化成向量时候用的embedding工具为 OpenAIEmbeddings
vector = FAISS.from_documents(documents, embeddings)

1.4.3 匹配对应的向量文档

1. 给定input，从vector database搜索相似的documents（文档）（trunks）
2. documents加入到prompt里面（prompt template, 变量比如{context})
3. prompt call LLM， LLM返回response(答案)
4. 通过output parser（输出解析器）得到格式化完之后的结果

# This chain takes a list of documents and formats them all into a prompt, then passes that prompt to an LLM.
from langchain.chains.combine_documents import create_stuff_documents_chain

prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context:

<context>
{context}
</context>

Question: {input}""")

document_chain = create_stuff_documents_chain(llm, prompt)

from langchain.chains import create_retrieval_chain

retriever = vector.as_retriever()
retrieval_chain = create_retrieval_chain(retriever, document_chain)

response = retrieval_chain.invoke({"input": "What is the Sora model?"})
print(response["answer"])

 create_retrieval_chain 相关参数：

1.4.4 构建Agent

非Agent：对于一个任务，我们明确制定 1. 2. 3. 4. 每一步都是非常清楚的，提前制定好的，包括调用什么模型，怎么调用。

Agent: 更加复杂的任务。

Agent开发一个APP：

项目负责人拆解任务，然后每个任务派发给不同的角色的人

假如： 提前有一些工具

• 视频做编辑的工具
• 视频转换成动画的工具
• 生成图片的工具
• 生成动画视频的工具
• TTS的工具：
• GPT的工具（输入，输出）
• 计算器工具（输入，输出）： 如果想做加减成熟等计算，要用此工具
• 编程的工具（输入，输出）
• 脚本分镜的工具（输入，输出）
• 图片的list转视频工具

任务：自动拍摄一个动画类短视频

1. GPT的工具：生成脚本（输入，输出）
2. 脚本分镜：很长的脚本分成不同的镜头
3. 每个分镜生成图片：生成图片的工具
4. 图片转换成视频

from langchain.tools.retriever import create_retriever_tool

retriever_tool = create_retriever_tool(
    retriever,
    "Sora",
    "Search for information about Sora. For any questions about Sora, you must use this tool!",
)

tools = [retriever_tool]

from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import create_openai_functions_agent
from langchain.agents import AgentExecutor


prompt = hub.pull("hwchase17/openai-functions-agent")
llm = ChatOpenAI(model="gpt-4", temperature=0)
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

agent_executor.invoke({"input": "What is the Sora model?"})

hwchase17/openai-functions-agent 是一个基于 LangChain Hub 的模板，用于构建能够调用外部函数的智能代理（Agent）。这个模板的主要功能是将 OpenAI 的语言模型与外部函数集成，使模型能够根据用户输入执行特定的操作。

 模板链接：LangSmith

二 PromptTemplate和ChatPromptTemplate

PromptTemplate 和 ChatPromptTemplate 是 LangChain 中用于生成提示（prompt）的 模板工具。

• PromptTemplate：用于生成通用的提示文本，通常用于单轮对话或简单的任务，帮助语言模型理解用户的意图并生成相应的回答。

• ChatPromptTemplate：专门用于生成聊天场景下的提示文本，更适合多轮对话，能够更好地处理对话历史和上下文信息，使对话更加连贯自然。

2.1 for LLM(base)

from langchain.prompts import PromptTemplate

prompt_template = PromptTemplate.from_template(
    "编写一段关于{主题}的小红书宣传文案，需要采用{风格}语气"
)
prompt_template.format(主题="美国留学", 风格="幽默")

# '编写一段关于美国留学的小红书宣传文案，需要采用幽默语气'

from langchain.prompts import PromptTemplate

prompt_template = PromptTemplate.from_template("编写一段关于美国留学的小红书宣传文案")
prompt_template.format()

# '编写一段关于美国留学的小红书宣传文案'

2.2 for Chat Model

from langchain_core.prompts import ChatPromptTemplate

chat_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是AI助教，你的名字是{name}."),
        ("human", "你好"),
        ("ai", "你好，有什么可以帮到您？"),
        ("human", "{user_input}"),
    ]
)

messages = chat_template.format_messages(name="张三", user_input="你的名字是什么？")
llm.invoke(messages)

# AIMessage(content='你好，我的名字是张三，我是你的AI助教。有什么可以帮助你的吗？')

chain = chat_template | llm
chain.invoke({"name":"张三", "user_input":"你的名字是什么？"})

# AIMessage(content='我的名字是张三。有什么问题我可以帮您解答呢？')

# query --> 大模型 ---> response
# w w w w w w w ...
for chunk in llm.stream(messages):
    print(chunk.content, end="", flush=True)

# 我的名字是张三。有什么问题我可以帮您解答？

# llm.invoke(messages)
# chain = messages | llm
# chain.invoke({"name":"张三", "user_input":"你的名字是什么？"})
# for chunk in llm.stream(messages):
#    print(chunk.content, end="", flush=True)

2.3 Few shot prompte templates for given examples

为给定的例子提供少量样本（Few-shot）提示模板。

from langchain.prompts import (
    ChatPromptTemplate,
    FewShotChatMessagePromptTemplate,
)

examples = [
    {"input": "2+2", "output": "4"},
    {"input": "2+3", "output": "5"},
]

# This is a prompt template used to format each individual example.
example_prompt = ChatPromptTemplate.from_messages(
    [
        ("human", "{input}"),
        ("ai", "{output}"),
    ]
)
few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
)

print(few_shot_prompt.format())

final_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a wondrous wizard of math."), # instructions
        few_shot_prompt,  # few shot examples 
        ("human", "{input}"),  # input
    ]
)

chain = final_prompt | llm
chain.invoke({"input": "4+6"})

# AIMessage(content='10')

2.4 few shot prompt template for dynamic examples

问题：why? 请自行查看 documentation

2.5 Cache（缓存）

对于之前问题的答案，直接从cache中返回，减少成本、提高效率。

%%time
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache

set_llm_cache(InMemoryCache())

# 第一次，需要直接调用，需要消耗时间
llm.invoke("讲一个冷笑话")

# AIMessage(content='为什么冰箱总是笑得开心？\n\n因为它有很多冷笑话！')

 

%%time
# 第二次调用，直接从cache中获取
llm.invoke("讲一个冷笑话")

# AIMessage(content='为什么冰箱总是笑得开心？\n\n因为它有很多冷笑话！')

2.6 追踪token的使用

from langchain.callbacks import get_openai_callback
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model_name="gpt-4")

with get_openai_callback() as cb:
    result = llm.invoke("最近心情怎么样？")
    print(cb)

with get_openai_callback() as cb:
    result = llm.invoke("Tell me three jokes")
    result2 = llm.invoke("Tell me a joke")
    print(cb)

2.7 Output Parsing 

CommaSeparatedListOutputParser() 是 LangChain 中的一个实用工具，用于将语言模型生成的文本输出解析为一个由逗号分隔的列表。当语言模型返回一个包含多个条目的字符串时，这个工具可以将字符串拆分为单独的条目，并以列表的形式返回，便于后续处理和使用。

例如，如果语言模型生成的输出是一个字符串，其中包含多个项目，如 "apple, banana, cherry"，使用 CommaSeparatedListOutputParser() 可以将其 解析为一个列表 ["apple", "banana", "cherry"]。这使得开发者能够更方便地处理和操作这些数据，例如进行进一步的分析或作为其他功能的输入。

# 创建一个 CommaSeparatedListOutputParser 实例
output_parser = CommaSeparatedListOutputParser()

# 使用提示模板生成一个具体的提示
prompt = prompt_template.format(query="apple, banana, cherry")

# 调用语言模型生成输出
response = llm(prompt)

# 使用 CommaSeparatedListOutputParser 解析输出
parsed_output = output_parser.parse(response)

# 打印解析后的列表
print(parsed_output)

三 langchain组件解析

Retrieval组件，Chain组件，Agent组件，记忆里模块

3.1 Retrieval组件（检索）

对应地址：langchain.chains.retrieval.create_retrieval_chain — 🦜🔗 LangChain 0.2.17

Retrieval 组件 是 LangChain 中 用于高效检索和管理外部数据的核心模块，它通过检索增强生成（RAG）技术为大型语言模型（LLM）提供用户特定的数据。

Retrieval 组件的作用

1. 高效检索：快速准确地从大量数据中检索出与用户查询最相关的信息。

2. 灵活集成：适应不同数据源和数据格式的检索需求。

3. 可扩展性：能够应对不断增长的数据量和查询负载。

3.1.1 Retrieval 的使用

Retrieval 组件由以下几个核心部分组成：

• Document Loaders：从各种数据源加载数据，并将其格式化为包含文本和元数据的“文档”。

• Text Splitters：将加载的文档转换为适合应用程序需求的格式，例如将大文档拆分为小片段。

• Text Embedding Models：将文本转换为向量表示，以便在向量空间中进行语义搜索。

• Vector Stores：存储嵌入向量，并执行高效的向量搜索。

• Retrievers：根据非结构化查询返回相关文档的接口。

• Indexing：将数据源同步到向量存储中，优化存储和检索过程。

from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.indexes import VectorstoreIndexCreator

# 1. 加载文档
# 假设我们有一个简单的文本文件作为数据源
loader = TextLoader("example.txt")  # 替换为你的文件路径
documents = loader.load()

# 2. 创建向量索引
# 使用默认的嵌入模型和向量存储
index_creator = VectorstoreIndexCreator()
vectorstore = index_creator.from_documents(documents)

# 3. 初始化语言模型
llm = OpenAI()  # 使用 OpenAI 的语言模型

# 4. 创建 RetrievalQA 链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # 使用简单的 "stuff" 链
    retriever=vectorstore.as_retriever()
)

# 5. 提出问题并获取回答
query = "What is the main topic of the document?"
response = qa_chain({"query": query})

# 打印回答
print(response["result"])

支持的文件类型及加载器

• 文本文件（TXT）：TextLoader

• PDF 文件：PyPDFLoader、UnstructuredPDFLoader、PDFMinerLoader 等

• Word 文件（DOCX）：Docx2txtLoader、UnstructuredFileLoader

• Excel 文件（XLSX）：UnstructuredFileLoader

• CSV 文件：CSVLoader

• Markdown 文件（MD）：UnstructuredMarkdownLoader、MarkdownTextSplitter

• HTML 文件：BSHTMLLoader、UnstructuredFileLoader

• 图像文件（如 JPG）：UnstructuredImageLoader

• JSON 文件：JSONLoader

• 多种文件类型：DirectoryLoader

 3.1.2 embedding

### text embedding
from langchain_openai import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 注意的点：
# 存储：文档—》trunks -embedding_model_A -> 向量。—〉 Vector database
# 给定一个query (string) -embedding_model_A-> 向量 —-> 去vector database搜索

# 示例文本向量化
text = "this is a text"
embedded_text = embeddings.embed_query(text)

# 输出向量结果（实际数值应为浮点型列表）
print(embedded_text)  # 示例输出格式: [-0.024295, 0.002757, 0.009773, 0.004708, ...]

3.1.3 写入向量数据库

import os
from langchain.vectorstores import Chroma
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings

# 配置OpenAI API密钥
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# ------ 文档处理与存储流程 ------
# 1. 加载文档并分割
loader = TextLoader("example_data/FDR_State_of_Union_1944.txt")
documents = loader.load()

# 2. 文本分块处理（使用tiktoken编码器）
text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=500)
docs = text_splitter.split_documents(documents)

# 3. 向量化存储到Chroma
embedding_function = OpenAIEmbeddings()
db = Chroma.from_documents(
    docs, 
    embedding_function, 
    persist_directory="../speech_new_dbl"  # 持久化目录
)
db.persist()  # 确保数据写入磁盘

# ------ 查询流程 ------
# 1. 建立数据库连接
db_new_connection = Chroma(
    persist_directory="../speech_new_dbl/",
    embedding_function=embedding_function  # 修正变量名拼写错误
)

# 2. 执行相似性搜索
new_doc = "what did FDR say about the cost of food law?"
similar_docs = db_new_connection.similarity_search(new_doc)

# 3. 输出结果
print(f"找到 {len(similar_docs)} 条相关文档片段：")
for i, doc in enumerate(similar_docs, 1):
    print(f"\n片段 {i}:\n{doc.page_content[:200]}...")  # 显示前200字符

3.1.4 检索相似文档

# 将数据库连接对象转换为检索器接口
retriever = db_new_connection.as_retriever()

# 使用检索器进行语义搜索
sim_docs = retriever.get_relevant_documents("cost food of law")

# 记录异常
if not sim_docs:
    print("未找到相关立法内容记录")

# 通过参数控制搜索行为
retriever = db.as_retriever(
    search_type="similarity",  # 相似度算法
    search_kwargs={"k": 5}     # 返回5个结果
)

3.2 Chain组件

LangChain 的 Chain（任务链） 是一种 将多个步骤串联成自动化流程的工具，类似于“任务流水线”。它通过连接不同模块（如语言模型、数据库、数据处理工具），让复杂任务（例如自动问答、内容生成）按预设步骤执行：前一步的输出自动成为下一步的输入。例如，用户提问后，Chain 可先检索资料，再用模型生成答案。

import os
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
from langchain.chains.sequential import SimpleSequentialChain
from langchain_openai import ChatOpenAI

# 配置OpenAI API密钥
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# 初始化大语言模型
llm = ChatOpenAI(temperature=0.7, model="gpt-3.5-turbo")

# ------ 定义处理链 ------
# 第一链：生成大纲
outline_template = """Give me a simple bullet point outline for a blog post on {topic}"""
outline_prompt = ChatPromptTemplate.from_template(outline_template)
outline_chain = LLMChain(llm=llm, prompt=outline_prompt, output_key="outline")

# 第二链：生成正文
content_template = """Write a blog post using this outline: {outline}"""
content_prompt = ChatPromptTemplate.from_template(content_template)
content_chain = LLMChain(llm=llm, prompt=content_prompt, output_key="post")

# ------ 构建顺序链 ------
full_chain = SimpleSequentialChain(
    chains=[outline_chain, content_chain],
    verbose=True  # 显示处理过程
)

# ------ 执行链 ------
try:
    result = full_chain.invoke({"input": "Data Science"})
    print("\n最终生成的博客文章：")
    print(result["output"]["post"])  # 提取最终输出
except Exception as e:
    print(f"生成失败: {str(e)}")

LangChain文档处理流程

1. 加载文档：从多种来源（如网页、PDF、数据库）读取原始文档，并转换为统一格式。

2. 分割文本：将长文档切割成小片段（如按段落或固定字数），便于后续处理。

3. 向量化存储：使用文本嵌入模型将文档片段转换为向量，并存入向量数据库（如Chroma）。

4. 检索与生成：当用户提问时，先从数据库检索相关文档片段，再交由语言模型（如ChatGPT）生成最终回答。

核心优势：自动化串联“加载→分割→存储→检索→生成”全流程，像流水线一样高效处理复杂任务。