想象你开了一家只做高端菜的中央厨房(RAG 系统),世界各地的食材(数据)都要赶在饭点前运进来:干货仓库的 PDF 调料包、生鲜市场的网页蔬菜、冷库里的数据库冻货、合作菜园的 Notion 时蔬。如果你亲自骑三轮车挨家去收菜,一路上要么包装破损、要么保鲜失效、还常常漏拿产地标签。LlamaHub 就是一座专业的食材调度中心,里面驻守着多支专属运输队(Connector):PDF 队负责拆箱验货,网页队负责快速分拣,数据库队负责冷链保鲜,Notion 队负责精挑时蔬。你只需在调度中心喊一声“我要这批货”,对应车队就会出发,把食材处理成中央厨房统一的半成品(Document),送到备菜台(索引)等大厨(大模型)取用。这篇文章,就带你逛一逛这座调度中心,搞懂每支运输队怎么选、怎么用、怎么造。

岗位关联

对 RAG 应用开发工程师和架构师而言,掌握 LlamaHub 连接器等于拿到了企业知识库的“万能进货通道”,能把散落各处的 PDF、网页、数据库等内容快速规范化接入检索系统,是决定 RAG 上线速度和检索质量的关键基本功。

目录
  1. 可视化演示
  2. LlamaHub 概述:食材调度中心
  3. 常用连接器全家福:四支专业运输队
  4. 加载解析全流程:从食材到备菜
  5. 自定义开发:定制专属运输车
  6. 检索策略搭配:大厨的选材技法
  7. 对比直接读取:散户采购 vs 专业运输
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示LlamaHub连接器将多源数据(PDF/网页/数据库)接入RAG系统的完整流程,含数据加载、解析、索引与检索策略。

本节配有交互动效(进入视口后自动加载,约 3KB)。

RAG数据接入管线 多源数据通过LlamaHub连接器统一接入 加载解析索引三步构建检索库 Source → Connector → Index → RAG LlamaHub打通多格式数据到RAG系统的入口

LlamaHub 概述:食材调度中心

一家中央厨房开张前,最头疼的往往不是菜谱,而是“进货”。店面数据库、文件服务器、合作菜园散落各处,如果每种食材都靠老板自己骑三轮车去拉,一趟下来包装破了、保鲜期过了、产地标签也丢了。于是在 RAG 的世界里,LlamaIndex 团队专门盖了一座“食材调度中心”——LlamaHub,让所有数据源的接入都有章可循。

LlamaHub 不是大模型,也不是检索算法。它是 LlamaIndex 生态里的连接器集合仓库(hub 本意就是“枢纽”),专门负责把各类外部数据源“接进来”。你只需从 Hub 上选一个连接器,调用它的加载方法,就能把 PDF、网页、数据库表、Notion 页面等原始数据统一转换成系统能处理的文档对象。对于做 RAG 应用的人来说,它解决了数据接入的“最后一公里”:不用为每种格式手写解析器,也不用操心数据规范不统一的问题。

用一句管道公式概括整个 RAG 数据入口:

所以把 LlamaHub 想象成调度中心非常贴切:它不做菜(不负责生成)、不尝菜(不负责排序),它只负责把最新鲜的食材在最短时间内送到厨房门口,后面的备菜和掌勺,交给索引和模型去完成。

Index=Embed(Chunk(Load(Source)))\displaystyle \text{Index} = \text{Embed}(\text{Chunk}(\text{Load}(\text{Source})))
这条公式描述了数据从源头到索引的完整旅程:加载、切块、向量化、建索引。LlamaHub 主要负责前两步中“加载”这一环,是整个链路的入口。
  1. Source(数据源)任何你想喂给系统的原始数据,比如 PDF 文件、网页链接、数据库表或 Notion 页面。
    Source∈{PDF, Web, SQL, Notion, ⋯ }\text{Source} \in \{\text{PDF},\ \text{Web},\ \text{SQL},\ \text{Notion},\ \cdots\}
  2. Load(加载)由 LlamaHub 上对应类型的 Connector 执行,把原始数据读成统一规范的 Document 对象。
    Load:Source→Document\text{Load}: \text{Source} \to \text{Document}
  3. Chunk(切块)把长文档按固定窗口和重叠切成小片段 Node,保证后续检索能定位到细粒度的内容。
    Chunk:Document→{Node1, Node2, …, Nodek}\text{Chunk}: \text{Document} \to \{\text{Node}_1,\ \text{Node}_2,\ \dots,\ \text{Node}_k\}
  4. Embed(向量化)把每个 Node 编码成高维向量,让查询和文档可以用语义相似度比较。
    vi=Embed(Nodei),vi∈Rd\mathbf{v}_i = \text{Embed}(\text{Node}_i), \quad \mathbf{v}_i \in \mathbb{R}^{d}
  5. Index(构建索引)把所有向量组织成可快速检索的结构,供查询阶段按相似度召回。
    Index=⋃i=1k{(Nodei, vi)}\displaystyle \text{Index} = \bigcup_{i=1}^{k} \{(\text{Node}_i,\ \mathbf{v}_i)\}

常用连接器全家福:四支专业运输队

调度中心里的运输队各有分工:干货仓库的 PDF 大箱货适合平板车,生鲜市场的网页蔬菜要冷链快车,数据库冷库的冻货得集装箱,合作菜园 Notion 的时蔬则有专属采买管家。仓库管理员绝不会让平板车去拉冻货——选错运输队,食材准坏在半路。

LlamaHub 上注册了成百上千个连接器,按数据源性质可分为四大家族。文档类连接器(PDFReader、DocxReader、MarkdownReader)负责把二进制文件解析成带结构的文本;网页类连接器(SimpleWebPageReader、BeautifulSoupWebReader)负责抓取 HTML 并清洗标签噪声;数据库类连接器(DatabaseReader)通过 SQL 把表记录读成文档;应用类连接器(NotionReader、SlackReader)则调用 SaaS 官方 API 获取工作区数据。每一类都封装了专门的解析逻辑,这也是它们比“裸读文件”更可靠的根本原因。

LlamaHub 的价值在于覆盖度:只要你的数据源格式能被描述,几乎都能在 Hub 上找到一个现成的运输队。选型时先判断数据属于哪一类,再决定调哪支车队。

选连接器的口诀可以记成:先看数据源是“干货、生鲜、冻货还是时蔬”,再挑对应的运输队。千万不要“一把抓”,拿同一个连接器处理所有数据源,那样跟骑着平板车拉冻货没什么区别。

∀ s∈S, ∃ c∈C: c(s)↦Document\displaystyle \forall\, s \in \mathcal{S},\ \exists\, c \in \mathcal{C}:\ c(s) \mapsto \text{Document}
这个“全称存在”公式的意思是:任何一个数据源,都能在连接器集合里找到对应的搬运工,把原始格式转成标准文档。
  1. 数据源集合 S包含 PDF 文件、HTML 页面、SQL 数据表、Notion 云端文档等所有可能的原始格式。
    S={pdf, web, sql, notion, ⋯ }\mathcal{S} = \{pdf,\ web,\ sql,\ notion,\ \cdots\}
  2. 连接器集合 CLlamaHub 上所有可用的 Connector,每种格式都有专门设计的解析器与其对应。
    C={cpdf, cweb, csql, cnotion, ⋯ }\mathcal{C} = \{c_{pdf},\ c_{web},\ c_{sql},\ c_{notion},\ \cdots\}
  3. 映射到 Document一个合格的数据源总能找到相应连接器,把它转成统一文档,就像每个货架都有对口搬运工。
    c(s)↦Document=(id, text, metadata)c(s) \mapsto \text{Document} = (id,\ text,\ metadata)

加载解析全流程:从食材到备菜

食材运到厨房后并不会直接下锅:验收员要先拆包检查,登记员要贴标签写清产地和保质期,切配师傅再把大鱼大肉切成一口大小。三个环节各司其职,缺一不可。在 LlamaIndex 中,这一流程对应的数据结构依次是 Reader、Document 和 Node。

加载器 Loader 负责读字节,把原始文件变成 Document 对象;Document 通常包含 id、text、metadata 三个字段,其中 metadata 存放文件名、页码、URL、时间等溯源信息;随后切分器按 chunk_size 和 chunk_overlap 把长文档切成Node——也就是检索的最小单元。切块大小直接影响检索质量:块太大检索不精准,块太小会丢失上下文,需要在实践中反复调参。

加载、切分、建索引的关系可以用下面两个映射表示:第一个映射把任意数据源变成文档,第二个映射把文档拆成节点集合。值得注意的是,metadata 会从 Document 一路带到 Node 上,这就是为什么检索结果能告诉你“答案来自哪一页”。

食材质量决定菜品上限,同理,Loader 解析得干不干净、元数据全不全、切块合不合理,直接决定了 RAG 系统这顿“AI 大餐”的下限。数据入口不牢,后面检索和生成再精巧也是空中楼阁。

Load:Source→Document,Chunk:Document→{Node1, …, Nodek}\displaystyle \text{Load}: \text{Source} \to \text{Document}, \qquad \text{Chunk}: \text{Document} \to \{\text{Node}_1,\ \dots,\ \text{Node}_k\}
Load 把外部世界的“杂货”规范成厨房的“标准半成品”,Chunk 再把半成品切成适合下锅的“小料”。两个映射一前一后,构成了数据准备阶段的主干。
  1. Load 映射加载器接收原始数据源,返回标准 Document 对象,完成格式归一化。
    Load(pdf)=Document(text="...", metadata={page:3})\text{Load}(pdf) = \text{Document}(text="...",\ metadata=\{page:3\})
  2. Document 结构文本内容与元数据分离存储,元数据就像食材包装上的产地标签,检索后可追溯来源。
    Document=(id, text, metadata)\text{Document} = (\text{id},\ \text{text},\ \text{metadata})
  3. Chunk 映射切分器把 Document 按窗口大小切成多个 Node,相邻块之间保留重叠以降低语义断裂风险。
    Chunk(Document)={Node1, Node2, …, Nodek}\text{Chunk}(\text{Document}) = \{\text{Node}_1,\ \text{Node}_2,\ \dots,\ \text{Node}_k\}
  4. Node 最小单元每个 Node 都是独立可检索的知识片段,向量化后参与相似度计算。
    Nodei=(texti, metadatai),i=1,…,k\text{Node}_i = (\text{text}_i,\ \text{metadata}_i), \quad i = 1,\dots,k

自定义开发:定制专属运输车

如果哪天真遇到一种特殊货物——比如工厂自研的“温控货箱格式”,市面上的运输队都不接单,该怎么办?LlamaHub 的设计者早就留好了造车图纸:只需照着图纸做一辆自己的车,挂上牌就能进调度中心拉活。

这份图纸就是抽象基类 BaseReader。自定义连接器时,只需要继承它并实现核心方法 load_data,返回 List[Document],LlamaIndex 就会像使用官方连接器一样原生识别它。无论是内部日志格式、遗留系统导出文件,还是某种私有协议数据,都能通过这个标准接口接入 RAG 流程。

开发完成后,你还可以把连接器打包发布到 LlamaHub 仓库,通过 pip 安装或 llamahub 命令分享给社区。这样一来,企业内部私有格式也能享受“官方待遇”,并且随着社区贡献者的增加,连接器生态会越来越丰富。

造车其实不难:图纸(BaseReader)现成,核心只改一个引擎(load_data),挂上 LlamaHub 的牌照就能跑运输。这也解释了为什么 LlamaHub 的连接器越来越多——社区里人人都能贡献自己的运输队,生态滚雪球式增长。

MyReader⊑BaseReader,load_data:Path→{Document1, …, Documentn}\displaystyle \text{MyReader} \sqsubseteq \text{BaseReader}, \qquad \text{load\_data}: \text{Path} \to \{\text{Document}_1,\ \dots,\ \text{Document}_n\}
自定义连接器的本质是“继承统一接口,实现自己的解析逻辑”。框架约定好了车型,你只需要改装引擎。
  1. 继承关系MyReader 是 BaseReader 的子类,天然继承统一接口约定,就像买现成底盘来改装。
    MyReader⊑BaseReader\text{MyReader} \sqsubseteq \text{BaseReader}
  2. load_data 参数输入数据路径及可选配置信息,连接器内部完成具体的解析工作。
    Path=(file_path, extra_info)\text{Path} = (file\_path,\ extra\_info)
  3. 返回值类型返回 Document 列表,每篇文档可携带元数据,保证与下游索引流程无缝衔接。
    load_data(Path)→{Document1, …, Documentn}\text{load\_data}(\text{Path}) \to \{\text{Document}_1,\ \dots,\ \text{Document}_n\}

检索策略搭配:大厨的选材技法

备菜台上摆满了几百种切好的食材,大厨要在一分钟内挑出最合适的配料。老练的师傅不会只凭“看着像”或只凭“名字对”来挑,而是两套功夫一起用:先用经验锁定方向,再结合菜名核对细节,最后综合打分。RAG 的检索阶段,也要这样搭配策略。

向量检索按嵌入向量的余弦相似度召回语义相近的片段,擅长处理“意思接近但字面不同”的查询;关键词检索(如 BM25)按字面命中召回,对专有名词、编号、产品名这类精确信息更敏感。混合检索把两者得分融合,兼顾语义理解与精确匹配。索引构建阶段,既建向量索引(如 HNSW),也可以保留倒排索引供关键词检索使用——而 LlamaHub 连接器加载的数据,正是这些索引的“原材料”。

混合检索最常见的融合方式是加权求和,公式如下。λ 是一个 0 到 1 之间的超参数,控制语义与字面的侧重:λ 偏大时结果更“懂意思”,λ 偏小时结果更“抠字眼”。

大厨的双重选材法,放到系统里就是“语义 + 关键词”的混合检索。连接器把数据送进厨房只是第一步,怎么挑、按什么比例挑,决定了这桌 AI 盛宴最终的口感和用户满意度。

score(q,d)=λ⋅simvec(q,d)+(1−λ)⋅simkw(q,d)\displaystyle \text{score}(q, d) = \lambda \cdot \text{sim}_{\text{vec}}(q, d) + (1 - \lambda) \cdot \text{sim}_{\text{kw}}(q, d)
检索得分是向量相似度与关键词相似度的加权平均。λ 像大厨脑海里的“经验权重”,决定这次选材更相信直觉还是更相信菜名。
  1. 最终得分查询 q 与文档片段 d 的综合相关度,得分越高越优先返回给生成模型。
    score(q,d)∈[0, 1]\text{score}(q, d) \in [0,\ 1]
  2. 权重系数 λ介于 0 和 1 之间,平衡语义检索与关键词检索的贡献比例。
    λ∈[0, 1]\lambda \in [0,\ 1]
  3. 向量相似度由 Embedding 向量的余弦距离得到,能捕捉“同义不同文”的表达差异。
    simvec(q,d)=cos⁡(vq, vd)\displaystyle \text{sim}_{\text{vec}}(q, d) = \cos(\mathbf{v}_q,\ \mathbf{v}_d)
  4. 关键词相似度基于词项匹配与逆文档频率加权,对编号、人名等精确信息更敏感。
    simkw(q,d)≈∑t∈qIDF(t)⋅TF(t,d)\displaystyle \text{sim}_{\text{kw}}(q, d) \approx \sum_{t \in q} \text{IDF}(t) \cdot \text{TF}(t, d)

对比直接读取:散户采购 vs 专业运输

同样是进一批山货,自己开三轮车去拉和叫调度中心的冷链车,差别肉眼可见:三轮车档位单一、没有保鲜设备、货物裹在一起还掉了标签;冷链车分区控温、单件打包、每箱都有溯源单。工程上的“直接读文件”和“用 Connector 接入”,正是这种差别。

所谓直接读文件,就是用 open()、pandas 等基础工具把文件读成字符串或 DataFrame 后直接塞进索引;用 Connector 接入,则是通过 LlamaHub 连接器完成格式解析、元数据抽取、结构保留后再进入索引流程。在格式处理上,PDF 直接读只能拿到乱序文本,而 PDFReader 能识别段落、表格、页眉页脚;在元数据保留上,连接器自动记录文件名、页码、URL、作者和时间,检索后可溯源,直接读取则通常全部丢失;在性能上,连接器支持并发加载、去重、缓存和流式读取,省去大量 DIY 代码。

两者产物的结构差异可以直观写成下面的对比:连接器得到的是“内容 + 丰富元数据”的完整包裹,手动读取得到的往往只有“裸文本”。

对生产环境来说,“能跑”和“跑得好”是两回事。选择 Connector 不是矫情,而是像成熟餐厅一定会用专业供应链一样——省下的时间、保住的质量,最终都会在线上问答的效果里兑现。

Documentconnector=(content, metadatarich),Documentmanual≈(content, ∅)\displaystyle \text{Document}_{\text{connector}} = (\text{content},\ \text{metadata}_{\text{rich}}), \qquad \text{Document}_{\text{manual}} \approx (\text{content},\ \varnothing)
左边是专业运输队的送货单:内容、产地、批次一应俱全;右边是散户采购的麻袋:只有内容,一切溯源信息都不知去向。
  1. 连接器的产物内容之外还携带丰富的结构化元数据,为溯源、过滤、去重提供支撑。
    metadatarich={page, url, created_at, author, ⋯ }\text{metadata}_{\text{rich}} = \{page,\ url,\ created\_at,\ author,\ \cdots\}
  2. 手动读取的产物往往只有纯文本,丢失所有上下文标签,像被揉成一团的采购单。
    metadatamanual=∅\text{metadata}_{\text{manual}} = \varnothing
  3. 对比结论前者配合混合检索和溯源功能“进可攻退可守”,后者只能勉强支撑最简单的向量检索。
    RAG Quality:connector≫manual\text{RAG Quality}: \text{connector} \gg \text{manual}

AI 应用场景

企业知识库问答

阶段:数据接入与准备

解决的问题:企业里动辄几千份 PDF 合同、Word 制度文件,人工整理成问答语料耗时且易漏。直接用 open() 读出来的文本混乱、无页码,检索后无法溯源。LlamaHub 的文档类连接器自动解析段落与表格,并保留页码元数据,几行代码就能把文件目录变成可检索索引。

具体案例:某律所上线内部法律咨询机器人,用 PDFReader 和 DocxReader 批量接入数千份判例与合同模板,回答时自动附带页码引用。律师助理的检索时间从每人每天 2 小时降到 5 分钟,且引用可一键回溯原文。

SaaS 应用数据接入

阶段:多源数据集成

解决的问题:团队知识散落在 Notion 工作区和 Slack 频道里,手动导出既容易遗漏又无法增量同步,知识库很快就过期。应用类连接器通过官方 API 读取页面树,保留块级结构,让系统能持续同步最新内容。

具体案例:某互联网团队用 NotionReader 把产品文档和会议纪要自动同步进 RAG 知识库,新同学提问“这个功能为什么这么设计”,系统直接给出带出处的回答,团队 onboarding 时间缩短约 40%。

数据库自然语言查询

阶段:检索与生成

解决的问题:运营同学想看数据却不会写 SQL,每次都要提工单等数仓排期。数据库类连接器先把表结构和字段说明作为元数据接入,检索阶段定位到相关表文档后,由大模型生成 SQL 并返回自然语言结论。

具体案例:某电商公司运营问“上个月华东区的退货率趋势”,系统先检索到对应订单表结构文档,再生成 SQL 查询返回结论,查询从隔天交付变成秒级响应。

Python 演示

python51 行
# -*- coding: utf-8 -*-"""演示 LlamaHub 连接器的使用与自定义开发"""from pathlib import Pathfrom typing import List, Optional from llama_index.core import SimpleDirectoryReader, VectorStoreIndexfrom llama_index.core.readers.base import BaseReaderfrom llama_index.core.schema import Document  class MyTxtReader(BaseReader):    """自定义连接器: 读取 .mytxt 标记文件, 每行一条记录"""     def load_data(        self, file_path: str, extra_info: Optional[dict] = None    ) -> List[Document]:        path = Path(file_path)        raw = path.read_text(encoding="utf-8")        lines = [ln.strip() for ln in raw.splitlines() if ln.strip()]        docs = []        for line in lines:            meta = {"source": str(path), "loader": "MyTxtReader"}            if extra_info:                meta.update(extra_info)            docs.append(Document(text=line, metadata=meta))        return docs  def main():    # 1. 用官方连接器批量加载 PDF/TXT 目录    reader = SimpleDirectoryReader(        input_dir="./data", required_exts=[".pdf", ".txt"]    )    documents = reader.load_data()    print(f"共加载 {len(documents)} 个官方文档")     # 2. 用自定义连接器接入私有格式    my_docs = MyTxtReader().load_data(        "./data/notes.mytxt", {"author": "rag-team"}    )    print(f"自定义连接器加载 {len(my_docs)} 条记录")     # 3. 统一构建向量索引并问答 (RAG 数据入口打通)    index = VectorStoreIndex.from_documents(documents + my_docs)    engine = index.as_query_engine()    answer = engine.query("如何用 LlamaHub 接入 Notion 数据?")    print(f"回答: {answer}")  if __name__ == "__main__":    main()
目的:演示两件事——用官方目录连接器批量加载 PDF/TXT,以及继承 BaseReader 自定义连接器接入私有格式,最后统一构建向量索引完成问答。
  1. from llama_index.core import SimpleDirectoryReader, VectorStoreIndex引入官方目录加载器和向量索引,前者就是“调度中心里的现成运输队”。
  2. from llama_index.core.readers.base import BaseReader引入抽象基类,也就是自定义连接器的“造车图纸”。
  3. class MyTxtReader(BaseReader):自定义连接器的入口,继承 BaseReader 就能被框架原生识别。
  4. raw = path.read_text(encoding="utf-8")先把原始文件读成文本,相当于把食材从仓库搬出来。
  5. docs.append(Document(text=line, metadata=meta))把每一行包装成带元数据的标准文档,这是连接器规范化的核心动作。
  6. input_dir="./data", required_exts=[".pdf", ".txt"]指定目录和后缀过滤,官方连接器会自动挑选并解析匹配的文件。
  7. index = VectorStoreIndex.from_documents(documents + my_docs)官方和自定义连接器的产物在这里汇合,统一建索引。
  8. engine = index.as_query_engine()把索引包装成问答引擎,检索与生成一步到位。

常见误区

误区第一次听到 LlamaHub 和 LlamaIndex 两个名字,以为它们是同一个东西,或者是一个可以和 LlamaIndex 平起平坐的独立框架,于是到处找“LlamaHub 的安装包”。

正解LlamaHub 只是 LlamaIndex 生态里负责“数据接入”的连接器集市,好比食材调度中心只是中央厨房的一个部门。LlamaIndex 是完整的 RAG 编排框架,涵盖数据加载、索引构建、检索、生成全流程;LlamaHub 专注于连接器的分发与共享。两者是“框架与插件市场”的关系,装 LlamaIndex 时通常会连带拿到访问 LlamaHub 的能力。

为何常见:两个名字都以 Llama 开头,官方文档常把它们放在一起介绍,新手容易把子模块误当成独立产品。

误区觉得连接器干的就是 `open()` 读文件的活,自己写几行文件读取代码就能替代,没必要引入额外依赖。

正解连接器的真正价值在“解析”而不在“读取”。PDF 的表格结构、网页的 HTML 标签、数据库的 Schema 映射、Notion 的块级层级,都会被解析成带元数据的 Document。直接 open() 得到的只是裸文本,如同把整条鱼扔进锅里;连接器会帮你去鳞、去骨、切好片,还贴上产地标签。

为何常见:对简单的 txt 文档来说两者差别确实不大,很容易以偏概全,忽略了复杂格式才是企业数据的常态。

误区公司用的私有格式接不进去,就以为要 fork LlamaIndex 源码、改框架内部逻辑才能支持,于是直接放弃接入。

正解只需继承 BaseReader 并实现 load_data 返回 List[Document],LlamaIndex 就会像使用官方连接器一样识别它。既不用改框架,也能享受统一的切分、索引和检索流程。造一辆新车不难,难的是不知道有图纸可循——BaseReader 就是那张图纸。

为何常见:源码阅读门槛高,而 BaseReader 这类抽象基类的用法在官方文档中不够醒目,容易被忽略。

误区认为把所有文件一股脑喂给连接器、索引建得越大越好,结果大量过期文档、重复内容和表格噪声一起进了知识库,问答质量反而下降。

正解RAG 的质量取决于“准”而不是“多”。冗余和噪声会污染召回结果,连接器选错还会把注释、页眉也读进来。正确做法是选对连接器、保留元数据、合理切块,并用混合检索提升精度。食材贵在精挑细选,而不是装满满一车烂叶子。

为何常见:直觉上“数据量大 = 知识多”,忽略了检索是精确匹配任务,噪声对召回的伤害远大于数据量带来的收益。

面试题

Q1. LlamaHub 在 LlamaIndex 的 RAG 流程中主要负责什么?

单选题 · easy

  • A.负责向量存储和相似度检索
  • B.负责把外部数据源接入成文档← 正确答案
  • C.负责语言模型的推理与生成
  • D.负责提示词模板的设计与管理

答案:B。LlamaHub 是连接器集市,负责数据接入这一环,把外部数据源规范成 Document,对应中央厨房里的“调度中心”角色。向量存储、模型推理、提示词管理分别是索引、生成和 Prompt 模块的职责,不属于 LlamaHub。

Q2. 下列哪一项不是 LlamaHub 提供的连接器类型?

单选题 · easy

  • A.PDF 文档加载器
  • B.关系数据库读取器
  • C.图像生成大模型← 正确答案
  • D.网页信息抓取器

答案:C。LlamaHub 只负责“进货”——把数据读进来,包括文档、网页、数据库等。图像生成大模型属于生成模型,是“做菜”环节的产物,不是数据入口的连接器,就像中央厨房不会把外卖员当成厨师。

Q3. 继承 BaseReader 自定义连接器时,至少需要实现哪个方法?

单选题 · mid

  • A.load_data() 加载方法← 正确答案
  • B.get_nodes() 切片方法
  • C.embed_text() 向量化方法
  • D.query_index() 查询方法

答案:A。BaseReader 的核心抽象方法是 load_data,返回 List[Document]。切片、向量化、查询都属于加载之后的其他流程,就像定制运输车只需改装“装货”这个核心动作,卸货和入库由厨房其他部门负责。

Q4. 加载后的 Document 要经过什么步骤才能变成可检索的索引?

单选题 · mid

  • A.直接送入大模型生成答案
  • B.切分成节点后再建索引← 正确答案
  • C.压缩成单字符串存入磁盘
  • D.先人工标注再手工入库

答案:B。Document 需要先经过 Chunk 切分成 Node,再经过 Embedding 向量化构建索引,这是 RAG 数据准备的标准流水线。跳过切分直接送模型或压缩成字符串都会丢失检索粒度,人工标注则违背了自动化接入的初衷。

Q5. 关于直接读文件与用 Connector 接入,下列说法正确的是?

单选题 · mid

  • A.直接读文件能保留全部元数据
  • B.连接器自动解析并保留元数据← 正确答案
  • C.两者在解析效率上完全相同
  • D.连接器只支持云端数据源

答案:B。连接器会解析格式并保留文件名、页码、URL 等元数据,而直接读文件通常只能得到裸文本,元数据大量丢失。两者解析效率也有明显差距,且连接器同样支持本地文件,所以 B 正确。

Q6. 混合检索公式 score = λ·sim_vec + (1-λ)·sim_kw 中,λ 的作用是什么?

单选题 · hard

  • A.控制两种检索方式的权重← 正确答案
  • B.控制文本切片的最小长度
  • C.调节向量模型的输出维度
  • D.决定连接器的并发数量

答案:A。λ 是 0 到 1 之间的权重系数,调节向量语义检索和关键词精确检索的贡献比例,就像大厨决定这次选材更相信直觉还是更抠菜名。切块长度、向量维度、并发数量都与 λ 无关,属于其他环节的配置。

Q7. 自定义连接器的 load_data 方法返回类型是什么?

单选题 · mid

  • A.字符串列表 List[str]
  • B.文档列表 List[Document]← 正确答案
  • C.索引对象 VectorStoreIndex
  • D.问答结果 Response 对象

答案:B。load_data 的约定返回类型是 List[Document],每个 Document 可携带文本和元数据,供下游切分与建索引。返回裸字符串会丢失元数据,返回索引或回答则把加载和检索两个阶段混为一谈。

Q8. 下列哪些数据源可以通过 LlamaHub 连接器接入?

多选题 · easy

  • A.PDF 文档文件← 正确答案
  • B.关系数据库表← 正确答案
  • C.Notion 工作区← 正确答案
  • D.大模型权重文件

答案:ABC。PDF、数据库、Notion 都是 RAG 系统常见的数据源,LlamaHub 分别有文档类、数据库类、应用类连接器。大模型权重文件属于模型参数而非知识数据,不需要也不应该通过连接器接入。

Q9. 用连接器接入企业知识库时,下列哪些做法有助于提升 RAG 效果?

多选题 · hard

  • A.保留文档来源元数据← 正确答案
  • B.按业务选合适连接器← 正确答案
  • C.原始文本全部拼接建索引
  • D.合理切块并混合检索← 正确答案

答案:ABD。保留元数据便于溯源与过滤,按业务选连接器能保证解析质量,合理切块配合混合检索能提升召回精度。把原始文本全部拼接建索引会让检索粒度消失,召回结果又大又杂,像把整筐菜直接倒进锅里。

Q10. 关于 LlamaHub 生态,下列说法正确的有哪些?

多选题 · extreme

  • A.连接器把原始数据规范化为文档← 正确答案
  • B.同一数据源只能对应唯一连接器
  • C.节点切分发生在建索引之前← 正确答案
  • D.连接器加载不保留任何元数据

答案:AC。连接器的核心价值就是把原始数据规范化成 Document;切分发生在建索引之前,顺序不可颠倒。同一数据源可能有多个连接器(比如网页连接器就有多种实现),连接器加载时恰恰会保留元数据,因此 B、D 错误。