LlamaIndex

在 Clore.ai 的 GPU 上构建 LlamaIndex 数据到 LLM 的流水线和 RAG 应用

LlamaIndex（前称 GPT Index）是一个 面向 LLM 应用的数据框架 ，拥有超过 37,000 个 GitHub stars。而 LangChain 专注于串联 LLM 调用，LlamaIndex 擅长 数据摄取、索引和结构化查询 ——当你的应用需要对大型、异构文档集合进行推理时，它是首选。

LlamaIndex 对复杂数据结构（数据库、API、PDF、Notion 页面、GitHub 仓库）和高级检索策略提供一流支持。在 Clore.ai GPU 服务器上结合本地 LLM 运行，可消除 API 成本并保持数据私密。

主要优势：

📊 数据连接器 — 160+ 集成（PDF、SQL、Notion、Slack、GitHub 等）
🗂️ 多种索引类型 — 向量、树、列表、关键词、知识图谱
🔍 高级检索 — 子问题分解、递归检索、混合搜索
🤖 查询引擎 — 针对任何数据源进行 SQL、结构化和自然语言查询
🧩 多模态 — 图像、音频和视频与文本并存
💾 持久化 — 内置支持 ChromaDB、Pinecone、Weaviate 等
⚡ 异步优先 — 专为生产吞吐量而构建
🔗 兼容 LangChain — 可将两个框架一起使用

所有示例都可以在通过以下方式租用的 GPU 服务器上运行 CLORE.AI 市场.

服务器要求

参数

最低

在 CLORE.AI 上快速部署

1. 找到合适的服务器

前往 CLORE.AI 市场并根据你的 LLM 规模选择：

使用场景

GPU

备注

开发 / 测试

RTX 3080（10 GB）

7B 模型，小型文档集

生产（小型）

RTX 4090（24 GB）

13B 模型，中型数据集

生产（大型）

A100 40G / 80G

34B–70B 模型，大型数据集

企业级

H100（80 GB）

最高吞吐量

2. 配置你的部署

Docker 镜像（基础）：

nvidia/cuda:12.8.1-cudnn-devel-ubuntu22.04

端口映射：

22    → SSH 访问
8000  → LlamaIndex API / Gradio 界面
11434 → Ollama 推理引擎

启动脚本：

#!/bin/bash
# 安装 Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5
ollama pull llama3:8b
ollama pull nomic-embed-text

# 安装 LlamaIndex
pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama
pip install chromadb fastapi uvicorn

python /workspace/app.py

3. 访问 API

http://<your-clore-server-ip>:8000

逐步设置

步骤 1：通过 SSH 登录你的服务器

ssh root@<your-clore-server-ip> -p <ssh-port>

步骤 2：安装 Ollama

curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5

# 拉取模型
ollama pull llama3:8b              # 用于生成的 LLM
ollama pull nomic-embed-text       # 嵌入模型

# 验证
ollama list

步骤 3：设置 Python 环境

mkdir -p /workspace/llamaindex-app
cd /workspace/llamaindex-app

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip

步骤 4：安装 LlamaIndex 包

# LlamaIndex 核心
pip install llama-index

# LLM 集成
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # 可选：OpenAI

# 嵌入集成
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# 向量存储集成
pip install llama-index-vector-stores-chroma

# 数据加载器
pip install llama-index-readers-file
pip install llama-index-readers-web

# 可选：其他读取器
pip install pypdf docx2txt

步骤 5：配置全局设置

# settings.py
from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# 配置 LLM
Settings.llm = Ollama(
    model="llama3:8b",
    base_url="http://localhost:11434",
    request_timeout=300.0,
    temperature=0.1,
)

# 配置嵌入
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434",
)

# 配置分块设置
Settings.chunk_size = 1024
Settings.chunk_overlap = 200

步骤 6：构建你的第一个索引

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# 从目录中加载文档
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"已加载 {len(documents)} 份文档")

# 构建向量索引（自动嵌入并存储）
index = VectorStoreIndex.from_documents(documents)

# 将索引保存到磁盘
index.storage_context.persist("/workspace/index_storage")
print("索引已构建并保存！")

步骤 7：查询索引

from llama_index.core import load_index_from_storage, StorageContext

# 加载现有索引
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# 创建查询引擎
query_engine = index.as_query_engine(similarity_top_k=5)

# 提问
response = query_engine.query("Clore.ai 上有哪些 GPU 服务器可用？")
print(f"答案：{response}")
print(f"\n来源：使用了 {len(response.source_nodes)} 个节点")

使用示例

示例 1：基础文档问答

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from pathlib import Path

# 使用本地 Ollama 模型配置 LlamaIndex
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# 创建示例文档目录
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# 创建一个示例文档
(data_dir / "clore_faq.txt").write_text("""
Clore.ai 常见问题

问：什么是 Clore.ai？
答：Clore.ai 是一个去中心化的 GPU 云市场，连接 GPU 所有者与需要算力的 AI 研究人员和开发者。

问：有哪些 GPU 可用？
答：Clore.ai 提供从 NVIDIA GTX 1080 到最新 H100 80GB 的各种 GPU。热门选项包括 RTX 4090、A100 40G/80G 和 RTX 3090。

问：定价如何运作？
答：价格由 GPU 提供商设定，并因 GPU 型号、显存和可用性而异。通常比 AWS/GCP 便宜 30-70%。

问：我可以运行什么软件？
答：任何 Docker 容器。可使用预配置的 PyTorch、TensorFlow、ComfyUI、Stable Diffusion 等镜像。
""")

# 构建索引
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# 查询
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "Clore.ai 提供哪些 GPU？",
    "Clore.ai 的定价与 AWS 相比如何？",
    "我可以运行自定义 Docker 容器吗？",
]

for q in questions:
    print(f"\n❓ {q}")
    response = query_engine.query(q)
    print(f"💬 {response}")

示例 2：使用 ChromaDB 的多文档 RAG

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, Settings
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb

# 配置 LLM 和嵌入
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# 连接到 ChromaDB（运行在同一台 Clore.ai 服务器上）
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# 为 LlamaIndex 创建 ChromaDB 向量存储
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# 从多个来源加载文档
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # 包含子目录
    required_exts=[".pdf", ".txt", ".md"],  # 仅这些格式
    filename_as_id=True          # 使用文件名作为文档 ID
).load_data()

print(f"从 {docs_dir} 加载了 {len(documents)} 份文档")

# 构建索引（存储到 ChromaDB）
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("索引已构建并持久化到 ChromaDB！")

# 加载现有索引（后续会话）
# index = VectorStoreIndex.from_vector_store(vector_store)

# 带元数据过滤的高级查询引擎
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# 使用元数据过滤查询
filtered_engine = index.as_query_engine(
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(key="file_type", value=".pdf"),
        ]
    )
)

response = filtered_engine.query("总结文档中的关键技术概念。")
print(f"\n过滤后的响应：{response}")

示例 3：子问题分解

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# 为不同知识领域创建独立索引
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# 独立知识库
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# 封装为工具
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="包含 Clore.ai 的定价信息、成本对比和账单详情。"
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="包含有关 GPU 规格、Docker 部署和 API 的技术文档。"
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="包含常见问题及其答案。"
        )
    ),
]

# 子问题引擎会将复杂查询分解
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# 复杂的多部分问题
"""
比较在 Clore.ai 上运行一个 7B 参数 LLM 与在 AWS 上运行 100 小时的成本，
并解释每种方案所需的技术设置。
"""

print(f"问题：{complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\n综合答案：\n{response}")

示例 4：知识图谱索引

from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:13b", base_url="http://localhost:11434")  # 更大的模型以便更好地抽取
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# 加载文档
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# 构建知识图谱（提取实体和关系）
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # 每个分块最多提取 10 个三元组
    include_embeddings=True,
    show_progress=True
)

# 保存图谱
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"知识图谱已构建！")
print(f"节点数：{len(kg_index.index_struct.table)}")

# 查询知识图谱
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # 包含源文本
    retriever_mode="keyword",     # 使用基于关键词的检索
    response_mode="tree_summarize"
)

questions = [
    "GPU 模型与使用场景之间有什么关系？",
    "定价与 GPU 规格之间如何关联？",
    "哪些部署方式连接到哪些服务？",
]

for q in questions:
    print(f"\n🔍 {q}")
    response = kg_query_engine.query(q)
    print(f"📊 {response}")

示例 5：数据库上的 SQL 查询引擎

from llama_index.core import SQLDatabase, Settings
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.ollama import Ollama
from sqlalchemy import create_engine, text
import pandas as pd

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")

# 创建包含 GPU 市场数据的示例数据库
engine = create_engine("sqlite:////workspace/clore_data.db")

# 创建并填充表
with engine.connect() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS gpu_servers (
            id INTEGER PRIMARY KEY,
            gpu_model TEXT,
            vram_gb INTEGER,
            price_per_hour REAL,
            location TEXT,
            available INTEGER
        )
    """))

    conn.execute(text("""
        INSERT OR REPLACE INTO gpu_servers VALUES
        (1, 'RTX 4090', 24, 0.65, 'US-East', 1),
        (2, 'RTX 4090', 24, 0.70, 'EU-West', 1),
        (3, 'A100 80G', 80, 2.50, 'US-West', 1),
        (4, 'H100 80G', 80, 4.20, 'US-East', 0),
        (5, 'RTX 3090', 24, 0.35, 'Asia-Pacific', 1),
        (6, 'RTX 3080', 10, 0.20, 'EU-East', 1),
        (7, 'A100 40G', 40, 1.50, 'US-East', 1)
    """))
    conn.commit()

# 创建 LlamaIndex SQL 数据库包装器
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])


# 自然语言转 SQL 查询引擎
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# 用自然语言查询数据库
nl_queries = [
    "当前可用的最便宜的 GPU 服务器是哪一个？",
    "显示所有 VRAM 大于 40GB 的 GPU 服务器",
    "RTX 4090 服务器的平均每小时价格是多少？",
    "哪些地点有可用的 GPU 服务器？",
    "按价格排序列出所有可用的 A100 服务器",
]

for query in nl_queries:
    print(f"\n💬 自然语言：{query}")
    response = query_engine.query(query)
    print(f"📊 答案：{response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL：{response.metadata['sql_query']}")

配置

Docker Compose（完整 LlamaIndex 技术栈）

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    runtime: nvidia
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped

  llamaindex-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: llamaindex-api
    ports:
      - "8000:8000"
    volumes:
      - ./data:/workspace/data
      - ./indices:/workspace/indices
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - CHROMA_HOST=chromadb
      - CHROMA_PORT=8000
      - LLM_MODEL=llama3:8b
      - EMBED_MODEL=nomic-embed-text
    depends_on:
      - ollama
      - chromadb
    restart: unless-stopped

volumes:
  ollama_models:
  chroma_data:

关键配置变量

设置

默认值

描述

Settings.llm

OpenAI GPT-3.5

用于生成的 LLM

Settings.embed_model

OpenAI Ada

嵌入模型

Settings.chunk_size

1024

文本分块大小（以 token 计）

Settings.chunk_overlap

200

分块之间的重叠

Settings.num_output

256

LLM 响应中的最大 token 数

Settings.context_window

4096

LLM 上下文窗口大小

性能提示

1. 用于提升吞吐量的异步查询

import asyncio
from llama_index.core import VectorStoreIndex

query_engine = index.as_query_engine(use_async=True)

async def batch_query(questions):
    tasks = [query_engine.aquery(q) for q in questions]
    return await asyncio.gather(*tasks)

questions = ["Q1?", "Q2?", "Q3?", "Q4?", "Q5?"]
answers = asyncio.run(batch_query(questions))

2. 混合搜索（关键词 + 语义）

from llama_index.core import VectorStoreIndex
from llama_index.core.retrievers import VectorIndexRetriever, KeywordTableSimpleRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import QueryFusionRetriever

# 结合向量检索和关键词检索
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # 向量检索
        index.as_retriever(retriever_mode="keyword"),  # 关键词检索
    ],
    similarity_top_k=5,
    num_queries=3,  # 生成多个查询变体
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)

3. 重排序以提升质量

from llama_index.core.postprocessor import SentenceTransformerRerank

# 在检索后添加重排序步骤
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # 检索更多候选项
    node_postprocessors=[reranker]  # 重排序到前 3 名
)

4. 用于响应式 UI 的流式输出

# 在 token 生成时流式输出
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("解释 Clore.ai 的工作原理")

for token in response.response_gen:
    print(token, end="", flush=True)

故障排查

问题：嵌入模型未连接到 Ollama

# 直接测试 Ollama 嵌入
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "test text"
}'

问题：索引构建速度很慢

# 在嵌入过程中监控 GPU 使用情况
watch -n1 nvidia-smi

# 使用更小的批次大小
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    docs,
    show_progress=True,
    # 分批插入
)

问题：集成出现 ModuleNotFoundError

# LlamaIndex 在 v0.10+ 中使用插件架构
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# 检查已安装的软件包
pip list | grep llama

问题：上下文窗口已超出

# 减小 chunk size
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# 或使用具有更大上下文的模型
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # 扩展上下文窗口
)

问题：查询返回无关结果

# 增大相似度 top-k
query_engine = index.as_query_engine(similarity_top_k=10)

# 或使用更好的嵌入模型
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)

链接

GitHub: https://github.com/run-llama/llama_index
官方文档: https://docs.llamaindex.ai
PyPI: https://pypi.org/project/llama-index
集成: https://llamahub.ai
Discord: https://discord.gg/dGcwcsnxhU
博客: https://www.llamaindex.ai/blog
CLORE.AI 市场: https://clore.ai/marketplace

Clore.ai GPU 推荐

使用场景