1
1. 知识截止日期
2
 - GPT-4 的知识截止于 2023 年 10 月
3
 - 之后发生的事，它不知道
4
 - Claude 的知识也有截止日期
5

6
2. 私有知识缺失
7
 - 企业内部文档、产品手册
8
 - 个人笔记、专属资料
9
 - 未公开的研究成果
10
 - 它全不知道
11

12
3. 幻觉问题
13
 - 不知道的它可能编
14
 - 编得还挺像真的
15
 - 关键场景风险大

1
知识可更新：更新文档即可，无需重新训练
2
可追溯来源：知道答案来自哪个文档
3
成本低：不需要微调，只需存储和检索
4
幻觉减少：基于真实文档回答
5
适合企业：私有数据不出本地

1
┌─────────────────────────────────────────────────────────────┐
2
│ RAG 工作流程 │
3
├─────────────────────────────────────────────────────────────┤
4
│ │
5
│ 【离线阶段：建知识库】 │
6
│ │
7
│ 文档 → 分块 → 向量化 → 存入向量数据库 │
8
│ │
9
│ │
10
│ 【在线阶段：回答问题】 │
11
│ │
12
│ 问题 → 向量化 → 检索相关文档 → 问题+文档喂给 LLM → 回答 │
13
│ │
14
└─────────────────────────────────────────────────────────────┘

1
分块策略：
2

3
1. 固定长度分块
4
 - 每块 512/1024 Token
5
 - 简单粗暴
6
 - 可能切断语义
7

8
2. 语义分块
9
 - 按段落、章节分
10
 - 语义完整
11
 - 块大小不均
12

13
3. 滑动窗口分块
14
 - 块之间有重叠（10-20%）
15
 - 减少边界信息丢失
16
 - 推荐方案
17

18
最佳实践：
19
- 块大小：512-1024 Token
20
- 重叠：10-20%
21
- 保留元数据（来源、标题、页码）

1
用户问题："公司年假多少天？"
2
 ↓ 向量化
3
 ↓ 检索（计算余弦相似度）
4
找到最相似的 3 个块：
5
- "入职满一年享有 5 天年假..."
6
- "年假最多累计 15 天..."
7
- "年假需提前 3 天申请..."

1
根据以下参考信息回答问题：
2

3
参考信息：
4
1. "入职满一年享有 5 天年假..."
5
2. "年假最多累计 15 天..."
6
3. "年假需提前 3 天申请..."
7

8
问题：公司年假多少天？
9

10
答案：根据公司规定，入职满一年享有 5 天年假，最多累计 15 天。
11
 如需休假，请提前 3 天申请。

1
# 安装依赖
2
# pip install langchain langchain-openai chromadb
3

4
from langchain.text_splitter import RecursiveCharacterTextSplitter
5
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
6
from langchain_community.vectorstores import Chroma
7
from langchain.chains import RetrievalQA
8
from langchain_community.document_loaders import TextLoader
9

10
# 1. 加载文档
11
loader = TextLoader("company_policy.txt")
12
documents = loader.load()
13

14
# 2. 分块
15
text_splitter = RecursiveCharacterTextSplitter(
16
 chunk_size=500,
17
 chunk_overlap=50,
18
 length_function=len
19
)
20
chunks = text_splitter.split_documents(documents)
21
print(f"分成 {len(chunks)} 个块")
22

23
# 3. 向量化并存入数据库
24
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
25
vectorstore = Chroma.from_documents(
26
 documents=chunks,
27
 embedding=embeddings,
28
 persist_directory="./chroma_db"
29
)
30

31
# 4. 创建检索器
32
retriever = vectorstore.as_retriever(
33
 search_type="similarity",
34
 search_kwargs={"k": 3} # 返回最相似的 3 个块
35
)
36

37
# 5. 创建问答链
38
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
39
qa_chain = RetrievalQA.from_chain_type(
40
 llm=llm,
41
 chain_type="stuff",
42
 retriever=retriever,
43
 return_source_documents=True
44
)
45

46
# 6. 提问
47
question = "公司的年假政策是什么？"
48
result = qa_chain({"query": question})
49

50
print("回答:", result["result"])
51
print("\n 来源文档:")
52
for doc in result["source_documents"]:
53
 print(f"- {doc.metadata.get('source', 'unknown')}")

1
# 安装依赖
2
# pip install llama-index llama-index-embeddings-openai llama-index-llms-openai
3

4
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
5
from llama_index.embeddings.openai import OpenAIEmbedding
6
from llama_index.llms.openai import OpenAI
7

8
# 配置
9
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
10
Settings.llm = OpenAI(model="gpt-4o-mini")
11

12
# 1. 加载文档
13
documents = SimpleDirectoryReader("./docs").load_data()
14

15
# 2. 创建索引
16
index = VectorStoreIndex.from_documents(documents)
17

18
# 3. 创建查询引擎
19
query_engine = index.as_query_engine(
20
 similarity_top_k=3,
21
 response_mode="compact"
22
)
23

24
# 4. 提问
25
response = query_engine.query("公司的报销流程是什么？")
26
print(response)
27

28
# 5. 查看来源
29
for node in response.source_nodes:
30
 print(f"来源: {node.node.metadata}")
31
 print(f"相关度: {node.score}")

1
import chromadb
2
from openai import OpenAI
3

4
# 初始化
5
client = OpenAI()
6
chroma_client = chromadb.Client()
7
collection = chroma_client.create_collection("documents")
8

9
def get_embedding(text):
10
 response = client.embeddings.create(
11
 model="text-embedding-3-small",
12
 input=text
13
 )
14
 return response.data[0].embedding
15

16
# 添加文档
17
docs = [
18
 "公司年假政策：入职满一年享有 5 天年假。",
19
 "报销流程：先提交申请，领导审批后财务打款。",
20
 "工作时间：上午 9 点到下午 6 点，午休 12-1 点。"
21
]
22

23
for i, doc in enumerate(docs):
24
 collection.add(
25
 ids=[f"doc_{i}"],
26
 embeddings=[get_embedding(doc)],
27
 documents=[doc]
28
 )
29

30
# 检索
31
query = "年假有多少天？"
32
results = collection.query(
33
 query_embeddings=[get_embedding(query)],
34
 n_results=2
35
)
36

37
print("相关文档:", results["documents"])
38

39
# 生成答案
40
context = "\n".join(results["documents"][0])
41
response = client.chat.completions.create(
42
 model="gpt-4o-mini",
43
 messages=[
44
 {"role": "system", "content": f"根据以下信息回答问题:\n{context}"},
45
 {"role": "user", "content": query}
46
 ]
47
)
48
print("回答:", response.choices[0].message.content)

1
向量检索：
2
语义相似性好
3
可能漏精确匹配（产品名、型号）
4

5
关键词检索（BM25）：
6
精确匹配
7
可能漏语义相关
8

9
混合检索 = 两者结合
10
召回率提升 10-30%

1
from langchain.retrievers import EnsembleRetriever
2
from langchain_community.retrievers import BM25Retriever
3

4
# 创建两种检索器
5
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
6
bm25_retriever = BM25Retriever.from_documents(chunks)
7
bm25_retriever.k = 5
8

9
# 混合检索
10
ensemble_retriever = EnsembleRetriever(
11
 retrievers=[bm25_retriever, vector_retriever],
12
 weights=[0.4, 0.6] # BM25 占 40%，向量占 60%
13
)

1
from cohere import Client
2

3
# 使用 Cohere Rerank
4
cohere_client = Client("your-api-key")
5

6
def rerank(query, documents, top_n=5):
7
 results = cohere_client.rerank(
8
 query=query,
9
 documents=documents,
10
 model="rerank-multilingual-v2.0",
11
 top_n=top_n
12
 )
13
 return [documents[r.index] for r in results]

1
原问题："这个怎么办"（太模糊）
2
改写后："产品 X 的错误代码 Y 如何解决"（更精确）
3

4
方法：
5
1. 让 LLM 改写问题
6
2. 提取关键词
7
3. 补充上下文

1
def rewrite_query(original_query, chat_history):
2
 prompt = f"""
3
 对话历史：{chat_history}
4
 当前问题：{original_query}
5

6
 请将问题改写得更加具体和易于检索。
7
 只输出改写后的问题，不要其他内容。
8
 """
9
 response = client.chat.completions.create(
10
 model="gpt-4o-mini",
11
 messages=[{"role": "user", "content": prompt}]
12
 )
13
 return response.choices[0].message.content

1
def hyde_retrieval(query, retriever, llm):
2
 # 1. 生成假设答案
3
 prompt = f"请为以下问题生成一个可能的答案：\n{query}"
4
 hypo_answer = llm.invoke(prompt)
5

6
 # 2. 用假设答案检索
7
 results = retriever.get_relevant_documents(hypo_answer)
8
 return results

1
在提示词中加入：
2

3
"请在回答中标注信息来源，格式：[来源 1]
4
如果参考信息中没有答案，请直接说'根据现有信息无法回答'"

1
在提示词中加入：
2

3
"如果参考信息中没有答案，请直接说'根据现有信息无法回答'，不要编造。
4
答案必须基于参考信息，不要使用你的预训练知识。"

1
适合 GraphRAG：
2
- 需要理解实体关系的问题
3
- 多跳推理（"A 的老板的部门是谁？"）
4
- 复杂知识结构（法律条文引用、产品依赖关系）
5

6
不需要 GraphRAG：
7
- 简单问答
8
- 知识关系简单
9
- 成本敏感（GraphRAG 成本更高）

1
主流框架：
2
- Microsoft GraphRAG：官方开源，功能完整
3
- LlamaIndex KnowledgeGraphIndex：集成在 LlamaIndex 中
4
- Neo4j + LangChain：用图数据库存储

1
┌─────────────────────────────────────────────────────────────┐
2
│ RAG 完整架构 │
3
├─────────────────────────────────────────────────────────────┤
4
│ │
5
│ ┌─────────────────────────────────────────────────────┐ │
6
│ │ 离线：知识库构建 │ │
7
│ │ │ │
8
│ │ 原始文档 ──→ 分块 ──→ 向量化 ──→ 向量数据库 │ │
9
│ │ │ │ │ │ │
10
│ │ Chunker Embedding VectorDB │ │
11
│ └─────────────────────────────────────────────────────┘ │
12
│ │
13
│ ┌─────────────────────────────────────────────────────┐ │
14
│ │ 在线：问答流程 │ │
15
│ │ │ │
16
│ │ 用户问题 ──→ 向量化 ──→ 相似度检索 ──→ 构建 Prompt │ │
17
│ │ │ │ │ │ │ │
18
│ │ │ Embedding VectorDB Context │ │
19
│ │ │ │ │ │
20
│ │ └──────────────────────────────────┘ │ │
21
│ │ ↓ │ │
22
│ │ LLM 生成 │ │
23
│ │ ↓ │ │
24
│ │ 回答 │ │
25
│ └─────────────────────────────────────────────────────┘ │
26
│ │
27
└─────────────────────────────────────────────────────────────┘