使用DeepSeek R1和Ollama构建检索增强生成系统指南

使用您的数据构建本地RAG系统

DeepSeek R1 和 Ollama 提供了创建 检索增强生成 (RAG) 这类系统的强大工具。本指南将介绍使用这些工具进行 RAG 应用开发的设置方法、实现步骤和最佳实践。

检索增强生成模型（RAG） 系统结合了搜索和 生成式人工智能 的优势，能够提供上下文相关的响应，这些响应精准且准确。借助工具如DeepSeek R1 和 Ollama，现在构建RAG系统已不再那么令人畏惧。无论是聊天机器人、知识助手还是AI驱动的搜索引擎的构建，本指南将为您提供所需的所有信息和工具。

• Python 3.10+（介绍了如何在Windows 11上安装Python）

• 如何在本地安装Ollama

• 设置 DeepSeek R1 和 Ollama 来进行 RAG。
• 实现文档处理、向量存储和查询管道的功能。
• 优化性能、相关性以及用户体验。

请确保你已经安装了所需的Python包，并可以使用pip等工具来安装它们。

    pip install langchain-core langchain-community langchain-ollama langchain-huggingface faiss-cpu psutil

安装语言链核心、社区版、ollama、huggingface、faiss-cpu和psutil的pip命令

• 导入所需的库

    from typing import List  
    from langchain_core.documents import Document  
    from langchain_core.output_parsers import StrOutputParser  
    from langchain_core.runnables import RunnablePassthrough  
    from langchain_core.prompts import ChatPromptTemplate  
    from langchain_community.document_loaders import TextLoader  
    from langchain_text_splitters import RecursiveCharacterTextSplitter  
    from langchain_huggingface import HuggingFaceEmbeddings  
    from langchain_ollama.llms import OllamaLLM  
    from langchain_community.vectorstores import FAISS  
    import logging  
    import psutil  
    import os

整个流程由RAGPipeline类管理，包括内存监控、文档加载、生成嵌入以及查询模型。

    class RAGPipeline:
        def __init__(self, model_name: str = "llama2:7b-chat-q4", max_memory_gb: float = 3.0):
            self.setup_logging()
            self.check_system_memory(max_memory_gb)

            # 加载语言模型（LLM）
            self.llm = OllamaLLM(model="deepseek-r1:8b")

            # 使用轻量级模型初始化嵌入
            self.embeddings = HuggingFaceEmbeddings(
                model_name="sentence-transformers/all-mpnet-base-v2",
                model_kwargs={'device': 'cpu'}  # 使用CPU以提升效率
            )

            # 定义提示模板
            self.prompt = ChatPromptTemplate.from_template("""
            请根据以下上下文简洁作答。如果在提供的信息中找不到答案，请回答“无法根据提供的信息回答此问题。”

            上下文: {context}
            问题: {question}
            回答: """)

为了防止在内存较低的环境中崩溃，我们在执行之前记录和检查可用内存。

定义一个名为setup_logging的方法，该方法用于设置日志。
设置基本的logging配置，日志级别为INFO。
将logger设置为当前模块的日志记录器。

    def check_system_memory(self, max_memory_gb: float):  
        available_memory = psutil.virtual_memory().available / (1024 ** 3)  
        self.logger.info(f"系统当前可用内存为：{available_memory:.1f} GB")  
        if available_memory < max_memory_gb:  
            self.logger.warning("内存不足，低于推荐值。")

我们利用 TextLoader 和 RecursiveCharacterTextSplitter 来高效处理这些文档。

    def 读取并拆分文档(self, file_path: str) -> List[Document]:  
        加载器 = TextLoader(file_path)  
        文档 = 加载器.load()  

        文本拆分器 = RecursiveCharacterTextSplitter(  
            chunk_size=500,  
            chunk_overlap=50,  
            length_function=len,  
            add_start_index=True,  
        )  
        拆分结果 = 文本拆分器.split_documents(文档)  
        self.logger.info(f"生成了 {len(拆分结果)} 个文档片段")  
        return 拆分结果

我们用FAISS来高效检索文档，并以小批量来处理文档。

    定义 create_vectorstore(self, documents: List[Document]) -> FAISS:  
        batch_size = 32  
        vectorstore = FAISS.from_documents(documents[:batch_size], self.embeddings)  

        for i in range(batch_size, len(documents), batch_size):  
            batch = documents[i:i + batch_size]  
            vectorstore.add_documents(batch)  
            self.logger.info(f"已处理批次 {i//batch_size + 1}")  
        return vectorstore

我们定义的检索机制是为了高效获取相关文档。

    def setup_rag_chain(self, vectorstore: FAISS):  
        retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 2, "fetch_k": 3})  

        def format_docs(docs):  
            return "\n\n".join(doc.page_content for doc in docs)  

        rag_chain = (  
            {"context": retriever | format_docs, "question": RunnablePassthrough()}  
            | self.prompt  
            | self.llm  
            | StrOutputParser()  
        )  
        return rag_chain

在带有内存监控功能的情况下查询模型。

在执行查询请求之前，系统记录内存使用情况。

    def query(self, chain, question: str) -> str:  
        内存用量 = psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024  
        self.logger.info(f"内存用量: {内存用量:.1f} MB")  
        return chain.invoke(question)

我们先初始化RAG流程，处理文档，然后运行一个测试查询。

    def main():  
        rag = RAGPipeline(model_name="deepseek-r1:8b", max_memory_gb=3.0)  

        doc_list = rag.load_and_split_documents("data/knowledge.txt")  
        vectorstore = rag.create_vectorstore(doc_list)  
        链 = rag.setup_rag_chain(vectorstore)  

        问题 = "AI是什么？"  
        回答 = rag.query(链, 问题)  
        print(f"问题：{问题}\n回答：{回答}")

    if __name__ == "__main__":
        # 如果该脚本被直接运行，将调用main()函数
        main()

这篇博客详细介绍了如何使用LangChain、Ollama、FAISS和Hugging Face embeddings构建一个内存高效的RAG管道系统。通过对文档分块、向量存储和内存监控的优化，这种方法确保即使在资源有限的情况下也能高效地进行AI驱动的文档检索。用你的数据集试试这个管道，并告诉我们你的想法吧！

bhavikjikadara.medium.com