用Chroma+Ollama打造个人AI助手：从文档处理到智能问答实战

你是否曾幻想过拥有一个只属于你自己的“贾维斯”？它熟知你所有的文档、笔记和知识储备，能随时回答你的专业问题，并且完全运行在你的本地电脑上，无需担心数据泄露。过去，这听起来像是科幻电影里的情节，但今天，借助像Chroma和Ollama这样的开源工具，任何具备基础编程能力的技术爱好者都能亲手将其变为现实。这篇文章，就是为你准备的“个人AI助手建造手册”。

我们将从一个非常实际的场景出发：假设你是一名开发者、研究者或知识工作者，电脑里散落着大量的技术文档、项目笔记、研究论文和会议记录。当你想快速查找某个模糊记忆中的概念，或者希望基于自己的资料库进行深度分析时，传统的文件搜索显得力不从心。而一个基于本地知识库的智能助手，能够理解你问题的语义，并从海量文档中精准定位相关信息，甚至综合这些信息生成一个连贯的答案。整个过程，从文档的向量存储到模型的智能推理，全部在你的掌控之中，数据不出本地，安全又高效。

接下来，我将带你走过从零到一的完整旅程。我们不仅会搭建环境、处理文档，更会深入探讨如何让这个系统变得更聪明、更高效。你会发现，构建一个可用的原型可能只需要一个下午，但要让它真正成为你得力的“第二大脑”，还需要一些巧思和优化。让我们开始吧。

1. 为什么是Chroma与Ollama？技术栈的深度解析

在开始动手之前，我们有必要花点时间理解手中的“工具”。为什么在众多选项中，Chroma和Ollama的组合特别适合个人或小团队构建本地AI助手？这背后是效率、易用性与功能强大性之间的精妙平衡。

Chroma的核心定位是一个开发者友好的向量数据库。与需要复杂部署和运维的工业级向量数据库（如Milvus）不同，Chroma追求的是“开箱即用”。它提供了简洁的Python API，让你用几行代码就能完成向量的存储和检索。更重要的是，它原生支持持久化到本地磁盘，这意味着你无需维护一个额外的数据库服务，数据文件就安静地躺在你的项目文件夹里，迁移和备份都变得异常简单。对于个人项目或原型开发，这种轻量化和低心智负担的设计是决定性的优势。

提示：向量数据库的本质是一个专门为高维向量（即嵌入）优化过的存储和检索系统。它能够快速找到与查询向量“最相似”的存储向量，这是实现语义搜索的基础。

而Ollama，则彻底改变了我们在本地运行大语言模型（LLM）的体验。在过去，想要在本地运行一个像LLaMA这样的模型，你需要面对复杂的模型转换、依赖安装和内存管理问题。Ollama将这些全部打包，提供了一个类似Docker的命令行工具。你只需要一句 ollama pull llama3.2:1b，它就会自动下载、配置并准备好一个可运行的模型实例。它内置了高效的推理引擎，并且通过一个统一的REST API提供服务，使得在代码中调用模型变得和调用一个普通函数一样简单。

两者的结合，形成了一个完美的闭环：

• Ollama 负责“思考”：提供文本嵌入（Embedding）和文本生成（Completion）能力。
• Chroma 负责“记忆”：高效存储和检索由Ollama生成的文档嵌入向量。

这个组合避免了云API的调用费用和延迟，也规避了数据上传的安全风险，真正实现了完全本地化、离线可用的AI能力。

2. 环境搭建与第一行代码：让机器“醒来”

理论说得再多，不如动手一试。让我们从最基础的环境准备开始，确保你的机器已经准备好运行我们的AI助手。

2.1 基础环境配置

首先，我们需要一个干净的Python环境。我强烈推荐使用Conda或venv来管理依赖，以避免与系统其他Python包发生冲突。

# 使用Conda创建并激活环境（推荐）
conda create -n my_ai_assistant python=3.10 -y
conda activate my_ai_assistant

# 或者使用Python内置的venv
python -m venv venv
# 在Windows上激活：venv\Scripts\activate
# 在Mac/Linux上激活：source venv/bin/activate

环境激活后，安装核心依赖。除了chromadb和ollama，我们还会安装langchain，它提供了一系列处理文档的链式工具，能极大简化我们的代码。

pip install chromadb ollama langchain-community pypdf

这里注意，我们安装了langchain-community，它包含了LangChain的许多社区维护的集成工具，以及pypdf用于处理PDF文档。

2.2 启动核心服务：Ollama与Chroma

Ollama的安装与模型拉取 Ollama的安装极其简单。访问其官网，下载对应操作系统的安装包，运行即可。安装完成后，打开终端，拉取我们需要的第一个模型。对于个人使用，一个较小的嵌入模型和对话模型是很好的起点。

# 拉取一个轻量且性能不错的嵌入模型
ollama pull nomic-embed-text
# 拉取一个轻量级的对话模型（例如Qwen2.5 0.5B，对硬件要求极低）
ollama pull qwen2.5:0.5b

现在，Ollama服务已经在后台运行，并准备好了我们指定的模型。

Chroma：以编程方式集成 与需要独立服务进程的数据库不同，Chroma可以直接在你的Python脚本中运行。这是它“轻量”的体现。我们不需要单独启动一个服务，而是在代码中初始化一个持久的客户端。

import chromadb

# 指定一个本地目录来持久化向量数据库
PERSIST_DIRECTORY = "./my_chroma_db"

# 创建（或连接）一个持久化的Chroma客户端
client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)

# 创建一个集合（Collection），类似于数据库中的表，用于存放某一类文档
# 如果集合已存在，get_or_create_collection会直接获取它
collection = client.get_or_create_collection(
    name="my_knowledge_base",
    metadata={"description": "存储个人文档的知识库"}
)

print(f"集合 '{collection.name}' 已就绪。")

运行这段代码，你会发现当前目录下生成了一个my_chroma_db文件夹。你的所有“记忆”都将安全地存储在这里。

3. 从杂乱文档到结构化知识：数据处理流水线

构建知识库最核心、也最繁琐的一步，就是将非结构化的原始文档（PDF、Word、TXT）转化为可以被高效检索的向量片段。这个过程需要一条精心设计的“流水线”。

3.1 文档加载：读取不同格式的内容

我们的文档可能五花八门。我们需要一个统一的加载器来处理它们。这里我们利用langchain的文档加载器，它们已经为我们处理了各种格式的解析细节。

from langchain_community.document_loaders import PyPDFLoader, TextLoader, Docx2txtLoader
from typing import List
import os

def load_documents_from_directory(directory_path: str) -> List[str]:
    """
    加载指定目录下的所有支持格式的文档，并返回纯文本列表。
    """
    supported_extensions = ['.pdf', '.txt', '.docx']
    all_texts = []

    for filename in os.listdir(directory_path):
        filepath = os.path.join(directory_path, filename)
        _, ext = os.path.splitext(filename)

        if ext.lower() not in supported_extensions:
            continue

        try:
            if ext.lower() == '.pdf':
                loader = PyPDFLoader(filepath)
            elif ext.lower() == '.docx':
                loader = Docx2txtLoader(filepath)
            else:  # .txt
                loader = TextLoader(filepath, encoding='utf-8')

            # 加载文档，返回的是Document对象列表（每页或每个文件一个Document）
            docs = loader.load()
            for doc in docs:
                all_texts.append(doc.page_content) # 提取页面内容
            print(f"成功加载: {filename}")
        except Exception as e:
            print(f"加载文件 {filename} 时出错: {e}")

    return all_texts

# 使用示例：加载'./my_docs'文件夹下的所有文档
raw_texts = load_documents_from_directory("./my_docs")
print(f"共加载了 {len(raw_texts)} 个文本片段。")

3.2 文本分割：将长文档切成“知识块”

大语言模型有上下文长度限制，我们不能把整本书都塞给它。因此，需要将长文本分割成大小适中的“块”（Chunk）。分割策略直接影响检索质量。简单的按字符数切割会割裂语义，我们采用更智能的递归字符分割。

from langchain.text_splitter import RecursiveCharacterTextSplitter

def split_texts_into_chunks(texts: List[str], chunk_size=500, chunk_overlap=50) -> List[str]:
    """
    使用递归分割器将文本列表分割成有重叠的块。
    chunk_size: 每个块的大致字符数。
    chunk_overlap: 块与块之间重叠的字符数，用于保持上下文连贯。
    """
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""], # 按中文标点优先分割
        length_function=len,
        is_separator_regex=False,
    )

    all_chunks = []
    for text in texts:
        chunks = text_splitter.split_text(text)
        all_chunks.extend(chunks)

    print(f"将文本分割成了 {len(all_chunks)} 个知识块。")
    return all_chunks

# 使用示例
document_chunks = split_texts_into_chunks(raw_texts, chunk_size=600, chunk_overlap=80)

chunk_overlap是关键参数，它让相邻的块有部分内容重叠，确保一个完整的句子或概念不会因为恰好被切在边界而丢失上下文信息。

3.3 向量化与存储：赋予文本“可检索的灵魂”

这是将普通文本变成知识库的关键一步。我们使用Ollama运行的嵌入模型，将每一个文本块转化为一个高维向量（嵌入），然后将其存入Chroma。

import ollama
from tqdm import tqdm  # 用于显示进度条，可选安装：pip install tqdm

def embed_and_store_chunks(collection, chunks: List[str], batch_size=10):
    """
    将文本块向量化并存储到Chroma集合中。
    批量处理以提高效率。
    """
    total_chunks = len(chunks)
    print(f"开始向量化并存储 {total_chunks} 个知识块...")

    for i in tqdm(range(0, total_chunks, batch_size)):
        batch_chunks = chunks[i:i+batch_size]
        batch_ids = [f"chunk_{i+j}" for j in range(len(batch_chunks))]
        batch_metadatas = [{"source_index": i+j} for j in range(len(batch_chunks))]

        # 批量生成嵌入向量
        batch_embeddings = []
        for chunk in batch_chunks:
            response = ollama.embeddings(model='nomic-embed-text', prompt=chunk)
            batch_embeddings.append(response['embedding'])

        # 批量添加到集合
        collection.add(
            documents=batch_chunks,
            embeddings=batch_embeddings,
            ids=batch_ids,
            metadatas=batch_metadatas
        )

    print("所有知识块已存入向量数据库。")

# 执行存储
embed_and_store_chunks(collection, document_chunks)

这个过程可能需要一些时间，取决于文档的数量和嵌入模型的速度。完成后，你的个人知识库就初步建成了！

4. 实现智能问答：从检索到生成

知识库建好了，现在让我们赋予它“对话”的能力。智能问答通常分为两步：检索（Retrieval） 和生成（Generation），即经典的RAG（Retrieval-Augmented Generation）流程。

4.1 核心检索函数：找到最相关的知识

当用户提出一个问题时，我们首先需要将这个问题也转化为向量，然后在知识库中查找最相似的文本块。

def retrieve_relevant_chunks(collection, query: str, n_results=3):
    """
    根据查询问题，从知识库中检索最相关的文本块。
    """
    # 1. 将查询问题向量化
    query_embedding_response = ollama.embeddings(model='nomic-embed-text', prompt=query)
    query_embedding = query_embedding_response['embedding']

    # 2. 查询Chroma数据库
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=n_results,
        include=["documents", "distances", "metadatas"] # 返回文档内容、距离和元数据
    )
    # results的结构是 {'ids': [[...]], 'distances': [[...]], 'documents': [[...]], ...}
    retrieved_docs = results['documents'][0]
    retrieved_distances = results['distances'][0]

    return retrieved_docs, retrieved_distances

# 测试检索
test_query = "如何在Python中读取JSON文件？"
docs, dists = retrieve_relevant_chunks(collection, test_query)
print(f"针对问题 '{test_query}'， 检索到 {len(docs)} 个相关片段：")
for i, (doc, dist) in enumerate(zip(docs, dists)):
    print(f"\n--- 片段 {i+1} (相似度距离: {dist:.4f}) ---")
    print(doc[:200] + "...") # 打印前200字符

距离值（distance）越小，表示相似度越高。这个检索结果为我们后续生成答案提供了事实依据。

4.2 构建提示词与生成答案：让模型“引经据典”

单纯的检索只是把资料找出来，我们需要大语言模型来消化这些资料，并组织成通顺的答案。这里的关键是构建一个高质量的提示词（Prompt），将检索到的上下文和用户问题结合起来。

def generate_answer_with_context(query: str, context_chunks: List[str]):
    """
    结合检索到的上下文，使用LLM生成答案。
    """
    # 将多个上下文块合并成一个文本
    context = "\n\n---\n\n".join(context_chunks)

    # 精心构造系统提示词，指导模型的行为
    system_prompt = """你是一个专业的AI助手，请严格根据用户提供的“参考上下文”来回答问题。
    如果答案在上下文中明确存在，请用简洁清晰的语言总结并回答。
    如果上下文中的信息不足以完全回答问题，请基于上下文给出部分答案，并说明局限性。
    绝对不要编造上下文中不存在的信息。
    回答结束时，可以注明相关信息的来源片段（如果有的话）。
    """

    # 用户提示词，清晰分隔上下文和问题
    user_prompt = f"""
参考上下文：
{context}

用户问题：{query}
请根据上述上下文回答用户问题。"""

    # 调用Ollama的生成API
    response = ollama.chat(
        model='qwen2.5:0.5b', # 使用你拉取的对话模型
        messages=[
            {'role': 'system', 'content': system_prompt},
            {'role': 'user', 'content': user_prompt}
        ],
        options={'temperature': 0.2} # 较低的温度使输出更确定、更基于事实
    )
    return response['message']['content']

# 组合检索与生成，完成一次问答
def ask_question(collection, question: str):
    print(f"\nQ: {question}")
    relevant_chunks, _ = retrieve_relevant_chunks(collection, question, n_results=2)
    if not relevant_chunks:
        answer = "抱歉，我的知识库中暂时没有相关信息可以回答这个问题。"
    else:
        answer = generate_answer_with_context(question, relevant_chunks)
    print(f"A: {answer}")

# 进行交互式问答
if __name__ == "__main__":
    print("个人AI助手已启动，输入您的问题（输入'退出'结束）...")
    while True:
        user_input = input("\n>> ")
        if user_input.lower() in ['退出', 'quit', 'exit']:
            print("再见！")
            break
        ask_question(collection, user_input)

现在，你的AI助手已经能“听懂”问题，并从自己的“记忆”（知识库）中寻找答案来回答你了。你可以尝试问一些你文档中明确涉及的概念或步骤。

5. 进阶优化：让你的助手更强大、更聪明

一个能跑起来的原型只是起点。要让这个助手真正实用，我们需要在性能、准确性和用户体验上做更多工作。

5.1 检索优化：超越简单相似度

直接基于嵌入向量的相似度检索（稠密检索）有时会漏掉一些关键词匹配但语义稍远的文档。一个常见的优化是引入混合检索（Hybrid Search），即结合稠密检索和传统的稀疏检索（如BM25）。

注意：Chroma最新版本已开始支持稀疏检索。但为了概念清晰，我们可以手动实现一个简化版：在检索后，对结果进行关键词匹配重排序。

from collections import Counter
import re

def hybrid_rerank(query: str, retrieved_docs, retrieved_distances, alpha=0.7):
    """
    简单的混合重排序：结合语义相似度距离和关键词匹配分数。
    alpha: 语义相似度的权重，(1-alpha)为关键词权重。
    """
    # 归一化语义距离分数（距离越小，分数越高）
    max_dist = max(retrieved_distances) if retrieved_distances else 1
    semantic_scores = [1 - (d / max_dist) for d in retrieved_distances]

    # 计算关键词匹配分数（简单的词频统计）
    query_words = set(re.findall(r'\w+', query.lower()))
    keyword_scores = []
    for doc in retrieved_docs:
        doc_words = Counter(re.findall(r'\w+', doc.lower()))
        score = sum(doc_words[word] for word in query_words if word in doc_words)
        keyword_scores.append(score)
    max_keyword = max(keyword_scores) if keyword_scores else 1
    keyword_scores = [s / max_keyword for s in keyword_scores]

    # 计算综合分数
    combined_scores = [alpha*s + (1-alpha)*k for s, k in zip(semantic_scores, keyword_scores)]

    # 按综合分数重新排序
    ranked_indices = sorted(range(len(combined_scores)), key=lambda i: combined_scores[i], reverse=True)
    ranked_docs = [retrieved_docs[i] for i in ranked_indices]
    ranked_distances = [retrieved_distances[i] for i in ranked_indices]

    return ranked_docs, ranked_distances

在retrieve_relevant_chunks函数获取初步结果后，调用这个重排序函数，可以让那些既语义相关又包含关键术语的文档排在更前面。

5.2 系统设计与配置管理

当功能增多时，我们需要一个更好的项目结构。将配置（如模型名称、块大小、路径）提取到配置文件或环境变量中是很好的实践。

config.yaml

models:
  embedding: nomic-embed-text
  generation: qwen2.5:0.5b

processing:
  chunk_size: 600
  chunk_overlap: 80
  data_directory: ./my_docs
  persist_directory: ./my_chroma_db

retrieval:
  top_k: 3
  hybrid_search_alpha: 0.7

在代码中加载配置：

import yaml

with open('config.yaml', 'r') as f:
    config = yaml.safe_load(f)

EMBED_MODEL = config['models']['embedding']
# ... 其他配置

这样，调整参数时无需修改代码，提高了可维护性。

5.3 性能与资源考量

• 模型选择：qwen2.5:0.5b 非常轻量，几乎在任何电脑上都能运行。如果你的机器性能较好（有8G以上显存），可以升级到 llama3.2:3b 或 qwen2.5:3b，以获得更强的推理和生成能力。
• 批处理：在嵌入和存储大量文档时，务必使用批处理（如前文代码所示），这比逐条处理快得多。
• 增量更新：知识库不是一成不变的。你需要设计一个机制来处理新增文档，并为它们生成向量后添加到现有集合中，同时避免重复添加。可以为每个文档计算一个哈希值（如MD5）存储在元数据中，添加前先检查。

构建这样一个个人AI助手的过程，就像在精心培育一个数字伙伴。从最初笨拙地读取文档，到后来能精准地回答你的问题，每一次优化都让它更懂你。我自己的知识库已经积累了超过一千份技术文档，它帮我节省了大量翻找资料的时间。最让我惊喜的不是它回答对了某个问题，而是在一些复杂问题上，它能将我不同时期、不同文档中的零散观点串联起来，给出一个我未曾明确写下、但逻辑自洽的综合性答案——这真正体现了“知识”从存储到“智能”的跃迁。你可以从一个小型的、专精于某个主题的文档库开始，慢慢扩展它的边界。