第一章：Agent智能体开发实战之【初步认识 LlamaIndex：从入门到实操】

Thomas.Sir2026-04-06 23:52

文章目录

  • 一、前言
  • [二、初步认识 LlamaIndex](#二、初步认识 LlamaIndex)
    • [2.1 LlamaIndex 介绍](#2.1 LlamaIndex 介绍)
      • [2.1.1 什么是 LlamaIndex？](#2.1.1 什么是 LlamaIndex？)
      • [2.1.2 LlamaIndex 的核心优势](#2.1.2 LlamaIndex 的核心优势)
      • [2.1.3 LlamaIndex 的应用场景](#2.1.3 LlamaIndex 的应用场景)
    • [2.2 LlamaIndex 快速入门](#2.2 LlamaIndex 快速入门)
      • [2.2.1 前置准备与环境搭建](#2.2.1 前置准备与环境搭建)
        • [1. 环境要求](#1. 环境要求)
        • [2. 安装依赖](#2. 安装依赖)
        • [3. 准备LLM API Key](#3. 准备LLM API Key)
      • [2.2.2 第一个LlamaIndex实例：文档问答](#2.2.2 第一个LlamaIndex实例：文档问答)
        • [1. 准备测试文档](#1. 准备测试文档)
        • [2. 核心代码（带详细注释）](#2. 核心代码（带详细注释）)
      • [2.2.3 代码解析与运行说明](#2.2.3 代码解析与运行说明)
        • [1. 核心代码解析](#1. 核心代码解析)
        • [2. 运行注意事项](#2. 运行注意事项)
        • [3. 运行结果预期](#3. 运行结果预期)
      • [2.2.4 入门拓展：多文档问答](#2.2.4 入门拓展：多文档问答)
    • [2.3 什么是代理？（Agent）](#2.3 什么是代理？（Agent）)
      • [2.3.1 代理的核心原理](#2.3.1 代理的核心原理)
      • [2.3.2 代理的核心组件](#2.3.2 代理的核心组件)
      • [2.3.3 代理实例：复杂任务自动化（可运行代码）](#2.3.3 代理实例：复杂任务自动化（可运行代码）)
      • [2.3.4 代理实例解析](#2.3.4 代理实例解析)
    • [2.4 工作流是什么？（Workflow）](#2.4 工作流是什么？（Workflow）)
      • [2.4.1 工作流的核心特点](#2.4.1 工作流的核心特点)
      • [2.4.2 工作流的核心组件](#2.4.2 工作流的核心组件)
      • [2.4.3 工作流实例：固定流程自动化（可运行代码）](#2.4.3 工作流实例：固定流程自动化（可运行代码）)
      • [2.4.4 工作流实例解析](#2.4.4 工作流实例解析)
  • 三、本章练习题及其答案
    • [3.1 选择题（每题5分，共25分）](#3.1 选择题（每题5分，共25分）)
    • [3.2 填空题（每空3分，共15分）](#3.2 填空题（每空3分，共15分）)
    • [3.3 简答题（每题10分，共30分）](#3.3 简答题（每题10分，共30分）)
    • [3.4 实操题（每题15分，共30分）](#3.4 实操题（每题15分，共30分）)
    • [3.5 练习题答案](#3.5 练习题答案)
  • 四、总结

一、前言

随着大语言模型（LLM）的普及，越来越多的开发者、AI爱好者开始尝试将LLM应用于实际项目，但在落地过程中，普遍面临"外部知识接入难""复杂任务无法拆解""多工具协同效率低"等痛点。LlamaIndex（曾用名GPT

Index）作为一款专为LLM应用开发设计的框架，恰好解决了这些问题，它能帮助开发者快速连接LLM与外部数据，实现复杂任务的拆解与自动化执行，降低LLM应用的开发门槛。

二、初步认识 LlamaIndex

在学习LlamaIndex之前，我们先明确一个核心定位：LlamaIndex不是一款大语言模型，而是一个"LLM应用开发框架"------它如同一个"桥梁"，连接大语言模型（如GPT、LLaMA、豆包等）与外部数据（文档、数据库、API等），同时提供代理、工作流等核心功能，帮助开发者快速构建复杂的LLM应用，无需从零搭建数据接入、任务拆解、工具协同的逻辑。

2.1 LlamaIndex 介绍

2.1.1 什么是 LlamaIndex？

LlamaIndex 是一个开源的LLM应用开发框架，由 Jerry Liu 团队开发，核心目标是"让LLM更好地理解和使用外部知识"。它提供了一套完整的工具链，帮助开发者解决LLM应用开发中的核心痛点：

  • 外部数据接入：支持多种数据源（PDF、Word、Excel、数据库、API、网页等）的快速接入，无需手动编写复杂的数据解析代码；

  • 知识结构化：将非结构化/半结构化数据转化为LLM可理解的结构化知识，提升LLM对外部数据的利用率；

  • 复杂任务拆解：通过代理（Agent）功能，将复杂任务自动拆解为多个简单子任务，调用相应工具完成执行；

  • 多工具协同：支持集成各类工具（数据库查询工具、API调用工具、文件处理工具等），实现多工具自动化协同工作；

  • 低代码开发：提供简洁的API接口和丰富的预置组件，开发者无需从零开发，快速搭建LLM应用。

简单来说，LlamaIndex

的核心价值是"降低LLM应用的开发门槛"，让无论是后端、前端、运维工程师，还是AI爱好者、在校学生，都能快速上手，将LLM与实际需求结合，开发出实用的AI应用。

2.1.2 LlamaIndex 的核心优势

相比其他LLM开发框架（如LangChain），LlamaIndex 具有以下核心优势，更适合新手入门：

1. 上手简单：API设计简洁直观，文档完善，即使是新手，也能在1-2小时内完成基础入门，搭建第一个LLM应用；

2. 数据接入能力强：内置多种数据源的解析器，支持PDF、Word、TXT、CSV、数据库（MySQL、Neo4j等）、API等，无需手动处理数据格式；

3. 轻量灵活：核心依赖少，可灵活集成不同的LLM（OpenAI、豆包、LLaMA等），支持本地部署和云端部署，适配不同场景；

4. 专注实用：聚焦"数据+LLM"的核心场景，功能模块精简，避免冗余，开发者可快速聚焦核心需求，无需学习复杂的额外功能；

5. 开源免费：完全开源，社区活跃，遇到问题可快速获取解决方案，同时支持自定义扩展，满足个性化需求。

2.1.3 LlamaIndex 的应用场景

LlamaIndex 适用于各类LLM应用场景，尤其适合需要接入外部数据、处理复杂任务的场景，常见应用包括：

  • 智能问答系统：接入企业文档、知识库，实现精准的问答（如员工手册问答、产品文档问答）；

  • 数据分析助手：连接数据库、Excel文件，自动分析数据，生成分析报告；

  • 自动化办公工具：拆解办公任务（如邮件处理、文档生成、数据统计），自动调用工具完成；

  • 知识管理系统：将非结构化文档转化为结构化知识，实现知识的检索、整理和复用；

  • 多工具协同应用：如"查询数据库→生成报告→发送邮件"的全流程自动化。

2.2 LlamaIndex 快速入门

本小节将通过"环境搭建→基础实例→代码解析"的步骤，帮助读者快速上手LlamaIndex，所有代码均经过测试可运行，带详细注释，新手可直接复制操作。

2.2.1 前置准备与环境搭建

1. 环境要求

确保已安装 Python 3.8+（推荐3.10版本），避免版本兼容问题。

2. 安装依赖

执行以下命令，安装LlamaIndex及核心依赖（包含LLM依赖、数据解析依赖）：

bash 复制代码 
# 安装核心LlamaIndex（稳定版）
pip install llama-index==0.10.18
# 安装OpenAI依赖（用于调用GPT模型，若使用其他LLM可跳过）
pip install openai==1.13.3
# 安装文档解析依赖（支持PDF、Word等文件解析）
pip install pypdf==4.0.1 python-docx==1.1.0
# 安装可视化依赖（可选，用于查看数据结构）
pip install llama-index-visualizer==0.1.0
3. 准备LLM API Key

本入门实例使用OpenAI的GPT-3.5-turbo模型，需要获取OpenAI API Key（可在OpenAI官网注册获取）；若无法访问OpenAI，可替换为国内LLM（如豆包），后续会给出替换方法。

2.2.2 第一个LlamaIndex实例：文档问答

我们将实现一个简单的文档问答应用：读取本地TXT文档，通过LlamaIndex连接GPT模型，实现对文档内容的问答，快速体验LlamaIndex的核心功能。

1. 准备测试文档

在本地创建一个名为 test_doc.txt 的文本文件，输入以下内容（可自定义内容）：

txt 复制代码 
LlamaIndex 是一款开源的LLM应用开发框架，核心目标是让LLM更好地理解和使用外部知识。
它支持多种数据源的接入，包括PDF、Word、数据库、API等，能够将非结构化数据转化为结构化知识。
LlamaIndex 提供了代理（Agent）和工作流（Workflow）功能，可实现复杂任务的拆解和多工具协同。
LlamaIndex 的优势是上手简单、轻量灵活，适合各类开发者快速搭建LLM应用。
2. 核心代码（带详细注释）
python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
LlamaIndex 快速入门：文档问答实例
功能：读取本地TXT文档，实现对文档内容的问答
依赖：llama-index、openai
"""

# 1. 导入所需依赖
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

# 2. 配置LLM（OpenAI GPT-3.5-turbo）
# 替换为自己的OpenAI API Key
OPENAI_API_KEY = "your_openai_api_key"

# 初始化OpenAI LLM（温度越低，回答越稳定）
llm = OpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-3.5-turbo",
    temperature=0.3
)

# 3. 读取本地文档（SimpleDirectoryReader 可读取指定目录下的所有文档）
# 此处读取当前目录下的 test_doc.txt 文件
reader = SimpleDirectoryReader(input_files=["test_doc.txt"])
# 将文档转化为LlamaIndex可处理的文档对象（Document）
documents = reader.load_data()
print(f"成功读取文档，共 {len(documents)} 个文档对象")

# 4. 构建索引（核心步骤：将文档转化为结构化知识）
# VectorStoreIndex 是LlamaIndex最基础的索引类型，基于向量存储文档内容
index = VectorStoreIndex.from_documents(
    documents=documents,
    llm=llm  # 关联LLM，用于生成文档的向量表示
)

# 5. 创建查询引擎（用于对索引进行查询，实现问答）
query_engine = index.as_query_engine()

# 6. 执行查询（问答）
# 可自定义查询问题，需与文档内容相关
test_queries = [
    "LlamaIndex 是什么？",
    "LlamaIndex 支持哪些数据源？",
    "LlamaIndex 的优势是什么？",
    "LlamaIndex 有哪些核心功能？"
]

# 逐个执行查询，输出结果
for idx, query in enumerate(test_queries, 1):
    print(f"n=== 查询 {idx} ===")
    print(f"问题：{query}")
    # 执行查询，获取回答
    response = query_engine.query(query)
    print(f"回答：{response}")

# 7. 扩展：替换为国内LLM（以豆包为例）
# 若无法访问OpenAI，可注释上面的代码，执行以下代码
# 安装豆包依赖：pip install doubao-api
# from llama_index.llms.doubao import Doubao
# llm = Doubao(api_key="your_doubao_api_key", model="doubao-pro")
# 后续步骤（读取文档、构建索引、查询）与上面一致

2.2.3 代码解析与运行说明

1. 核心代码解析

  • 依赖导入：SimpleDirectoryReader 用于读取本地文档，VectorStoreIndex 用于构建文档索引，OpenAI 用于集成OpenAI模型；

  • LLM配置：初始化OpenAI模型，设置API Key、模型名称和温度（temperature），温度越低，回答越稳定，适合问答场景；

  • 文档读取：SimpleDirectoryReader 可读取指定文件或目录下的文档，支持TXT、PDF、Word等格式，自动解析文档内容；

  • 索引构建：将文档转化为结构化的向量索引，便于后续快速检索相关内容，这是LlamaIndex实现"外部知识接入"的核心步骤；

  • 查询引擎：通过索引创建查询引擎，调用query 方法即可实现问答，LlamaIndex会自动检索文档中与问题相关的内容，结合LLM生成回答。

2. 运行注意事项

  • API Key替换：必须将代码中的 your_openai_api_key 替换为自己的OpenAI API Key，否则无法调用LLM；

  • 文档路径：确保 test_doc.txt 文件与代码文件在同一目录下，若路径不同，需修改 input_files 中的路径；

  • 版本兼容：若出现导入错误，需确保安装的LlamaIndex版本为0.10.18，可执行 pip install llama-index==0.10.18 固定版本；

  • 国内LLM替换：若无法访问OpenAI，可使用豆包、文心一言等国内LLM，只需修改LLM的初始化代码，替换API Key即可，后续步骤完全一致。

3. 运行结果预期

运行代码后，会依次输出每个查询的回答，回答内容均来自 test_doc.txt 文档，例如：

text 复制代码 
成功读取文档，共 1 个文档对象

=== 查询 1 ===
问题：LlamaIndex 是什么？
回答：LlamaIndex 是一款开源的LLM应用开发框架，核心目标是让LLM更好地理解和使用外部知识。它支持多种数据源的接入，能够将非结构化数据转化为结构化知识，还提供了代理（Agent）和工作流（Workflow）功能，可实现复杂任务的拆解和多工具协同，且具有上手简单、轻量灵活的优势，适合各类开发者快速搭建LLM应用。

2.2.4 入门拓展：多文档问答

若需要读取多个文档（如多个TXT、PDF文件），只需修改文档读取部分的代码，将 input_files 改为目录路径，SimpleDirectoryReader 会自动读取目录下的所有支持格式的文档：

python 复制代码 
# 读取指定目录下的所有文档（如 docs 目录）
reader = SimpleDirectoryReader(input_dir="docs")
documents = reader.load_data()
print(f"成功读取 {len(documents)} 个文档")

其他步骤与单文档问答完全一致，LlamaIndex会自动整合所有文档的内容，构建统一的索引，实现多文档的联合问答。

2.3 什么是代理？（Agent）

在LlamaIndex中，代理（Agent）是实现"复杂任务自动化"的核心组件，也是LlamaIndex区别于简单文档问答工具的重要功能。很多新手会混淆"代理"和"查询引擎"，这里先明确两者的区别：

查询引擎（Query Engine）：只能执行单一的查询任务（如文档问答、数据库查询），无法处理复杂任务；

代理（Agent）：可以理解为"LLM驱动的智能助手"，能够接收复杂任务，自动拆解为多个简单子任务，选择合适的工具（如查询引擎、数据库工具、API工具）执行每个子任务，最终整合所有子任务的结果，生成最终答案。

2.3.1 代理的核心原理

LlamaIndex中的代理，核心是"LLM + 工具集 + 任务规划"，其工作流程如下：

  1. 接收用户需求：用户提出一个复杂任务（如"读取本地文档，统计文档中提到的LlamaIndex功能，并生成一份markdown格式的报告"）；

  2. 任务拆解：代理调用LLM，将复杂任务拆解为多个子任务（如子任务1：读取本地文档；子任务2：统计LlamaIndex功能；子任务3：生成markdown报告）；

  3. 工具选择：针对每个子任务，代理自动选择合适的工具（如子任务1用文档读取工具，子任务2用查询引擎，子任务3用LLM生成工具）；

  4. 执行子任务：调用对应工具，执行每个子任务，获取子任务结果；

  5. 结果整合：将所有子任务的结果整合，调用LLM生成最终的回答或报告。

简单来说，代理的核心价值是"让LLM具备自主决策和执行能力"，无需开发者手动拆解任务、调用工具，实现复杂任务的全自动化。

2.3.2 代理的核心组件

LlamaIndex中的代理由以下3个核心组件组成，缺一不可：

  1. LLM（核心驱动）：负责任务拆解、工具选择和结果整合，是代理的"大脑"；

  2. 工具集（执行单元）：代理可调用的各类工具，如文档查询工具、数据库工具、API工具、文件生成工具等，LlamaIndex内置了多种常用工具，也支持自定义工具；

  3. 代理控制器（决策单元）：负责协调LLM和工具集，确保任务拆解、工具调用、结果整合的流程顺畅，避免出现任务遗漏或工具调用错误。

2.3.3 代理实例：复杂任务自动化（可运行代码）

我们将实现一个简单的代理实例：接收复杂任务"读取test_doc.txt文档，统计文档中提到的LlamaIndex核心功能，生成一份markdown格式的报告，保存到本地"，代理自动拆解任务、调用工具完成执行。

python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
LlamaIndex 代理（Agent）实例：复杂任务自动化
功能：自动拆解复杂任务，调用工具完成文档读取、统计、报告生成
依赖：llama-index、openai
"""

# 1. 导入所需依赖
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
from llama_index.core.agents import ReActAgent
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.core.output_parsers import StrOutputParser

# 2. 配置LLM
OPENAI_API_KEY = "your_openai_api_key"
llm = OpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-3.5-turbo",
    temperature=0.3
)

# 3. 构建文档查询工具（作为代理可调用的工具之一）
# 读取文档，构建索引
reader = SimpleDirectoryReader(input_files=["test_doc.txt"])
documents = reader.load_data()
index = VectorStoreIndex.from_documents(documents=documents, llm=llm)
query_engine = index.as_query_engine()

# 封装查询工具（给工具命名和描述，方便代理识别）
query_tool = QueryEngineTool(
    query_engine=query_engine,
    metadata=ToolMetadata(
        name="document_query_tool",  # 工具名称（唯一）
        description="用于查询test_doc.txt文档中的内容，可获取LlamaIndex的相关信息，如功能、优势、数据源等"  # 工具描述（关键，代理通过描述判断是否使用该工具）
    )
)

# 4. 定义自定义工具：生成markdown报告并保存到本地
from llama_index.core.tools import BaseTool, ToolOutput
import os

class MarkdownReportTool(BaseTool):
    """自定义工具：生成markdown报告并保存到本地"""
    name = "markdown_report_tool"
    description = "用于将给定的内容生成markdown格式的报告，并保存到本地文件，输入为报告内容，输出为文件保存路径"

    def _run(self, content: str) -> ToolOutput:
        """工具执行逻辑：将内容写入markdown文件"""
        # 定义报告保存路径
        report_path = "llama_index_report.md"
        # 写入内容
        with open(report_path, "w", encoding="utf-8") as f:
            f.write(content)
        # 返回执行结果
        return ToolOutput(
            content=f"markdown报告已生成，保存路径：{os.path.abspath(report_path)}",
            tool_name=self.name
        )

# 实例化自定义工具
report_tool = MarkdownReportTool()

# 5. 初始化代理（ReActAgent是LlamaIndex最常用的代理类型）
agent = ReActAgent(
    llm=llm,
    tools=[query_tool, report_tool],  # 代理可调用的工具集
    output_parser=StrOutputParser(),  # 输出解析器，确保输出格式规范
    verbose=True  # 开启verbose模式，可查看代理的任务拆解、工具调用过程（便于调试和教学）
)

# 6. 提交复杂任务，执行代理
complex_task = """
请完成以下任务：
1. 读取test_doc.txt文档，统计文档中提到的LlamaIndex的核心功能；
2. 将统计结果整理成markdown格式的报告，报告标题为"LlamaIndex核心功能统计"；
3. 将报告保存到本地。
"""

print("提交的复杂任务：", complex_task)
print("n=== 代理执行过程 ===")
# 执行代理，获取结果
response = agent.chat(complex_task)

print("n=== 代理执行结果 ===")
print(response)

# 验证：查看生成的markdown报告
if os.path.exists("llama_index_report.md"):
    with open("llama_index_report.md", "r", encoding="utf-8") as f:
        report_content = f.read()
    print("n=== 生成的markdown报告内容 ===")
    print(report_content)

2.3.4 代理实例解析

  • 工具封装：将查询引擎封装为QueryEngineTool，自定义报告生成工具继承BaseTool，每个工具都需要明确名称和描述，代理通过描述判断该工具是否适合执行当前子任务；

  • 代理初始化：使用ReActAgent（LlamaIndex最常用的代理类型，基于ReAct思维链），传入LLM和工具集，开启verbose=True，可直观查看代理的任务拆解和工具调用过程；

  • 任务执行：代理接收复杂任务后，会自动拆解为3个子任务，依次调用document_query_tool（统计核心功能）、markdown_report_tool（生成并保存报告），最终返回执行结果；

  • 自定义工具：通过继承BaseTool，可实现任意自定义工具（如邮件发送工具、API调用工具），拓展代理的能力。

运行代码后，会生成llama_index_report.md文件，同时在控制台输出代理的执行过程，清晰展示任务拆解和工具调用的细节，帮助读者理解代理的工作原理。

2.4 工作流是什么？（Workflow）

工作流（Workflow）是LlamaIndex中另一个核心功能，与代理（Agent）类似，都用于处理复杂任务，但两者的核心区别在于：

代理（Agent） ：动态拆解任务，任务拆解和工具调用由LLM自主决策，适合任务流程不固定、需要灵活调整的场景；

工作流（Workflow ）：静态定义流程，开发者提前定义好任务的执行步骤、工具调用顺序，代理按照固定流程执行，适合任务流程固定、可重复执行的场景。

简单来说，工作流是"固定流程的自动化"，而代理是"灵活流程的自动化"，两者可结合使用，适配不同的复杂任务场景。

2.4.1 工作流的核心特点

  • 流程固定：开发者提前定义好任务的执行步骤、每个步骤调用的工具、步骤之间的依赖关系，工作流按照固定流程执行，不会随意调整；

  • 可复用性强：一旦定义好工作流，可重复执行相同类型的任务，无需重复编写代码；

  • 易于调试：流程固定，出现问题时可快速定位到具体步骤，便于调试和优化；

  • 低代码配置：LlamaIndex提供了简洁的API，可通过代码快速定义工作流，无需复杂的配置。

2.4.2 工作流的核心组件

LlamaIndex中的工作流，核心由以下2个组件组成：

1. 步骤（Step）：工作流的最小执行单元，每个步骤对应一个工具调用或一个简单任务，如"读取文档""查询数据""生成报告"；

2. 流程控制器（Workflow Controller）：负责按照提前定义的顺序，执行每个步骤，处理步骤之间的依赖关系（如"必须先读取文档，才能查询数据"），确保流程顺畅执行。

2.4.3 工作流实例：固定流程自动化（可运行代码）

我们将实现一个固定流程的工作流："读取文档→查询文档内容→生成markdown报告→保存报告"，流程固定，可重复执行，对比代理的动态拆解，感受工作流的特点。

python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
LlamaIndex 工作流（Workflow）实例：固定流程自动化
功能：按照固定步骤执行任务：读取文档→查询内容→生成报告→保存报告
依赖：llama-index、openai
"""

# 1. 导入所需依赖
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
from llama_index.core.workflow import (
    Workflow,
    step,
    Context,
    Input,
    Output
)
from llama_index.core.tools import QueryEngineTool, ToolMetadata
import os

# 2. 配置LLM
OPENAI_API_KEY = "your_openai_api_key"
llm = OpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-3.5-turbo",
    temperature=0.3
)

# 3. 定义工作流（继承Workflow，通过@step装饰器定义每个步骤）
class LlamaIndexWorkflow(Workflow):
    """LlamaIndex 固定流程工作流：读取文档→查询内容→生成报告→保存报告"""
    
    # 步骤1：读取本地文档，返回文档对象列表
    @step
    def read_document(self, context: Context, input: Input[str]) -> Output[list]:
        """步骤1：读取本地文档"""
        print("=== 执行步骤1：读取文档 ===")
        # input为文档路径
        reader = SimpleDirectoryReader(input_files=[input])
        documents = reader.load_data()
        print(f"成功读取文档，共 {len(documents)} 个文档对象")
        # 返回文档对象列表，供下一个步骤使用
        return documents
    
    # 步骤2：构建索引，查询文档中的LlamaIndex核心功能
    @step
    def query_document(self, context: Context, input: Input[list]) -> Output[str]:
        """步骤2：查询文档内容，统计LlamaIndex核心功能"""
        print("=== 执行步骤2：查询文档内容 ===")
        # input为步骤1返回的文档对象列表
        index = VectorStoreIndex.from_documents(documents=input, llm=llm)
        query_engine = index.as_query_engine()
        # 固定查询：统计LlamaIndex核心功能
        query = "请统计test_doc.txt文档中提到的LlamaIndex核心功能，用简洁的语言总结"
        response = query_engine.query(query)
        print(f"查询结果：{response}")
        # 返回查询结果，供下一个步骤使用
        return str(response)
    
    # 步骤3：将查询结果生成markdown格式的报告
    @step
    def generate_report(self, context: Context, input: Input[str]) -> Output[str]:
        """步骤3：生成markdown报告"""
        print("=== 执行步骤3：生成markdown报告 ===")
        # input为步骤2返回的查询结果
        report_content = f"# LlamaIndex核心功能统计nn{input}"
        print(f"报告内容：n{report_content}")
        # 返回报告内容，供下一个步骤使用
        return report_content
    
    # 步骤4：将报告保存到本地
    @step
    def save_report(self, context: Context, input: Input[str]) -> Output[str]:
        """步骤4：保存报告到本地"""
        print("=== 执行步骤4：保存报告 ===")
        # input为步骤3返回的报告内容
        report_path = "llama_index_workflow_report.md"
        with open(report_path, "w", encoding="utf-8") as f:
            f.write(input)
        save_path = os.path.abspath(report_path)
        print(f"报告已保存到：{save_path}")
        # 返回保存路径，作为工作流最终结果
        return save_path

# 4. 初始化工作流并执行
if __name__ == "__main__":
    # 初始化工作流
    workflow = LlamaIndexWorkflow()
    
    # 执行工作流，传入初始输入（文档路径）
    # 工作流会按照步骤1→步骤2→步骤3→步骤4的顺序执行
    result = workflow.run(input="test_doc.txt")
    
    # 输出工作流最终结果
    print("n=== 工作流执行完成 ===")
    print(f"最终结果：报告已保存到 {result}")
    
    # 验证报告
    if os.path.exists("llama_index_workflow_report.md"):
        with open("llama_index_workflow_report.md", "r", encoding="utf-8") as f:
            print("n=== 生成的报告内容 ===")
            print(f.read())

2.4.4 工作流实例解析

  • 工作流定义：通过继承Workflow类，使用@step装饰器定义每个步骤，每个步骤的输入是上一个步骤的输出，形成固定的流程链路；

  • 步骤依赖：步骤1的输出（文档对象列表）作为步骤2的输入，步骤2的输出（查询结果）作为步骤3的输入，步骤3的输出（报告内容）作为步骤4的输入，流程固定，不可随意调整；

  • 执行方式：调用workflow.run()传入初始输入（文档路径），工作流会自动按照定义的步骤顺序执行，无需手动干预；

  • 与代理的区别：该工作流的步骤、查询内容、工具调用都是固定的，适合重复执行"读取指定文档→生成固定格式报告"的任务，而代理可根据不同的任务动态调整步骤和工具。

运行代码后，会按照"读取文档→查询内容→生成报告→保存报告"的固定流程执行，生成llama_index_workflow_report.md文件，对比代理实例，可清晰感受到工作流"固定流程、可复用"的特点。

三、本章练习题及其答案

为帮助读者巩固本章所学知识，结合LlamaIndex基础介绍、快速入门、代理、工作流的核心内容，设计以下练习题，涵盖选择、填空、简答、实操四种题型，所有题目均贴合教学重点，答案详细易懂，适合自我检测和教学使用。

3.1 选择题（每题5分，共25分）

  1. 以下关于LlamaIndex的描述，正确的是（ ）

    • A. LlamaIndex是一款大语言模型，可直接生成回答

    • B. LlamaIndex是一个LLM应用开发框架，用于连接LLM与外部数据

    • C. LlamaIndex只能处理PDF文档，无法处理其他格式的文档

    • D. LlamaIndex不支持国内LLM，只能使用OpenAI模型

  2. LlamaIndex中，用于读取本地文档的组件是（ ）

    • A. VectorStoreIndex

    • B. SimpleDirectoryReader

    • C. ReActAgent

    • D. Workflow

  3. 以下关于代理（Agent）和工作流（Workflow）的区别，正确的是（ ）

    • A. 代理是固定流程，工作流是动态流程

    • B. 代理和工作流都只能处理简单任务

    • C. 代理动态拆解任务，工作流固定流程

    • D. 代理不支持工具调用，工作流支持工具调用

  4. LlamaIndex中，构建文档索引最基础的索引类型是（ ）

    • A. TreeIndex

    • B. VectorStoreIndex

    • C. ListIndex

    • D. KeywordTableIndex

  5. 以下哪项不是LlamaIndex的核心优势（ ）

    • A. 上手简单，API简洁

    • B. 数据接入能力强，支持多种数据源

    • C. 只能部署在云端，无法本地部署

    • D. 开源免费，社区活跃

3.2 填空题（每空3分，共15分）

  1. LlamaIndex的核心目标是________________，帮助开发者快速连接LLM与外部数据。

  2. LlamaIndex中，________________是实现复杂任务动态拆解的核心组件，而________________是实现固定流程自动化的核心组件。

  3. 构建文档问答应用时，需要先通过________________读取文档，再通过________________构建索引，最后通过查询引擎执行问答。

  4. 代理（Agent）的核心组件包括LLM、工具集和________________。

3.3 简答题（每题10分，共30分）

  1. 简述LlamaIndex的核心优势，至少列出3点。

  2. 简述代理（Agent）的工作流程，分步骤说明。

  3. 简述LlamaIndex中查询引擎（Query Engine）、代理（Agent）、工作流（Workflow）三者的区别与联系。

3.4 实操题（每题15分，共30分）

  1. 实操任务：使用LlamaIndex实现PDF文档问答。要求：① 读取本地一个PDF文档（自定义内容）；② 构建索引；③ 实现3个相关问题的问答，代码带详细注释，确保可运行。

  2. 实操任务：使用LlamaIndex的工作流，实现"读取TXT文档→查询文档中提到的LLM模型→生成txt格式的查询报告→保存到本地"的固定流程，代码带详细注释，确保可运行。

3.5 练习题答案

3.5.1 选择题答案

  1. B（解析：A错误，LlamaIndex是框架，不是LLM；C错误，支持多种格式文档；D错误，支持国内LLM如豆包）

  2. B（解析：SimpleDirectoryReader用于读取本地文档，VectorStoreIndex用于构建索引，ReActAgent是代理，Workflow是工作流）

  3. C（解析：代理动态拆解任务，工作流固定流程，A错误；两者都能处理复杂任务，B错误；两者都支持工具调用，D错误）

  4. B（解析：VectorStoreIndex是LlamaIndex最基础、最常用的索引类型，基于向量存储文档内容）

  5. C（解析：LlamaIndex支持本地部署和云端部署，C选项描述错误）

3.5.2 填空题答案

  1. 让LLM更好地理解和使用外部知识

  2. 代理（Agent）；工作流（Workflow）

  3. SimpleDirectoryReader；VectorStoreIndex

  4. 代理控制器（决策单元）

3.5.3 简答题答案

  1. 答：LlamaIndex的核心优势包括：

    • 上手简单：API设计简洁直观，文档完善，新手可快速入门；

    • 数据接入能力强：内置多种数据源解析器，支持PDF、Word、数据库、API等，无需手动处理数据格式；

    • 轻量灵活：核心依赖少，可灵活集成不同LLM，支持本地和云端部署；

    • 专注实用：聚焦"数据+LLM"核心场景，功能精简，避免冗余；

    • 开源免费：社区活跃，支持自定义扩展，遇到问题可快速获取解决方案。（答出3点及以上即可）

  2. 答：代理（Agent）的工作流程分为5个步骤：

    1. 接收用户需求：用户提出复杂任务；

    2. 任务拆解：代理调用LLM，将复杂任务拆解为多个简单子任务；

    3. 工具选择：针对每个子任务，代理根据工具描述，选择合适的工具；

    4. 执行子任务：调用对应工具，执行每个子任务，获取子任务结果；

    5. 结果整合：将所有子任务结果整合，调用LLM生成最终回答。

  3. 答：区别：

    复制代码 
     联系：三者都是LlamaIndex的核心组件，查询引擎可作为代理和工作流的工具，代理和工作流都依赖LLM，都用于处理复杂任务，可结合使用（如工作流中嵌入代理，实现固定流程中的灵活任务处理）。

    • 查询引擎：只能执行单一查询任务（如文档问答），无法处理复杂任务，无任务拆解能力；

    • 代理：动态拆解复杂任务，自主选择工具，流程灵活，适合任务流程不固定的场景；

    • 工作流：提前定义固定流程，按步骤执行任务，流程固定，适合可重复执行的场景。

3.5.4 实操题答案

实操题1：PDF文档问答（可运行代码）
python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
实操题1：LlamaIndex PDF文档问答
功能：读取本地PDF文档，构建索引，实现问答
依赖：llama-index、openai、pypdf
"""

# 1. 导入所需依赖
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI

# 2. 配置LLM（替换为自己的API Key）
OPENAI_API_KEY = "your_openai_api_key"
llm = OpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-3.5-turbo",
    temperature=0.3
)

# 3. 读取PDF文档（确保本地有test_doc.pdf文件，可自定义PDF内容）
# SimpleDirectoryReader 自动识别PDF格式，无需额外处理
reader = SimpleDirectoryReader(input_files=["test_doc.pdf"])
documents = reader.load_data()
print(f"成功读取PDF文档，共 {len(documents)} 个文档对象")

# 4. 构建索引（与TXT文档问答一致，LlamaIndex自动处理PDF内容解析）
index = VectorStoreIndex.from_documents(
    documents=documents,
    llm=llm
)

# 5. 创建查询引擎，执行问答
query_engine = index.as_query_engine()

# 6. 测试3个相关问题（根据PDF内容自定义）
test_queries = [
    "PDF文档中提到的LlamaIndex应用场景有哪些？",
    "PDF文档中介绍了LlamaIndex的哪些核心组件？",
    "如何使用LlamaIndex构建文档索引？"
]

# 执行查询并输出结果
for idx, query in enumerate(test_queries, 1):
    print(f"n=== 查询 {idx} ===")
    print(f"问题：{query}")
    response = query_engine.query(query)
    print(f"回答：{response}")

说明：需提前准备test_doc.pdf文档（可将之前的TXT内容复制到PDF中），安装pypdf依赖（已在入门部分的依赖安装中包含），替换API Key即可运行。

实操题2：工作流实现固定流程（可运行代码）
python 复制代码 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
实操题2：LlamaIndex 工作流实操
功能：固定流程：读取TXT文档→查询LLM模型→生成txt报告→保存报告
依赖：llama-index、openai
"""

# 1. 导入所需依赖
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.openai import OpenAI
from llama_index.core.workflow import (
    Workflow,
    step,
    Context,
    Input,
    Output
)
import os

# 2. 配置LLM（替换为自己的API Key）
OPENAI_API_KEY = "your_openai_api_key"
llm = OpenAI(
    api_key=OPENAI_API_KEY,
    model="gpt-3.5-turbo",
    temperature=0.3
)

# 3. 定义工作流
class LLMQueryWorkflow(Workflow):
    # 步骤1：读取TXT文档
    @step
    def read_txt(self, context: Context, input: Input[str]) -> Output[list]:
        print("=== 步骤1：读取TXT文档 ===")
        reader = SimpleDirectoryReader(input_files=[input])
        documents = reader.load_data()
        print(f"成功读取文档：{input}")
        return documents
    
    # 步骤2：查询文档中提到的LLM模型
    @step
    def query_llm(self, context: Context, input: Input[list]) -> Output[str]:
        print("=== 步骤2：查询LLM模型 ===")
        index = VectorStoreIndex.from_documents(documents=input, llm=llm)
        query_engine = index.as_query_engine()
        query = "请列出文档中提到的所有LLM模型，简要说明每个模型的特点"
        response = query_engine.query(query)
        return str(response)
    
    # 步骤3：生成txt格式报告
    @step
    def generate_txt_report(self, context: Context, input: Input[str]) -> Output[str]:
        print("=== 步骤3：生成txt报告 ===")
        report_content = f"LLM模型查询报告n{'='*20}n{input}"
        return report_content
    
    # 步骤4：保存报告到本地
    @step
    def save_txt_report(self, context: Context, input: Input[str]) -> Output[str]:
        print("=== 步骤4：保存报告 ===")
        report_path = "llm_query_report.txt"
        with open(report_path, "w", encoding="utf-8") as f:
            f.write(input)
        save_path = os.path.abspath(report_path)
        return save_path

# 4. 执行工作流
if __name__ == "__main__":
    # 初始化工作流
    workflow = LLMQueryWorkflow()
    # 执行工作流，传入TXT文档路径（确保本地有test_doc.txt）
    result = workflow.run(input="test_doc.txt")
    # 输出结果
    print(f"n工作流执行完成，报告保存路径：{result}")
    # 验证报告
    with open("llm_query_report.txt", "r", encoding="utf-8") as f:
        print("n报告内容：")
        print(f.read())

说明：使用之前的test_doc.txt文档（可在文档中添加LLM模型相关内容，如"GPT-3.5-turbo是OpenAI的轻量型大模型，适合日常问答；LLaMA是Meta开源的大模型，支持本地部署"），替换API

Key即可运行，运行后会生成llm_query_report.txt报告文件。

四、总结

本文围绕"初步认识LlamaIndex"展开，从前言引入，详细介绍了LlamaIndex的核心定位、优势和应用场景，通过可运行的代码实例，讲解了LlamaIndex的快速入门（文档问答）、代理（Agent）和工作流（Workflow）的核心概念与实操方法，最后搭配配套练习题及答案，形成完整的教学体系。

通过本文学习，读者可快速建立对LlamaIndex的初步认知，掌握基础的文档接入、索引构建、问答实现，以及代理和工作流的核心用法，能够独立完成简单的LLM应用开发。LlamaIndex的核心价值是降低LLM应用的开发门槛，无论是后端、前端、运维工程师，还是AI爱好者、在校学生，都能借助LlamaIndex快速将LLM与实际需求结合，实现各类AI应用。后续可进一步深入学习LlamaIndex的高级特性，逐步提升LLM应用的开发能力，更好地发挥框架的价值。

本文作为LlamaIndex的入门教学教案，旨在为读者搭建完整的基础认知框架，提供可落地的实操方法和配套练习，帮助读者快速上手。LLM应用开发是一个持续学习、不断实践的过程，希望读者能够以本文为起点，不断探索、深入学习，充分发挥LlamaIndex的优势，开发出更多实用、高效的AI应用，在AI技术快速发展的浪潮中，提升自身的核心竞争力。

🌟 感谢您耐心阅读到这里！

🚀 技术成长没有捷径，但每一次的阅读、思考和实践，都在默默缩短您与成功的距离。

💡 如果本文对您有所启发，欢迎点赞👍、收藏📌、分享📤给更多需要的伙伴！

🗣️ 期待在评论区看到您的想法、疑问或建议，我会认真回复，让我们共同探讨、一起进步～

🔔 关注我，持续获取更多干货内容！

🤗 我们下篇文章见！

相关推荐
笨笨饿2 小时前
29_Z变换在工程中的实际意义
c语言·开发语言·人工智能·单片机·mcu·算法·机器人
boy快快长大2 小时前
【大模型应用开发】记忆
人工智能
数据知道2 小时前
claw-code 源码详细分析：Route / Bootstrap / Tool-Pool——把提示词映射到「可执行面」的分层策略
网络·ai·web·claude code
LaughingZhu2 小时前
Product Hunt 每日热榜 | 2026-04-05
前端·数据库·人工智能·经验分享·神经网络
OPHKVPS2 小时前
GoBruteforcer（GoBrut）僵尸网络新攻势：AI 生成弱配置成“帮凶”，瞄准加密货币及区块链数据库
网络·人工智能·区块链
ZTL-NPU2 小时前
Jetbrains开发ros
ide·python·pycharm·编辑器·ros·clion
打乒乓球只会抽3 小时前
AI Agent：大模型+工具的智能革命
人工智能
Pelb3 小时前
求导 y = f(x) = x^2
人工智能·深度学习·神经网络·数学建模
workflower3 小时前
注塑机行业目前自动化现状分析
运维·人工智能·语言模型·自动化·集成测试·软件工程·软件需求
热门推荐
01GitHub 镜像站点02OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程03Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）04VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）05【技术干货】Gemma 4 上手深度指南：本地多模态大模型的新基线06最新更新版本，OpenClaw v2026.4.2 深度解读剖析：Task Flow 重磅回归与安全架构的全面硬化07Claude Code 未登录 使用第三方模型08AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南09纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！10UV安装并设置国内源