Cogito-v1-preview-llama-3B实战教程：结合LangChain构建本地RAG应用

1. 引言：为什么选择这个组合？

如果你正在寻找一个既小巧又聪明，还能在本地电脑上流畅运行的AI模型，那么Cogito-v1-preview-llama-3B绝对值得你关注。这个只有30亿参数的模型，在很多测试中表现甚至超过了同级别的其他知名模型。

但模型本身再强，如果只是简单问答，它的价值也有限。今天我要带你做的，是给它装上“外挂”——用LangChain框架，结合RAG（检索增强生成）技术，打造一个属于你自己的本地知识库问答系统。

简单来说，RAG就像给模型配了一个超级大脑。当模型回答问题时，它会先去你的文档库里查找相关资料，然后结合找到的信息来生成答案。这样不仅能提高答案的准确性，还能让模型回答它原本不知道的事情。

这篇文章，我会手把手带你完成从模型部署到RAG应用搭建的全过程。即使你之前没怎么接触过这些技术，跟着步骤走，也能在自己的电脑上跑起来。

2. 认识Cogito-v1-preview-llama-3B模型

在开始动手之前，我们先花几分钟了解一下今天的主角。

2.1 模型的核心特点

Cogito-v1-preview-llama-3B虽然体积不大，但能力不容小觑。它有几个让我觉得特别实用的特点：

混合推理能力：这是它最大的亮点。大多数模型要么直接生成答案，要么需要你明确告诉它“先思考再回答”。Cogito模型可以自动切换模式——简单问题直接回答，复杂问题先自我反思再给出答案。这就像有个聪明的助手，知道什么时候该快速反应，什么时候该深思熟虑。

多语言支持：模型训练时用了超过30种语言的数据，这意味着它不仅能理解中文和英文，对很多其他语言也有不错的表现。如果你需要处理多语言文档，这个特性会很实用。

超长上下文：支持128k的上下文长度。简单解释一下，就是模型能“记住”很长的对话历史或文档内容。在构建RAG系统时，这个能力特别重要，因为我们需要把相关文档片段和问题一起喂给模型。

开源商用：模型采用开放许可，你可以免费用于商业项目。这对个人开发者和小团队来说，是个很大的优势。

2.2 性能表现如何？

根据官方提供的数据，Cogito v1预览版在多个标准测试中都表现不错。特别是在推理模式下，它的表现超过了同规模的其他模型。

不过测试数据只是参考，实际效果如何，我们待会儿自己试试就知道。

3. 环境准备与快速部署

好了，理论部分了解得差不多了，现在开始动手。我会带你用最简单的方式把模型跑起来。

3.1 通过Ollama快速启动

如果你之前用过Ollama，那么启动Cogito模型会非常容易。Ollama是一个专门用于在本地运行大模型的工具，它把复杂的部署过程简化成了几条命令。

首先，确保你已经安装了Ollama。如果还没安装，可以去官网下载对应你操作系统的版本。

安装完成后，打开终端（Windows用户打开命令提示符或PowerShell），输入以下命令：

ollama run cogito:3b

第一次运行时会自动下载模型，文件大小大概在2GB左右，下载速度取决于你的网络。下载完成后，模型就会自动启动，你可以直接在命令行里和它对话了。

试试问个简单的问题：

你好，请介绍一下你自己。

你应该能看到模型的回复。如果一切正常，恭喜你，模型已经成功运行了！

3.2 使用Web界面交互

如果你更喜欢图形界面，Ollama也提供了Web UI。在模型运行的情况下，打开浏览器，访问 http://localhost:11434，就能看到一个简单的聊天界面。

不过对于我们要构建的RAG应用来说，我们需要的是API接口。Ollama默认会在11434端口提供API服务，这正好符合我们的需求。

你可以用下面的Python代码测试一下API是否正常工作：

import requests
import json

# 测试Ollama API
url = "http://localhost:11434/api/generate"
data = {
    "model": "cogito:3b",
    "prompt": "你好，请用一句话介绍你自己。",
    "stream": False
}

response = requests.post(url, json=data)
result = response.json()

print("模型回复：", result.get("response", "无回复"))

如果看到模型的自我介绍，说明API服务运行正常。

4. 搭建本地RAG应用的核心步骤

现在模型已经跑起来了，接下来我们要给它装上“外挂大脑”——构建RAG系统。我会分步骤详细讲解每个环节。

4.1 安装必要的Python库

我们需要几个关键的Python库。建议你先创建一个新的虚拟环境，避免包冲突。

# 创建虚拟环境（可选但推荐）
python -m venv rag_env
source rag_env/bin/activate  # Linux/Mac
# 或者
# rag_env\Scripts\activate  # Windows

# 安装核心库
pip install langchain langchain-community chromadb pypdf sentence-transformers

我来解释一下每个库的作用：

• langchain：我们的核心框架，提供了构建AI应用的各种组件
• langchain-community：包含社区贡献的各种工具和集成
• chromadb：向量数据库，用于存储和检索文档的向量表示
• pypdf：用于读取PDF文档
• sentence-transformers：用于将文本转换成向量

4.2 准备你的知识库文档

RAG系统的核心就是知识库。你可以准备任何格式的文档——TXT文本、PDF文件、Word文档，甚至是网页内容。

为了演示，我创建了一个简单的示例文档 knowledge.txt：

Cogito-v1-preview-llama-3B是由Deep Cogito开发的混合推理模型。
该模型有30亿参数，支持128k上下文长度。
模型采用迭代蒸馏和放大(IDA)方法训练，在编码、STEM和指令执行方面表现优异。
模型支持超过30种语言，并采用开放许可，允许商业使用。
在推理模式下，该模型在常见基准测试中优于同规模的其他模型。

你可以用自己的文档替换这个示例。如果是PDF文件，代码会自动处理；如果是其他格式，可能需要稍微调整一下读取方式。

4.3 构建完整的RAG应用代码

下面是完整的Python代码，我把每个部分都加了详细注释：

import os
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain_community.llms import Ollama

class LocalRAGSystem:
    def __init__(self, model_name="cogito:3b"):
        """
        初始化RAG系统
        model_name: 使用的Ollama模型名称
        """
        self.model_name = model_name
        self.vectorstore = None
        self.qa_chain = None
        
    def load_documents(self, file_path):
        """
        加载文档
        file_path: 文档文件路径
        """
        print(f"正在加载文档: {file_path}")
        
        # 根据文件类型选择加载器
        if file_path.endswith('.txt'):
            loader = TextLoader(file_path, encoding='utf-8')
        elif file_path.endswith('.pdf'):
            from langchain_community.document_loaders import PyPDFLoader
            loader = PyPDFLoader(file_path)
        else:
            raise ValueError("暂不支持该文件格式，请使用txt或pdf文件")
        
        documents = loader.load()
        print(f"成功加载 {len(documents)} 个文档")
        return documents
    
    def split_documents(self, documents, chunk_size=500, chunk_overlap=50):
        """
        分割文档为小块
        chunk_size: 每个块的大小
        chunk_overlap: 块之间的重叠部分
        """
        print("正在分割文档...")
        
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=chunk_size,
            chunk_overlap=chunk_overlap,
            length_function=len,
            separators=["\n\n", "\n", "。", "！", "？", "；", "，", "、", " ", ""]
        )
        
        chunks = text_splitter.split_documents(documents)
        print(f"文档被分割为 {len(chunks)} 个块")
        return chunks
    
    def create_vector_store(self, chunks, persist_directory="./chroma_db"):
        """
        创建向量存储
        persist_directory: 向量数据库保存路径
        """
        print("正在创建向量数据库...")
        
        # 使用中文优化的嵌入模型
        embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
        )
        
        # 创建向量存储
        self.vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=embeddings,
            persist_directory=persist_directory
        )
        
        # 保存到本地
        self.vectorstore.persist()
        print(f"向量数据库已创建并保存到: {persist_directory}")
    
    def setup_qa_chain(self):
        """
        设置问答链
        """
        print("正在设置问答系统...")
        
        # 初始化Ollama模型
        llm = Ollama(
            model=self.model_name,
            temperature=0.1,  # 较低的温度使回答更确定
            num_predict=512   # 最大生成长度
        )
        
        # 创建检索器
        retriever = self.vectorstore.as_retriever(
            search_type="similarity",
            search_kwargs={"k": 3}  # 每次检索3个最相关的文档块
        )
        
        # 创建问答链
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=llm,
            chain_type="stuff",  # 简单地将所有检索到的文档拼接
            retriever=retriever,
            return_source_documents=True,  # 返回源文档用于验证
            verbose=True  # 显示详细过程
        )
        
        print("问答系统设置完成！")
    
    def ask_question(self, question):
        """
        提问并获取答案
        question: 你的问题
        """
        if not self.qa_chain:
            raise ValueError("请先初始化问答系统")
        
        print(f"\n问题: {question}")
        print("正在检索和生成答案...")
        
        # 获取答案
        result = self.qa_chain({"query": question})
        
        print(f"\n答案: {result['result']}")
        
        # 显示参考来源
        if result['source_documents']:
            print("\n参考来源:")
            for i, doc in enumerate(result['source_documents'][:2], 1):
                print(f"{i}. {doc.page_content[:200]}...")
        
        return result

# 使用示例
def main():
    # 初始化RAG系统
    rag_system = LocalRAGSystem(model_name="cogito:3b")
    
    # 1. 加载文档
    documents = rag_system.load_documents("knowledge.txt")
    
    # 2. 分割文档
    chunks = rag_system.split_documents(documents)
    
    # 3. 创建向量数据库
    rag_system.create_vector_store(chunks)
    
    # 4. 设置问答链
    rag_system.setup_qa_chain()
    
    # 5. 开始问答
    print("\n" + "="*50)
    print("RAG系统已就绪！开始提问吧（输入'退出'结束）")
    print("="*50)
    
    while True:
        question = input("\n请输入你的问题: ").strip()
        
        if question.lower() in ['退出', 'exit', 'quit']:
            print("再见！")
            break
        
        if question:
            rag_system.ask_question(question)

if __name__ == "__main__":
    main()

4.4 代码运行与测试

保存上面的代码为 rag_app.py，确保你的 knowledge.txt 文档在同一个目录下，然后运行：

python rag_app.py

你会看到程序一步步执行：

1. 加载文档
2. 分割文档
3. 创建向量数据库（第一次运行需要一些时间）
4. 设置问答系统

完成后，你就可以开始提问了。试试问一些基于你文档内容的问题，比如：

Cogito模型有多少参数？
模型支持哪些语言？
这个模型有什么特点？

观察模型的回答，你会发现它不仅能回答，还能告诉你答案来自文档的哪个部分。

5. 实际应用示例与技巧

现在基础系统已经搭建好了，我们来看看怎么让它更实用。

5.1 处理多种文档格式

实际应用中，你的知识库可能包含多种格式的文档。下面是一个增强版的文档加载函数：

def load_multiple_documents(self, folder_path):
    """
    加载文件夹中的所有文档
    folder_path: 包含文档的文件夹路径
    """
    all_documents = []
    
    # 支持的文件类型
    supported_extensions = ['.txt', '.pdf', '.md', '.docx']
    
    for filename in os.listdir(folder_path):
        file_path = os.path.join(folder_path, filename)
        file_ext = os.path.splitext(filename)[1].lower()
        
        if file_ext in supported_extensions:
            try:
                if file_ext == '.txt':
                    loader = TextLoader(file_path, encoding='utf-8')
                elif file_ext == '.pdf':
                    from langchain_community.document_loaders import PyPDFLoader
                    loader = PyPDFLoader(file_path)
                elif file_ext == '.md':
                    from langchain_community.document_loaders import UnstructuredMarkdownLoader
                    loader = UnstructuredMarkdownLoader(file_path)
                elif file_ext == '.docx':
                    from langchain_community.document_loaders import UnstructuredWordDocumentLoader
                    loader = UnstructuredWordDocumentLoader(file_path)
                
                documents = loader.load()
                all_documents.extend(documents)
                print(f"成功加载: {filename}")
                
            except Exception as e:
                print(f"加载 {filename} 时出错: {str(e)}")
    
    print(f"总共加载了 {len(all_documents)} 个文档")
    return all_documents

5.2 优化检索效果

有时候模型可能找不到最相关的信息，或者找到的信息太多。我们可以调整检索策略：

def setup_optimized_retriever(self):
    """
    设置优化的检索器
    """
    # 使用多种检索策略的组合
    from langchain.retrievers import ContextualCompressionRetriever
    from langchain.retrievers.document_compressors import LLMChainExtractor
    
    # 基础检索器
    base_retriever = self.vectorstore.as_retriever(
        search_type="mmr",  # 使用最大边际相关性，兼顾相关性和多样性
        search_kwargs={
            "k": 5,  # 检索5个文档
            "fetch_k": 20,  # 先获取20个，再筛选
            "lambda_mult": 0.7  # 多样性权重
        }
    )
    
    # 使用LLM压缩检索结果（需要额外的模型调用）
    llm = Ollama(model=self.model_name)
    compressor = LLMChainExtractor.from_llm(llm)
    
    # 创建压缩检索器
    compression_retriever = ContextualCompressionRetriever(
        base_compressor=compressor,
        base_retriever=base_retriever
    )
    
    return compression_retriever

5.3 添加对话历史

让系统记住之前的对话，可以提供更连贯的体验：

class ConversationalRAGSystem(LocalRAGSystem):
    def __init__(self, model_name="cogito:3b"):
        super().__init__(model_name)
        self.conversation_history = []
    
    def ask_with_history(self, question, max_history=3):
        """
        带对话历史的提问
        max_history: 保留的最大历史对话轮数
        """
        # 构建包含历史的提示
        history_context = ""
        for i, (q, a) in enumerate(self.conversation_history[-max_history:]):
            history_context += f"用户: {q}\n助手: {a}\n\n"
        
        full_question = f"{history_context}用户: {question}\n助手:"
        
        # 获取答案
        result = self.qa_chain({"query": full_question})
        answer = result['result']
        
        # 保存到历史
        self.conversation_history.append((question, answer))
        
        # 限制历史长度
        if len(self.conversation_history) > max_history * 2:
            self.conversation_history = self.conversation_history[-(max_history * 2):]
        
        return result

6. 常见问题与解决方案

在实际使用中，你可能会遇到一些问题。这里我整理了几个常见的情况和解决方法。

6.1 模型回答不准确怎么办？

如果模型给出的答案和文档内容不符，可以尝试以下几个方法：

调整检索数量：在创建检索器时，修改 search_kwargs={"k": 3} 中的数字。增加这个值会让系统检索更多文档，但可能会引入不相关信息；减少这个值会让检索更精准，但可能遗漏重要信息。

优化文档分割：调整 chunk_size 和 chunk_overlap 参数。如果文档分割得太碎，模型可能看不到完整上下文；如果分割得太大，检索可能不够精准。一般建议：

• 普通文档：chunk_size=500, chunk_overlap=50
• 技术文档：chunk_size=800, chunk_overlap=100
• 对话记录：chunk_size=300, chunk_overlap=30

添加指令提示：在提问时，明确告诉模型要基于文档回答：

def ask_with_instruction(self, question):
    enhanced_question = f"""
    请基于提供的文档内容回答以下问题。
    如果文档中没有相关信息，请明确说明"根据文档，没有找到相关信息"。
    
    问题：{question}
    
    请只使用文档中的信息回答。
    """
    return self.qa_chain({"query": enhanced_question})

6.2 处理速度太慢怎么优化？

Cogito-3B模型本身推理速度很快，但如果你的文档很多，创建向量数据库可能会比较慢。可以尝试：

分批处理文档：如果文档很多，不要一次性全部加载，可以分批处理：

def process_large_documents(self, folder_path, batch_size=10):
    """分批处理大量文档"""
    all_chunks = []
    
    # 获取所有文档文件
    doc_files = [f for f in os.listdir(folder_path) if f.endswith(('.txt', '.pdf'))]
    
    # 分批处理
    for i in range(0, len(doc_files), batch_size):
        batch_files = doc_files[i:i+batch_size]
        print(f"处理批次 {i//batch_size + 1}: {batch_files}")
        
        batch_docs = []
        for filename in batch_files:
            file_path = os.path.join(folder_path, filename)
            docs = self.load_documents(file_path)
            batch_docs.extend(docs)
        
        chunks = self.split_documents(batch_docs)
        all_chunks.extend(chunks)
        
        # 每处理完一批就保存一次
        if all_chunks:
            self.create_vector_store(all_chunks)
    
    return all_chunks

使用更快的嵌入模型：我们之前用的 paraphrase-multilingual-MiniLM-L12-v2 是多语言模型，如果你只需要处理中文，可以换成更快的纯中文模型：

# 使用纯中文嵌入模型（速度更快）
embeddings = HuggingFaceEmbeddings(
    model_name="GanymedeNil/text2vec-large-chinese"
)

6.3 如何更新知识库？

当你有新文档需要添加时，不需要重新构建整个向量数据库：

def update_knowledge_base(self, new_documents, persist_directory="./chroma_db"):
    """向现有知识库添加新文档"""
    
    # 加载现有的向量存储
    embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
    )
    
    if os.path.exists(persist_directory):
        # 加载现有的
        existing_store = Chroma(
            persist_directory=persist_directory,
            embedding_function=embeddings
        )
        
        # 分割新文档
        new_chunks = self.split_documents(new_documents)
        
        # 添加新文档
        existing_store.add_documents(new_chunks)
        existing_store.persist()
        
        print(f"成功添加 {len(new_chunks)} 个新文档块")
        self.vectorstore = existing_store
    else:
        # 如果不存在，创建新的
        self.create_vector_store(new_documents, persist_directory)

7. 总结

通过这篇文章，我们完成了一个完整的本地RAG应用搭建。让我们回顾一下关键步骤和收获：

7.1 我们完成了什么？

1. 成功部署了Cogito-v1-preview-llama-3B模型：这个只有30亿参数的模型在本地运行流畅，而且支持混合推理模式，能智能地处理不同复杂度的问题。

2. 构建了完整的RAG系统：我们使用LangChain框架，结合Chroma向量数据库，创建了一个能够理解并基于文档内容回答问题的智能系统。

3. 实现了实用的功能：系统支持多种文档格式、能记住对话历史、可以优化检索效果，还能方便地更新知识库。

4. 解决了常见问题：针对回答不准确、处理速度慢等实际问题，提供了具体的解决方案和优化建议。

7.2 这个方案的优势

完全本地运行：所有数据都在你的电脑上，不需要联网，保护了隐私和安全。

成本极低：除了电费，几乎没有其他成本。Cogito-3B模型对硬件要求不高，普通笔记本电脑就能运行。

灵活可定制：你可以根据自己的需求调整每个环节——文档处理方式、检索策略、提示词设计等。

易于扩展：这个框架可以轻松扩展到更多功能，比如支持更多文件格式、添加网页抓取能力、集成其他工具等。

7.3 下一步可以做什么？

如果你对这个系统感兴趣，还可以尝试以下扩展：

添加Web界面：用Gradio或Streamlit创建一个简单的网页界面，让非技术人员也能方便使用。

集成更多工具：让模型不仅能回答问题，还能执行操作，比如查询天气、发送邮件等。

优化性能：尝试不同的嵌入模型、调整检索参数、使用缓存等技术来提升响应速度。

处理更复杂的文档：比如带有表格、图片的文档，或者整个网站的内容。

最重要的是，现在你有了一个可以实际使用的本地AI助手。你可以用它来管理个人知识库、辅助学习研究、或者作为项目的智能文档查询系统。

技术的价值在于应用。希望这个教程能帮你迈出第一步，在实际使用中不断优化和改进，打造出真正适合自己需求的AI应用。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。