This resume is also available in English.

九、RAG 與工具第 2 / 5 篇 · 全部目錄

專欄 › 九、RAG 與工具 › 第 39 篇

RAG 的品質從哪裡來:切塊、embedding、向量資料庫與混合檢索

Where RAG Quality Comes From: Chunking, Embeddings, Vector Databases and Hybrid Search

把 RAG 拆成五個環節,看每一環怎麼決定答案好壞;用 Go 寫依標題切塊、餘弦相似度與 RRF 合併,並說明向量資料庫怎麼搭配、要注意什麼,以及篩選與上下文預算。

  • RAG
  • AI
  • Go
  • Embedding
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:五個環節,每一環都會掉分
  3. 第 2 步:切塊——大小、重疊與依結構切
  4. 第 3 步:Embedding——把文字變成可以比較的向量
  5. 第 4 步:向量與關鍵字的混合檢索,用 RRF 合併
  6. 第 5 步:向量資料庫——怎麼選、怎麼搭配、要注意什麼
  7. 第 6 步:重排——先撈多,再精排
  8. 第 7 步:組提示——片段數量、順序與上下文預算
  9. 第 8 步:中繼資料篩選——權限、版本、語言與時間
  10. 常見陷阱
  11. 重點整理
  12. 下一篇

上一篇〈RAG 入門:讓模型先查資料再回答,核心價值在哪裡〉說過,RAG 裡找資料的是檢索,不是模型。這篇是中階:同樣一批文件、同一個模型,為什麼有的 RAG 答得準、有的答非所問?答案幾乎都在檢索這一側。

這篇要解決什麼

值班的人問:「PAYMENT_TIMEOUT 時可以重試扣款嗎?」系統回答「文件裡沒有寫」。但 runbook 明明寫了。可能的原因很多:

  • 那句話被切在兩段的交界,兩邊都只剩半句。
  • 向量檢索把「付款逾時」和「訂單逾時」當成很像,前幾名全是 order 的文件。
  • 錯誤碼 PAYMENT_TIMEOUT 這種字串,向量檢索本來就不擅長。
  • 找到了,但排在第 9 名,只取前 5 名就漏掉了。
  • 找到了也放進提示,但前面塞了太多不相關的片段,模型沒有用到它。

這篇把 RAG 拆成五個環節,逐一說明每一環的取捨,並用 Go 寫出關鍵的幾段:

  1. 五個環節與「每一環都會掉分」。
  2. 切塊:大小、重疊、依結構切,以及每段要帶的中繼資料。
  3. Embedding:向量、相似度、模型的一致性。
  4. 向量檢索與關鍵字檢索各自擅長什麼,用 RRF 合併。
  5. 向量資料庫:怎麼選、怎麼搭配 RAG、要注意什麼。
  6. 重排:先撈多,再精排。
  7. 組提示:片段數量、順序、上下文預算與拒答規則。
  8. 中繼資料篩選:權限、版本、語言與時間。

第 1 步:五個環節,每一環都會掉分

切塊 大小與重疊 依標題切 帶標題路徑 Embedding 同一個模型 多語言 換模型要重建 檢索 向量+關鍵字 RRF 合併 權限篩選 重排 先撈 30–50 段 精排取前幾段 看成本取捨 組提示 片段帶 ID 上下文預算 找不到就拒答 一次問答經過的五個環節(下面是每一環最常調的地方) 前一環漏掉的東西,後一環救不回來:調整由左往右。

圖:一次問答經過五個環節,每一環下面是它最常調整的地方。前一環漏掉的東西,後一環救不回來。

把這五個環節想成一條串聯的管線:切塊切壞了,embedding 再好也沒用;檢索沒撈到,重排也排不出來;片段撈到了但提示組得不好,模型還是可能沒用到。所以調整 RAG 的順序通常是由前往後:先確定對的段落存在、而且被撈得到,再談排序和提示。

第 2 步:切塊——大小、重疊與依結構切

切塊(chunking)決定「檢索的單位」。太大,一段裡混了好幾件事,向量變得模糊,放進提示也浪費空間;太小,一句話失去上下文(「它不能重試」的「它」是誰?)。

常見的做法有三種:

  • 固定長度:每 N 個字一段。簡單,但常把一句話、一個表格、一段程式碼從中間切開。
  • 依結構切:照 Markdown 標題、段落、程式碼區塊切。同一節的內容留在一起,最適合技術文件。
  • 依語意切:用 embedding 偵測主題轉換的位置。效果有時更好,但成本高、難除錯,通常不是第一步。

技術文件建議從「依標題切,再限制大小」開始:先照 ##、### 切成小節;某一節太長,再照段落切成幾段,並保留少量重疊(例如前一段的最後一兩句),避免關鍵句剛好落在交界。

每一段除了文字,還要帶著中繼資料:來源檔案、行號、標題路徑(例如「付款逾時 › 可以重試嗎」)、文件類型、更新日期、可讀的角色。標題路徑特別有用:把它加在段落文字前面一起做 embedding,「可以重試嗎」這段就知道自己講的是付款逾時。

// internal/rag/chunk.go:依 Markdown 標題切塊,太長的一節再依段落切
package rag

import "strings"

type Chunk struct {
	Source string // 檔案路徑
	Line   int    // 起始行號(從 1 開始)
	Path   string // 標題路徑,例如「付款逾時 › 可以重試嗎」
	Text   string
}

// Split 照 ## 與 ### 切成小節;每段不超過 max 個字(rune),超過就在空行處再切
func Split(source, doc string, max int) []Chunk {
	var out []Chunk
	var heads []string // 目前的標題路徑
	var buf []string
	start := 1
	flush := func(next int) {
		text := strings.TrimSpace(strings.Join(buf, "\n"))
		if text != "" {
			for _, part := range bySize(text, max) {
				out = append(out, Chunk{source, start, strings.Join(heads, " › "), part})
			}
		}
		buf, start = nil, next
	}
	for i, line := range strings.Split(doc, "\n") {
		level := 0
		if strings.HasPrefix(line, "## ") {
			level = 1
		} else if strings.HasPrefix(line, "### ") {
			level = 2
		}
		if level == 0 {
			buf = append(buf, line)
			continue
		}
		flush(i + 1)
		if len(heads) >= level {
			heads = heads[:level-1]
		}
		heads = append(heads, strings.TrimSpace(strings.TrimLeft(line, "# ")))
	}
	flush(0)
	return out
}

// bySize 在空行(段落)處切,讓每段不超過 max 個字;單一段落本身太長就整段保留
func bySize(text string, max int) []string {
	var out []string
	cur := ""
	for _, p := range strings.Split(text, "\n\n") {
		if cur != "" && len([]rune(cur))+len([]rune(p)) > max {
			out = append(out, cur)
			cur = ""
		}
		if cur != "" {
			cur += "\n\n"
		}
		cur += p
	}
	if cur != "" {
		out = append(out, cur)
	}
	return out
}

(為了讓重點清楚,這裡省略了重疊與「程式碼區塊裡的 ## 不是標題」的處理;實作篇的版本會補上。一段太長時記下的行號是那一節的起點,實作篇會改成每段自己的行號。)

大小怎麼定?沒有通用答案,要用下一篇的評估方法實測。一個合理的起點是:技術文件每段幾百到一千字左右、重疊一兩句。比起追求「最佳大小」,依結構切與帶標題路徑通常帶來更大的改善。

第 3 步:Embedding——把文字變成可以比較的向量

Embedding 模型把一段文字轉成一串數字(向量),意思相近的文字,向量的方向也相近。檢索時把問題也轉成向量,找方向最接近的幾段。「方向多接近」最常用餘弦相似度:兩個向量夾角的餘弦,越接近 1 越像。

// internal/rag/cosine.go
package rag

import "math"

// Cosine 回傳兩個向量的餘弦相似度;長度不同或其中一個是零向量時回傳 0
func Cosine(a, b []float32) float64 {
	if len(a) != len(b) || len(a) == 0 {
		return 0
	}
	var dot, na, nb float64
	for i := range a {
		dot += float64(a[i]) * float64(b[i])
		na += float64(a[i]) * float64(a[i])
		nb += float64(b[i]) * float64(b[i])
	}
	if na == 0 || nb == 0 {
		return 0
	}
	return dot / (math.Sqrt(na) * math.Sqrt(nb))
}

幾個容易踩的規則:

  • 建索引和查詢必須用同一個 embedding 模型(同一個版本)。不同模型的向量不能互相比較;換模型就要整個重建索引。索引裡要記下用的是哪個模型。
  • 語言要對得上。問題是中文、文件是英文時,要選支援多語言的 embedding 模型,並用實際的中英問題測過。
  • 向量擅長「意思像」,不擅長「字一模一樣」。錯誤碼、訂單編號、函式名稱、版本號這類字串,向量常常找不準。這就是下一步要加關鍵字檢索的原因。

第 4 步:向量與關鍵字的混合檢索,用 RRF 合併

兩種檢索剛好互補:

向量檢索關鍵字檢索(例如 BM25、全文搜尋)
擅長換句話說、同義詞(「退款」找到「撤銷扣款」)精確字串(PAYMENT_TIMEOUT、order-1234、WithCancel)
不擅長錯誤碼、編號、很短的查詢用詞不同但意思相同的問題

所以實務上兩個都做,再把兩份排名合併。兩邊的分數單位不同(餘弦相似度和 BM25 分數不能直接相加),最簡單又穩定的合併法是 RRF(Reciprocal Rank Fusion):只看名次,不看分數。一段文件在每份排名裡得到 1 / (k + 名次) 分,加總後重新排序。k 常用 60,作用是讓第 1 名和第 2 名的差距不要太大。

向量檢索的排名 1. c7 1/(60+1) 2. c2 1/(60+2) 3. c9 1/(60+3) 關鍵字檢索的排名 1. c2 1/(60+1) 2. c4 1/(60+2) 3. c7 1/(60+3) RRF 合併後 1. c2 0.0325 2. c7 0.0323 3. c4 0.0161 4. c9 0.0159 每段在每份排名得到 1/(k+名次) 分(k=60),加總後重排;只看名次,不必比較兩種分數。 c2 在兩邊都很前面,所以排第一;c9 只有向量檢索找到,而且排第三。

圖:向量檢索與關鍵字檢索各自排名,RRF 把名次換成分數相加;兩邊都排得前面的段落會浮到最上面。

// internal/rag/rrf.go
package rag

import "sort"

// RRF 合併多份排名(每份是由好到壞的 ID 清單),回傳合併後由好到壞的 ID
func RRF(k float64, rankings ...[]string) []string {
	score := map[string]float64{}
	for _, ranking := range rankings {
		for i, id := range ranking {
			score[id] += 1 / (k + float64(i+1)) // 名次從 1 開始
		}
	}
	ids := make([]string, 0, len(score))
	for id := range score {
		ids = append(ids, id)
	}
	sort.Slice(ids, func(i, j int) bool {
		if score[ids[i]] != score[ids[j]] {
			return score[ids[i]] > score[ids[j]]
		}
		return ids[i] < ids[j] // 同分時固定順序,結果才可重現
	})
	return ids
}

例如向量檢索排出 [c7, c2, c9]、關鍵字檢索排出 [c2, c4, c7],RRF(60, …) 的結果是 [c2, c7, c4, c9]:c2 在兩邊都很前面,所以排第一。

第 5 步:向量資料庫——怎麼選、怎麼搭配、要注意什麼

向量資料庫負責「存向量、快速找最近的幾個」。文件只有幾千段時,把向量放在記憶體裡逐一算餘弦相似度就夠快;段落到了幾十萬、上百萬,才需要專門的索引。選擇大致有兩類:

  • 在現有資料庫加上向量功能:例如 PostgreSQL 的 pgvector 擴充、Elasticsearch/OpenSearch 的向量欄位。好處是資料、權限、備份、交易都沿用現有的那套,關鍵字檢索也在同一個地方。
  • 專門的向量資料庫:例如 Qdrant、Milvus、Weaviate。資料量很大、向量查詢是主要負載時比較有優勢,但多一套要維運、備份、監控的系統。

對大部分團隊,先用已經在用的資料庫(實作篇用 PostgreSQL + pgvector),量真的大到撐不住再換。搭配 RAG 時要注意這幾件事:

  • 它找的是「近似」最近鄰。HNSW、IVF 這類索引用一點準確度換速度,可能漏掉真正最近的幾個。索引參數(例如 pgvector HNSW 的 ef_search、IVFFlat 的 probes)就是在調這個取捨;調整後要用下一篇的 recall 指標實測,而不是只看速度。
  • 距離函式要和 embedding 模型一致。模型說用餘弦就用餘弦(pgvector 的 <=> 是餘弦距離,<#> 是負內積,<-> 是歐氏距離);索引建立時指定的運算子類別也要對上,否則查詢不會用到索引。
  • 維度固定在欄位上。vector(1024) 的欄位放不進 1536 維的向量。換 embedding 模型等於新開一個欄位或一張表,整批重建,重建完再切換。
  • 篩選和近似搜尋會互相影響。「先找最近的 10 個,再篩掉沒權限的」可能只剩 2 個,甚至 0 個。要嘛讓資料庫在搜尋時一起篩選(pgvector 0.8 起的 iterative scan、專門資料庫的 filtered search),要嘛先撈多一點再篩,並且測試篩選很嚴格的情況。
  • 不要只存向量。每一列同時存原文、來源、行號、標題路徑、內容雜湊、embedding 模型名稱與中繼資料。回答要引用原文,篩選要靠中繼資料,重建要靠雜湊。
  • 跟著文件更新與刪除。文件改了要重算那幾段,文件刪了要刪掉對應的列,否則模型會引用已經不存在的內容。依內容雜湊做增量更新,並定期比對「索引裡有、檔案裡沒有」的段落。
  • 混合檢索要兩種索引。向量索引之外,還要全文或關鍵字索引;同一個資料庫裡兩者都有,第 4 步的 RRF 才好做。

第 6 步:重排——先撈多,再精排

向量與關鍵字檢索都要快,所以它們是「粗篩」:問題和每段文件是分開轉成向量或索引的,彼此沒有真正一起讀過。重排(rerank)則是把問題和候選段落放在一起交給一個專門的模型(常見的是 cross-encoder 型的 reranker,或請 LLM 判斷),逐一打分數。它準得多,但也慢得多、貴得多。

所以常見的做法是兩階段:

  1. 混合檢索先撈出比較多的候選,例如 30 到 50 段。
  2. 重排模型只對這些候選打分數,取前 5 到 8 段放進提示。

要不要加重排,看評估結果:如果正確的段落常常「有撈到但排在後面」,重排的效果就會很明顯;如果正確的段落根本沒撈到,要回頭修切塊或檢索,重排救不回來。

第 7 步:組提示——片段數量、順序與上下文預算

段落撈到了,最後一步是把它們放進提示。這一步常被忽略,卻直接決定模型有沒有用到對的段落:

  • 不是越多越好。放進 30 段,模型要在一大堆不相關的內容裡找答案,反而容易用錯或忽略關鍵段。先從 5 段左右開始,用評估結果調整。
  • 設定上下文預算。例如「片段總共不超過 N 個 token」,超過就從排名最後的開始丟。成本與延遲也跟著可控。
  • 每段帶 ID 與來源。模型引用 ID,程式再把 ID 換回檔案與行號給讀者看。
  • 同一份文件的相鄰段落合併。連續的第 3、4 段合成一段,讀起來比較完整。
  • 寫清楚規則。只根據片段回答;每句標 ID;片段裡沒有就說不知道;片段之間互相矛盾時要指出來,而不是自己挑一個。
  • 片段是資料,不是指令。文件裡如果寫著「忽略以上規則」,那只是文件內容。把片段放在明確的標記之間,並在系統提示裡說明;更重要的防線在進階篇與實作篇會講。

第 8 步:中繼資料篩選——權限、版本、語言與時間

切塊時帶的中繼資料,到了檢索時就是篩選條件,而且要在檢索之前或同時套用,不是撈完再交給模型判斷:

  • 權限:依登入身分只檢索看得到的文件。模型看不到的片段,才是真正說不出來的。
  • 版本:API v1 與 v2 的文件同時存在時,依使用者問的服務版本篩選,或預設只看目前版本。
  • 語言:中文問題優先中文文件;沒有才找英文。
  • 時間與狀態:已作廢的 runbook、草稿不要進入檢索;事故紀錄可以依日期排序或加權。

篩選做在檢索這一層,還有一個好處:每次回答用了哪些片段、為什麼是這些,都能從日誌查出來。

常見陷阱

一開始就換更大的模型。答錯的原因多半在檢索;先看正確的段落有沒有被撈到。

只用向量檢索。錯誤碼、編號、函式名稱常常找不到;加上關鍵字檢索再用 RRF 合併。

換了 embedding 模型卻沒有重建索引。新舊向量不能比較,檢索會悄悄變差。索引要記錄模型名稱與版本。

片段越多越好。塞太多會稀釋關鍵內容,也更貴、更慢。用上下文預算控制。

篩選放在近似搜尋之後。先取前 10 名再篩權限,常常只剩一兩段,甚至沒有;篩選要在搜尋時一起做。

權限交給模型判斷。「請不要透露機密文件」不是權限控制;要在檢索時就篩掉。

切塊時丟掉標題。「可以重試嗎」少了「付款逾時」這個標題,向量就不知道在講什麼。

重點整理

  • RAG 是五個環節串成的管線:切塊、embedding、檢索、重排、組提示;前一環漏掉的,後一環救不回來,調整由前往後。
  • 技術文件依標題切、再限制大小、保留少量重疊;每段帶來源、行號、標題路徑與可讀角色。
  • 建索引與查詢用同一個 embedding 模型;換模型就重建索引;多語言要實測。
  • 向量擅長意思相近,關鍵字擅長精確字串;兩者都做,用 RRF(1/(k+名次),k 常用 60)只看名次合併。
  • 向量資料庫先用現有的(例如 pgvector),量大再換;它找的是近似最近鄰,距離函式與維度要和 embedding 模型一致,篩選要在搜尋時一起做,每列存原文、來源與雜湊,文件更新與刪除要同步。
  • 重排是先撈多、再精排;正確段落「撈到但排後面」時效果最明顯。
  • 組提示時控制片段數量與上下文預算,每段帶 ID,規定只根據片段回答、找不到就說不知道,片段是資料不是指令。
  • 權限、版本、語言、時間在檢索時就篩選,不交給模型判斷。

下一篇

每一環都有可以調的地方,那怎麼知道調了之後是變好還是變壞?憑感覺問幾題是不夠的。下一篇〈RAG 的評估與常見失敗:怎麼知道它答得對〉建立問題集,分開量檢索與回答,並整理 RAG 最常見的失敗與對策。