手把手教你搭一个个人AI知识库：从零到可用的完整流程#

我有一个习惯：看到好的技术文章、文档片段、代码方案都会存下来。存了一年之后，我的笔记文件夹里有大概800个文件。

问题是：存了等于没存。因为真遇到一个问题的时候，我不会去翻那800个文件。

于是我决定做一个能”对话”的知识库——把笔记丢进去，然后用自然语言提问。

方案选择#

我先列了几个要求：

本地运行——笔记里有公司的内容，不方便传到云端
低成本——个人项目，不想花钱
能跑就行——不追求生产级，先能用起来

最后选的组合：

Ollama——跑本地模型
Chroma——向量存储（本地，零配置）
Python——胶水语言
Qwen2.5-7B量化版——中文能力好的小模型

这个组合的优点是：全部免费、全部本地、全部能在自己的机器上搞定。

第一步：准备环境#

1
# 安装Ollama（Mac/Linux）
2
curl -fsSL https://ollama.com/install.sh | sh
3

4
# Windows去官网下载
5

6
# 下载模型
7
ollama pull qwen2.5:7b
8

9
# 安装Python依赖
10
pip install chromadb sentence-transformers langchain

如果你用的是Windows，Python依赖最好用虚拟环境装，避免跟系统Python冲突。

第二步：处理你的文档#

知识库的第一步是把你的文件变成向量。

我笔记的格式比较乱——有Markdown、有TXT、甚至有几个Word文档。所以我先做了统一转换：全部转成纯文本。

1
import os
2
from pathlib import Path
3

4
def read_all_docs(directory: str) -> list[dict]:
5
    """读取目录下所有文档"""
6
    docs = []
7
    for filepath in Path(directory).rglob('*'):
8
        if filepath.suffix in ['.md', '.txt', '.py', '.js']:
9
            content = filepath.read_text(encoding='utf-8')
10
            docs.append({
11
                "content": content,
12
                "source": str(filepath),
13
                "title": filepath.stem
14
            })
15
    return docs
16

17
documents = read_all_docs("./my-notes")
18
print(f"共读取 {len(documents)} 个文档")

然后切分。这里我用了一个简单的策略：按段落切分，每段不超过500个字符。

1
def split_into_chunks(docs: list[dict], chunk_size: int = 500) -> list[dict]:
2
    """按段落切分文档"""
3
    chunks = []
4
    for doc in docs:
5
        paragraphs = doc["content"].split("\n\n")
6
        current_chunk = ""
7
        for para in paragraphs:
8
            if len(current_chunk) + len(para) > chunk_size:
9
                if current_chunk:
10
                    chunks.append({
11
                        "content": current_chunk.strip(),
12
                        "source": doc["source"],
13
                        "title": doc["title"]
14
                    })
15
                current_chunk = para
16
            else:
17
                current_chunk += "\n\n" + para if current_chunk else para
18

19
        if current_chunk.strip():
20
            chunks.append({
21
                "content": current_chunk.strip(),
22
                "source": doc["source"],
23
                "title": doc["title"]
24
            })
25
    return chunks
26

27
chunks = split_into_chunks(documents)
28
print(f"切分为 {len(chunks)} 个片段")

我的800个文档切完之后变成了大约3500个片段。

第三步：向量化并存储#

1
import chromadb
2
from sentence_transformers import SentenceTransformer
3

4
# 加载Embedding模型
5
embedder = SentenceTransformer("shibing624/text2vec-base-chinese")
6

7
# 连接Chroma
8
client = chromadb.PersistentClient(path="./knowledge-db")
9
collection = client.get_or_create_collection("my-knowledge")
10

11
# 批量处理（避免一次全部塞进去内存爆炸）
12
batch_size = 100
13
for i in range(0, len(chunks), batch_size):
14
    batch = chunks[i:i+batch_size]
15
    texts = [c["content"] for c in batch]
16

17
    # 生成向量
18
    embeddings = embedder.encode(texts).tolist()
19

20
    # 存储
21
    collection.add(
22
        documents=texts,
23
        embeddings=embeddings,
24
        metadatas=[{"source": c["source"], "title": c["title"]} for c in batch],
25
        ids=[f"chunk_{i+j}" for j in range(len(batch))]
26
    )
27

28
    print(f"已处理 {i+len(batch)}/{len(chunks)} 个片段")

这个过程在我的机器上跑了大约10分钟。800个文档不算多，如果你有上万个文件，建议分批跑。

第四步：查询#

1
def query_knowledge(question: str, top_k: int = 3) -> list[dict]:
2
    """查询知识库"""
3
    # 生成查询向量
4
    query_vector = embedder.encode([question]).tolist()
5

6
    # 检索
7
    results = collection.query(
8
        query_embeddings=query_vector,
9
        n_results=top_k
10
    )
11

12
    return [
13
        {
14
            "content": doc,
15
            "source": meta["source"],
16
            "title": meta["title"]
17
        }
18
        for doc, meta in zip(results["documents"][0], results["metadatas"][0])
19
    ]
20

21
# 试试
22
results = query_knowledge("如何在Python中处理JSON？")
23
for r in results:
24
    print(f"来源: {r['title']} ({r['source']})")
25
    print(f"内容: {r['content'][:100]}...")
26
    print()

到这里，纯检索部分就完成了。你能通过自然语言问题找到最相关的笔记片段。

第五步：加一个LLM让它能对话#

光检索还不够——你拿到的是几个文本片段，需要自己读。加上LLM，它就能帮你总结和组织答案了。

1
import requests
2

3
def ask_knowledge_base(question: str) -> str:
4
    """查询知识库并让LLM生成答案"""
5
    # 检索相关片段
6
    results = query_knowledge(question, top_k=3)
7

8
    # 构建上下文
9
    context = "\n\n".join([
10
        f"【来自 {r['title']}】\n{r['content']}"
11
        for r in results
12
    ])
13

14
    # 让LLM生成答案
15
    prompt = f"""基于以下知识库内容回答问题：
16

17
{context}
18

19
问题：{question}
20

21
如果知识库中没有相关信息，请明确说明。"""
22

23
    # 调用本地Ollama
24
    response = requests.post("http://localhost:11434/api/generate", json={
25
        "model": "qwen2.5:7b",
26
        "prompt": prompt,
27
        "stream": False
28
    })
29

30
    return response.json()["response"]
31

32
# 试试
33
answer = ask_knowledge_base("Docker容器的端口映射怎么做？")
34
print(answer)