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
└─────────────────────────────────────────────────────────────┘