> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-zh/ai-ping-tai-yu-zhi-neng-ti/anythingllm.md).

# AnythingLLM RAG 平台

在 Clore.ai 上部署 AnythingLLM——一个集成式 RAG 应用和 AI 智能体平台，内置文档聊天、无代码智能体构建器和 MCP 支持，运行在高性价比的 GPU 云服务器上。

## 概览

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) 是一个功能齐全、开源的 AI 工作区，拥有 4 万+ GitHub stars。它将基于文档的 RAG（检索增强生成）、AI 智能体以及无代码智能体构建器整合到一个自托管应用中——ทั้งหมด通过简洁直观的 UI 管理，搭建时无需任何编码。

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

* **开箱即用的完整 RAG 流水线** — 上传 PDF、Word 文档、网站和 YouTube 转录文本。AnythingLLM 会自动分块、嵌入并存储它们，以便进行语义搜索。
* **应用无需 GPU** — AnythingLLM 默认使用基于 CPU 的嵌入。将其与运行 Ollama 或 vLLM 的 Clore.ai 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 RAM） | 约 $0.05–0.10/小时                   | AnythingLLM + 外部 API 提供方    |
| RTX 3090（24 GB 显存）      | $0.07–0.21/小时                     | AnythingLLM + Ollama 本地 LLM |
| RTX 4090（24 GB 显存）      | $0.14–0.42/小时                     | AnythingLLM + 更快的本地推理       |
| A100 80 GB              | [裸机](https://clore.ai/bare-metal) | 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 渲染，因此需要更高的容器权限。

**步骤 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
```

### 向量数据库选项

| 数据库        | 描述            | 最适合           |
| ---------- | ------------- | ------------- |
| `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 模型性能

| 模型            | GPU       | 显存    | 嵌入速度 | 推理速度        | 每小时成本   |
| ------------- | --------- | ----- | ---- | ----------- | ------- |
| Llama 3.2 3B  | RTX 3090  | 2 GB  | 快    | 60–80 tok/s | \~$0.20 |
| Llama 3.1 8B  | RTX 3090  | 6 GB  | 快    | 40–60 tok/s | \~$0.20 |
| Mistral 7B    | RTX 3090  | 5 GB  | 快    | 45–65 tok/s | \~$0.20 |
| Llama 3.1 70B | A100 80GB | 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

# 替代方案：使用主机网络
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
# 检查内存使用情况
docker stats anythingllm

# 通过减少 LanceDB 缓存释放内存
# 或切换到 RAM 更大的 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-zhi-nan/gpu-comparison.md) — 选择合适的 Clore.ai 套餐
* [MCP 文档](https://modelcontextprotocol.io) — 用于扩展代理的模型上下文协议
* [AnythingLLM API 参考](https://docs.anythingllm.com/api-reference) — 用于自动化的 REST API


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.