跳转到主要内容

LangChain

12 · 检索与优化

检索失效场景与优化手段,含 BM25 混合检索与 Docker 部署 Elasticsearch

  • LangChain
  • Python

本节速览

这一节的每一块内容,分别是干什么的:

内容是干什么的
MultiQueryRetrieverLLM 把一个问题改写成多个角度,提高召回
ContextualCompressionRetriever检索后再用 LLM 压缩出最相关的片段
相似度阈值过滤按 score 卡掉不相关文档
BM25(rank_bm25)关键词字面检索,精确词一击命中,零部署
Docker 部署 Elasticsearch生产级 BM25:持久化、增量、中文分词

基础检索是「问题转向量,取相似度最高的 top-k 块」。相似度只度量字面与浅层语义的距离,两类场景会失效。本章先看失效场景,再给两种优化手段。

本章每块代码都自带 embeddings 的构造(GLM embedding-3,写法见 11 章),单独复制任意一块都能直接跑,不依赖前面的块:

import os   # 读取环境变量

from dotenv import load_dotenv   # 从 .env 读环境变量
from langchain_openai import OpenAIEmbeddings   # OpenAI 兼容的向量化接口

load_dotenv()

embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,原因见 11 章
)

少数几块(混合检索、ES 混合检索)会复用上文已建好的 bm25、docs、es、vectorstore 等对象,已在块前明确标注「接上一块」,连着上文一起跑即可。

一个贯穿全章的约束:加载已建好的向量库时,传的 embedding 必须是建库时那个模型——11 章用 GLM embedding-3 建的库,这里就得用 GLM embedding-3 加载,换了模型向量空间对不上,检索结果直接失效。

两类检索失效场景

场景一:提问缺少原文关键词。 问「下酒菜一般是什么」,原文的答案在「便可以买一碟盐煮笋,或者茴香豆,做下酒物」这一块里,但「下酒菜」一词原文不存在。相似度排序会偏离真正包含答案的块。增大 k 能缓解,不能根治。

实测一次(语料《孔乙己》,k=2):

from langchain_openai import OpenAIEmbeddings   # OpenAI 兼容的向量化接口
from langchain_core.vectorstores import InMemoryVectorStore   # 内存向量库
import os   # 读取环境变量
from dotenv import load_dotenv   # 从 .env 读环境变量

load_dotenv()
embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,见 11 章
)

# 语料《孔乙己》节选入库(演示用;真实项目由文档加载 + 切分而来)
vectorstore = InMemoryVectorStore.from_texts(
    [
        "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
        "他对人说话,总是满口之乎者也,教人半懂不懂的",
        "孔乙己是站着喝酒而穿长衫的唯一的人",
    ],
    embedding=embeddings,
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

for doc in retriever.invoke("下酒菜一般是什么?"):
    print(doc.page_content[:30])

示例输出:

要酒要菜,慢慢地坐喝
倘肯多花一文,便可以买一碟盐煮笋,或者茴香豆,做下酒物

第一条只是字面带「菜」,不含答案;真正包含答案的块排在第二。「下酒菜」这个词原文里没有,相似度就被字面相近的内容带偏了。

场景二:需要多层语义转换。 问「孔乙己用什么谋生」,答案在「替人抄书换一碗饭吃」这类描述中。从「谋生」到「抄书」要先抽象「生计手段」、再匹配具体行为,两层转换超出向量相似度的表达范围。

对策:场景一用 LLM 改写查询(MultiQueryRetriever),场景二靠 LLM 改写或上层模型推理兜底。

场景三:精确词不敏感。 问「ERR_CONN_RESET 是什么问题」,报错码、型号、人名这类字符串对 embedding 来说是「无语义的乱码」,向量排不出差异,唯一包含答案的块可能进不了 top-k。这类问题向量天生弱,要靠**关键词检索(BM25)**兜底——本章后半专门讲。

MultiQueryRetriever:LLM 改写查询

没有它会怎样——用户问法单一,向量库措辞稍有不同就漏:问「怎么防止 cookis 被盗」,库里写的是「会话固定攻击防护」,top-k 全是擦边的,答案缺关键一块。

有了它——LLM 把一个问题改写成多个角度再各查一遍、并集去重,召回率明显上来。

用 LLM 把问题改写成几条不同表述(默认 3 条),各检索一次再合并去重,克服关键词与原文不一致的偏差:

from langchain_openai import ChatOpenAI, OpenAIEmbeddings   # 聊天模型与向量化
import os   # 读取环境变量
from dotenv import load_dotenv   # 从 .env 读环境变量
from langchain_classic.retrievers import MultiQueryRetriever   # 多路改写检索器
from langchain_core.vectorstores import InMemoryVectorStore   # 内存向量库

load_dotenv()

llm = ChatOpenAI(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["GLM_MODEL_ID"],
)
embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,见 11 章
)

# 语料《孔乙己》节选入库(演示用;真实项目由文档加载 + 切分而来)
vectorstore = InMemoryVectorStore.from_texts(
    [
        "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
        "他对人说话,总是满口之乎者也,教人半懂不懂的",
        "孔乙己是站着喝酒而穿长衫的唯一的人",
    ],
    embedding=embeddings,
)

retriever = MultiQueryRetriever.from_llm(
    llm=llm,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
)

res = retriever.invoke("茴香豆是做什么用的")

(这里用 InMemoryVectorStore 就地建库,图的是单块可直接跑通。真实项目里检索的是已落盘的向量库——本套教程的 19 章综合项目用的是 Qdrant,加载后 .as_retriever() 即可;想用本地文件库,FAISS 的 load_local("db/kongyiji", embeddings, allow_dangerous_deserialization=True) 是等价方案,见 11 章。无论哪种,加载时传的 embeddings 必须是建库时那个模型。)

要点:

  • 想看生成的改写 query,把模块日志调到 INFO:logging.getLogger("langchain_classic.retrievers.multi_query").setLevel(logging.INFO)。
  • 内置 prompt 默认生成 3 条改写。要改条数就换 from_llm 的 prompt 参数;include_original=True 可以把原始问题也纳入检索。
  • 每次调用增加 1 次 LLM 改写加 N 次检索,延迟与费用同步上升。改写对模型能力要求不高,用便宜模型承担。

ContextualCompressionRetriever:LLM 压缩文档

没有它会怎样——命中的 chunk 动辄几千字,真正相关的就两句;全塞给模型,token 花在无关内容上,还稀释注意力,答案质量反而降。

有了它——检索后先用 LLM 把每块压到只剩相关部分,进 prompt 的字字有用。

k 的两难:k 小可能漏掉答案;k 大则无关内容挤占上下文。压缩检索在检索之后追加一步:LLM 从每个文档中原样摘出与问题相关的片段,无关文档整体丢弃:

from langchain_openai import ChatOpenAI, OpenAIEmbeddings   # 聊天模型与向量化
import os   # 读取环境变量
from dotenv import load_dotenv   # 从 .env 读环境变量
from langchain_classic.retrievers import ContextualCompressionRetriever   # 压缩式检索器
from langchain_classic.retrievers.document_compressors import LLMChainExtractor   # LLM 摘取相关片段
from langchain_core.vectorstores import InMemoryVectorStore   # 内存向量库

load_dotenv()

llm = ChatOpenAI(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["GLM_MODEL_ID"],
)
embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,见 11 章
)

compressor = LLMChainExtractor.from_llm(llm)

# 语料《孔乙己》节选入库(演示用;真实项目由文档加载 + 切分而来)
vectorstore = InMemoryVectorStore.from_texts(
    [
        "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
        "他对人说话,总是满口之乎者也,教人半懂不懂的",
        "孔乙己是站着喝酒而穿长衫的唯一的人",
    ],
    embedding=embeddings,
)

retriever = ContextualCompressionRetriever(
    base_compressor=compressor,
    base_retriever=vectorstore.as_retriever(search_kwargs={"k": 2}),
)

res = retriever.invoke("茴香豆是做什么用的")

内置 prompt 有两处关键设计:*AS IS* 与 *DO NOT* edit 强制原样摘录,防止 LLM 改写或脑补原文;无相关内容时返回固定标记 NO_OUTPUT,该文档被丢弃。

坑:每个文档一次 LLM 调用;「是否相关」由 LLM 判断,存在关键信息被误判为无关的风险。

按相似度阈值过滤(ScoreThresholdRetriever 已移除)

没有它会怎样——库里根本没有答案时,检索器照样返回「最像」的 top-k,模型拿着不相关资料硬答,一本正经地胡说。

有了它——score 低于阈值的直接丢,没有相关资料就明确说没有,不硬编。

旧教程里的 ScoreThresholdRetriever(相似度达标才返回)在 1.x 中已移除,langchain-classic 和 langchain-community 里都没有这个类。需要「只要达标结果」时,直接取带分数的检索结果自己过滤:

from langchain_openai import OpenAIEmbeddings   # OpenAI 兼容的向量化接口
from langchain_core.vectorstores import InMemoryVectorStore   # 内存向量库
import os   # 读取环境变量
from dotenv import load_dotenv   # 从 .env 读环境变量

load_dotenv()
embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,见 11 章
)

# 语料《孔乙己》节选入库(演示用;真实项目由文档加载 + 切分而来)
vectorstore = InMemoryVectorStore.from_texts(
    [
        "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
        "他对人说话,总是满口之乎者也,教人半懂不懂的",
        "孔乙己是站着喝酒而穿长衫的唯一的人",
    ],
    embedding=embeddings,
)

results = vectorstore.similarity_search_with_score("茴香豆是做什么用的", k=5)

for doc, score in results:
    print(round(score, 4), doc.page_content[:20])   # 先看分数分布,再定阈值
# 0.5636 便可以买一碟盐煮笋,或者茴香豆,做下酒物
# 0.3707 孔乙己是站着喝酒而穿长衫的唯一的人
# 0.3597 他对人说话,总是满口之乎者也,教人半懂不

hits = [doc for doc, score in results if score >= 0.45]   # 阈值按自己的语料实测
print(len(hits), hits[0].page_content[:20] if hits else "(全部被过滤)")
# 1 便可以买一碟盐煮笋,或者茴香豆,做下酒物

InMemoryVectorStore 返回的是相似度(越大越近),所以过滤条件是 score >= 阈值;这里 0.45 卡在「相关块 0.56」和「不相关块 0.37」之间,只留下真正相关的那条。阈值不能照抄——它取决于 embedding 模型和语料,0.8 这种凭感觉的值在 Cosine 相似度下经常会把所有结果都挡掉(实测最高分才 0.56),表现成「什么都答不上来」却不报错,是最隐蔽的坑。

对比:FAISS 的 similarity_search_with_score 返回的是距离(越小越近),过滤条件反过来是 score <= 阈值。换向量库时先 print 几条分数看清方向和量级,再定阈值——19 章的 calibrate.py 就是把这件事自动化了。

BM25:关键词检索与混合检索

没有它会怎样——向量检索管「意思一样字不一样」,但管不了「就是这个字」:报错码、产品型号、人名这类精确词,embedding 分不出差异,唯一含答案的块被挤出 top-k。

有了它——BM25 按字面词匹配打分,精确词一击命中;与向量检索两路并行、结果融合,就是混合检索(Hybrid Search)。

BM25 是 TF-IDF 的改良版打分算法,直觉两点:词频饱和——某词出现 10 次的得分到不了 5 次的两倍,防止堆词刷分;文档长度归一——长文档不因为字多而占便宜。它不做任何语义理解,只认字面。使用上分轻重两档:轻量用 rank_bm25(纯 Python,进程内跑),生产用 Elasticsearch(BM25 就是它的默认文本评分)。

用法一:rank_bm25,零部署起步

pip install rank_bm25 jieba
from langchain_community.retrievers import BM25Retriever   # 关键词检索器
from langchain_core.documents import Document   # 统一文档对象
import jieba   # 中文分词

corpus = [
    "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
    "他对人说话,总是满口之乎者也,教人半懂不懂的",
    "连接失败时网关返回 ERR_CONN_RESET,多为上游服务重启所致",
    "孔乙己是站着喝酒而穿长衫的唯一的人",
]
docs = [Document(page_content=t, metadata={"id": i}) for i, t in enumerate(corpus)]

# 坑:rank_bm25 默认按空格切词,中文整句会变成一个"词",检索直接失效
# 必须传 preprocess_func 自己分词
bm25 = BM25Retriever.from_documents(docs, preprocess_func=lambda x: jieba.lcut(x))
bm25.k = 2

for doc in bm25.invoke("ERR_CONN_RESET 什么意思"):
    print(doc.page_content)
# 连接失败时网关返回 ERR_CONN_RESET,多为上游服务重启所致

单独一路 BM25 解决精确词,单独一路向量解决语义——混合检索把两路的结果融合。接上一块:用到上面建好的 bm25 与语料 docs。

from langchain_openai import OpenAIEmbeddings   # OpenAI 兼容的向量化接口
from langchain_classic.retrievers import EnsembleRetriever   # 多路融合检索器
from langchain_core.vectorstores import InMemoryVectorStore   # 内存向量库
import os   # 读取环境变量
from dotenv import load_dotenv   # 从 .env 读环境变量

load_dotenv()
embeddings = OpenAIEmbeddings(
    base_url=os.environ["GLM_BASE_URL"],
    api_key=os.environ["GLM_API_KEY"],
    model=os.environ["EMBEDDING_ID"],
    check_embedding_ctx_length=False,   # 非 OpenAI 端点必须,见 11 章
)

# bm25、docs 来自上一块「用法一」
vectorstore = InMemoryVectorStore.from_documents(docs, embedding=embeddings)

hybrid = EnsembleRetriever(
    retrievers=[bm25, vectorstore.as_retriever(search_kwargs={"k": 2})],
    weights=[0.4, 0.6],   # 两路权重,按自己的语料实测调
)

for doc in hybrid.invoke("下酒菜一般是什么?"):
    print(doc.page_content[:30])
# 孔乙己是站着喝酒而穿长衫的唯一的人
# 便可以买一碟盐煮笋,或者茴香豆,做下酒物
# 连接失败时网关返回 ERR_CONN_RESET,多为上游服务重启所致

先别急着觉得结果对了——真正含答案的「便可以买一碟盐煮笋…做下酒物」被挤到了第二,第一是无关的「孔乙己是站着喝酒」。这不是 bug,是 RRF 的机制:它按「两路排名的倒数」求和,偏好多路都命中的块。「孔乙己」那条恰好在 BM25 路(排第 1)和向量路(排第 2)都出现了,两路加分叠加,就压过了只在向量路命中的正确答案。

对这个纯语义查询,BM25 那一路其实是噪声(「下酒菜」在原文无精确匹配,BM25 只能按 IDF 乱排),它把正确答案挤下去了。实测想纠正它:

做法top1 结果
混合 weights=[0.4, 0.6]孔乙己…(错)
混合 weights=[0.2, 0.8](调低 BM25 权重)孔乙己…还是错
去掉 BM25,纯向量便可以买一碟盐煮笋…(对)

调低 BM25 权重并不能翻盘——因为 RRF 是排名倒数求和,只要「孔乙己」在两路都上榜,它就同时拿两路的分;把 BM25 权重从 0.4 降到 0.2,它那一路的排名贡献仍在,不足以被单路的正确答案超过。真要纠正,得对纯语义查询直接去掉 BM25 这一路。

这恰恰说明混合检索不是「永远更好」:

  • 它的前提是「两路各有一路擅长」。本例的查询是纯语义的,BM25 全程帮倒忙,反而把正确答案挤下去了。
  • 在这个 29 块的干净小语料上,实测构造不出「只有 BM25 能救」的场景:试过的每个查询(「下酒菜」语义类、「茴香豆那段原文」语义+精确词类、ERR_CONN_RESET 纯精确词类),纯向量要么已经答对、要么和混合一样——BM25 没有一次单独把向量答不出的问题救回来,反而在纯语义查询上拖了后腿。混合检索的真正价值要在更大、更杂、词面与语义经常对不上的语料上才显现(比如海量报错码/型号/专有名词,向量分不清但字面唯一)。
  • 所以别在这个小 demo 上得出「混合一定更好」的结论。先用纯向量把链路跑通,拿自己的真实语料 evaluate.py 一遍(见 19 章),BM25 到底加不加分,让数据说话,别信通用结论——包括别信这一段。

要点:

  • 融合用的是 RRF(倒数排名融合)——比较两路的「排名」而不是「分数」。BM25 分数和余弦相似度量纲完全不同,直接加权分数没有意义,这也是 EnsembleRetriever 选 RRF 的原因。
  • rank_bm25 是进程内的:没有持久化、没有增量更新、多进程不共享。语料几万块以内的 demo 和小项目够用,再往上就该换 Elasticsearch。

用法二:Docker 部署 Elasticsearch,生产级 BM25

为什么上 ES:BM25 就是 Elasticsearch 的默认文本评分,还自带中文分词(IK 插件)、持久化、增量写入、权限控制,向量检索也可以放同一个库里做混合——一套服务全齐。

第一步:给 Docker 配国内镜像源。 Docker Hub 直连慢或直接失败,先给 Docker daemon 配 registry mirrors。Mac 上 Docker Desktop:Settings → Docker Engine,编辑 JSON(Linux 是 /etc/docker/daemon.json):

{
  "registry-mirrors": [
    "https://docker.1ms.run",
    "https://docker.m.daocloud.io",
    "https://dockerproxy.net"
  ]
}

改完重启 Docker(Docker Desktop 菜单 Restart;Linux sudo systemctl restart docker),用 docker info 确认 Registry Mirrors 一节已生效。镜像站会失效轮换,拉不动就换一个。

第二步:起一个单节点 ES。 学习环境关安全认证、限内存:

docker run -d \
  --name es-bm25 \
  -p 9200:9200 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
  docker.elastic.co/elasticsearch/elasticsearch:8.14.3

参数逐个说明:single-node 单机模式跳过集群发现;xpack.security.enabled=false 免认证(仅学习环境,生产必开);ES_JAVA_OPTS 把 JVM 压到 512m,避免教学机内存被吃穿。镜像来自 elastic 官方仓库 docker.elastic.co,一般无需加速即可拉取;实在拉不动,换国内同步前缀,tag 不变:elastic.m.daocloud.io/elasticsearch/elasticsearch:8.14.3。

验证:

curl http://localhost:9200
# {"name":"...","cluster_name":"docker-cluster","version":{"number":"8.14.3",...

第三步:装 IK 中文分词插件。 ES 内置分词器把中文按单字切,BM25 的词匹配质量会很差,必须换 IK:

docker exec -it es-bm25 elasticsearch-plugin install \
  https://get.infini.cloud/elasticsearch/analysis-ik/8.14.3
docker restart es-bm25

插件版本必须与 ES 版本完全一致(这里都是 8.14.3)。上面的 inmini 源国内直连快;官方地址在 GitHub(github.com/medcl/elasticsearch-analysis-ik/releases),下载慢时用上面的镜像。

第四步:写入语料,用 match 查询——它默认就是 BM25 打分。

pip install "elasticsearch>=8,<9"
from elasticsearch import Elasticsearch   # ES 官方客户端

es = Elasticsearch("http://localhost:9200")

# 建索引:默认分词器换成 ik_smart
if not es.indices.exists(index="notes"):
    es.indices.create(
        index="notes",
        settings={"analysis": {"analyzer": {"default": {"type": "ik_smart"}}}},
    )

corpus = [
    "便可以买一碟盐煮笋,或者茴香豆,做下酒物",
    "他对人说话,总是满口之乎者也,教人半懂不懂的",
    "连接失败时网关返回 ERR_CONN_RESET,多为上游服务重启所致",
    "孔乙己是站着喝酒而穿长衫的唯一的人",
]
for i, text in enumerate(corpus):
    es.index(index="notes", id=str(i), document={"text": text})
es.indices.refresh(index="notes")   # 立即可查(默认 1 秒刷新)

# match 查询:按字段分词后逐词匹配,评分函数就是 BM25
res = es.search(index="notes", query={"match": {"text": "ERR_CONN_RESET 重启"}}, size=2)

for hit in res["hits"]["hits"]:
    print(round(hit["_score"], 2), hit["_source"]["text"])
# 6.51 连接失败时网关返回 ERR_CONN_RESET,多为上游服务重启所致

想看 BM25 打分明细(词频、IDF、字段长度归一三部分的贡献),查询里加 "explain": True,返回里每条 hit 会带完整打分推导——课程演示 BM25 公式时非常好用。

第五步:接回 LangChain 做混合检索。 langchain-elasticsearch 包把 ES 的 BM25 检索封装成了 Retriever,与向量检索器一起丢进 EnsembleRetriever 即可:

pip install langchain-elasticsearch
from elasticsearch import Elasticsearch   # ES 官方客户端
from langchain_elasticsearch import ElasticsearchBM25Retriever   # ES 承载的 BM25 检索器
from langchain_classic.retrievers import EnsembleRetriever   # 多路融合检索器

# 接前几块:es 来自「第四步」,vectorstore(embeddings 版)来自「用法一」的混合检索块
es_bm25 = ElasticsearchBM25Retriever(client=es, index_name="notes")

hybrid = EnsembleRetriever(
    retrievers=[es_bm25, vectorstore.as_retriever(search_kwargs={"k": 2})],
    weights=[0.4, 0.6],
)

与用法一的唯一区别:BM25 这一路从进程内对象换成了 ES——语料的增删改直接写 ES 索引,检索端代码不动。

rank_bm25 还是 Elasticsearch

维度rank_bm25Elasticsearch
部署pip install 即用Docker/服务器,有运维成本
持久化与增量无(每次进程重建)有,写入即生效
多实例共享不共享(各进程各一份)共享(独立服务)
中文分词自己传 jiebaIK 插件(ik_smart / ik_max_word)
适合demo、课程、小项目生产、多人协作、大体量语料

一句话:先用 rank_bm25 把混合检索跑通,语料量或协作需求上来了,检索代码一行不改地迁到 ES。

对比与选型

手段解决的问题引入 LLM额外代价
as_retriever(k)基础 top-k 检索否最低
MultiQueryRetriever关键词、措辞与原文不一致是,改写 query1 次 LLM 加 N 次检索
ContextualCompressionRetriever返回块冗长、无关内容挤占上下文是,逐块压缩每个文档块 1 次 LLM
similarity_search_with_score 加手动过滤只保留相似度达标的结果否无额外开销
BM25 + 向量混合检索精确词(报错码/型号/专有名词)否一路额外检索

引入 LLM 的两种手段效果最好,费用与延迟也最高;改写与压缩交给便宜模型即可。各手段可叠加,比如 MultiQuery 的多路结果再交给压缩检索。调试全链路时打开 set_debug(True)(见 LCEL)。


上一节:Embedding 与向量存储 · 下一节:完整 RAG 链