Hỏi thẳng một chatbot nối trực tiếp vào mô hình ngôn ngữ: "Quá 30 ngày rồi thì còn được hoàn tiền không?" Nó trả lời ngay, lễ phép, kèm một con số ngày cụ thể và vài điều kiện đi kèm. Câu trả lời nghe rất hợp lý. Có điều, nó không nằm trong bất kỳ tài liệu nào công ty từng công bố.
Mô hình không cố tình nói dối. Nó chỉ làm đúng việc nó được huấn luyện: viết tiếp cuộc hội thoại bằng đoạn chữ có khả năng xuất hiện tiếp theo cao nhất. Với chuyện phiếm thì đó là tính năng. Với một câu hỏi về chính sách thì đó là rủi ro, vì người đọc không phân biệt được đâu là điều mô hình thật sự nhớ, đâu là một câu đoán trơn tru. Mà chính mô hình cũng không phân biệt được.
Tôi phải xử lý đúng vấn đề này trong một nền tảng mười ba service NestJS. Một service trong đó chạy trợ lý chat, trả lời câu hỏi dựa trên vài tài liệu chính sách và một danh mục sản phẩm. Lời giải là retrieval-augmented generation (RAG), và hóa ra phần vector search lại là phần dễ nhất. Thứ quyết định chất lượng là ba lựa chọn nhỏ hơn: không có gì khớp thì làm gì, câu trả lời cho thấy nó lấy từ đâu bằng cách nào, và index được giữ mới ra sao. Tất cả chạy gọn trong Postgres. Mọi thứ dưới đây lấy từ repository, con số giữ nguyên như trong code, kể cả những con số tôi chưa tinh chỉnh.
Hãy giữ trong đầu một hình ảnh: thi mở sách, nhưng câu trả lời nào cũng phải ghi số trang. Cuốn sách giúp trả lời đúng được. Quy định ghi số trang giúp kiểm tra được. Còn một sinh viên giỏi, lật mãi không thấy trang nào nói về câu hỏi, sẽ ghi "tài liệu không đề cập" thay vì tự bịa. RAG đưa cho mô hình cuốn sách. Phần lớn bài này nói về hai quy định còn lại.
Vì sao LLM vẫn trả lời dù không có nguồn?
Trọng số của mô hình là một dạng trí nhớ nén từ dữ liệu huấn luyện. Chính sách hoàn tiền của bạn không nằm trong đó. Nếu trong đó có gì, thì đó là chính sách hoàn tiền của người khác, hoặc một phiên bản cũ của bạn. Hỏi thẳng mô hình là một bài thi đóng sách: nó sẽ viết một cái gì đó, vì viết là việc duy nhất nó làm được. Thêm câu "hãy trả lời chính xác" vào prompt chỉ đổi được giọng văn, không đổi được kiến thức.
Cách sửa đầu tiên ai cũng nghĩ tới là dán hết các chính sách vào system prompt. Công bằng mà nói, với năm tài liệu ngắn thì cách này chạy được, và đơn giản hơn mọi thứ phía dưới. Tôi không dừng ở đó vì ba lý do. Cùng trợ lý đó còn phải tìm trong danh mục sản phẩm, lớn hơn nhiều và thay đổi liên tục trong ngày. Lượt hội thoại nào cũng phải trả token cho toàn bộ tài liệu. Và câu trả lời vẫn không nói được nó đã dùng tài liệu nào.
RAG là gì, và nó thực sự thay đổi điều gì?
RAG chỉ có một ý: trước khi mô hình trả lời, tìm đoạn văn bản liên quan rồi đưa cho mô hình làm bằng chứng. Bài thi đóng sách thành bài thi mở sách.
Đây là phiên bản mà đa số tutorial bắt đầu:
const hits = await vectorSearch(question, { topK: 3 });
const answer = await llm.chat([
{
role: 'system',
content: `Answer using this context:\n${hits.map((hit) => hit.body).join('\n---\n')}`,
},
{ role: 'user', content: question },
]);Giờ thử hỏi "Có trả góp được không?" trong khi không tài liệu nào nhắc đến trả góp. topK: 3 vẫn trả về ba tài liệu, vì lúc nào cũng có một láng giềng gần nhất. Nó trả về ba tài liệu ít xa nhất, chẳng hạn chính sách hoàn tiền, chính sách xuất dữ liệu và chính sách xóa tài khoản. Mô hình giờ cầm trong tay một ngữ cảnh trông rất chính thức nhưng lạc đề, và system prompt vừa bảo nó dùng ngữ cảnh đó.
Đây chính là cậu sinh viên thi mở sách lật đại tới trang na ná nhất rồi cứ thế viết. RAG kiểu ngây thơ không loại bỏ được hallucination. Nó còn có thể làm hallucination thuyết phục hơn, vì giờ câu trả lời trích được văn bản thật.
Vậy câu hỏi thật sự là: search quyết định rằng không có gì liên quan bằng cách nào, và quyết định đó đến tay người dùng nguyên vẹn ra sao?
Sao để vector trong Postgres mà không dùng vector database riêng?
Tài liệu vốn đã nằm trong database Postgres của chính service trợ lý (mỗi service một database; lý do nằm ở bài database per service và saga). Extension pgvector thêm kiểu cột vector và các toán tử khoảng cách. Nhờ vậy tôi có được ba thứ:
- Một transaction. Nội dung tài liệu, embedding, cờ published và version thay đổi cùng nhau. Không có kho thứ hai nào để lệch pha.
- Bộ lọc là mệnh đề
WHERE. Tài liệu đã publish chưa, sản phẩm còn bán không, đều là một cột để lọc. Độ tương đồng không bao giờ được phép đoán chuyện đó. Đây là quy tắc ghi rõ từ thiết kế ban đầu. - Full-text search nằm ngay trong cùng engine, nên hybrid search chỉ là một câu query.
Cái mất đi là bộ công cụ approximate search quy mô lớn của một engine chuyên dụng. Với một kho chỉ có vài tài liệu cộng thêm một danh mục sản phẩm, đánh đổi này quá dễ chấp nhận.
Bảng chính sách, tên đã được đổi cho trung tính:
CREATE EXTENSION IF NOT EXISTS vector;
CREATE TABLE policy_documents (
id BIGSERIAL PRIMARY KEY,
doc_key VARCHAR(80) NOT NULL UNIQUE, -- chính là trích dẫn
title_vi VARCHAR(200) NOT NULL,
title_en VARCHAR(200) NOT NULL,
body_vi TEXT NOT NULL,
body_en TEXT NOT NULL,
search_text TEXT NOT NULL,
search_vector TSVECTOR GENERATED ALWAYS AS (to_tsvector('simple', search_text)) STORED,
embedding vector(768),
embedding_model VARCHAR(120),
is_published BOOLEAN NOT NULL DEFAULT TRUE,
version INTEGER NOT NULL DEFAULT 1
);
CREATE INDEX policy_documents_search_idx
ON policy_documents USING GIN (search_vector);
CREATE INDEX policy_documents_embedding_idx
ON policy_documents USING hnsw (embedding vector_cosine_ops)
WHERE embedding IS NOT NULL;Vài lựa chọn ở đây là có chủ ý:
- Một row chứa cả hai ngôn ngữ.
search_textnối tiêu đề và nội dung tiếng Việt với bản tiếng Anh (đã chuẩn hóa NFKC), nên câu hỏi bằng ngôn ngữ nào cũng có thể khớp. - Dùng
'simple', không dùng cấu hình theo ngôn ngữ. Postgres không có sẵn stemmer cho tiếng Việt.simplechỉ chuyển về chữ thường và tách theo ranh giới từ, không stemming, không bỏ stop word. Nó cũng giữ nguyên dấu, nên gõ không dấu sẽ không khớp keyword với văn bản có dấu. Đây là lỗ hổng đã biết, tôi quay lại ở cuối bài. embeddingđược phép NULL. Một tài liệu có thể tồn tại, và tìm được bằng keyword, trước khi có vector.- 768 chiều đến từ một embedding model dạng hosted (
gemini-embedding-001của Gemini, output dimensionality đặt là 768). Tài liệu được embed với task type "retrieval document", câu hỏi với "retrieval query", để model biết mỗi đoạn văn bản nằm ở phía nào của phép tìm kiếm.
Hybrid search kết hợp pgvector và full-text search thế nào?
Quay lại phòng thi. Sinh viên có hai cách tìm đúng trang. Bảng tra cứu cuối sách tìm được đúng từng chữ: một mã lỗi, một tên sản phẩm, "30 ngày". Đọc lướt theo ý tìm được đoạn viết "trả lại tiền" dù câu hỏi dùng chữ "hoàn tiền". Mỗi cách hỏng đúng ở chỗ cách kia làm tốt: embedding làm nhòe các token chính xác, còn keyword thì bỏ sót cách diễn đạt khác. Hybrid search dùng cả hai.
Câu query, gần với bản trong repository:
SELECT doc_key, title_vi, title_en, body_vi, body_en,
( 0.7 * COALESCE(1 - (embedding <=> $2::vector), 0)
+ 0.3 * ts_rank_cd(search_vector, websearch_to_tsquery('simple', $1))
)::double precision AS score
FROM policy_documents
WHERE is_published
AND (
search_vector @@ websearch_to_tsquery('simple', $1)
OR (embedding IS NOT NULL AND (embedding <=> $2::vector) <= 0.75)
)
ORDER BY score DESC, doc_key ASC
LIMIT 3;Nên đọc câu query này thành hai nửa.
Mệnh đề WHERE là cổng chặn. Một row chỉ thành ứng viên nếu text của nó khớp keyword, hoặc vector của nó nằm trong khoảng cách cosine 0.75 so với câu hỏi. <=> là cosine distance của pgvector: 0 là cùng hướng, 2 là ngược hướng, và 1 - distance là cosine similarity. Row nào không qua cổng thì bị loại hẳn. Chính điều này làm cho kết quả rỗng có thể xảy ra, và kết quả rỗng là thứ cho phép hệ thống nói "không biết".
SELECT và ORDER BY chỉ để xếp hạng. Điểm số pha 70% vector similarity với 30% keyword rank. COALESCE(…, 0) nghĩa là row chưa có vector chỉ cạnh tranh bằng keyword. doc_key dùng để phá thế hòa, giúp thứ tự luôn xác định: cùng một câu hỏi cho ra cùng các tài liệu theo cùng thứ tự, nên viết test được. LIMIT 3 giới hạn lượng chữ mô hình phải đọc.
0.7, 0.3 và 0.75 ở đâu ra?
Từ cảm tính, không phải từ đo đạc. Repository chưa có bộ đánh giá (evaluation set), nên không có gì chứng minh đây là giá trị đúng. Cách pha điểm còn có một lỗi đã biết. Không truyền cờ normalization thì ts_rank_cd không bị chặn trong khoảng 0–1, và giá trị của nó nằm trên một thang đo khác hẳn cosine similarity. Nên "70% ý nghĩa, 30% keyword" chỉ mô tả hệ số, không mô tả thứ phép tính thực sự đang cân. Cổng 0.75 cũng lỏng: nó cho qua mọi thứ có similarity từ 0.25 trở lên.
Cả hai đều có cách sửa chuẩn, tôi liệt kê ở cuối bài. Với một kho nhỏ thế này, cổng lỏng thường chỉ khiến thỉnh thoảng lọt thêm một tài liệu lạc đề. Tool có schema chặt ở phần sau sẽ ngăn chuyện đó biến thành một câu trả lời sai đầy tự tin.
Vì sao phía keyword cần keyword chứ không cần nguyên câu hỏi?
websearch_to_tsquery nối các từ không nằm trong ngoặc kép bằng AND. Đưa vào "hoàn tiền mất bao lâu vậy" thì tài liệu phải chứa đủ cả sáu từ mới khớp, và vì simple không bỏ stop word nào, "vậy" hay "mất" cũng bị tính. Thế nên một câu hỏi đầy đủ hiếm khi khớp được phía keyword.
Đó là lý do mô hình viết search query, chứ không phải người dùng. Phần mô tả input của tool xin "câu hỏi hoặc từ khóa về chính sách", và ví dụ đi kèm chỉ là một cụm hai, ba chữ. Mô hình đọc câu hỏi dài dòng của người dùng rồi truyền một cụm ngắn vào tool. LLM đóng vai query rewriter, còn phía vector bắt những cách diễn đạt mà keyword bỏ sót.
Index HNSW có giúp gì cho câu query này không?
Không, và nên biết vì sao. pgvector dùng index HNSW cho những query có dạng ORDER BY embedding <=> $q LIMIT n. Query này sắp xếp theo điểm pha trộn và lọc bằng ngưỡng khoảng cách nằm trong một vế OR, nên Postgres phải tính khoảng cách cho mọi row đã publish. Với vài tài liệu thì chẳng tốn gì. Với một triệu row thì nên tách ra: một query nearest-neighbour đi qua index, một query full-text đi qua index, rồi hợp nhất hai danh sách ứng viên.
Embedding API sập thì sao?
Câu hỏi nào cũng phải được embed, nghĩa là một API bên ngoài nằm ngay trên hot path. Embedding client trong repository cho mỗi lần thử timeout sau 10 giây, thử tối đa ba lần (mỗi lần một API key đã cấu hình), từ chối vector sai số chiều, và trả về null thay vì throw. Phần search rẽ nhánh dựa trên đó (đã rút gọn):
const vector = await embeddings.embedQuery(query); // readonly number[] | null
const rows = vector
? await documents.searchHybrid(query, vector, MAX_RESULTS)
: await documents.searchKeywordsOnly(query, MAX_RESULTS);Query chỉ có keyword là cùng câu SQL đó, bỏ phần vector. Chất lượng giảm (cách diễn đạt khác không còn khớp) nhưng tính năng vẫn chạy. Điều đáng chú ý là nó hỏng theo hướng nào: ít kết quả khớp hơn thì trợ lý nói "không biết" nhiều hơn. Nó chỉ dè dặt hơn, chứ không bao giờ bịa nhiều hơn.
Làm sao để hệ thống RAG biết nói "không biết"?
Cổng chặn nằm ở bước retrieval, không nằm ở mô hình. Trước khi mô hình thấy bất cứ thứ gì, hệ thống đã quyết định xong là có bằng chứng hay không. Nếu không có, mô hình nhận một kết quả có kiểu rõ ràng nói đúng như vậy.
Có hai kiểu "rỗng" khác nhau, và nhập nhằng giữa chúng là lỗi kinh điển:
- Không có gì khớp. Search đã chạy và không thấy gì liên quan. Câu trung thực là "không có chính sách nào về chuyện đó".
- Không search được. Database hoặc mạng gặp lỗi. Câu trung thực là "hiện tại chưa kiểm tra được".
Phiên bản sai là bắt mọi lỗi rồi trả về []. Thế là một sự cố hạ tầng biến thành một khẳng định: "chúng tôi không có chính sách đó". Repository tách hai trường hợp ra:
async getPolicy(input: unknown): Promise<PolicyToolOutput> {
const { query } = policyToolInput.parse(input);
try {
const vector = await this.embeddings.embedQuery(query);
const rows = await this.documents.search(query, vector, MAX_RESULTS);
if (rows.length === 0) {
return policyToolOutput.parse({
available: false,
policies: [],
reason: 'no_policy_match',
});
}
return policyToolOutput.parse({ available: true, policies: rows.map(toSummary) });
} catch (error: unknown) {
if (error instanceof ToolOutputValidationError) throw error; // đây là bug, không phải sự cố hạ tầng
return policyToolOutput.parse({
available: false,
policies: [],
reason: 'policy_unavailable',
});
}
}System prompt lo nửa còn lại: không bao giờ bịa nội dung chính sách, và khi tool báo không có dữ liệu khớp thì nói thẳng ra, rồi hướng người dùng tới bộ phận hỗ trợ. Câu chữ cố định phía server cũng tách y như vậy. Không khớp: "Mình không tìm thấy chính sách phù hợp với câu hỏi này." Sự cố: "Thông tin chính sách hiện chưa khả dụng. Vui lòng thử lại sau." Hai kiểu rỗng, hai câu trung thực khác nhau. Không hào nhoáng gì, nhưng đúng.
Vì sao retrieval nên là một tool có schema chặt?
Có hai cách nối retrieval vào: luôn search trước mọi lượt hội thoại, hoặc đưa search thành một tool để mô hình tự gọi. Trợ lý này có nhiều tool, trong đó có search danh mục sản phẩm, nên tra chính sách là một tool trong số đó. Mô hình quyết định khi nào câu hỏi liên quan đến chính sách. Server quyết định tool được phép trả về cái gì.
Hợp đồng là một cặp schema Zod:
import { z } from 'zod';
const MAX_RESULTS = 3;
const QUERY_MAX_LENGTH = 200;
const boundedText = (maxLength: number) => z.string().trim().min(1).max(maxLength);
export const policyToolInput = z.strictObject({
query: boundedText(QUERY_MAX_LENGTH).describe(
'A policy question or keywords, for example "refund policy"',
),
});
const policySummary = z.strictObject({
docKey: boundedText(80),
titleVi: boundedText(200),
titleEn: boundedText(200),
bodyVi: boundedText(10_000),
bodyEn: boundedText(10_000),
});
export const policyToolOutput = z.union([
z.strictObject({
available: z.literal(true),
policies: z.array(policySummary).min(1).max(MAX_RESULTS),
}),
z.strictObject({
available: z.literal(false),
policies: z.array(policySummary).max(0),
reason: z.enum(['invalid_arguments', 'policy_unavailable', 'no_policy_match']),
}),
]);
export type PolicyToolOutput = z.infer<typeof policyToolOutput>;Mỗi ràng buộc đóng lại một cánh cửa:
strictObjecttừ chối key lạ ở cả hai chiều. Mô hình không truyền được tham số mà tool không định nghĩa, và tool không làm lộ được cột thừa như điểm số hay id nội bộ.- Thành công thì phải có ít nhất một tài liệu. Trạng thái "thành công nhưng không thấy gì" không biểu diễn được, nên search rỗng bắt buộc phải trả về
no_policy_match. - Thất bại thì không được kèm tài liệu nào. "Lỗi rồi, nhưng vẫn gửi kèm vài tài liệu" cũng không biểu diễn được.
- Query tối đa 200 ký tự. Đó là một cụm từ tìm kiếm, không phải chỗ để dán cả tài liệu vào.
- Output được validate trước khi ra khỏi tool. Nếu tool lỡ tạo ra thứ gì nằm ngoài hợp đồng, đó là bug và nó throw. Mô hình không bao giờ thấy một kết quả hợp lệ một nửa.
Phía ghi của API cũng cần đúng kỷ luật này: làm sao để trạng thái sai không thể biểu diễn được, rồi để type system chặn thay mình. Bài idempotency key và optimistic locking làm điều tương tự cho retry.
Làm sao để trích dẫn không thể bị làm giả?
Cách dễ nghĩ tới nhất là bảo mô hình "kết thúc bằng [1], [2] trỏ tới nguồn". Vấn đề là mô hình viết trích dẫn y như cách nó viết mọi thứ khác. Nó có thể tạo ra một chú thích trông rất chuẩn nhưng chẳng trỏ tới đâu, hoặc trỏ nhầm tài liệu. Trích dẫn do mô hình viết là một lời khẳng định, không phải bằng chứng.
Vì vậy trích dẫn đi bên ngoài phần văn xuôi. doc_key là duy nhất, và nó chính là danh tính của nguồn. Khi tool chính sách trả kết quả, server phát một event có kiểu rõ ràng lên response stream:
await emit({
type: 'tool_result',
kind: 'policy_faq',
payload: output.policies, // đã validate: doc key, tiêu đề, nội dung
});Client hiển thị payload đó thành một thẻ nằm cạnh câu trả lời của mô hình. Người đọc thấy phần tóm tắt, và ngay bên cạnh là chính những tài liệu mô hình đã được đưa. Nếu phần tóm tắt lệch khỏi nguồn, độ lệch hiện ngay trên màn hình. Nói theo ngôn ngữ phòng thi: giám khảo lấy số trang từ sổ mượn sách của thư viện, chứ không lấy từ nét chữ của thí sinh.
Hai chi tiết nữa đi theo cùng tinh thần đó. Nếu nhà cung cấp mô hình lỗi sau khi tool đã trả tài liệu, server có thể trả lời thẳng từ kết quả của tool, dùng nội dung tài liệu đầu tiên cắt còn 1.000 ký tự, thay vì để mô hình ứng biến. Và payload của event trên stream được validate bằng đúng schema tài liệu mà output của tool dùng, nên client không thể nhận một dạng dữ liệu mà server chưa kiểm tra.
Cũng phải nói rõ giới hạn: cách này chứng minh mô hình đã thấy những tài liệu nào, chứ không chứng minh từng câu trong câu trả lời đều suy ra từ đó. Chưa có bước kiểm tra độ trung thực ở mức từng câu (một lượt mô hình thứ hai, hoặc một phép kiểm tra entailment với văn bản được trích).
Giữ embedding luôn mới khi tài liệu thay đổi thế nào?
Index là một bản sao, mà bản sao thì sẽ cũ đi. Hai kho dữ liệu được nạp theo hai cách khác nhau.
Tài liệu chính sách đến từ một seed script. Mỗi mục mang một content version và mã băm SHA-256 của payload, và lệnh upsert từ chối thay một row bằng bản có version thấp hơn.
Sản phẩm trong danh mục đi theo event từ service sở hữu chúng. Service trợ lý coi mỗi event là một tín hiệu, không phải dữ liệu. Nó ghi event vào một inbox theo event id (cùng id mà khác mã băm payload là lỗi, không phải bản trùng). Sau đó nó hỏi service sở hữu trạng thái hiện tại của sản phẩm bằng một lời gọi HTTP đọc thông thường, embed, rồi upsert sau một lớp chặn version. Viết quy tắc đó thành một câu lệnh thì như sau:
INSERT INTO item_documents (item_id, search_text, source_version, embedding, embedding_model)
VALUES ($1, $2, $3, $4::vector, $5)
ON CONFLICT (item_id) DO UPDATE
SET search_text = EXCLUDED.search_text,
source_version = EXCLUDED.source_version,
embedding = EXCLUDED.embedding,
embedding_model = EXCLUDED.embedding_model
WHERE item_documents.source_version <= EXCLUDED.source_version;Repository so sánh version bên trong một transaction chứ không đặt trong ON CONFLICT, nhưng quy tắc vẫn vậy: một event cũ đến muộn không thể ghi đè lên nội dung mới hơn. Những event đó từ đâu ra, và vì sao không cái nào thất lạc dọc đường, là chuyện của transactional outbox.
Một reconcile job chạy mỗi 15 phút (cron 0 */15 * * * *). Nó retry tối đa 50 event lỗi. Sau đó, nếu bảng tài liệu đang rỗng, nó backfill toàn bộ danh mục. Bước này phủ được cả những sản phẩm có từ trước khi consumer chạy lần đầu, lẫn những lần seed lại mà không phát event nào. Lúc service khởi động cũng kiểm tra y như vậy. Khi bảng đã có dữ liệu, bước backfill không làm gì cả và không tốn chút quota embedding nào.
Ở đây có một lỗ hổng mà tôi không muốn giấu. Khi một sản phẩm được embed đúng lúc embedding API đang sập, row của nó được lưu với vector NULL. Nó vẫn tìm được bằng keyword, đó là fallback đúng. Nhưng không có gì embed lại nó cho tới khi sản phẩm thay đổi lần nữa: reconcile job retry các event lỗi, không retry các vector bị thiếu. Cột embedding_model được lưu trên mọi row, đúng là thứ bạn cần khi đổi model (vector từ hai model khác nhau không so sánh được với nhau), nhưng chưa có job nào đọc nó. Phần quét còn thiếu khá ngắn:
SELECT item_id
FROM item_documents
WHERE embedding IS NULL OR embedding_model <> $1
ORDER BY item_id
LIMIT 50;Sao không chia nhỏ (chunk) tài liệu?
Lời khuyên phổ biến là cắt tài liệu dài thành từng đoạn rồi embed từng đoạn. Hệ thống này không làm vậy, và là cố ý.
Mỗi tài liệu chính sách đều ngắn và chỉ nói về một chủ đề. Cả tài liệu là đơn vị tự nhiên để trích dẫn: "xem chính sách hoàn tiền" là kiểu trích dẫn mà ai cũng tự kiểm tra được. Chunking còn có một cạnh sắc. Đường cắt có thể tách một quy định khỏi ngoại lệ của nó, khiến retriever trả về "được hoàn tiền trong thời hạn" mà thiếu mất câu "trừ trường hợp…" ở đoạn kế tiếp.
Tôi sẽ bắt đầu chunk khi một tài liệu nói về nhiều chủ đề, hoặc dài tới mức một vector duy nhất làm nhòe các phần của nó vào nhau. Lúc đó trích dẫn sẽ là document key cộng với một section anchor, và retrieval nên trả kèm các đoạn lân cận của chunk khớp.
Thiết kế này phải trả giá gì?
- Mỗi câu hỏi một lời gọi ra ngoài. Câu hỏi nào về chính sách cũng phải embed query trước. Với timeout 10 giây và tối đa ba lần thử, một embedding API chậm có thể đốt gần hết thời gian của một lượt trước khi fallback keyword kịp chạy.
- Hai ngôn ngữ trong một row. Sửa một chính sách là sửa hai lần, và search text trộn cả hai ngôn ngữ vào chung một túi từ.
- Postgres gánh phần toán vector. Ở quy mô này thì ổn, nhưng câu query viết như hiện tại sẽ không scale nếu không đổi cấu trúc.
Nếu làm lại, tôi sẽ làm khác gì?
Viết bộ đánh giá trước tiên. Tôi sẽ bắt đầu với ba mươi đến năm mươi câu hỏi thật, mỗi câu gắn nhãn doc_key mong đợi hoặc "không có", gồm cả những câu đáng lẽ phải trả về rỗng. Đo tỉ lệ trúng và tỉ lệ khớp nhầm, rồi mới chọn ngưỡng và trọng số. Thiếu bước đó thì mọi ngưỡng trong bài này đều là đoán.
Hợp nhất thứ hạng, đừng cộng điểm. Reciprocal Rank Fusion bỏ qua chuyện hai thang điểm không tương thích và chỉ dùng vị trí của tài liệu trong hai danh sách. Nó có trong thiết kế ban đầu, nhưng thứ được ship lại là tổng có trọng số. Tối thiểu thì cờ normalization 32 của ts_rank_cd (rank / (rank + 1)) sẽ đưa điểm keyword về khoảng 0–1.
Thêm job quét để embed lại các vector NULL và các row dùng model cũ, đồng thời cho phần embed câu hỏi một ngân sách thời gian chặt hơn phía tài liệu.
Cho phía keyword không phân biệt dấu bằng extension unaccent trong cấu hình text search, để tiếng Việt gõ không dấu vẫn khớp. Thiết kế ban đầu đã tính tới chuyện này, chỉ là chưa kịp đưa vào bản đầu tiên.
Tóm tắt
- Lúc nào cũng có một láng giềng gần nhất. Đặt cổng "có gì liên quan không?" vào mệnh đề
WHEREđể kết quả rỗng có thể xảy ra. - Hybrid search ghép vector (bắt cách diễn đạt khác) với full-text (bắt đúng từng chữ). Để mô hình tự rút câu hỏi thành một query keyword ngắn.
- "Không có gì khớp" và "không search được" là hai câu đúng khác nhau. Giữ chúng thành hai kết quả có kiểu riêng.
- Biến retrieval thành một tool chặt chẽ: nhánh thành công không thể rỗng, nhánh thất bại không thể mang theo tài liệu.
- Gửi trích dẫn dưới dạng dữ liệu (document key và nội dung) nằm cạnh văn xuôi, đừng bao giờ để mô hình tự viết chú thích.
- Giữ index luôn mới là cả một pipeline: inbox, lớp chặn version, reconcile job, và một job quét các vector chưa từng được ghi.
- Trọng số chưa tinh chỉnh chỉ là phỏng đoán. Dựng bộ đánh giá trước khi chỉnh bất cứ thứ gì.
Trích dẫn do mô hình viết là lời khẳng định, còn tài liệu do server trao tận tay mới là bằng chứng. Quy tắc đó cũng đúng với một coding agent báo "xong rồi": xem cách kiểm chứng việc AI agent đã làm.