# AnythingLLM RAG 平台

## 概览

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) 是一个功能完备的开源 AI 工作区，拥有 40K+ 的 GitHub 星标。它将基于文档的 RAG（检索增强生成）、AI 代理和无代码代理构建器整合到一个自托管应用中 —— 通过干净、直观的界面管理，设置无需编程。

**为什么在 Clore.ai 上运行 AnythingLLM？**

* **开箱即用的完整 RAG 管道** — 上传 PDF、Word 文档、网站和 YouTube 转录。AnythingLLM 会自动分块、嵌入并存储它们以用于语义搜索。
* **应用不需要 GPU** — AnythingLLM 默认使用基于 CPU 的嵌入。可将其与在 Clore.ai 上运行 Ollama 或 vLLM 的 GPU 服务器配对以进行本地推理。
* **具有真实工具的 AI 代理** — 内置代理可以浏览网页、编写并执行代码、管理文件和调用外部 API —— 所有这些都通过 GUI 编排。
* **MCP 兼容性** — 与 Model Context Protocol 生态集成，以扩展工具连接性。
* **工作区隔离** — 为不同项目或团队创建具有不同知识库和 LLM 设置的独立工作区。

### 架构概览

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (端口 3001)           │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/文档 │  │  代理    │  │  用户    │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM 提供者路由器       │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama（本地）
  Claude        Gemini      vLLM（本地）
```

***

## 要求

### 服务器规格

| 组件      | 最低     | 推荐                  | 注意事项                |
| ------- | ------ | ------------------- | ------------------- |
| **GPU** | 不需要    | RTX 3090（如使用本地 LLM） | 仅适用于 Ollama/vLLM 后端 |
| **显存**  | —      | 24 GB               | 用于本地模型推理            |
| **CPU** | 2 vCPU | 4 个 vCPU            | 嵌入在 CPU 上运行         |
| **内存**  | 4 GB   | 8 GB                | 更多 = 内存中更大的文档索引     |
| **存储**  | 10 GB  | 50+ GB              | 文档存储、向量数据库、模型缓存     |

### Clore.ai 价格参考

| 服务器类型                  | 大致费用            | 模型变体                         |
| ---------------------- | --------------- | ---------------------------- |
| CPU 实例（4 vCPU，8 GB 内存） | 约 $0.05–0.10/小时 | AnythingLLM + 外部 API 提供商     |
| RTX 3090（24 GB 显存）     | \~$0.20/小时      | AnythingLLM + Ollama 本地 LLMs |
| RTX 4090（24 GB 显存）     | \~$0.35/小时      | AnythingLLM + 更快的本地推理        |
| A100 80 GB             | \~$1.10/小时      | AnythingLLM + 大型 70B+ 模型     |

> 💡 **专业提示：** AnythingLLM 的内置嵌入（LanceDB + 本地 CPU 嵌入器）无需 GPU 即可工作。对于 LLM 后端，你可以使用 OpenRouter 或 Groq 等免费额度 API 提供商以将成本保持在最低。

### 先决条件

* 带 SSH 访问的 Clore.ai 服务器
* Docker（Clore.ai 服务器上预装）
* 至少一个 LLM API 密钥 **或** 本地 Ollama/vLLM 后端

***

## 快速开始

### 方法 1：单个 Docker 容器（推荐）

官方的单容器部署包含所有内容：Web UI、LanceDB 向量存储和文档处理器。

**步骤 1：连接到你的 Clore.ai 服务器**

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

**步骤 2：设置存储目录**

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"
```

**步骤 3：运行 AnythingLLM**

```bash
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

> **原因 `--cap-add SYS_ADMIN`?** AnythingLLM 使用 Chromium 进行网页抓取和 PDF 渲染，这需要容器提升的能力（capabilities）。

**步骤 4：验证启动**

```bash
docker logs anythingllm --tail 30 -f
# 等待："Server listening on port 3001"
```

**步骤 5：完成设置向导**

在浏览器中打开：

```
http://<your-clore-server-ip>:3001
```

首次设置向导将引导你完成：

1. 创建管理员账户
2. 选择 LLM 提供者
3. 选择嵌入模型
4. 配置你的第一个工作区

***

### 方法 2：Docker Compose（多服务）

用于具有独立服务和更易管理的生产部署：

**步骤 1：创建项目目录**

```bash
mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env
```

**步骤 2：创建 `docker-compose.yml`**

```bash
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment:
      STORAGE_DIR: "/app/server/storage"
      # LLM 提供者（配置一种）
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # 嵌入
      EMBEDDING_ENGINE: native
      # 向量数据库
      VECTOR_DB: lancedb
      # 认证
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF
```

**步骤 3：创建 `.env` 文件**

```bash
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=your-random-64-char-secret-here
EOF
```

**步骤 4：启动**

```bash
docker compose up -d
docker compose logs anythingllm -f
```

***

### 方法 3：使用预配置环境变量

用于无需设置向导的自动化部署：

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=openai \
  -e OPEN_AI_KEY=sk-your-key \
  -e OPEN_MODEL_PREF=gpt-4o-mini \
  -e EMBEDDING_ENGINE=native \
  -e VECTOR_DB=lancedb \
  -e AUTH_TOKEN=your-password \
  -e JWT_SECRET=$(openssl rand -hex 32) \
  mintplexlabs/anythingllm
```

***

## 配置

### LLM 提供者选项

AnythingLLM 支持多种 LLM 后端。在 UI 中于以下位置设置 **设置 → LLM 偏好**，或通过环境变量：

**OpenAI：**

```bash
-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o
```

**Anthropic Claude：**

```bash
-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5
```

**Google Gemini：**

```bash
-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro
```

**Ollama（本地）：**

```bash
-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2
```

**OpenRouter（访问 100+ 模型）：**

```bash
-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free
```

### 嵌入配置

| 引擎        | 后端         | 需要 GPU | 质量    |
| --------- | ---------- | ------ | ----- |
| `native`  | CPU（内置）    | 否      | 良好    |
| `openai`  | OpenAI API | 否      | 优秀    |
| `ollama`  | 本地 Ollama  | 可选     | 良好-优秀 |
| `localai` | LocalAI    | 可选     | 变量    |

```bash
# 为获得最佳质量使用 OpenAI 嵌入
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# 使用 Ollama 嵌入以实现完全本地化的管道
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text
```

### 向量数据库选项

| 数据库        | 4s            | 最适合           |
| ---------- | ------------- | ------------- |
| `lancedb`  | 内置，无需配置       | 默认，适用于小到中等数据集 |
| `chroma`   | ChromaDB（外部）  | 中等数据集，灵活性高    |
| `pinecone` | Pinecone 云    | 大型数据集，生产环境    |
| `weaviate` | Weaviate（自托管） | 高级用例          |

### 工作区配置

AnythingLLM 工作区是具有自身以下内容的隔离环境：

* 文档知识库
* LLM 设置（可覆盖全局设置）
* 聊天历史
* 代理配置

通过 UI 或 API 创建工作区：

```bash
# 通过 API 创建工作区
curl -X POST http://localhost:3001/api/v1/workspace/new \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "similarityThreshold": 0.7}'
```

### 文档摄取

通过 UI 或 API 上传文档：

```bash
# 通过 API 上传文档
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@/path/to/document.pdf"

# 将文档移动到工作区
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'
```

***

## GPU 加速

AnythingLLM 本身在 CPU 上运行。GPU 加速适用于 LLM 推理后端。

### 在同一 Clore.ai 服务器上运行 Ollama

```bash
# 使用 GPU 支持启动 Ollama
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama

# 为 AnythingLLM 拉取模型
docker exec ollama ollama pull llama3.2          # 2B，快速
docker exec ollama ollama pull llama3.1:8b       # 8B，平衡
docker exec ollama ollama pull nomic-embed-text  # 用于嵌入
docker exec ollama ollama pull mxbai-embed-large # 更好的嵌入

# 使用 Ollama 配置重启 AnythingLLM
docker stop anythingllm && docker rm anythingllm

docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=ollama \
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \
  -e OLLAMA_MODEL_PREF=llama3.1:8b \
  -e EMBEDDING_ENGINE=ollama \
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \
  mintplexlabs/anythingllm
```

### Clore.ai 上的 GPU-模型性能

| A100          | GPU    | 显存    | 嵌入速度 | 推理速度        | 每小时成本   |
| ------------- | ------ | ----- | ---- | ----------- | ------- |
| Llama 3.2 3B  | 速度     | 2 GB  | 快速   | 60–80 tok/s | \~$0.20 |
| Llama 3.1 8B  | 速度     | 6 GB  | 快速   | 40–60 tok/s | \~$0.20 |
| Mistral 7B    | 速度     | 5 GB  | 快速   | 45–65 tok/s | \~$0.20 |
| Llama 3.1 70B | 4 小时会话 | 40 GB | 中等   | 20–35 tok/s | \~$1.10 |

***

## 提示与最佳实践

### 文档摄取最佳实践

```bash
# 对于大量文档集，请增加 Node.js 内存
-e NODE_OPTIONS="--max-old-space-size=4096"

# 面向不同文档类型的推荐分块设置
# 技术文档：分块大小 1000，重叠 200
# 法律/合同：分块大小 500，重叠 100
# 书籍/文章：分块大小 1500，重叠 300
```

* **预处理大型 PDF** — 含大量 OCR 的扫描会减慢摄取速度。事先使用 `pdftotext` 或 Adobe OCR。
* **按工作区组织** — 为每个项目/领域创建独立工作区以提高检索精确度。
* **使用针对性的查询** — RAG 对具体问题效果最佳，而非宽泛请求。

### 在 Clore.ai 上的成本管理

```bash
# 在停止 Clore.ai 实例之前备份你的存储
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# 要在新的 Clore.ai 实例上恢复，请还原备份
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/
```

由于 Clore.ai 实例是短暂的，请始终备份存储目录。它包含：

* 向量嵌入（LanceDB）
* 已上传的文档
* 聊天历史
* 代理配置

### 多用户设置

```bash
# 在 UI 中启用多用户模式：
# 设置 → 安全 → 启用多用户模式

# 或通过环境变量：
-e MULTI_USER_MODE=true

# 启用多用户后通过 API 创建用户
curl -X POST http://localhost:3001/api/v1/admin/users/new \
  -H "Authorization: Bearer admin-api-key" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "securepass", "role": "default"}'
```

### AI 代理配置

AnythingLLM 代理可以执行真实世界任务。在以下位置启用工具 **设置 → 代理**:

* **网页浏览** — 抓取并读取网页
* **Google 搜索** — 搜索 Google（需要 API 密钥）
* **代码解释器** — 在沙箱中执行 Python
* **GitHub** — 读取代码仓库
* **SQL 连接器** — 查询数据库

```bash
# 通过环境变量启用代理能力
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key
```

### 性能调优

```bash
# 对于繁重的文档处理工作负载
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  --cpus="4" \
  --memory="8g" \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

### 更新 AnythingLLM

```bash
# 拉取最新镜像
docker pull mintplexlabs/anythingllm:latest

# 先备份
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# 停止并移除旧容器（数据在卷中，安全）
docker stop anythingllm && docker rm anythingllm

# 使用相同命令重启
docker run -d \
  --name anythingllm \
  --restart unless-stopped \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

***

## # 使用固定种子以获得一致结果

### 容器启动但 UI 无法访问

```bash
# 检查容器是否在运行
docker ps | grep anythingllm

# 检查启动错误日志
docker logs anythingllm --tail 50

# 验证端口绑定
ss -tlnp | grep 3001

# 检查 Clore.ai 服务器在端口映射中是否包含 3001
# （在 Clore.ai 部署设置中添加）
```

### 文档上传失败

```bash
# 检查可用磁盘空间
df -h

# 检查文档处理器日志
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# 验证是否已设置 SYS_ADMIN 能力（Chromium 所需）
docker inspect anythingllm | grep -A5 CapAdd
```

### RAG 响应质量差 / 幻觉问题

常见原因与修复：

```bash
# 1. 调整相似度阈值（更低 = 检索更多文档）
# 设置 → 工作区 → 向量数据库 → 相似度阈值：0.5

# 2. 增加 top-K 结果数
# 设置 → 工作区 → 向量数据库 → 最大上下文片段数：10

# 3. 改进分块大小（更改后重新摄取文档）
# 设置 → 工作区 → 文本分割器 → 分块大小：1000，重叠：200

# 4. 切换到更好的嵌入模型
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large
```

### AnythingLLM 无法连接到 Ollama

```bash
# 在 AnythingLLM 容器中进行测试
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# 如果失败，查找实际的 Docker 桥接 IP
ip route | grep docker
# 在 OLLAMA_BASE_PATH 中使用该 IP

# 另一种：使用主机网络（host networking）
docker run -d \
  --name anythingllm \
  --network host \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e OLLAMA_BASE_PATH=http://localhost:11434 \
  mintplexlabs/anythingllm
```

### 内存耗尽 / 容器崩溃

```bash
free -h
docker stats anythingllm

# 通过减少 LanceDB 缓存释放内存
# 或切换到具有更多内存的 Clore.ai 实例

# 使用内存限制和交换重启
docker run -d \
  --name anythingllm \
  --memory=6g \
  --memory-swap=8g \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm
```

***

## 延伸阅读

* [AnythingLLM 文档](https://docs.anythingllm.com) — 完整的设置和 API 参考
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — 源代码、问题追踪、路线图
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — 镜像标签
* [在 Clore.ai 上运行 Ollama](/guides/guides_v2-zh/yu-yan-mo-xing/ollama.md) — AnythingLLM 的本地 LLM 后端
* [在 Clore.ai 上运行 vLLM](/guides/guides_v2-zh/yu-yan-mo-xing/vllm.md) — 高性能推理
* [GPU 比较指南](/guides/guides_v2-zh/ru-men/gpu-comparison.md) — 选择合适的 Clore.ai 等级
* [MCP 文档](https://modelcontextprotocol.io) — 用于扩展代理的 Model Context Protocol
* [AnythingLLM API 参考](https://docs.anythingllm.com/api-reference) — 用于自动化的 REST API


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-zh/ai-ping-tai-yu-zhi-neng-ti/anythingllm.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.