Day 8:从零实现一个最小 RAG——Embedding、Chroma 与 DeepSeek 实战

31 阅读13分钟

Day 8:从零实现一个最小 RAG——Embedding、Chroma 与 DeepSeek 实战

AI 应用工程师学习路线 Day 8
从理解 RAG,到真正把 RAG 跑起来。

前几天已经学习了 RAG 的基本原理:

Document
   ↓
Chunk
   ↓
Embedding
   ↓
Vector DB
   ↓
Vector Search
   ↓
TopK
   ↓
Context
   ↓
LLM
   ↓
Answer

Day 8 的目标不再是继续停留在概念层面,而是:

不使用 LangChain、LlamaIndex 等框架,自己从零实现一个最小 RAG。

最终使用:

  • Python
  • SiliconFlow Embedding
  • BAAI/bge-large-zh-v1.5
  • Chroma
  • DeepSeek LLM

完成一个能够读取企业知识库、进行向量检索,并让 DeepSeek 基于检索结果回答问题的完整 RAG。


一、Day 8 的最终目标

我们希望实现这样的系统:

knowledge.txt
      ↓
    Chunk
      ↓
 Embedding
      ↓
   Chroma
      ↑
      │
 用户问题
      ↓
 Query Embedding
      ↓
 Vector Search
      ↓
    TopK
      ↓
   Context
      ↓
   DeepSeek
      ↓
    Answer

例如知识库中存在:

公司工资于每月15日发放。

公司工作时间为周一至周五,每天上午9点到下午6点。

员工入职满一年后可以享受带薪年假。

公司每周五下午提供下午茶。

公司的办公地点位于上海。

用户问:

公司提供下午茶吗?

系统应该:

  1. 将问题转换成向量
  2. 在 Chroma 中搜索相关知识
  3. 找到:
公司每周五下午提供下午茶。
  1. 将这个知识作为 Context
  2. 交给 DeepSeek
  3. 最终回答:
根据提供的知识,公司每周五下午提供下午茶。

二、为什么 Day 8 不直接使用 LangChain?

实际项目中当然可以使用 LangChain、LlamaIndex 等框架。

但是在学习阶段,我选择先不用框架。

原因很简单:

如果直接使用:

vectorstore.similarity_search(...)

我们可能只知道:

“调用这个方法就能搜索。”

但并不知道背后到底发生了什么。

所以 Day 8 先自己实现:

Embedding
↓
Vector
↓
Vector DB
↓
Similarity Search
↓
TopK
↓
Context
↓
LLM

把底层流程理解清楚之后,再学习框架,会更容易理解框架到底帮我们做了什么。


三、Embedding:把文本转换成向量

RAG 的第一步是 Embedding。

Embedding 可以理解为:

把文本转换成一组能够表示语义信息的数字。

例如:

公司什么时候发工资?

经过 Embedding 后,可能得到:

[  -0.0365,   0.0023,  -0.0120,  ...]

这就是一个向量。

本次使用的模型:

BAAI/bge-large-zh-v1.5

返回的向量维度:

1024

也就是说:

一句文本
   ↓
Embedding
   ↓
1024维向量

四、OpenAI SDK 不代表一定使用 OpenAI Embedding

这里有一个非常容易混淆的地方。

我们的代码使用:

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("SILICONFLOW_API_KEY"),
    base_url="https://api.siliconflow.cn/v1"
)

虽然使用的是 OpenAI Python SDK,但实际上请求发送到了:

SiliconFlow

原因是:

base_url="https://api.siliconflow.cn/v1"

因此:

OpenAI SDK 只是客户端调用方式,真正决定 Embedding 模型的是 API 服务地址和 model。

当前架构实际上是:

Python OpenAI SDK
       ↓
SiliconFlow API
       ↓
BAAI/bge-large-zh-v1.5
       ↓
1024维向量

五、为什么 Embedding 和 LLM 可以使用不同厂商?

本次项目使用:

Embedding
↓
SiliconFlow

而:

LLM
↓
DeepSeek

这是完全没有问题的。

因为 Embedding 和 LLM 是两个不同的职责。

可以理解成:

SiliconFlow
负责:
“帮我把问题转换成向量,并搜索相关知识”

而:

DeepSeek
负责:
“根据这些知识,帮我组织语言回答用户”

最终架构:

┌───────────────┐
                 │  SiliconFlow  │
                 │   Embedding   │
                 └───────┬───────┘
                         ↓
用户问题 ─────────→ Query Vector
                         ↓
                    Vector Search
                         ↓
                       TopK
                         ↓
                      Context
                         ↓
                 ┌───────┴───────┐
                 │    DeepSeek   │
                 │      LLM      │
                 └───────┬───────┘
                         ↓
                       Answer

这是生产环境中非常常见的架构。


六、一个非常重要的原则:知识库和查询必须使用同一个 Embedding 模型

假设知识库使用:

BAAI/bge-large-zh-v1.5

那么用户的问题也必须使用:

BAAI/bge-large-zh-v1.5

进行 Embedding。

原因是:

只有处于同一个向量空间中的向量,才有意义进行相似度比较。

例如:

知识:
公司每周五下午提供下午茶。

        ↓
Embedding A

用户问题:
公司提供下午茶吗?

        ↓
Embedding B

A 和 B 使用同一个模型生成,才能进行合理的相似度计算。

如果:

知识 → 模型A

问题 → 模型B

那么两个向量空间可能完全不同,直接比较没有意义。

因此:

如果更换 Embedding 模型,通常需要重新对整个知识库进行 Embedding 和索引。


七、Chunk:为什么不能把整个知识库做成一个向量?

假设有一个 10000 行的公司知识库。

最简单的想法是:

10000行文本
     ↓
Embedding
     ↓
一个巨大向量

这种方式存在很大的问题。

因为用户问:

公司年假是多少?

如果整个 10000 行文本只有一个向量,那么 Vector Search 最多只能告诉我们:

“这个大文档和问题比较相关。”

但它无法精确告诉我们:

“第 3421 行关于年假的内容最相关。”

所以需要进行 Chunk。

例如:

10000行文档
      ↓
切成很多 Chunk
      ↓
Chunk 1
Chunk 2
Chunk 3
...
Chunk N

每个 Chunk 单独进行 Embedding:

Chunk 1 → Vector 1
Chunk 2 → Vector 2
Chunk 3 → Vector 3
...

这样搜索的时候就可以定位到更细粒度的知识。


八、Day 8 的简单 Chunk 实现

我们的 knowledge.txt 使用空行分隔不同知识。

因此可以简单使用:

chunks = [
    chunk.strip()
    for chunk in text.split("\n\n")
    if chunk.strip()
]

例如:

公司工资于每月15日发放。

公司工作时间为周一至周五,每天上午9点到下午6点。

员工入职满一年后可以享受带薪年假。

最终变成:

[    "公司工资于每月15日发放。",    "公司工作时间为周一至周五,每天上午9点到下午6点。",    "员工入职满一年后可以享受带薪年假。"]

在真实项目中,Chunk 会复杂很多。

例如可能需要考虑:

  • Chunk Size
  • Chunk Overlap
  • Token 数量
  • Markdown 标题
  • Word/PDF 段落
  • 表格
  • HTML
  • 代码
  • 文档层级

这些会在后续 RAG 检索优化阶段继续学习。


九、Vector DB:为什么需要向量数据库?

有了 Embedding 之后,我们就有:

文本
 ↓
向量

例如:

{
    "text": "公司工资于每月15日发放。",
    "vector": [...]
}

但是如果数据越来越多:

100条
1000条
10万条
100万条

我们不能每次查询都自己:

for document in documents:
    cosine_similarity(...)

因此需要 Vector DB。

常见的 Vector DB 包括:

  • Chroma
  • Milvus
  • Qdrant
  • Weaviate
  • pgvector

Day 8 选择:

Chroma

因为它简单,非常适合学习和快速搭建原型。


十、Chroma 的基本使用

首先创建持久化数据库:

import chromadb

client = chromadb.PersistentClient(
    path="./chroma_db"
)

这里:

./chroma_db

意味着数据会保存到本地。

所以 Python 程序退出之后,数据仍然存在。


十一、把 Embedding 写入 Chroma

首先对所有 Chunk 进行 Embedding:

response = embedding_client.embeddings.create(
    model=EMBEDDING_MODEL,
    input=chunks,
)

embeddings = [
    item.embedding
    for item in response.data
]

然后写入 Chroma:

collection.add(
    ids=[
        f"doc_{index}"
        for index in range(len(chunks))
    ],
    documents=chunks,
    embeddings=embeddings,
)

这里非常重要。

Chroma 中实际上保存了:

ID
+
原始文本
+
向量

也就是说:

向量负责找,原文负责回答。

Vector Search 找到的是向量对应的数据,但最后交给 LLM 的必须是原始文本。


十二、为什么 Chroma 不应该自动帮我们做 Embedding?

第一次使用 Chroma 时,我们写了:

collection.add(
    ids=...,
    documents=documents
)

没有提供:

embeddings=...

结果 Chroma 尝试使用自己的默认 Embedding 模型。

它会尝试下载:

ONNXMiniLM_L6_V2

最终因为网络问题出现:

httpx.ConnectTimeout

这其实给我们上了一课:

Vector DB 和 Embedding 模型是两个不同的东西。

Chroma 是:

Vector DB

它负责:

存储
搜索
管理向量

Embedding 模型负责:

文本 → 向量

所以这次我们明确使用:

embeddings=embeddings

把 SiliconFlow 生成的向量直接交给 Chroma。

架构变成:

文本
 ↓
SiliconFlow Embedding
 ↓
向量
 ↓
Chroma

十三、为什么重新构建知识库时需要删除旧 Collection?

最初使用:

collection = client.get_or_create_collection(
    name="company_knowledge"
)

然后:

collection.add(...)

如果重复执行脚本,就可能不断向已有 Collection 添加数据。

于是出现了:

公司工资于每月15日发放。
公司工资于每月15日发放。

这种重复数据。

学习阶段,我们采用最简单的方案:

try:
    client.delete_collection(
        name="company_knowledge"
    )
except Exception:
    pass

collection = client.create_collection(
    name="company_knowledge"
)

这样每次执行构建脚本都会:

删除旧知识库
      ↓
创建新知识库
      ↓
读取 knowledge.txt
      ↓
Chunk
      ↓
Embedding
      ↓
写入 Chroma

这种方式适合学习和 Demo。

但是生产环境不能每次都删除整个知识库。

生产环境通常应该做到:

新增文件
   ↓
只处理新增文件
   ↓
Chunk
   ↓
Embedding
   ↓
写入 Vector DB

后续会学习增量索引。


十四、查询阶段:用户问题也需要 Embedding

知识库构建完成以后:

knowledge.txt
 ↓
Chunk
 ↓
Embedding
 ↓
Chroma

接下来就是查询。

用户输入:

公司提供下午茶吗?

不能直接拿字符串和向量比较。

需要:

response = embedding_client.embeddings.create(
    model=EMBEDDING_MODEL,
    input=question,
)

query_vector = response.data[0].embedding

于是:

用户问题
   ↓
Embedding
   ↓
Query Vector

十五、使用 Chroma 进行 Vector Search

然后:

results = collection.query(
    query_embeddings=[query_vector],
    n_results=5,
)

这里:

n_results=5

就是我们之前学习过的:

TopK

意思是:

找出最相关的 5 条知识。


十六、Chroma 返回的是 distance

这里还有一个容易混淆的地方。

之前我们自己计算:

cosine similarity

通常:

越大越相似

例如:

0.98
0.92
0.71

但是 Chroma 查询结果返回的是:

distance

通常:

越小越相似

例如:

0.87
1.10
1.25

所以不要把:

distance

直接理解成:

similarity

这是两个不同概念。


十七、TopK 暴露出来的第一个真实 RAG 问题

我们第一次查询:

公司提供下午茶吗?

当:

n_results=3

时,返回的是:

公司工作时间……
公司工资……
公司工资……

却没有:

公司每周五下午提供下午茶。

但是知识库明明存在这条信息。

为什么?

因为:

Vector Search
      ↓
Top 3
      ↓
下午茶 Chunk 没进入 Top 3
      ↓
LLM 根本没有看到正确答案

后来改成:

n_results=5

重新构建干净的知识库后:

公司每周五下午提供下午茶。
公司工作时间……
公司工资……
员工年假……
办公地点……

终于把正确答案召回了。


十八、这就是 Recall

这个实验非常好地验证了 Day 7 学到的:

Recall(召回率)关注的是:正确答案有没有被召回。

TopK 太小:

TopK = 3

可能:

正确答案 ❌

TopK 大一点:

TopK = 5

可能:

正确答案 ✅

但是 TopK 也不是越大越好。

例如:

TopK = 50

可能把大量无关内容一起交给 LLM。

于是又产生:

噪声
Token 消耗
上下文变长
LLM 注意力分散

所以生产环境常见的思路是:

Vector Search
      ↓
Top 20 / Top 50
      ↓
Rerank
      ↓
Top 3 / Top 5
      ↓
LLM

这也是 Day 9 可以继续学习的内容。


十九、为什么“检索不到”比“LLM 不会回答”更重要?

假设知识库中有:

公司每周五下午提供下午茶。

但是 Vector Search 没有找到。

那么发送给 DeepSeek 的 Context 可能是:

公司工作时间为周一至周五,每天上午9点到下午6点。

公司工资于每月15日发放。

员工入职满一年后可以享受带薪年假。

此时 DeepSeek 回答:

根据提供的知识,没有找到关于公司是否提供下午茶的信息。

这个回答其实是正确的。

因为 DeepSeek 根本没有看到:

公司每周五下午提供下午茶。

所以:

LLM 回答错误,很多时候并不是 LLM 的问题,而是 Retrieval 出了问题。

这是 RAG 系统非常重要的工程思想。


二十、Context:把检索结果交给 LLM

Chroma 返回:

results["documents"][0]

得到:

documents = results["documents"][0]

然后拼接:

context = "\n".join(documents)

例如:

公司每周五下午提供下午茶。
公司工作时间为周一至周五,每天上午9点到下午6点。
公司工资于每月15日发放。

这个就是:

Context

也就是提供给 LLM 的上下文。


二十一、RAG Prompt

然后将 Context 和用户问题一起发送给 DeepSeek:

prompt = f"""
你是一个企业知识库助手。

请严格根据下面提供的知识回答用户问题。

要求:
1. 只能使用提供的知识回答。
2. 如果知识中没有相关信息,请明确告诉用户知识库中没有找到相关信息。
3. 不要根据自己的知识进行猜测或编造。

知识:
{context}

用户问题:
{question}
"""

这个 Prompt 非常重要。

因为我们希望 LLM:

只根据检索到的知识回答

而不是:

根据自己训练过程中学到的知识自由回答

二十二、最终调用 DeepSeek

使用 OpenAI SDK:

deepseek_client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com",
)

然后:

response = deepseek_client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "user",
            "content": prompt,
        }
    ],
)

获取答案:

answer = response.choices[0].message.content

至此,一个最小 RAG 就完成了。


二十三、完整的 RAG 数据流

现在可以把整个 Day 8 流程分成两个阶段。

第一阶段:知识库构建

这个阶段不是用户每次查询都执行。

knowledge.txt
      ↓
    Chunk
      ↓
Embedding
      ↓
   Vector
      ↓
   Chroma

这是:

离线索引阶段


第二阶段:用户查询

用户每次提问时执行:

用户问题
      ↓
Query Embedding
      ↓
Chroma Vector Search
      ↓
TopK
      ↓
Context
      ↓
DeepSeek
      ↓
Answer

这是:

在线查询阶段

这两个阶段一定要分清楚。


二十四、最终项目结构

Day 8 最终可以形成这样的项目:

day8/
│
├── .env
├── .env.example
├── .gitignore
├── requirements.txt
│
├── knowledge.txt
│
├── file_rag_demo.py
├── query_demo.py
│
└── chroma_db/

其中:

file_rag_demo.py

负责:

构建知识库。

而:

query_demo.py

负责:

查询知识库并调用 DeepSeek。


二十五、Day 8 最重要的几个结论

经过 Day 8,应该真正理解下面这些关系。

1. Embedding

文本 → 向量

用于表达语义。


2. Vector DB

向量 + 原文 + Metadata

用于存储和检索。


3. Chunk

大文档 → 小知识块

提高检索粒度。


4. TopK

从搜索结果中取前 K 条

K 太小:

Recall ↓

K 太大:

噪声 ↑

5. Context

Vector DB 检索出来的知识

最终提供给 LLM。


6. LLM

Context + Question
        ↓
      Answer

LLM 的主要任务是:

理解检索结果,并生成自然语言答案。


二十六、Day 8 最核心的一句话

如果只记住一句话,我认为是:

Vector DB 负责找,LLM 负责答。

进一步完整一点:

Embedding
负责把文本变成可比较的向量

Vector DB
负责存储和检索向量

TopK
决定拿多少候选知识

Context
把检索结果交给 LLM

LLM
负责理解 Context 并生成答案

最终:

RAG
               │
       ┌───────┴────────┐
       │                │
   知识库构建          用户查询
       │                │
    Document          Question
       ↓                ↓
     Chunk           Embedding
       ↓                ↓
   Embedding        Vector Search
       ↓                ↓
   Vector DB           TopK
       │                ↓
       │             Context
       │                ↓
       └────────────→  LLM
                         ↓
                       Answer

二十七、Day 8 实战总结

Day 8 最大的变化是:

从“我知道什么是 RAG”,进入到“我可以自己写一个 RAG”。

虽然现在这个版本还非常简单:

  • 文档只有 TXT
  • Chunk 规则很简单
  • Vector DB 使用本地 Chroma
  • 没有 Rerank
  • 没有 Hybrid Search
  • 没有 Metadata Filter
  • 没有权限控制
  • 没有增量索引
  • 没有生产级异常处理

但是核心链路已经完整:

Document
   ↓
Chunk
   ↓
Embedding
   ↓
Chroma
   ↓
Vector Search
   ↓
TopK
   ↓
Context
   ↓
DeepSeek
   ↓
Answer

这条链路就是后面学习各种 RAG 框架的基础。


Day 8 → Day 9

Day 8 解决的是:

RAG 是怎么跑起来的?

Day 9 可以进一步解决:

为什么 RAG 有时候明明有答案,却搜不到?

重点进入 RAG 的检索质量优化:

Chunk Size
      ↓
Chunk Overlap
      ↓
TopK
      ↓
Recall
      ↓
Precision
      ↓
Rerank
      ↓
Metadata Filter
      ↓
Hybrid Search

也就是说:

Day 8 学会“造一台 RAG 机器”,Day 9 开始学习“怎么让这台机器搜得更准”。

Day 8 这篇建议你直接作为学习路线里的正式博客保存。尤其是最后的**“知识库构建阶段 vs 用户查询阶段”和“Vector DB 负责找,LLM 负责答”**,这两个概念后面做 Agent、RAG 框架时都会反复用到。