用 DeepSeek 向量构建自定义知识库：从零到可用的语义检索系统

在大模型与 RAG（Retrieval-Augmented Generation，检索增强生成）盛行的时代，知识库已经成为让 AI 系统准确检索事实信息的关键基础设施。

在这里，知识库通常指一组经过处理的文档或数据，它们被转换成 AI 易于搜索的形式——最常见的方式就是把文本转成数值向量（embeddings），用于语义检索。

与传统关键词搜索不同，向量表示的是“含义”而不是“词面”。文本被映射到高维向量空间后，即便查询语句与文档没有任何相同关键词，只要语义接近，也能被检索出来。这种语义检索能力对问答系统、文档分析、智能客服和 AI 助手等场景至关重要。

本文将围绕 DeepSeek 的嵌入模型（embeddings） 展开，讲解如何用它来构建自定义知识库，也就是搭建你自己的语义搜索系统或 AI Copilot。

我们会依次介绍：

DeepSeek 嵌入模型的特点与使用方式
环境与依赖配置（云端 API、本地推理）
从文档加载、切分、向量化到向量数据库入库的完整流程
如何基于向量库做语义检索与问答
典型应用场景与性能优化建议

最终，你会看到：DeepSeek 的嵌入能力完全可以作为 OpenAI Embeddings 的替代方案，用于构建高效、可扩展的知识驱动应用。

一、DeepSeek Embeddings 概览

1. 什么是 DeepSeek 向量嵌入？

DeepSeek 提供高质量的嵌入模型，可以把文本（句子、段落甚至整篇文档）编码成定长的稠密向量，捕捉其语义信息。

例如，默认的嵌入模型 deepseek-embedding-v2 会把任意输入文本转换为一个 768 维向量（768 个浮点数）。每一维都可以理解为文本在某个“语义特征”上的投影。

语义相近的文本会被映射到向量空间中彼此靠近的位置（常用余弦相似度或内积来衡量）。因此，DeepSeek 向量特别适合：

语义搜索：根据含义而非关键词检索相关文档
文档聚类与分类：按语义相似度自动分组、发现主题
推荐系统：根据语义相似度推荐相似内容、相似问题
AI 助手与聊天机器人：把历史对话或知识片段向量化，作为“长期记忆”随时检索

2. 哪些 DeepSeek 模型可以生成向量？

DeepSeek 提供专门的嵌入模型，通过 API 即可调用：

主力模型：deepseek-embedding-v2
- 专为嵌入任务设计
- 默认输出 768 维向量
- 类似于 OpenAI 的 text-embedding-ada-002 在生态中的定位

DeepSeek 的大语言模型（如 DeepSeek-V3、R1 系列）理论上也可以通过提取隐层状态来生成向量，但：

它们并非为嵌入任务优化
一致性和检索效果通常不如专门的嵌入模型

社区实践普遍建议：检索任务优先使用专用嵌入模型，因此本文聚焦 deepseek-embedding-v2。

3. 输出格式与维度

DeepSeek 嵌入 API 的返回结果是一个 JSON，其中包含每段输入文本对应的向量。例如：

{
  "data": [
    {"embedding": [0.123, 0.456, ..., -0.078], "index": 0},
    {"embedding": [0.234, -0.157, ..., 0.489], "index": 1}
  ]
}

embedding：一个浮点数组，即文本的向量表示
index：对应输入文本在请求中的顺序

deepseek-embedding-v2 默认输出长度为 768 的向量。与 OpenAI ada-002 的 1536 维相比，768 维在表达能力与存储成本之间取得了不错的平衡。

4. 如何访问 DeepSeek 嵌入模型？

DeepSeek 嵌入主要有两种使用方式：

云端 API 调用
- 基础 URL：https://api.deepseek.com/v1
- 嵌入接口：POST https://api.deepseek.com/v1/embeddings
- 请求体需指定模型名（如 "model": "deepseek-embedding-v2"）和 input 文本数组
- 使用 Bearer Token 方式在 Authorization 头中携带 API Key
本地自托管（Self-hosted）
- DeepSeek 部分模型权重已开源，可在本地 GPU 上运行
- 例如较小的 DeepSeek-R1 / R1-Lite 可以在单机高端 GPU 上部署
- 可配合 Ollama 等工具，通过本地 HTTP 接口获取向量
- 本地部署无需 API 费用，延迟更低，但需要足够硬件资源

后文会分别展开云端与本地的配置方式。

二、环境搭建与访问方式

构建基于 DeepSeek 的知识库，首先要解决两件事：

如何拿到文本的向量（云端 API 或本地模型）
如何存储和检索这些向量（向量数据库或索引库）

1. 使用 DeepSeek 云端 API 获取向量

云端 API 是最简单的起步方式。你需要：

在 DeepSeek 平台注册并获取 API Key
使用 OpenAI 兼容格式调用嵌入接口

示例（Python + requests）：

import requests

API_URL = "https://api.deepseek.com/v1/embeddings"
API_KEY = "YOUR_API_KEY"

texts = [
    "Artificial intelligence is transforming industries.",
    "Vector databases enable efficient semantic search."
]

payload = {
    "model": "deepseek-embedding-v2",
    "input": texts
}
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

response = requests.post(API_URL, json=payload, headers=headers)
data = response.json()

embeddings = [item["embedding"] for item in data["data"]]
print(f"Got {len(embeddings)} embeddings of length {len(embeddings[0])}.")

要点：

DeepSeek API 与 OpenAI API 几乎完全兼容，可以直接复用 OpenAI 的 SDK，只需改 base URL 和 Key
支持批量输入 input，一次请求向量化多段文本，提高吞吐
注意控制单次文本长度与总 tokens 数量，长文建议先切分

2. 本地运行 DeepSeek 模型（Ollama / Hugging Face）

如果你希望：

避免外部网络依赖
数据必须留在内网或本地
控制成本（大量向量化任务）

可以考虑本地部署 DeepSeek 模型。

常见方式：

Ollama 本地服务

安装并启动 Ollama（默认监听 localhost:11434）
通过 ollama pull deepseek-r1 拉取 DeepSeek-R1 模型
使用 ChromaDB 等工具的 OllamaEmbeddingFunction 作为嵌入函数

示例（伪代码）：

import chromadb
from chromadb.utils.embedding_functions import OllamaEmbeddingFunction

client = chromadb.Client()
ollama_ef = OllamaEmbeddingFunction(
    url="http://localhost:11434",
    model_name="deepseek-r1"
)
collection = client.create_collection(
    name="deepseek_documents",
    embedding_function=ollama_ef
)

之后向 collection 添加文档时，Chroma 会自动调用本地 DeepSeek 模型生成向量。

Hugging Face Transformers
- 对于已在 Hugging Face 发布的 DeepSeek 模型，可用 transformers 加载
- 若有专门的嵌入 checkpoint，可用 SentenceTransformer 或自定义头部生成向量

硬件注意事项：

R1 20B 或 R1-Lite 级别模型通常需要 20GB+ VRAM 的 GPU 才能流畅运行
更大的 DeepSeek-V2 / V3 适合通过云端 API 或多卡/TPU 集群推理
若只有 CPU，可考虑先用小型开源句向量模型做本地实验，或直接使用 DeepSeek 云端嵌入服务

3. 依赖库与工具

构建完整知识库流水线，常用到：

DeepSeek API 客户端：
- Python 可直接用 requests 或 OpenAI 官方 SDK（改 base URL）
- Java 可使用 deepseek4j SDK
Hugging Face Transformers：
- 用于本地加载 DeepSeek 或其他模型
LangChain：
- 提供文档加载、切分、检索器、RAG 链路等高层封装
- 有 langchain-deepseek 集成，可把 DeepSeek 作为 LLM 使用
向量数据库 / 向量索引：
- FAISS：高性能本地向量检索库，适合内存索引和大规模向量
- ChromaDB：轻量级开源向量数据库，易于集成与持久化
- Qdrant：独立服务型向量数据库，支持过滤、持久化和生产级部署
其他工具：
- PDF 解析：PyMuPDF、pdfplumber、pypdf
- HTML 解析：BeautifulSoup
- 文本切分：LangChain text_splitter 或自定义脚本
- Web / API：FastAPI、Flask、Streamlit 等

示例安装命令：

pip install transformers langchain langchain-deepseek chromadb faiss-cpu sentence-transformers numpy

如需 Qdrant，再安装 qdrant-client 并部署 Qdrant 服务。

三、从零搭建自定义知识库：完整流程

一个典型的 DeepSeek 知识库流水线包含五步：

加载文档（PDF、HTML、Markdown、数据库等）
文本切分（chunking）
生成向量（DeepSeek Embeddings）
存入向量数据库（FAISS / Chroma / Qdrant）
语义检索与问答

下面逐步拆解。

步骤 1：加载文档

首先收集你希望纳入知识库的内容：

PDF 手册、报告
Markdown / 文本文件
网页 HTML
数据库记录或 API 返回数据

不同格式需要不同解析方式，例如：

import os
from bs4 import BeautifulSoup

docs = []

# 读取文件夹中的 .txt 文本
for filename in os.listdir("knowledge_base_docs"):
    if filename.endswith(".txt"):
        with open(os.path.join("knowledge_base_docs", filename), encoding="utf-8") as f:
            text = f.read()
        docs.append(text)

# 读取 HTML 文件
with open("page.html", encoding="utf-8") as f:
    html = f.read()

soup = BeautifulSoup(html, "lxml")
text = soup.get_text(separator=" ")  # 提取可见文本
docs.append(text)

实践中，你也可以使用 LangChain 的各种 DocumentLoader，直接加载 PDF、Notion、网页等。

清洗文本 很重要：

去掉导航栏、页脚、广告等无关内容
统一空白符、去除多余换行

目标是得到一个“文档文本列表”，每个元素是一篇相对干净的原始文本。

步骤 2：文本切分（Chunking）

直接对整篇长文做嵌入通常不是好主意：

可能超过模型输入上限
向量会混合过多主题，降低检索精度

更好的做法是：把文档切分成较小的语义单元（chunk），每个 chunk 表示一段相对完整的内容。

常见策略：

按段落或标题切分
按字符/Token 数切分（如每 500 字符或 500 tokens）
使用滑动窗口 + 重叠（overlap），保证跨段落的上下文连续

使用 LangChain 的 RecursiveCharacterTextSplitter 示例：

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)

all_chunks = []
for doc in docs:
    chunks = splitter.split_text(doc)
    all_chunks.extend(chunks)

print(f"Created {len(all_chunks)} chunks from {len(docs)} documents.")

参数建议：

chunk_size：可从 200–500 字（或等价 tokens）起步
chunk_overlap：适当重叠（如 10–20%）有助于保留跨段落语境

DeepSeek 嵌入模型可以处理较长输入，但 chunk 过大往往会降低检索精度，宁可略小也不要过大。

步骤 3：生成向量（DeepSeek Embeddings）

有了所有 chunk 文本，下一步是调用 DeepSeek 生成向量。

3.1 使用云端 API 批量向量化

批量请求可以显著提高吞吐量：

import math
import requests

API_URL = "https://api.deepseek.com/v1/embeddings"
API_KEY = "YOUR_API_KEY"
headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

batch_size = 20
embeddings = []

for i in range(0, len(all_chunks), batch_size):
    batch = all_chunks[i: i + batch_size]
    payload = {
        "model": "deepseek-embedding-v2",
        "input": batch
    }
    res = requests.post(API_URL, json=payload, headers=headers)
    res.raise_for_status()
    data = res.json()
    batch_embeddings = [item["embedding"] for item in data["data"]]
    embeddings.extend(batch_embeddings)
    print(f"Processed batch {i // batch_size + 1}")

完成后，embeddings[j] 与 all_chunks[j] 一一对应。

3.2 使用本地模型生成向量

如果你用的是本地句向量模型（示例用 MiniLM 占位）：

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
embeddings = model.encode(all_chunks, batch_size=32)

DeepSeek 若发布专门的本地嵌入 checkpoint，也可以通过类似方式加载。

将向量转为 NumPy 便于后续处理：

import numpy as np

embedding_matrix = np.array(embeddings, dtype='float32')
print(embedding_matrix.shape)  # (num_chunks, 768)

至此，你已经拥有了整个知识库的“向量表示矩阵”。

步骤 4：存入向量数据库

向量生成完毕后，需要一个高效的结构来支持相似度检索。

4.1 使用 FAISS 构建内存索引

import faiss
import numpy as np

# 可选：先对向量做 L2 归一化，便于用内积近似余弦相似度
for i in range(embedding_matrix.shape[0]):
    norm = np.linalg.norm(embedding_matrix[i])
    if norm > 0:
        embedding_matrix[i] /= norm

# 维度
d = embedding_matrix.shape[1]

# 使用内积（IP）索引；若用欧氏距离则用 IndexFlatL2
index = faiss.IndexFlatIP(d)
index.add(embedding_matrix)

print(f"Indexed {index.ntotal} vectors.")

# 可持久化到磁盘
faiss.write_index(index, "kb_index.faiss")

FAISS 适合：

本地部署
高性能、低延迟检索
需要灵活控制索引结构（Flat、IVF、HNSW 等）

4.2 使用 ChromaDB

如果你更希望有“文档 + 向量 + 元数据”的一体化存储，可以用 Chroma：

import chromadb

client = chromadb.Client()
collection = client.create_collection("my_knowledge_base")

collection.add(
    documents=all_chunks,
    embeddings=embeddings,
    ids=[str(i) for i in range(len(all_chunks))]
)

查询示例：

results = collection.query(
    query_texts=["What is artificial intelligence?"],
    n_results=3
)

for doc, score in zip(results["documents"][0], results["distances"][0]):
    print(f"Score {score:.2f}: {doc[:100]}")

Chroma 会自动调用你配置的嵌入函数（如 OllamaEmbeddingFunction）对查询做向量化，然后进行相似度检索。

4.3 使用 Qdrant 等服务型向量库

Qdrant 适合：

需要独立服务、网络访问
需要复杂的元数据过滤
生产环境多实例部署

典型流程是：

启动 Qdrant 服务（Docker 或二进制）
使用 qdrant-client 创建 collection（指定维度、度量方式）
调用 upsert 写入向量与 payload（元数据）

无论使用哪种向量库，都建议：

为每个 chunk 分配唯一 ID
在元数据中记录来源文档、章节标题、页码等

这样在检索结果中就能快速定位原文，并在前端展示出处。

步骤 5：语义检索与问答

知识库构建完成后，使用方式就是：

对用户查询做向量化
在向量库中做相似度检索
返回最相关的若干 chunk
（可选）把这些 chunk 作为上下文，交给大模型生成最终回答

以 FAISS 为例：

import numpy as np
import requests

query = "How is AI changing businesses?"

# 1. 调用 DeepSeek 嵌入 API
q_payload = {
    "model": "deepseek-embedding-v2",
    "input": [query]
}
q_res = requests.post(API_URL, json=q_payload, headers=headers)
q_res.raise_for_status()
query_vec = np.array(q_res.json()["data"][0]["embedding"], dtype='float32')

# 2. 与索引中向量一样做归一化
norm = np.linalg.norm(query_vec)
if norm > 0:
    query_vec /= norm

# 3. 检索前 5 个最相似向量
D, I = index.search(np.array([query_vec]), k=5)

for idx, score in zip(I[0], D[0]):
    print("Score:", score, "Snippet:", all_chunks[idx][:100])

如果使用 Chroma，只需：

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

此时你已经拥有一个可用的语义搜索引擎，可以直接用于：

文档搜索界面（返回相关片段）
RAG 问答系统的“检索层”

四、典型应用场景

1. 企业内部文档搜索

很多公司内部有大量 Wiki、规章制度、项目文档、FAQ 等，传统关键词搜索往往难以找到真正需要的内容：

员工提问方式与文档表述不一致
关键词过多或过少导致结果噪声大

通过 DeepSeek 嵌入构建内部知识库后，员工可以用自然语言进行语义搜索：

“我怎么申请一台新服务器用于项目？”

即便文档中写的是“资源申请流程”“服务器资源开通指引”，系统也能通过语义相似度找到对应页面，大幅提升检索效率。

如果对数据安全有严格要求，可以将整个流水线（向量化 + 向量库 + LLM）全部部署在内网。

2. 个人 AI 助手的长期记忆

个人 AI 助手如果能记住你的：

笔记
待办事项
重要邮件
历史对话

就会变得非常有用。

做法是：

把所有个人笔记、对话记录等定期向量化
存入本地或私有向量库
聊天时根据当前问题检索相关记忆

例如：

“提醒我下个月的旅行计划是什么？”

助手可以检索到你之前写下的行程安排笔记，并据此回答。

DeepSeek 支持本地部署，这种“个人知识库”可以完全在本机运行，隐私更有保障。

3. 企业级知识助手（客服 / 销售 / 培训）

企业可以基于 DeepSeek 构建内部“ChatGPT”：

知道公司产品文档、API 文档
知道历史工单、FAQ
知道内部流程与制度

客服人员可以问：

“我们应用的 502 错误有什么临时解决方案？”

系统会检索到相关知识库文章或工单，并用 DeepSeek LLM 生成一段结构化、可直接发送给客户的回答。

销售、培训、HR 等部门也可以用同一套知识库，只是检索范围和界面不同。

DeepSeek 模型具备多语言能力，跨语言检索 也成为可能：

中文提问，检索到英文文档
英文提问，检索到中文内部资料

这对跨国企业尤其有价值。

五、性能优化与最佳实践

构建知识库不仅是“能用”，更要“好用”和“快用”。下面是一些关键经验。

1. 合理选择 Chunk 大小与重叠

过大：一个向量包含太多主题，检索结果不够精确
过小：上下文被切碎，回答缺乏完整信息

经验值：

200–500 词（或等价 tokens）是常见起点
对于技术文档，较小 chunk 通常更好
对于法律、故事类文本，适当放大 chunk 保留语境
使用 1–2 句的重叠可以避免“句子被切断”导致的信息丢失

2. 嵌入缓存

对于重复查询，可以按“标准化后的查询字符串”缓存其向量
对于文档嵌入，生成一次后务必持久化（向量库本身或单独文件）

这样可以：

避免重复调用 API
服务重启后无需重新向量化所有文档

Chroma、Qdrant 等数据库本身就提供持久化，相当于天然缓存。

3. 检索参数调优

K 值（返回条数）：
- 初始可设为 5
- 若经常“漏掉”相关内容，可提高到 10 或 20，再在应用层做二次筛选
相似度度量：
- 文本嵌入最常用 余弦相似度
- 在 FAISS 中可通过向量归一化 + IndexFlatIP 实现
元数据过滤：
- 按文档类型、时间、部门等过滤检索范围
- Qdrant、Chroma 等都支持向量 + 结构化过滤
混合检索（Hybrid Search）：
- 先用关键词过滤，再在候选集上做向量检索
- 或使用支持 BM25 + 向量混合打分的系统
重排序（Re-ranking）：
- 对检索出的前 N 个结果，用更精细的交叉编码器模型做二次排序
- 提升精度，代价是额外计算开销

4. 监控与迭代

把知识库当作一个持续演进的系统：

记录用户查询与检索结果
分析哪些问题回答不好
针对性补充数据源或调整 chunk 策略
必要时考虑对嵌入模型做领域微调

5. 扩展与伸缩

向量数量上百万时：
- FAISS Flat 仍可用，但延迟会线性增长
- 可考虑使用 IVF、HNSW 等近似索引
- 或使用 Qdrant 等专门的向量数据库
存储优化：
- 768 维 float32 向量，100 万条约占 3GB 内存
- 可考虑 float16 或 int8 量化，节省内存

六、后端 API 与前端集成

知识库搭好后，需要通过 API 或界面暴露给用户或其他系统。

1. 用 FastAPI 暴露检索接口

示例：提供一个 /query 接口，输入问题，返回最相关的若干文本片段：

from fastapi import FastAPI
from pydantic import BaseModel
import numpy as np

app = FastAPI()

# 假设 index 是 FAISS 索引，all_chunks 是 chunk 文本列表
# embed_text(query) 是调用 DeepSeek 嵌入 API 的函数

class QueryRequest(BaseModel):
    query: str
    top_k: int = 5

@app.post("/query")
def query_kb(request: QueryRequest):
    query_vec = embed_text(request.query)  # DeepSeek 向量
    query_vec = np.array(query_vec, dtype='float32')
    norm = np.linalg.norm(query_vec)
    if norm > 0:
        query_vec /= norm

    D, I = index.search(np.array([query_vec]), request.top_k)

    results = []
    for idx, dist in zip(I[0], D[0]):
        results.append({
            "text": all_chunks[idx],
            "score": float(dist)
        })

    return {"query": request.query, "results": results}

在此基础上，你可以再加一个 /ask 接口：

先检索 top-k 相关 chunk
把问题 + 这些 chunk 拼成 prompt
调用 DeepSeek Chat 模型生成最终回答

这样，前端只需调用一个 HTTP 接口，就能获得“带引用的智能回答”。

2. 与 LangChain / LlamaIndex 集成

如果你使用 LangChain，可以用 RetrievalQA 链把向量检索与 DeepSeek LLM 串起来：

from langchain.chains import RetrievalQA
from langchain_deepseek import ChatDeepSeek
from langchain.vectorstores import FAISS

# 假设 my_deepseek_embed_function 是一个调用 DeepSeek 嵌入 API 的函数

db = FAISS(
    embedding_function=my_deepseek_embed_function,
    index=index,
    docstore=dict(enumerate(all_chunks))
)

llm = ChatDeepSeek(
    model="deepseek-chat",
    temperature=0,
    api_key="YOUR_API_KEY"
)

qa_chain = RetrievalQA(
    llm=llm,
    retriever=db.as_retriever()
)

answer = qa_chain.run("Explain the relationship between LangChain and DeepSeek.")
print(answer)

LlamaIndex（GPT Index）也可以通过自定义 Embedding 类接入 DeepSeek 嵌入，再用 DeepSeek Chat 作为 LLM，自动完成切分、索引和检索。

3. 构建前端或聊天界面