索引类型 #
概述 #
索引是 LlamaIndex 中组织和检索数据的核心结构。不同的索引类型适用于不同的场景，选择合适的索引对应用性能至关重要。
text
┌─────────────────────────────────────────────────────────────┐
│ 索引类型总览 │
├─────────────────────────────────────────────────────────────┤
│ │
│ VectorStoreIndex 语义搜索、问答 │
│ ├── 最常用 │
│ ├── 基于 Embedding 相似度 │
│ └── 需要 Embedding 模型 │
│ │
│ SummaryIndex 文档总结 │
│ ├── 遍历所有节点 │
│ ├── 生成综合摘要 │
│ └── 不需要 Embedding │
│ │
│ TreeIndex 大型文档集 │
│ ├── 层级结构 │
│ ├── 从根到叶查询 │
│ └── 适合层次化内容 │
│ │
│ KeywordTableIndex 关键词搜索 │
│ ├── 提取关键词 │
│ ├── 精确匹配 │
│ └── 不需要 Embedding │
│ │
└─────────────────────────────────────────────────────────────┘
VectorStoreIndex #
概述 #
VectorStoreIndex 是最常用的索引类型，它将文本转换为向量，支持语义相似度搜索。
text
┌─────────────────────────────────────────────────────────────┐
│ VectorStoreIndex 工作原理 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 索引构建： │
│ Node ──→ Embedding Model ──→ Vector ──→ Vector Store │
│ │
│ 查询过程： │
│ Query ──→ Embedding Model ──→ Query Vector │
│ ──→ Similarity Search ──→ Top-K Nodes │
│ ──→ LLM ──→ Response │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("你的问题")
print(response)
从节点创建 #
python
from llama_index.core import VectorStoreIndex, Document
from llama_index.core.node_parser import SentenceSplitter
doc = Document(text="很长的文档内容...")
splitter = SentenceSplitter(chunk_size=512)
nodes = splitter.get_nodes_from_documents([doc])
index = VectorStoreIndex(nodes)
配置选项 #
python
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
documents,
show_progress=True,
storage_context=storage_context,
)
query_engine = index.as_query_engine(
similarity_top_k=5,
response_mode="compact",
streaming=True,
)
使用向量存储 #
python
import chromadb
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import StorageContext
db = chromadb.PersistentClient(path="./chroma_db")
chroma_collection = db.get_or_create_collection("my_collection")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(
documents,
storage_context=storage_context,
)
index.storage_context.persist()
增量添加文档 #
python
from llama_index.core import VectorStoreIndex, Document
index = VectorStoreIndex.from_documents([
Document(text="初始文档")
])
index.insert(Document(text="新文档 1"))
index.insert(Document(text="新文档 2"))
for doc in new_documents:
index.insert(doc)
SummaryIndex #
概述 #
SummaryIndex（原名 ListIndex）会遍历所有节点，适合需要综合所有内容的场景。
text
┌─────────────────────────────────────────────────────────────┐
│ SummaryIndex 工作原理 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 索引结构： │
│ Node1 ←→ Node2 ←→ Node3 ←→ Node4 ←→ Node5 │
│ │
│ 查询过程： │
│ Query ──→ 遍历所有节点 ──→ 合成响应 │
│ │
│ 适合： │
│ - 文档总结 │
│ - 需要全面信息的查询 │
│ - 不需要 Embedding 的场景 │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
from llama_index.core import SummaryIndex, Document
documents = [
Document(text="文档1内容..."),
Document(text="文档2内容..."),
Document(text="文档3内容..."),
]
index = SummaryIndex.from_documents(documents)
query_engine = index.as_query_engine(
response_mode="tree_summarize"
)
response = query_engine.query("总结所有文档的主要内容")
print(response)
响应模式 #
python
from llama_index.core import SummaryIndex, get_response_synthesizer
index = SummaryIndex.from_documents(documents)
compact_engine = index.as_query_engine(
response_mode="compact"
)
tree_summarize_engine = index.as_query_engine(
response_mode="tree_summarize"
)
refine_engine = index.as_query_engine(
response_mode="refine"
)
不使用 Embedding #
python
from llama_index.core import SummaryIndex, Document, Settings
from llama_index.llms.openai import OpenAI
Settings.llm = OpenAI(model="gpt-4o-mini")
documents = [Document(text="文档内容...")]
index = SummaryIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("总结文档")
TreeIndex #
概述 #
TreeIndex 将节点组织成树形结构，从根节点到叶节点进行查询，适合大型文档集。
text
┌─────────────────────────────────────────────────────────────┐
│ TreeIndex 结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 根节点 │
│ │ │
│ ┌──────────┼──────────┐ │
│ │ │ │ │
│ 子节点1 子节点2 子节点3 │
│ │ │ │ │
│ ┌──┴──┐ ┌──┴──┐ ┌──┴──┐ │
│ │ │ │ │ │ │ │
│ 叶1 叶2 叶3 叶4 叶5 叶6 │
│ │
│ 查询从根开始，逐层向下选择最相关的分支 │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
from llama_index.core import TreeIndex, Document
documents = [
Document(text="文档1内容..."),
Document(text="文档2内容..."),
Document(text="文档3内容..."),
]
index = TreeIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("你的问题")
print(response)
配置选项 #
python
from llama_index.core import TreeIndex
index = TreeIndex.from_documents(
documents,
summary_template=summary_template,
num_children=10,
)
query_engine = index.as_query_engine(
child_branch_factor=2,
)
检索器 #
python
from llama_index.core import TreeIndex
from llama_index.core.retrievers import TreeRetriever
index = TreeIndex.from_documents(documents)
retriever = TreeRetriever(
index=index,
child_branch_factor=2,
)
nodes = retriever.retrieve("查询内容")
KeywordTableIndex #
概述 #
KeywordTableIndex 提取节点中的关键词，通过关键词匹配进行检索。
text
┌─────────────────────────────────────────────────────────────┐
│ KeywordTableIndex 结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 关键词表： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ "Python" → [Node1, Node3, Node5] │ │
│ │ "机器学习" → [Node2, Node4] │ │
│ │ "数据分析" → [Node1, Node4, Node6] │ │
│ │ "深度学习" → [Node2, Node5] │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 查询过程： │
│ Query ──→ 提取关键词 ──→ 匹配节点 ──→ 返回结果 │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
from llama_index.core import KeywordTableIndex, Document
documents = [
Document(text="Python 是一种编程语言，广泛用于数据分析和机器学习。"),
Document(text="机器学习是人工智能的一个分支，包括深度学习等技术。"),
Document(text="数据分析使用 Python 进行数据处理和可视化。"),
]
index = KeywordTableIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("Python 有什么用途？")
print(response)
自定义关键词提取 #
python
from llama_index.core import KeywordTableIndex, Document
from llama_index.core.keyword_extractors import SimpleKeywordExtractor
index = KeywordTableIndex.from_documents(
documents,
keyword_extractor=SimpleKeywordExtractor(),
)
多文档索引 #
多文档向量索引 #
python
from llama_index.core import VectorStoreIndex, Document
documents = [
Document(text="文档1", metadata={"source": "file1.txt"}),
Document(text="文档2", metadata={"source": "file2.txt"}),
Document(text="文档3", metadata={"source": "file3.txt"}),
]
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine(
similarity_top_k=3,
)
response = query_engine.query("查询内容")
for node in response.source_nodes:
print(f"来源: {node.node.metadata.get('source')}")
print(f"相似度: {node.score:.4f}")
多索引组合 #
python
from llama_index.core import VectorStoreIndex, SummaryIndex, Document
from llama_index.core.tools import QueryEngineTool
from llama_index.core.query_engine import RouterQueryEngine
documents = [Document(text="文档内容...")]
vector_index = VectorStoreIndex.from_documents(documents)
summary_index = SummaryIndex.from_documents(documents)
vector_tool = QueryEngineTool.from_defaults(
query_engine=vector_index.as_query_engine(),
name="vector_search",
description="适合语义搜索和问答",
)
summary_tool = QueryEngineTool.from_defaults(
query_engine=summary_index.as_query_engine(response_mode="tree_summarize"),
name="summary",
description="适合文档总结",
)
query_engine = RouterQueryEngine.from_defaults(
query_engine_tools=[vector_tool, summary_tool],
)
response = query_engine.query("总结文档的主要内容")
索引持久化 #
本地存储 #
python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents)
index.storage_context.persist(persist_dir="./storage")
from llama_index.core import StorageContext, load_index_from_storage
storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)
向量存储持久化 #
python
import chromadb
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import StorageContext
db = chromadb.PersistentClient(path="./chroma_db")
chroma_collection = db.get_or_create_collection("knowledge_base")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(
documents,
storage_context=storage_context,
)
db = chromadb.PersistentClient(path="./chroma_db")
chroma_collection = db.get_collection("knowledge_base")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
index = VectorStoreIndex.from_vector_store(vector_store)
索引选择指南 #
text
┌─────────────────────────────────────────────────────────────┐
│ 索引选择指南 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 需求 推荐索引 │
│ ───────────────────────────────────────────────────────── │
│ 语义搜索/问答 VectorStoreIndex │
│ 文档总结 SummaryIndex │
│ 大型文档集 TreeIndex │
│ 关键词搜索 KeywordTableIndex │
│ 不需要 Embedding SummaryIndex / KeywordTable │
│ 精确匹配 KeywordTableIndex │
│ 层级内容 TreeIndex │
│ │
└─────────────────────────────────────────────────────────────┘
完整示例 #
python
import os
from llama_index.core import (
VectorStoreIndex,
SummaryIndex,
SimpleDirectoryReader,
Settings,
)
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
os.environ["OPENAI_API_KEY"] = "sk-your-key"
Settings.llm = OpenAI(model="gpt-4o-mini")
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
documents = SimpleDirectoryReader("./data").load_data()
print(f"加载了 {len(documents)} 个文档")
vector_index = VectorStoreIndex.from_documents(documents)
vector_engine = vector_index.as_query_engine(similarity_top_k=3)
response = vector_engine.query("文档的主要内容是什么？")
print(f"\n向量搜索回答: {response}")
summary_index = SummaryIndex.from_documents(documents)
summary_engine = summary_index.as_query_engine(response_mode="tree_summarize")
response = summary_engine.query("总结所有文档的主要内容")
print(f"\n总结回答: {response}")
vector_index.storage_context.persist(persist_dir="./vector_storage")
summary_index.storage_context.persist(persist_dir="./summary_storage")
下一步 #
了解索引类型后，接下来学习 查询引擎 掌握如何执行查询和生成回答！
最后更新：2026-03-30