LlamaIndex：构建RAG应用与私有数据问答的LLM数据框架 | 300+数据连接器

llamaindex by davila7/claude-code-templates

259 周安装量

23,000 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/davila7/claude-code-templates --skill llamaindex

AI/机器学习数据处理自然语言处理

🇨🇳中文介绍

LlamaIndex - 大型语言模型应用数据框架

连接大型语言模型与您的数据的领先框架。

何时使用 LlamaIndex

在以下场景中使用 LlamaIndex：

构建 RAG（检索增强生成）应用
需要对私有数据进行文档问答
从多个数据源（300+ 连接器）摄取数据
为大型语言模型创建知识库
利用企业数据构建聊天机器人
需要从文档中提取结构化数据

指标：

45,100+ GitHub stars
23,000+ 代码仓库 使用 LlamaIndex
300+ 数据连接器 (LlamaHub)
1,715+ 贡献者
v0.14.7 (稳定版)

替代方案：

LangChain : 更通用，更适合智能体
Haystack : 生产级搜索管道
txtai : 轻量级语义搜索
Chroma : 仅需向量存储

快速开始

安装

# 入门包（推荐）
pip install llama-index

# 或最小化核心包 + 特定集成
pip install llama-index-core
pip install llama-index-llms-openai
pip install llama-index-embeddings-openai

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

相关 Skills

find-skills 技能搜索工具 - Vercel Labs 开源智能体技能包管理器

776,000 周安装

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

106,200 周安装

AI Elements：基于shadcn/ui的AI原生应用组件库，快速构建对话界面

56,200 周安装

AI 代码实施计划编写技能 | 自动化开发任务分解与 TDD 流程规划工具

43,400 周安装

from llama_index.core import SimpleDirectoryReader, Document
from llama_index.readers.web import SimpleWebPageReader
from llama_index.readers.github import GithubRepositoryReader

# 文件目录
documents = SimpleDirectoryReader("./data").load_data()

# 网页
reader = SimpleWebPageReader()
documents = reader.load_data(["https://example.com"])

# GitHub 仓库
reader = GithubRepositoryReader(owner="user", repo="repo")
documents = reader.load_data(branch="main")

# 手动创建文档
doc = Document(
    text="This is the document content",
    metadata={"source": "manual", "date": "2025-01-01"}
)

from llama_index.core import VectorStoreIndex, ListIndex, TreeIndex

# 向量索引（最常用 - 语义搜索）
vector_index = VectorStoreIndex.from_documents(documents)

# 列表索引（顺序扫描）
list_index = ListIndex.from_documents(documents)

# 树状索引（分层摘要）
tree_index = TreeIndex.from_documents(documents)

# 保存索引
index.storage_context.persist(persist_dir="./storage")

# 加载索引
from llama_index.core import load_index_from_storage, StorageContext
storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)

# 基础查询
query_engine = index.as_query_engine()
response = query_engine.query("What is the main topic?")
print(response)

# 流式响应
query_engine = index.as_query_engine(streaming=True)
response = query_engine.query("Explain quantum computing")
for text in response.response_gen:
    print(text, end="", flush=True)

# 自定义配置
query_engine = index.as_query_engine(
    similarity_top_k=3,          # 返回前3个片段
    response_mode="compact",     # 或 "tree_summarize", "simple_summarize"
    verbose=True
)

# 向量检索器
retriever = index.as_retriever(similarity_top_k=5)
nodes = retriever.retrieve("machine learning")

# 带过滤功能
retriever = index.as_retriever(
    similarity_top_k=3,
    filters={"metadata.category": "tutorial"}
)

# 自定义检索器
from llama_index.core.retrievers import BaseRetriever

class CustomRetriever(BaseRetriever):
    def _retrieve(self, query_bundle):
        # 您的自定义检索逻辑
        return nodes

from llama_index.core.agent import FunctionAgent
from llama_index.llms.openai import OpenAI

# 定义工具
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

# 创建智能体
llm = OpenAI(model="gpt-4o")
agent = FunctionAgent.from_tools(
    tools=[multiply, add],
    llm=llm,
    verbose=True
)

# 使用智能体
response = agent.chat("What is 25 * 17 + 142?")
print(response)

from llama_index.core.tools import QueryEngineTool

# 如前所述创建索引
index = VectorStoreIndex.from_documents(documents)

# 将查询引擎包装为工具
query_tool = QueryEngineTool.from_defaults(
    query_engine=index.as_query_engine(),
    name="python_docs",
    description="Useful for answering questions about Python programming"
)

# 带文档搜索 + 计算器的智能体
agent = FunctionAgent.from_tools(
    tools=[query_tool, multiply, add],
    llm=llm
)

# 智能体决定何时搜索文档或进行计算
response = agent.chat("According to the docs, what is Python used for?")

from pydantic import BaseModel
from llama_index.core.output_parsers import PydanticOutputParser

class Summary(BaseModel):
    title: str
    main_points: list[str]
    conclusion: str

# 获取结构化响应
output_parser = PydanticOutputParser(output_cls=Summary)
query_engine = index.as_query_engine(output_parser=output_parser)

response = query_engine.query("Summarize the document")
summary = response  # Pydantic 模型
print(summary.title, summary.main_points)

from llama_index.vector_stores.chroma import ChromaVectorStore
import chromadb

# 初始化 Chroma
db = chromadb.PersistentClient(path="./chroma_db")
collection = db.get_or_create_collection("my_collection")

# 创建向量存储
vector_store = ChromaVectorStore(chroma_collection=collection)

# 在索引中使用
from llama_index.core import StorageContext
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

from llama_index.vector_stores.pinecone import PineconeVectorStore
import pinecone

# 初始化 Pinecone
pinecone.init(api_key="your-key", environment="us-west1-gcp")
pinecone_index = pinecone.Index("my-index")

# 创建向量存储
vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

from llama_index.core import SimpleDirectoryReader
from llama_index.multi_modal_llms.openai import OpenAIMultiModal

# 加载图像和文档
documents = SimpleDirectoryReader(
    "./data",
    required_exts=[".jpg", ".png", ".pdf"]
).load_data()

# 多模态索引
index = VectorStoreIndex.from_documents(documents)

# 使用多模态 LLM 查询
multi_modal_llm = OpenAIMultiModal(model="gpt-4o")
query_engine = index.as_query_engine(llm=multi_modal_llm)

response = query_engine.query("What is in the diagram on page 3?")

from llama_index.core.evaluation import RelevancyEvaluator, FaithfulnessEvaluator

# 评估相关性
relevancy = RelevancyEvaluator()
result = relevancy.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Relevancy: {result.passing}")

# 评估忠实度（无幻觉）
faithfulness = FaithfulnessEvaluator()
result = faithfulness.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Faithfulness: {result.passing}")

# 完整的 RAG 管道
documents = SimpleDirectoryReader("docs").load_data()
index = VectorStoreIndex.from_documents(documents)
index.storage_context.persist(persist_dir="./storage")

# 查询
query_engine = index.as_query_engine(
    similarity_top_k=3,
    response_mode="compact",
    verbose=True
)
response = query_engine.query("What is the main topic?")
print(response)
print(f"Sources: {[node.metadata['file_name'] for node in response.source_nodes]}")

操作	延迟	备注
索引100个文档	~10-30秒	一次性操作，可持久化
查询（向量）	~0.5-2秒	检索 + LLM
流式查询	~0.5秒首个词元	用户体验更佳
带工具的智能体	~3-8秒	多个工具调用

功能	LlamaIndex	LangChain
最适合	RAG, 文档问答	智能体, 通用LLM应用
数据连接器	300+ (LlamaHub)	100+
RAG专注度	核心功能	众多功能之一
学习曲线	RAG方面更简单	更陡峭
自定义性	高	非常高
文档	优秀	良好

🇺🇸English

LlamaIndex - Data Framework for LLM Applications

The leading framework for connecting LLMs with your data.

When to use LlamaIndex

Use LlamaIndex when:

Building RAG (retrieval-augmented generation) applications
Need document question-answering over private data
Ingesting data from multiple sources (300+ connectors)
Creating knowledge bases for LLMs
Building chatbots with enterprise data
Need structured data extraction from documents

Metrics :

45,100+ GitHub stars
23,000+ repositories use LlamaIndex
300+ data connectors (LlamaHub)
1,715+ contributors
v0.14.7 (stable)

Use alternatives instead :

LangChain : More general-purpose, better for agents
Haystack : Production search pipelines
txtai : Lightweight semantic search
Chroma : Just need vector storage

Quick start

Installation

# Starter package (recommended)
pip install llama-index

# Or minimal core + specific integrations
pip install llama-index-core
pip install llama-index-llms-openai
pip install llama-index-embeddings-openai

5-line RAG example

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Load documents
documents = SimpleDirectoryReader("data").load_data()

# Create index
index = VectorStoreIndex.from_documents(documents)

# Query
query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")
print(response)

Core concepts

1. Data connectors - Load documents

from llama_index.core import SimpleDirectoryReader, Document
from llama_index.readers.web import SimpleWebPageReader
from llama_index.readers.github import GithubRepositoryReader

# Directory of files
documents = SimpleDirectoryReader("./data").load_data()

# Web pages
reader = SimpleWebPageReader()
documents = reader.load_data(["https://example.com"])

# GitHub repository
reader = GithubRepositoryReader(owner="user", repo="repo")
documents = reader.load_data(branch="main")

# Manual document creation
doc = Document(
    text="This is the document content",
    metadata={"source": "manual", "date": "2025-01-01"}
)

2. Indices - Structure data

from llama_index.core import VectorStoreIndex, ListIndex, TreeIndex

# Vector index (most common - semantic search)
vector_index = VectorStoreIndex.from_documents(documents)

# List index (sequential scan)
list_index = ListIndex.from_documents(documents)

# Tree index (hierarchical summary)
tree_index = TreeIndex.from_documents(documents)

# Save index
index.storage_context.persist(persist_dir="./storage")

# Load index
from llama_index.core import load_index_from_storage, StorageContext
storage_context = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage_context)

3. Query engines - Ask questions

# Basic query
query_engine = index.as_query_engine()
response = query_engine.query("What is the main topic?")
print(response)

# Streaming response
query_engine = index.as_query_engine(streaming=True)
response = query_engine.query("Explain quantum computing")
for text in response.response_gen:
    print(text, end="", flush=True)

# Custom configuration
query_engine = index.as_query_engine(
    similarity_top_k=3,          # Return top 3 chunks
    response_mode="compact",     # Or "tree_summarize", "simple_summarize"
    verbose=True
)

4. Retrievers - Find relevant chunks

# Vector retriever
retriever = index.as_retriever(similarity_top_k=5)
nodes = retriever.retrieve("machine learning")

# With filtering
retriever = index.as_retriever(
    similarity_top_k=3,
    filters={"metadata.category": "tutorial"}
)

# Custom retriever
from llama_index.core.retrievers import BaseRetriever

class CustomRetriever(BaseRetriever):
    def _retrieve(self, query_bundle):
        # Your custom retrieval logic
        return nodes

Agents with tools

Basic agent

from llama_index.core.agent import FunctionAgent
from llama_index.llms.openai import OpenAI

# Define tools
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

# Create agent
llm = OpenAI(model="gpt-4o")
agent = FunctionAgent.from_tools(
    tools=[multiply, add],
    llm=llm,
    verbose=True
)

# Use agent
response = agent.chat("What is 25 * 17 + 142?")
print(response)

RAG agent (document search + tools)

from llama_index.core.tools import QueryEngineTool

# Create index as before
index = VectorStoreIndex.from_documents(documents)

# Wrap query engine as tool
query_tool = QueryEngineTool.from_defaults(
    query_engine=index.as_query_engine(),
    name="python_docs",
    description="Useful for answering questions about Python programming"
)

# Agent with document search + calculator
agent = FunctionAgent.from_tools(
    tools=[query_tool, multiply, add],
    llm=llm
)

# Agent decides when to search docs vs calculate
response = agent.chat("According to the docs, what is Python used for?")

Advanced RAG patterns

Chat engine (conversational)

from llama_index.core.chat_engine import CondensePlusContextChatEngine

# Chat with memory
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",  # Or "context", "react"
    verbose=True
)

# Multi-turn conversation
response1 = chat_engine.chat("What is Python?")
response2 = chat_engine.chat("Can you give examples?")  # Remembers context
response3 = chat_engine.chat("What about web frameworks?")

Metadata filtering

from llama_index.core.vector_stores import MetadataFilters, ExactMatchFilter

# Filter by metadata
filters = MetadataFilters(
    filters=[
        ExactMatchFilter(key="category", value="tutorial"),
        ExactMatchFilter(key="difficulty", value="beginner")
    ]
)

retriever = index.as_retriever(
    similarity_top_k=3,
    filters=filters
)

query_engine = index.as_query_engine(filters=filters)

Structured output

from pydantic import BaseModel
from llama_index.core.output_parsers import PydanticOutputParser

class Summary(BaseModel):
    title: str
    main_points: list[str]
    conclusion: str

# Get structured response
output_parser = PydanticOutputParser(output_cls=Summary)
query_engine = index.as_query_engine(output_parser=output_parser)

response = query_engine.query("Summarize the document")
summary = response  # Pydantic model
print(summary.title, summary.main_points)

Data ingestion patterns

Multiple file types

# Load all supported formats
documents = SimpleDirectoryReader(
    "./data",
    recursive=True,
    required_exts=[".pdf", ".docx", ".txt", ".md"]
).load_data()

Web scraping

from llama_index.readers.web import BeautifulSoupWebReader

reader = BeautifulSoupWebReader()
documents = reader.load_data(urls=[
    "https://docs.python.org/3/tutorial/",
    "https://docs.python.org/3/library/"
])

Database

from llama_index.readers.database import DatabaseReader

reader = DatabaseReader(
    sql_database_uri="postgresql://user:pass@localhost/db"
)
documents = reader.load_data(query="SELECT * FROM articles")

API endpoints

from llama_index.readers.json import JSONReader

reader = JSONReader()
documents = reader.load_data("https://api.example.com/data.json")

Vector store integrations

Chroma (local)

from llama_index.vector_stores.chroma import ChromaVectorStore
import chromadb

# Initialize Chroma
db = chromadb.PersistentClient(path="./chroma_db")
collection = db.get_or_create_collection("my_collection")

# Create vector store
vector_store = ChromaVectorStore(chroma_collection=collection)

# Use in index
from llama_index.core import StorageContext
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

Pinecone (cloud)

from llama_index.vector_stores.pinecone import PineconeVectorStore
import pinecone

# Initialize Pinecone
pinecone.init(api_key="your-key", environment="us-west1-gcp")
pinecone_index = pinecone.Index("my-index")

# Create vector store
vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

FAISS (fast)

from llama_index.vector_stores.faiss import FaissVectorStore
import faiss

# Create FAISS index
d = 1536  # Dimension of embeddings
faiss_index = faiss.IndexFlatL2(d)

vector_store = FaissVectorStore(faiss_index=faiss_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

Customization

Custom LLM

from llama_index.llms.anthropic import Anthropic
from llama_index.core import Settings

# Set global LLM
Settings.llm = Anthropic(model="claude-sonnet-4-5-20250929")

# Now all queries use Anthropic
query_engine = index.as_query_engine()

Custom embeddings

from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# Use HuggingFace embeddings
Settings.embed_model = HuggingFaceEmbedding(
    model_name="sentence-transformers/all-mpnet-base-v2"
)

index = VectorStoreIndex.from_documents(documents)

Custom prompt templates

from llama_index.core import PromptTemplate

qa_prompt = PromptTemplate(
    "Context: {context_str}\n"
    "Question: {query_str}\n"
    "Answer the question based only on the context. "
    "If the answer is not in the context, say 'I don't know'.\n"
    "Answer: "
)

query_engine = index.as_query_engine(text_qa_template=qa_prompt)

Multi-modal RAG

Image + text

from llama_index.core import SimpleDirectoryReader
from llama_index.multi_modal_llms.openai import OpenAIMultiModal

# Load images and documents
documents = SimpleDirectoryReader(
    "./data",
    required_exts=[".jpg", ".png", ".pdf"]
).load_data()

# Multi-modal index
index = VectorStoreIndex.from_documents(documents)

# Query with multi-modal LLM
multi_modal_llm = OpenAIMultiModal(model="gpt-4o")
query_engine = index.as_query_engine(llm=multi_modal_llm)

response = query_engine.query("What is in the diagram on page 3?")

Evaluation

Response quality

from llama_index.core.evaluation import RelevancyEvaluator, FaithfulnessEvaluator

# Evaluate relevance
relevancy = RelevancyEvaluator()
result = relevancy.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Relevancy: {result.passing}")

# Evaluate faithfulness (no hallucination)
faithfulness = FaithfulnessEvaluator()
result = faithfulness.evaluate_response(
    query="What is Python?",
    response=response
)
print(f"Faithfulness: {result.passing}")

Best practices

Use vector indices for most cases - Best performance
Save indices to disk - Avoid re-indexing
Chunk documents properly - 512-1024 tokens optimal
Add metadata - Enables filtering and tracking
Use streaming - Better UX for long responses
Enable verbose during dev - See retrieval process
Evaluate responses - Check relevance and faithfulness
Use chat engine for conversations - Built-in memory
Persist storage - Don't lose your index
Monitor costs - Track embedding and LLM usage

Common patterns

Document Q&A system

# Complete RAG pipeline
documents = SimpleDirectoryReader("docs").load_data()
index = VectorStoreIndex.from_documents(documents)
index.storage_context.persist(persist_dir="./storage")

# Query
query_engine = index.as_query_engine(
    similarity_top_k=3,
    response_mode="compact",
    verbose=True
)
response = query_engine.query("What is the main topic?")
print(response)
print(f"Sources: {[node.metadata['file_name'] for node in response.source_nodes]}")

Chatbot with memory

# Conversational interface
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",
    verbose=True
)

# Multi-turn chat
while True:
    user_input = input("You: ")
    if user_input.lower() == "quit":
        break
    response = chat_engine.chat(user_input)
    print(f"Bot: {response}")

Performance benchmarks

Operation	Latency	Notes
Index 100 docs	~10-30s	One-time, can persist
Query (vector)	~0.5-2s	Retrieval + LLM
Streaming query	~0.5s first token	Better UX
Agent with tools	~3-8s	Multiple tool calls

LlamaIndex vs LangChain

Feature	LlamaIndex	LangChain
Best for	RAG, document Q&A	Agents, general LLM apps
Data connectors	300+ (LlamaHub)	100+
RAG focus	Core feature	One of many
Learning curve	Easier for RAG	Steeper
Customization	High	Very high
Documentation	Excellent	Good

Use LlamaIndex when:

Your primary use case is RAG
Need many data connectors
Want simpler API for document Q&A
Building knowledge retrieval system

Use LangChain when:

Building complex agents
Need more general-purpose tools
Want more flexibility
Complex multi-step workflows

References

Query Engines Guide - Query modes, customization, streaming
Agents Guide - Tool creation, RAG agents, multi-step reasoning
Data Connectors Guide - 300+ connectors, custom loaders

Resources

GitHub : https://github.com/run-llama/llama_index ⭐ 45,100+
Docs : https://developers.llamaindex.ai/python/framework/
LlamaHub : https://llamahub.ai (data connectors)
LlamaCloud : https://cloud.llamaindex.ai (enterprise)
Discord : https://discord.gg/dGcwcsnxhU
Version : 0.14.7+
License : MIT

Weekly Installs

231

Repository

davila7/claude-…emplates

GitHub Stars

22.6K

First Seen

Jan 21, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykWarn

Installed on

opencode185

gemini-cli177

claude-code167

cursor165

codex162

github-copilot152

LlamaIndex：构建RAG应用与私有数据问答的LLM数据框架 | 300+数据连接器

🇨🇳中文介绍

LlamaIndex - 大型语言模型应用数据框架

何时使用 LlamaIndex

快速开始

安装

相关 Skills

5行RAG示例

核心概念

1. 数据连接器 - 加载文档

2. 索引 - 结构化数据

3. 查询引擎 - 提出问题

4. 检索器 - 查找相关片段

带工具的智能体

基础智能体

RAG智能体（文档搜索 + 工具）

高级RAG模式

聊天引擎（对话式）

元数据过滤

结构化输出

数据摄取模式

多种文件类型

网络爬取

数据库

API端点

向量存储集成

Chroma（本地）

Pinecone（云端）

FAISS（快速）

自定义

自定义LLM

自定义嵌入

自定义提示模板

多模态RAG

图像 + 文本

评估

响应质量

最佳实践

常见模式

文档问答系统

带记忆的聊天机器人

性能基准

LlamaIndex 对比 LangChain

参考资料

资源