LangChain实战快速入门笔记（三）--LangChain使用之Chains

Jack___Xue2025-12-13 9:57

LangChain实战快速入门笔记（三）--LangChain使用之Chains

文章目录

一、Chains的基本使用

1.Chain的基本概念

Chain: 链，用于将多个组件（提示模板、LLM 模型、记忆、工具等）连接起来，形成可复用的工作流，完成复杂的任务。

Chain 的核心思想

通过组合不同的模块化单元，实现比单一组件更强大的功能。比如：

• 将 LLM 与 Prompt Template （提示模板）结合

• 将 LLM 与输出解析器 结合

• 将 LLM 与外部数据 结合，例如用于问答

• 将 LLM 与长期记忆 结合，例如用于聊天历史记录

• 通过将第一个 LLM 的输出作为第二个 LLM 的输入，...，将多个 LLM 按顺序结合在一起

2.LCEL 及其基本构成

使用LCEL，可以构造出结构最简单的Chain。

LangChain表达式语言（LCEL，LangChain Expression Language）是一种声明式方法，可以轻松地将多个组件链接成 AI 工作流。它通过Python原生操作符（如管道符 | ）将组件连接成可执行流程，显著简化了AI应用的开发。

**LCEL的基本构成：**提示（Prompt）+ 模型（Model）+ 输出解析器（OutputParser）

即：

python 复制代码 
# 在这个链条中，用户输入被传递给提示模板，然后提示模板的输出被传递给模型，然后模型的输出被传递给输出解析器。
chain = prompt | model | output_parser

chain.invoke({"input": "What's your name?"})

• Prompt ：Prompt 是一个 BasePromptTemplate，这意味着它接受一个模板变量的字典并生成一个 PromptValue 。PromptValue 可以传递给 LLM（它以字符串作为输入）或 ChatModel（它以消息序列作为输入）。

• Model ：将 PromptValue 传递给 model。如果我们的 model 是一个 ChatModel，这意味着它将输出一个 BaseMessage 。

• OutputParser ：将 model 的输出传递给 output_parser，它是一个 BaseOutputParser，意味着它可以接受字符串或 BaseMessage 作为输入。

• chain ：我们可以使用 | 运算符轻松创建这个 Chain。| 运算符在 LangChain 中用于将两个元素组合在一起。

• invoke ：所有 LCEL 对象都实现了 Runnable 协议，保证一致的调用方式（invoke / batch / stream ）

3.Runnable

Runnable是LangChain定义的一个抽象接口（Protocol），它强制要求所有LCEL组件实现一组标准方法：

python 复制代码 
class Runnable(Protocol):
    def invoke(self, input: Any) -> Any: ...  # 单输入单输出
    def batch(self, inputs: List[Any]) -> List[Any]: ...  # 批量处理
    def stream(self, input: Any) -> Iterator[Any]: ...  # 流式输出
    # 还有其他方法如 ainvoke（异步）等...

任何实现了这些方法的对象都被视为LCEL兼容组件。比如：聊天模型、提示词模板、输出解析器、检索

器、代理(智能体)等。

每个 LCEL 对象都实现了 Runnable 接口，该接口定义了一组公共的调用方法。这使得 LCEL 对象链也自动支持这些调用成为可能。

3.1 为什么需要统一调用方式？

传统问题

假设没有统一协议：

• 提示词渲染用 .format()

• 模型调用用 .generate()

• 解析器解析用 .parse()

• 工具调用用 .run()

代码会变成：

python 复制代码 
prompt_text = prompt.format(topic="猫")  # 方法1
model_out = model.generate(prompt_text)  # 方法2
result = parser.parse(model_out)         # 方法3

痛点：每个组件调用方式不同，组合时需要手动适配。

3.2 LCEL解决方案

通过 Runnable 协议统一：

python 复制代码 
# (分步调用)
prompt_text = prompt.invoke({"topic": "猫"})  # 方法1
model_out = model.invoke(prompt_text)        # 方法2
result = parser.invoke(model_out)            # 方法3

# (LCEL管道式)
chain = prompt | model | parser  # 用管道符组合
result = chain.invoke({"topic": "猫"})  # 所有组件统一用invoke

• 一致性 ：无论组件的功能多复杂（模型/提示词/工具），调用方式完全相同

• 组合性 ：管道操作符 | 背后自动处理类型匹配和中间结果传递

3.3 使用举例

举例1：

情况1：没有使用chain

python 复制代码 
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
import os
import dotenv

dotenv.load_dotenv()

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY1")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")

chat_model = ChatOpenAI(
    model = "gpt-4o-mini"
)

prompt_template = PromptTemplate.from_template(
    template = "给我讲一个关于{topic}话题的简短笑话"
)

parser = StrOutputParser()

prompt_value = prompt_template.invoke({"topic": "冰淇淋"})
result = chat_model.invoke(prompt_value)
out_put = parser.invoke(result)

print(out_put)
print(type(out_put))

情况2：使用chain：将提示模板、模型、解析器链接在一起。使用LCEL将不同的组件组合成一个单一的链条

python 复制代码 
from dotenv import load_dotenv
from langchain_core.output_parsers import StrOutputParser

load_dotenv()
chat_model = ChatOpenAI(model="gpt-4o-mini")


prompt_template = PromptTemplate.from_template(
    template = "给我讲一个关于{topic}话题的简短笑话"
)

parser = StrOutputParser()

# 构建链式调用（LCEL语法）
chain = prompt_template | chat_model | parser
out_put = chain.invoke({"topic": "ice cream"})

print(out_put)
print(type(out_put))

二、传统Chain的使用

1.基础链：LLMChain

1.1 使用说明

LCEL之前，最基础也最常见的链类型是LLMChain。
这个链至少包括一个提示词模板（PromptTemplate），一个语言模型（LLM 或聊天模型）。
特点：

• 用于 单次问答 ，输入一个 Prompt，输出 LLM 的响应。

• 适合 无上下文 的简单任务（如翻译、摘要、分类等）。

• 无记忆：无法自动维护聊天历史

1.2 主要步骤

1、 配置任务链：使用LLMChain类将任务与提示词结合，形成完整的任务链。

python 复制代码 
result = chain.invoke(...)

print(result)

1.3 参数说明

这里我们可以整理如下：

举例1：
python 复制代码 
from langchain.chains.llm import LLMChain
from langchain_core.prompts import PromptTemplate
import os
import dotenv
from langchain.openai import ChatOpenAI

dotenv.load_dotenv()

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY1")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")

# 1、创建大模型实例
chat_model = ChatOpenAI(model="gpt-4o-mini")

# 2、原始字符串模板
template = "桌上有{number}个苹果，四个桃子和3本书，一共有几个水果？"
prompt = PromptTemplate.from_template(template)

# 3、创建LLMChain
llm_chain = LLMChain(
    llm=chat_model,
    prompt=prompt
)

# 4、调用LLMChain，返回结果
result = llm_chain.invoke({"number": 2})
print(result)
举例2：verbose参数，使用使用ChatPromptTemplate。
python 复制代码 
# 1.导入相关包
from langchain.chains.llm import LLMChain
from langchain_core.prompts import ChatPromptTemplate
from langchain.openai import ChatOpenAI

# 2.定义提示词模板对象
chat_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一位{area}领域具备丰富经验的高端技术人才"),
        ("human", "给我讲一个{adjective}笑话"),
    ]
)

# 3.定义模型
llm = ChatOpenAI(model="gpt-4o-mini")

# 4.定义LLMChain
llm_chain = LLMChain(llm=llm, prompt=chat_template, verbose=True)

# 5.调用LLMChain
response = llm_chain.invoke({"area": "互联网", "adjective": "上班的"})
print(response)

补充说明：调用方法除了invoke()外，还有run()、predict()、实例方法等，效果与invoke()相同，这里不再介绍。

2. 顺序链之 SimpleSequentialChain

顺序链（SequentialChain）允许将多个链顺序连接起来，每个Chain的输出作为下一个Chain的输入，

形成特定场景的流水线（Pipeline）。
顺序链有两种类型：

• 单个输入/输出：对应着 SimpleSequentialChain

• 多个输入/输出：对应着：SequentialChain

2.1 说明

SimpleSequentialChain：最简单的顺序链，多个链 串联执行 ，每个步骤都有单一的输入和输出，一个步骤的输出就是下一个步骤的输入，无需手动映射。

2.2 使用举例

python 复制代码 
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain

chainA_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一位精通各领域知识的知名教授"),
        ("human", "请你尽可能详细的解释一下：{knowledge}"),
    ]
)

chainA_chains = LLMChain(llm=llm,
                         prompt=chainA_template,
                         verbose=True
                         )

chainA_chains.invoke({"knowledge": "什么是LangChain？"})

继续：

python 复制代码 
from langchain_core.prompts import ChatPromptTemplate

chainB_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你非常善于提取文本中的重要信息，并做出简短的总结"),
        ("human", "这是针对一个提问的完整的解释说明内容：{description}"),
        ("human", "请你根据上述说明，尽可能简短的输出重要的结论，请控制在20个字以内"),
    ]
)

chainB_chains = LLMChain(llm=llm,
                         prompt=chainB_template,
                         verbose=True
                         )
python 复制代码 
# 导入SimpleSequentialChain
from langchain.chains import SimpleSequentialChain

# 在chains参数中，按顺序传入LLMChain A和LLMChain B
full_chain = SimpleSequentialChain(chains=[chainA_chains, chainB_chains], verbose=True)
full_chain.invoke({"input": "什么是langChain？"})

在这个过程中，因为SimpleSequentialChain 定义的是顺序链，所以在chains 参数中传递的列表要按照顺序来进行传入，即LLMChain A 要在LLMChain B之前。同时，在调用时，不再使用LLMChain A中定义的**{knowledge}** 参数，也不是LLMChainB中定义的**{description}**参数，而是要使用 input进行变量的传递。

源码：

python 复制代码 
class SimpleSequentialChain(Chain):
    """Simple chain where the outputs of one step feed directly into next."""

    chains: List[Chain]
    strip_outputs: bool = False
    input_key: str = "input"  #:meta private:
    output_key: str = "output"  #:meta private:

举例2：

创建了两条chain，并且让第一条chain给剧名写大纲，输出该剧名大纲，作为第二条chain的输入，然后生成一个剧本的大纲评论。最后利用SimpleSequentialChain即可将两个chain直接串联起来。

python 复制代码 
# 1.导入相关包
from langchain.chains import LLMChain
from langchain_core.prompts import PromptTemplate
from langchain.chains import SimpleSequentialChain

# 2.创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 3.定义一个给剧名写大纲的LLMChain
template1 = """你是个剧作家，给定剧本的标题，你的工作就是为这个标题写一个大纲。
Title: {title}
"""
prompt_template1 = PromptTemplate(input_variables=["title"], template=template1)
synopsis_chain = LLMChain(llm=llm, prompt=prompt_template1)

# 4.定义一个剧本大纲写一篇评论的LLMChain
template2 = """你是《纽约时报》的剧评家，有了剧本的大纲，你的工作就是为剧本写一篇评论
剧情大纲:
{synopsis}
"""
prompt_template2 = PromptTemplate(input_variables=["synopsis"], template=template2)
review_chain = LLMChain(llm=llm, prompt=prompt_template2)

# 5.定义一个完整的链按顺序运行这两条链
# (verbose=True打印链的执行过程)
overall_chain = SimpleSequentialChain(
    chains=[synopsis_chain, review_chain], verbose=True
)

# 6.调用完整链顺序执行这两个链
review = overall_chain.invoke("日落海滩上的悲剧")

# 7.打印结果
print(review)

3. 顺序链之SequentialChain

3.1 说明

SequentialChain：更通用的顺序链，具体来说：

• 多变量支持 ：允许不同子链有独立的输入/输出变量。

• 灵活映射 ：需 显式定义 变量如何从一个链传递到下一个链。即精准地命名输入关键字和输出关键字，来明确链之间的关系。

• 复杂流程控制 ：支持分支、条件逻辑（分别通过 input_variables 和 output_variables 配置输入和输出）。

3.2 使用举例

举例1：

python 复制代码 
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import SequentialChain
from langchain.openai import ChatOpenAI
from langchain.chains import LLMChain
from openai import OpenAI
import os

# 创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

schainA_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一位精通各领域知识的知名教授"),
        ("human", "请你先尽可能详细的解释一下：{knowledge}，并且{action}")
    ]
)

schainA_chains = LLMChain(llm=llm,
                          prompt=schainA_template,
                          verbose=True,
                          output_key="schainA_chains_key"
                          )

# schainA_chains.invoke({
# "knowledge": "中国的篮球怎么样？",
# "action": "举一个实际的例子"
# })

schainB_template = ChatPromptTemplate.from_messages(
    [
        ("system", "你非常善于提取文本中的重要信息，并做出简短的总结"),
        ("human", "这是针对一个提问完整的解释说明内容：{schainA_chains_key}"),
        ("human", "请你根据上述说明，尽可能简短的输出重要的结论，请控制在100个字以内")
    ]
)

schainB_chains = LLMChain(llm=llm,
                          prompt=schainB_template,
                          verbose=True,
                          output_key="schainB_chains_key"
                          )

Seq_chain = SequentialChain(
    chains=[schainA_chains, schainB_chains],
    input_variables=["knowledge", "action"],
    output_variables=["schainA_chains_key", "schainB_chains_key"],
    verbose=True
)

response = Seq_chain.invoke({
    "knowledge": "中国足球为什么踢得烂",
    "action": "举一个实际的例子"
})

print(response)

还可以单独输出：

python 复制代码 
print(response["schainA_chains_key"])

print(response["schainB_chains_key"])

举例2：

python 复制代码 
# 1.导入相关包
from langchain.chains.llm import LLMChain
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
from langchain.chains import SequentialChain

# 创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 2.定义任务链一
# first chain1 任务：翻译成中文
first_prompt = PromptTemplate.from_template("把下面内容翻译成中文:\n\n{content}")
chain_one = LLMChain(
    llm=llm,
    prompt=first_prompt,
    verbose=True,
    output_key='Chinese_Review'
)

# 3.定义任务链二
# chain2 任务：对翻译后的中文进行总结摘要 input key是上一个chain的output key
second_prompt = PromptTemplate.from_template("用一句话总结下面内容:\n\n{Chinese_Review}")
chain_two = LLMChain(
    llm=llm,
    prompt=second_prompt,
    verbose=True,
    output_key='Chinese_Summary'
)

# 4.定义任务链三
# chain3 任务：识别语言
third_prompt = PromptTemplate.from_template("下面内容是什么语言:\n\n{Chinese_Summary}")
chain_three = LLMChain(
    llm=llm,
    prompt=third_prompt,
    verbose=True,
    output_key='language'
)

# 5.定义任务链四
# chain4 任务对摘要要使用指定语言进行评论 input key是上一个chain的output key
fourth_prompt = PromptTemplate.from_template("请使用指定的语言对以下内容进行评论:\n\n内容{Chinese_Summary}\n\n语言{language}")
chain_four = LLMChain(
    llm=llm,
    prompt=fourth_prompt,
    verbose=True,
    output_key='Comment'
)

# 6.总链
# overall 任务：翻译成中文->为翻译后的中文进行总结摘要->智能识别语言->针对摘要使用指定语言
overall_chain = SequentialChain(
    chains=[chain_one, chain_two, chain_three, chain_four],
    input_variables=['content'],
    output_variables=['Chinese_Review', 'Chinese_Summary', 'language', 'Comment'],
)

#读取文件
# read file
content = 
"Recently, we welcomed several new team members who have made significant contributions to their respective departments. I would like to recognize Jane Smith (SSN: 04945-5928) for her outstanding performance in customer service. Jane has consistently received positive feedback from our clients. Furthermore, please remember that the open enrollment period for our employee benefits program is fast approaching. Should you have any questions or require assistance, please contact our HR representative, Michael Johnson (phone: 418-4923850, email: michael.johnson@example.com)."
overall_chain.invoke(content)





3.3 顺序链使用场景

场景 ：多数据源处理

举例：根据产品名

使用 SimpleSequentialChain（会失败）

python 复制代码 
# 假设链1返回 {"price": 100}, 链2需要 {product: "xx", price: xx}
# 结构不匹配，无法自动传递！

使用 SequentialChain（正确方式）

python 复制代码 
from langchain.chains import SequentialChain

# 创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 第1环节:
query_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(template="请模拟查询{product}的市场价格，直接返回一个合理的价格数字（如6999），不要包含任何其他文字或代码）",
    verbose=True,
    output_key="price"
)

# 第2环节:
promo_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(template="为{product}（售价：{price}元）创作一篇50字以内的促销文案，要求突出产品卖点）",
    verbose=True,
    output_key="promo_text"
)

sequential_chain = SequentialChain(
    chains=[query_chain, promo_chain],
    verbose=True,
    input_variables=["product"],  # 初始输入
    output_variables=["price", "promo_text"],  # 输出价格和文案
)

result = sequential_chain.invoke({"product": "iPhone16"})
print(result)
# print(result["price"])
# print(result["promo_text"])

通过这两个例子可以看出：当需要处理多变量或异构数据时，SequentialChain 的灵活性是必不可少的。

4. 数学链 LLMMathChain (了解)

LLMMathChain将用户问题转换为数学问题，然后将数学问题转换为可以使用 Python 的 numexpr 库执行的表达式。使用运行此代码的输出来回答问题。

使用LLMMathChain，需要安装numexpr库👇：

python 复制代码 
pip install numexpr
python 复制代码 
from langchain.chains import LLMMathChain
import os
import dotenv
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain

dotenv.load_dotenv()

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY1")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")

# 创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 创建链
llm_math = LLMMathChain.from_llm(llm)

# 执行链
res = llm_math.invoke("10 ** 3 + 100的结果是多少？")
print(res)

5. 路由链 RouterChain (了解)

路由链（RouterChain）用于创建可以动态选择下一条链的链。可以自动分析用户的需求，然后引导到最适合的链中执行，获取响应并返回最终结果。

比如，我们目前有三类chain，分别对应三种学科的问题解答。我们的输入内容也是与这三种学科对应，但是随机的，比如第一次输入数学问题、第二次有可能是历史问题... 这时候期待的效果是：可以根据输入的内容是什么，自动将其应用到对应的子链中。RouterChain就为我们提供了这样一种能力。


RouterChain图示：

6. 文档链 StuffDocumentsChain(了解)

StuffDocumentsChain 是一种文档处理链，它的核心作用是将
多个文档内容合并（"填充"或"塞入"）到单个提示（prompt）中，然后传递给语言模型（LLM）进行处理。

使用场景 ：由于所有文档被完整拼接，LLM 能同时看到全部内容，所以适合需要全局理解的任务，如总结、问答、对比分析等。但注意，仅适合处理 少量/中等长度文档 的场景。

举例：

python 复制代码 
#1.导入相关包
from langchain.chains import StuffDocumentsChain
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.document_loaders import PyPDFLoader
from langchain.chat_models import ChatOpenAI

#2.加载PDF
loader = PyPDFLoader("./asset/example/loader.pdf")

#3.定义提示词
prompt_template = """对以下文字做简洁的总结:
{text}
简洁的总结:"""

#4.定义提示模板
prompt = PromptTemplate.from_template(prompt_template)

#5.定义模型
llm = ChatOpenAI(model="gpt-4o-mini")

#6.定义LLM链
llm_chain = LLMChain(llm=llm, prompt=prompt )

#7.定义文档链
stuff_chain = StuffDocumentsChain(
    llm_chain=llm_chain,
    document_variable_name="text", # 在prompt模板中,文档内容应该用哪个变量名表示
)#document_variable_name="text"告诉StuffDocumentsChain把合并后的文档内容填充到{text}变量中。

#8.加载pdf文档
docs = loader.load()

#9.执行链
res=stuff_chain.invoke(docs)
#print(res)
print(res["output_text"])

三、基于LCEL构建的Chains的类型

前面讲解的都是Legacy Chains，下面看最新的基于LCEL构建的Chains。

sql 复制代码 
create_sql_query_chain
create_stuff_documents_chain
create_openai_fn_runnable
create_structured_output_runnable
load_query_constructor_runnable
create_history_aware_retriever
create_retrieval_chain

1. create_sql_query_chain

create_sql_query_chain，SQL查询链，是创建生成SQL查询的链，用于将 自然语言 转换成 数据库的SQL查询

举例1：

这里使用MySQL数据库，需要安装pymysql👇

python 复制代码 
pip install pymysql
python 复制代码 
from langchain_community.utilities import SQLDatabase

# 连接 MySQL数据库
db_user = "root"
db_password = "abc123"  # 根据自己的密码填写
db_host = "127.0.0.1"
db_port = "3306"
db_name = "atguigudb"

# mysql+pymysql://用户名:密码@ip地址:端口号/数据库名
db = SQLDatabase.from_uri(f"mysql+pymysql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}")

print("哪种数据库：", db.dialect)
print("获取数据表：", db.get_usable_table_names())
# 执行查询
res = db.run("SELECT count(*) FROM employees;")
print("查询结果：", res)

进而：

python 复制代码 
from langchain_openai import ChatOpenAI
from langchain.chains.sql_database.query import create_sql_query_chain

# 创建大模型实例
llm = ChatOpenAI(model="gpt-4o-mini")

# 调用Chain
chain = create_sql_query_chain(llm=llm, db=db)
# response = chain.invoke({"question": "数据表employees中哪个员工工资高？"})
# print(response)
# response = chain.invoke({"question": "查询departments表中一共有多少个部门？"})
# print(response)
# response = chain.invoke({"question": "查询last_name叫King的基本情况"})
# print(response)
## 限制使用的表
response = chain.invoke({"question": "一共有多少个员工？", "table_names_to_use": ["employees"]})
print(response)

2. create_stuff_documents_chain(了解)

create_stuff_documents_chain用于将多个文档内容合并成单个长文本的链式工具，并一次性传递给LLM处理（而不是分多次处理）。

适合场景：

• 保持上下文完整，适合需要全局理解所有文档内容的任务（如总结、问答）

•适合处理 少量/中等长度文档 的场景。

举例1：多文档摘要

python 复制代码 
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.documents import Document

# 定义提示词模板
prompt = PromptTemplate.from_template("""
如下文档{docs}中说，香蕉是什么颜色的？
""")

# 创建链
llm = ChatOpenAI(model="gpt-4o-mini")
chain = create_stuff_documents_chain(llm, prompt, document_variable_name="docs")

# 文档输入
docs = [
    Document(
        page_content="苹果，学名Malus pumila Mill，别称西洋苹果、奈，属于蔷薇科苹果属的植物。苹果是全球最广泛种植和销售的水果之一，具有悠久的栽培历史和广泛的分布范围。苹果的原始种群主要起源于中亚的天山山脉附近，尤其是现代哈萨克斯坦的阿拉木图地区，提供了所有现代苹果品种的基因库。苹果通过早期的贸易路线，如丝绸之路，从中亚向外扩散到全球各地。"
    ),
    Document(
        page_content="香蕉是白色的水果，主要产自热带地区。"
    ),
    Document(
        page_content="蓝莓是蓝色的浆果，含有抗氧化物质。"
    )
]

# 执行摘要
chain.invoke({"docs": docs})

总结

记得关注么么哒

相关推荐
jinxinyuuuus2 小时前
FIRE之旅 财务计算器：实时交互式建模与前端性能工程
前端·人工智能·算法·自动化
IT·小灰灰2 小时前
当AI开口说话：可灵视频2.6如何终结“默片时代“重塑视听共生
大数据·人工智能·python·深度学习·数据挖掘·开源·音视频
nju_spy2 小时前
复杂结构数据挖掘（八）社交网络挖掘：标签传播、社区发现、影响力传播
人工智能·数据挖掘·谱聚类·社交网络挖掘·图标签转播·迭代改进·社交影响力分析
多则惑少则明2 小时前
AI测试、大模型测试(八)SpringAI核心技术
人工智能·ai测试·ai大模型测试
youcans_2 小时前
【跟我学YOLO】Mamba-YOLO-World：YOLO-World与Mamba 融合的开放词汇目标检测
论文阅读·人工智能·yolo·计算机视觉·mamba
Python极客之家2 小时前
基于数据挖掘的中风智能预测系统
人工智能·python·数据挖掘·毕业设计·课程设计
摇滚侠2 小时前
Redis 零基础到进阶，类型概述，命令查询，key 操作命令，大小写和帮助命令，string，list，hash，set，笔记11-19
redis·笔记·哈希算法
yiersansiwu123d2 小时前
AI重构日常生活：从无感服务到智能生态的全面进化
人工智能·重构
Elwin Wong2 小时前
将你的LangChian Agent可视化
人工智能·langchain·agent
热门推荐
01GitHub 镜像站点02【AutoGLM部署】本地私有化部署AI手机Agent03UV安装并设置国内源04【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）05Open-AutoGLM Windows 安装部署教程06Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08Linux下V2Ray安装配置指南09Windows 11 官方系统安装与重装完整教程（2025年最新版）10BongoCat - 跨平台键盘猫动画工具