前言
“什么是向量模型？”
“BGE-M3和OpenAI的embedding有什么区别？”
“Obsidian能做本地RAG吗？不需要联网那种？”
“FastGPT如何对接BGE-M3？”
这些问题是我们构建个人知识库时经常遇到的。今天我们就来全面解答。
一、向量模型基础
1.1 什么是向量模型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
┌─────────────────────────────────────────────────────────────────┐
│ 向量模型是什么？ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 向量模型 = 把文字变成数字的神器 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ "什么是机器学习" │ │
│ │ ↓ │ │
│ │ 向量模型 │ │
│ │ ↓ │ │
│ │ [0.23, -0.45, 0.89, ...] (1024维向量) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 核心能力： │
│ ├── 语义理解：相似的文字 → 相似的向量 │
│ ├── 语义搜索：找"最相关"的内容 │
│ └── 知识检索：RAG的核心组件 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
1.2 向量相似度原理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
┌─────────────────────────────────────────────────────────────────┐
│ 向量相似度原理 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 相似的内容，生成相似的向量 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 向量空间： │ │
│ │ │ │
│ │ "深度学习模型" │ │
│ │ ● │ │
│ │ / \ │ │
│ │ / \ │ │
│ │ / \ │ │
│ │ "神经网络"● ●"机器学习算法" │ │
│ │ \ / │ │
│ │ \ / │ │
│ │ \ / │ │
│ │ ● │ │
│ │ "Python编程" │ │
│ │ │ │
│ │ 距离越近 = 语义越相似 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 相似度计算方式： │
│ ├── 余弦相似度 (Cosine Similarity) │
│ ├── 点积 (Dot Product) │
│ └── 欧氏距离 (Euclidean Distance) │
│ │
└─────────────────────────────────────────────────────────────────┘
|
1.3 主流向量模型对比
| 模型 |
维度 |
上下文 |
语言 |
特点 |
| OpenAI text-embedding-3-large |
3072 |
8K |
多语言 |
效果好，收费 |
| BGE-M3 |
1024 |
8K |
100+语言 |
开源免费，本地可跑 |
| M3E |
1536 |
512 |
中英 |
开源，体积小 |
| Jina-v3 |
1024 |
8K |
多语言 |
开源 |
| Nomic-embed-text |
768 |
8K |
英 |
开源，可本地 |
| BGE-large-zh |
1024 |
512 |
中文 |
中文优化 |
二、BGE-M3详解
2.1 BGE-M3是什么
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
┌─────────────────────────────────────────────────────────────────┐
│ BGE-M3是什么？ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ BGE-M3 = BAAI General Embedding M3 │
│ ├── BAAI = 北京人工智能研究院 │
│ └── M3 = Multi-Lingual, Multi-Functionality, Multi-Granularity│
│ │
│ 核心亮点： │
│ ├── ✅ 三合一检索模式（稠密+稀疏+多向量） │
│ ├── ✅ 支持100+语言 │
│ ├── ✅ 支持8192 token超长文本 │
│ ├── ✅ 完全开源免费 │
│ └── ✅ 可本地部署 │
│ │
│ 基础参数： │
│ ├── 参数量：5.67亿 │
│ ├── 模型大小：2.27GB │
│ ├── 向量维度：1024 │
│ └── 最大长度：8192 tokens │
│ │
└─────────────────────────────────────────────────────────────────┘
|
2.2 BGE-M3的三大特性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
┌─────────────────────────────────────────────────────────────────┐
│ BGE-M3三大特性 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 1. Multi-Functionality (多功能) │ │
│ │ │ │
│ │ 一模型支持三种检索方式： │ │
│ │ ├── Dense（稠密向量） │ │
│ │ ├── Sparse（稀疏向量/词权重） │ │
│ │ └── ColBERT（多向量交互） │ │
│ │ │ │
│ │ 传统方案：需要3个模型 │ │
│ │ BGE-M3：一个模型全搞定 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 2. Multi-Linguality (多语言) │ │
│ │ │ │
│ │ 支持100+语言： │ │
│ │ ├── 中文、英语、日语、韩语 │ │
│ │ ├── 德语、法语、西班牙语 │ │
│ │ ├── 阿拉伯语、俄语 │ │
│ │ └── 等等... │ │
│ │ │ │
│ │ 特别优化：中文、英文 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 3. Multi-Granularity (多粒度) │ │
│ │ │ │
│ │ 支持从短句到长文档： │ │
│ │ ├── 短句（几个词） │ │
│ │ ├── 段落（几百字） │ │
│ │ └── 长文档（8000+ tokens） │ │
│ │ │ │
│ │ 关键技术：MCLS (Multiple CLS) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
2.3 三种检索模式详解
Dense（稠密向量）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
┌─────────────────────────────────────────────────────────────────┐
│ Dense检索模式 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 原理：将整个文本压缩成一个向量 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ "机器学习是人工智能的分支" │ │
│ │ ↓ │ │
│ │ [0.12, -0.34, 0.56, ..., 0.78] ← 1个1024维向量 │ │
│ │ │ │
│ │ 特点： │ │
│ │ ├── 简单高效 │ │
│ │ ├── 适合语义相似性搜索 │ │
│ │ └── 计算快，存储小 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 适用场景： │
│ ├── 通用语义搜索 │
│ ├── 文档相似度计算 │
│ └── RAG知识检索 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
Sparse（稀疏向量/词权重）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
┌─────────────────────────────────────────────────────────────────┐
│ Sparse检索模式 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 原理：类似BM25，输出每个词的权重 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ "机器学习是人工智能的分支" │ │
│ │ ↓ │ │
│ │ { │ │
│ │ "机器": 0.89, │ │
│ │ "学习": 0.92, │ │
│ │ "人工智能": 0.95, │ │
│ │ "分支": 0.45, │ │
│ │ "是": 0.1, │ │
│ │ ... │ │
│ │ } │ │
│ │ │ │
│ │ 特点： │ │
│ │ ├── 精确关键词匹配 │ │
│ │ ├── 专业术语敏感 │ │
│ │ └── 不依赖语义理解 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 适用场景： │
│ ├── 专业术语搜索 │
│ ├── 品牌/型号搜索 │
│ └── 精确匹配需求 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
ColBERT（多向量/后期交互）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
┌─────────────────────────────────────────────────────────────────┐
│ ColBERT检索模式 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 原理：每个token生成一个向量，计算交互分数 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Query: "机器学习" │ │
│ │ Query向量: [V1, V2] ← 2个向量 │ │
│ │ │ │
│ │ Doc: "机器学习是人工智能技术" │ │
│ │ Doc向量: [D1, D2, D3, D4] ← 4个向量 │ │
│ │ │ │
│ │ 分数 = Σ max(Vi · Dj) │ │
│ │ = max(V1·D1, V1·D2,...) │ │
│ │ + max(V2·D1, V2·D2,...) │ │
│ │ │ │
│ │ 特点： │ │
│ │ ├── 细粒度交互 │ │
│ │ ├── 适合长文档 │ │
│ │ └── 效果最好但最慢 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 适用场景： │
│ ├── 高精度检索 │
│ ├── 长文档问答 │
│ └── Rerank排序 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
2.4 性能对比
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
┌─────────────────────────────────────────────────────────────────┐
│ BGE-M3性能评测 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 在MTEB多任务Embedding基准测试中的表现： │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 多语言检索 (MIRACL): │ │
│ │ BGE-M3 ⭐⭐⭐⭐⭐ (SOTA) │ │
│ │ │ │
│ │ 跨语言检索 (MKQA): │ │
│ │ BGE-M3 ⭐⭐⭐⭐⭐ (超越OpenAI) │ │
│ │ │ │
│ │ 长文档检索 (MLDR): │ │
│ │ BGE-M3 ⭐⭐⭐⭐ (领先BM25) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 优势： │
│ ├── 开源免费 │
│ ├── 可本地部署 │
│ ├── 支持混合检索 │
│ └── 中文效果好 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
三、BGE-M3使用指南
3.1 Python调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
# 安装
pip install FlagEmbedding
from FlagEmbedding import BGEM3FlagModel
# 加载模型
model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=True)
# Dense向量
sentences = ["什么是机器学习", "深度学习和机器学习的区别"]
result = model.encode(sentences)
print(result['dense_vecs'].shape) # (2, 1024)
# Sparse向量（词权重）
result = model.encode(sentences, return_sparse=True)
print(model.convert_id_to_token(result['lexical_weights']))
# [{'机器': 0.89, '学习': 0.92, ...}, ...]
# ColBERT向量
result = model.encode(sentences, return_colbert_vecs=True)
print(result['colbert_vecs'][0].shape) # (seq_len, 1024)
# 混合检索评分
score = model.compute_score([
["什么是机器学习", "机器学习是AI的一个分支"]
], weights_for_different_modes=[0.4, 0.2, 0.4])
print(score)
|
3.2 Ollama本地部署
1
2
3
4
5
6
7
8
9
10
11
12
|
# 安装Ollama
# Mac: brew install ollama
# Linux: curl -fsSL https://ollama.com/install.sh | sh
# 拉取BGE-M3（需要transformers模型）
ollama pull nomic-embed-text # 轻量替代方案
# 或者使用其他embedding模型
ollama pull mxbai-embed-large
# 测试
ollama embeddings -p "机器学习的定义"
|
3.3 Text Generation Inference (TGI)
1
2
3
4
5
6
7
8
9
10
11
|
# 使用HuggingFace TGI部署
docker run -d --gpus all \
-p 8080:80 \
-v $PWD/data:/data \
ghcr.io/huggingface/text-embeddings-inference:latest \
--model-id BAAI/bge-m3
# API调用
curl -X POST http://localhost:8080/embed \
-H "Content-Type: application/json" \
-d '{"inputs": ["什么是机器学习"]}'
|
四、Obsidian本地RAG方案
4.1 方案概述
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
┌─────────────────────────────────────────────────────────────────┐
│ Obsidian本地RAG方案 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Obsidian笔记库 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 本地向量数据库 │ │
│ │ (LanceDB / ChromaDB) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 本地Embedding模型 │ │
│ │ (BGE-M3 / Nomic / Ollama) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 本地LLM推理 │ │
│ │ (Ollama + Qwen / Llama) │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ✅ 完全本地运行 │
│ ✅ 不需要网络 │
│ ✅ 隐私安全 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
4.2 方案一：Obsidian Vector Search插件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
┌─────────────────────────────────────────────────────────────────┐
│ Obsidian Vector Search │
├─────────────────────────────────────────────────────────────────┤
│ │
│ GitHub: github.com/sdiehl/obsidian-vector-search │
│ │
│ 特点： │
│ ├── 基于Transformers.js（WebAssembly运行） │
│ ├── 完全本地，无需API │
│ ├── 自动索引 │
│ └── 支持混合搜索 │
│ │
│ 安装： │
│ └── Community Plugins → 搜索 "Vector Search" │
│ │
│ 配置： │
│ ├── Settings → 选择Embedding模型 │
│ ├── 推荐：Xenova/multilingual-e5-small │
│ └── 可选：BGE-M3 (需本地Ollama) │
│ │
└─────────────────────────────────────────────────────────────────┘
|
4.3 方案二：Text Generator插件 + 本地LLM
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# Text Generator + 本地RAG配置
## 安装插件
1. Community Plugins → 安装 "Text Generator"
2. 安装 Ollama (本地LLM)
## 配置Text Generator
Settings → Text Generator:
- API Provider: Ollama
- Endpoint: http://localhost:11434
- Model: qwen2.5:7b
## 配置本地Embedding
使用Shell Commands或其他插件调用本地BGE-M3:
```bash
# 启动BGE-M3服务
python -m uvicorn app:app --host 0.0.0.0 --port 5000
# 或使用Ollama的embedding
ollama pull nomic-embed-text
|
1
2
|
### 4.4 方案三：Python脚本 + Obsidian Shell Commands
|
┌─────────────────────────────────────────────────────────────────┐
│ 完整本地RAG方案 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 架构： │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Obsidian Vault │ │
│ │ │ │ │
│ │ ▼ (Shell Commands触发) │ │
│ │ Python脚本 ──→ LanceDB向量数据库 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ BGE-M3 Embedding (本地) │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Ollama LLM (本地推理) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ Python脚本示例： │
│ python │ │ import lance │ │ import pyarrow as pa │ │ from FlagEmbedding import BGEM3FlagModel │ │ import os │ │ │ │ # 初始化模型 │ │ model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=True) │ │ │ │ # 读取笔记 │ │ notes = [] │ │ for root, dirs, files in os.walk('vault'): │ │ for f in files: │ │ if f.endswith('.md'): │ │ with open(os.path.join(root, f), 'r') as fp: │ │ notes.append({'path': f, 'content': fp.read()})│ │ │ │ # 生成向量 │ │ texts = [n['content'] for n in notes] │ │ embeddings = model.encode(texts)['dense_vecs'] │ │ │ │ # 存入LanceDB │ │ table = lance.writeLance( │ │ pa.table({'text': texts, 'vector': embeddings}), │ │ 'vectors.lance' │ │ ) │ │ │
│ │
└─────────────────────────────────────────────────────────────────┘
1
2
|
### 4.5 方案四：Obsidian Notes RAG
|
┌─────────────────────────────────────────────────────────────────┐
│ obsidian-notes-rag方案 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ GitHub: github.com/ernestkoe/obsidian-rag │
│ │
│ 特点： │
│ ├── MCP服务器 + CLI工具 │
│ ├── 支持Ollama/LM Studio │
│ ├── sqlite-vec存储向量（~200KB） │
│ └── 支持Cursor/Claude/Windsurf集成 │
│ │
│ 安装： │
│ bash │ │ pip install obsidian-notes-rag │ │ │
│ │
│ 使用： │
│ bash │ │ # 初始化 │ │ rag init /path/to/vault │ │ │ │ # 索引笔记 │ │ rag index │ │ │ │ # 搜索 │ │ rag search "机器学习的定义" │ │ │
│ │
└─────────────────────────────────────────────────────────────────┘
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
### 4.6 方案对比
| 方案 | 难度 | Embedding | 本地LLM | 推荐度 |
|------|------|-----------|---------|--------|
| Vector Search插件 | ⭐ | Transformers.js | ❌ | ⭐⭐⭐ |
| Text Generator + Ollama | ⭐⭐ | Ollama | ✅ | ⭐⭐⭐⭐ |
| Python脚本 + LanceDB | ⭐⭐⭐ | BGE-M3本地 | ✅ | ⭐⭐⭐⭐⭐ |
| obsidian-notes-rag | ⭐⭐ | Ollama | ✅ | ⭐⭐⭐⭐ |
---
## 五、FastGPT配置BGE-M3
### 5.1 FastGPT概述
|
┌─────────────────────────────────────────────────────────────────┐
│ FastGPT是什么？ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ FastGPT = 开源的LLM知识库问答系统 │
│ │
│ 核心功能： │
│ ├── RAG知识库问答 │
│ ├── 多模型支持 │
│ ├── 工作流编排 │
│ ├── API开放 │
│ └── 团队协作 │
│ │
│ GitHub: github.com/labring/FastGPT │
│ │
│ 官网: fastgpt.run │
│ │
└─────────────────────────────────────────────────────────────────┘
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
### 5.2 BGE-M3服务部署
```bash
# 方式1：使用FastDeploy (推荐)
docker run -d -p 5000:80 \
--gpus all \
-e MODEL_NAME=BAAI/bge-m3 \
ghcr.io/netease-youdao/bge-m3-serving:latest
# 方式2：使用text-embeddings-inference
docker run -d -p 5000:80 \
--gpus all \
-v ~/.cache/huggingface:/data \
ghcr.io/huggingface/text-embeddings-inference:latest \
--model-id BAAI/bge-m3
# 方式3：使用FlagEmbedding服务
pip install fastapi uvicorn
# 创建app.py (见下方)
|
app.py:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
from fastapi import FastAPI
from pydantic import BaseModel
from FlagEmbedding import BGEM3FlagModel
import uvicorn
app = FastAPI()
model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=True)
class EmbedRequest(BaseModel):
texts: list[str]
@app.post("/embed")
async def embed(request: EmbedRequest):
result = model.encode(request.texts)
return {"embeddings": result['dense_vecs'].tolist()}
@app.post("/embed_sparse")
async def embed_sparse(request: EmbedRequest):
result = model.encode(request.texts, return_sparse=True)
return {"lexical_weights": result['lexical_weights']}
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=5000)
|
5.3 One-API配置BGE-M3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
┌─────────────────────────────────────────────────────────────────┐
│ One-API配置BGE-M3 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ One-API = API管理和配额分发平台 │
│ │
│ 作用： │
│ ├── 统一管理多个AI模型的API │
│ ├── 充当代理网关 │
│ └── 支持自定义模型接入 │
│ │
│ 配置步骤： │
│ │
│ 1. 添加渠道 │
│ ├── 渠道类型: Custom Provider │
│ ├── 模型: BGE-M3 │
│ └── Base URL: http://your-server:5000 │
│ │
│ 2. 添加模型 │
│ ├── 模型名称: bge-m3 │
│ ├── 模型ID: bge-m3 │
│ └── 向量维度: 1024 │
│ │
│ 3. 使用 │
│ └── 在FastGPT中填入One-API的API地址 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
5.4 FastGPT配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
{
"vectorModel": {
"name": "BAAI/bge-m3",
"avatar": "🧮",
"disabled": false,
"provider": "custom",
"modelType": "embedding",
"price": 0,
"maxToken": 8192,
"dims": 1024,
"ChineseName": "BGE-M3多语言向量模型",
"baseUrl": "http://your-server:5000",
"maxResponse": 100,
"frequency_penalty": 0,
"presence_penalty": 0,
"log": false,
"customcqRatio": 0,
"defaultToken": 0,
"maxContext": 8000
}
}
|
5.5 完整部署流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
┌─────────────────────────────────────────────────────────────────┐
│ FastGPT + BGE-M3完整部署 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. 部署基础服务 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ # Docker Compose (基础服务) │ │
│ │ services: │ │
│ │ mysql: │ │
│ │ image: mysql:8 │ │
│ │ redis: │ │
│ │ image: redis:7 │ │
│ │ minio: │ │
│ │ image: minio/minio │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 2. 部署BGE-M3向量服务 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ docker run -d -p 5000:80 \ │ │
│ │ --gpus all \ │ │
│ │ ghcr.io/huggingface/text-embeddings-inference \ │ │
│ │ --model-id BAAI/bge-m3 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 3. 部署FastGPT │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ # 修改config.json │ │
│ │ { │ │
│ │ "vectorModel": { │ │
│ │ "name": "BAAI/bge-m3", │ │
│ │ "baseUrl": "http://your-server:5000" │ │
│ │ } │ │
│ │ } │ │
│ │ │ │
│ │ # 启动 │ │
│ │ docker-compose -f docker-compose.yml up -d │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 4. 创建知识库 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 访问 FastGPT 管理后台: http://your-ip:3000 │ │
│ │ │ │
│ │ 1. 创建知识库 │ │
│ │ 2. 上传文档（PDF/Markdown/TXT） │ │
│ │ 3. 自动分chunk并生成向量 │ │
│ │ 4. 创建应用，关联知识库 │ │
│ │ 5. 开始问答 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
六、混合检索与Rerank
6.1 为什么要混合检索
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
┌─────────────────────────────────────────────────────────────────┐
│ 混合检索原理 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 单一检索的局限： │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Dense检索: │ │
│ │ ✅ "深度学习是机器学习的分支" → 相关 │ │
│ │ ❌ 搜索"DL" → 可能搜不到 │ │
│ │ │ │
│ │ Sparse检索: │ │
│ │ ✅ "DL" → 精确匹配"深度学习" │ │
│ │ ❌ 无法理解"DL"和"深度学习"的语义关系 │ │
│ │ │ │
│ │ 混合检索: │ │
│ │ ✅ 结合两者优势，既能语义匹配又能精确匹配 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 公式： │
│ Final_Score = α × Dense_Score + (1-α) × Sparse_Score │
│ │
│ 其中α可调，通常建议α=0.7左右 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
6.2 BGE-M3 + Milvus混合检索
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
from pymilvus import MilvusClient
from FlagEmbedding import BGEM3FlagModel
# 初始化
model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=True)
client = MilvusClient("milvus_demo.db")
# 存储（同时存Dense和Sparse）
texts = ["机器学习是AI的分支", "深度学习是机器学习的分支"]
output = model.encode(texts, return_dense=True, return_sparse=True)
for i, text in enumerate(texts):
client.insert(
"bge_m3_hybrid",
{
"id": i,
"text": text,
"dense_vector": output['dense_vecs'][i],
"sparse_vector": output['lexical_weights'][i]
}
)
# 混合检索
query = "深度学习"
query_output = model.encode([query], return_dense=True, return_sparse=True)
results = client.search(
"bge_m3_hybrid",
data=[query_output['dense_vecs'][0]],
limit=5,
sparse_vector=query_output['lexical_weights'][0],
vector_field_name="dense_vector",
sparse_vector_field_name="sparse_vector",
sparse_vector_factors={"sparse_vector": 0.3}
)
|
6.3 Rerank优化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
┌─────────────────────────────────────────────────────────────────┐
│ Rerank流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. Embedding检索（初筛） │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Query → BGE-M3 Dense → Top 20 结果 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ │
│ 2. Rerank排序（精排） │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Top 20 → BGE-Reranker → Top 5 结果 │ │
│ │ │ │
│ │ BGE-Reranker特点： │ │
│ │ ├── 交叉编码，效果更精确 │ │
│ │ ├── 速度慢，适合小规模重排 │ │
│ │ └── 开源可用 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ │
│ 3. 最终结果 │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Top 5 → 送给LLM生成答案 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
七、实战配置示例
7.1 Obsidian + 本地RAG完整配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
# 1. 安装Ollama
curl -fsSL https://ollama.com/install.sh | sh
# 2. 下载模型
ollama pull nomic-embed-text # Embedding模型
ollama pull qwen2.5:7b # LLM模型
# 3. 安装Obsidian插件
# - Text Generator
# - Shell Commands
# - Templater
# 4. 创建Shell命令
#!/bin/bash
# obsidian_rag_search.sh
query="$1"
python3 ~/scripts/rag_search.py "$query"
# 5. Python搜索脚本
"""
~/scripts/rag_search.py
"""
import sys
import requests
query = sys.argv[1]
# Ollama embedding
response = requests.post(
"http://localhost:11434/api/embeddings",
json={"model": "nomic-embed-text", "prompt": query}
)
query_vector = response.json()["embedding"]
# 搜索（这里用简单的余弦相似度）
# 实际使用ChromaDB或LanceDB
print(f"搜索: {query}")
print("找到相关笔记...")
# 调用Ollama生成
response = requests.post(
"http://localhost:11434/api/generate",
json={
"model": "qwen2.5:7b",
"prompt": f"基于以下内容回答：{query}\n\n相关内容..."
}
)
print(response.json()["response"])
|
7.2 FastGPT + BGE-M3完整配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
# docker-compose.yml
version: '3.8'
services:
# BGE-M3向量服务
bge-m3:
image: ghcr.io/huggingface/text-embeddings-inference:latest
container_name: bge-m3
ports:
- "5000:80"
volumes:
- ~/.cache/huggingface:/data
environment:
- MODEL_ID=BAAI/bge-m3
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
# FastGPT
fastgpt:
image: registry.cn-wulanchabu.aliyuncs.com/fastgpt/fastgpt:latest
container_name: fastgpt
ports:
- "3000:3000"
volumes:
- ./config.json:/app/config.json
- ./data:/app/data
depends_on:
- mysql
- redis
environment:
- DB_MAX_LINK=30
- TOKEN_KEY=your-token-key
- ROOT_KEY=your-root-key
|
config.json:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
{
"systemEnv": {
"vectorMaxProcess": 512,
"chatMaxToken": 2000,
"qaMaxToken": 2000
},
"chatModels": [
{
"model": "qwen2.5:7b",
"name": "Qwen 2.5",
"price": 0,
"maxToken": 32000,
"stream": true,
"baseUrl": "http://localhost:11434",
"apiKey": ""
}
],
"vectorModels": [
{
"model": "BAAI/bge-m3",
"name": "BGE-M3",
"price": 0,
"maxToken": 8192,
"dims": 1024,
"baseUrl": "http://bge-m3:80",
"apiKey": ""
}
]
}
|
八、常见问题
8.1 BGE-M3相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
┌─────────────────────────────────────────────────────────────────┐
│ BGE-M3常见问题Q&A │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q: BGE-M3需要多大显存？ │
│ A: 约4GB显存（FP16），可以用CPU但较慢 │
│ │
│ Q: BGE-M3和其他模型如何选择？ │
│ A: │
│ ├── 需要多语言 → BGE-M3 │
│ ├── 纯英文 → Nomic-embed-text │
│ ├── 纯中文 → BGE-large-zh │
│ └── 需要极快 → Nomic-embed-text │
│ │
│ Q: Dense/Sparse/ColBERT选哪个？ │
│ A: 混合使用效果最好，单独用Dense也足够 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
8.2 Obsidian相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
┌─────────────────────────────────────────────────────────────────┐
│ Obsidian RAG常见问题Q&A │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q: Obsidian能完全本地运行吗？ │
│ A: 可以，用Ollama作为LLM后端 │
│ │
│ Q: 笔记太多会很慢吗？ │
│ A: 首次索引慢，后续检索快。建议定期增量更新 │
│ │
│ Q: 手机上能用吗？ │
│ A: 部分插件支持移动端（只读模式） │
│ │
└─────────────────────────────────────────────────────────────────┘
|
8.3 FastGPT相关
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
┌─────────────────────────────────────────────────────────────────┐
│ FastGPT常见问题Q&A │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Q: FastGPT必须用Docker吗？ │
│ A: 不是，但Docker部署更简单 │
│ │
│ Q: BGE-M3和M3E哪个好？ │
│ A: BGE-M3效果更好，支持更长上下文 │
│ │
│ Q: 如何更新向量库？ │
│ A: 删除知识库重新上传，或使用API增量更新 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
九、总结
9.1 BGE-M3核心优势
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
┌─────────────────────────────────────────────────────────────────┐
│ BGE-M3 vs 其他方案 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ BGE-M3 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ✅ 开源免费 │ │
│ │ ✅ 支持100+语言 │ │
│ │ ✅ 支持8000 token超长上下文 │ │
│ │ ✅ 三种检索模式（Dense/Sparse/ColBERT） │ │
│ │ ✅ 中文效果好 │ │
│ │ ✅ 可本地部署 │ │
│ │ │ │
│ │ ⚠️ 模型较大（2.27GB） │ │
│ │ ⚠️ 建议有GPU │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 推荐场景： │
│ ├── 个人知识库 │
│ ├── 企业RAG系统 │
│ ├── 多语言文档检索 │
│ └── 长文档问答 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
9.2 部署方案推荐
| 场景 |
推荐方案 |
难度 |
成本 |
| 个人笔记 |
Obsidian + Vector Search |
⭐ |
免费 |
| 个人笔记+LLM |
Obsidian + Ollama |
⭐⭐ |
免费 |
| 企业知识库 |
FastGPT + BGE-M3 |
⭐⭐⭐ |
服务器成本 |
| 研究用 |
本地Docker部署 |
⭐⭐ |
GPU成本 |
9.3 学习路线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
第一阶段：理解向量模型
→ 理解向量是什么
→ 知道BGE-M3的三大特性
第二阶段：本地运行BGE-M3
→ 用Python调用
→ 用Ollama部署
→ 用Docker部署
第三阶段：Obsidian本地RAG
→ 安装Vector Search插件
→ 配置本地Embedding
→ 实现笔记搜索
第四阶段：FastGPT企业知识库
→ Docker部署FastGPT
→ 配置BGE-M3向量服务
→ 创建知识库和应用
|
希望这篇文章能帮你搭建自己的本地RAG知识库！如果有问题，欢迎在评论区交流。