【实战分享】构建企业级RAG（Retrieval-Augmented Generation）知识库的全面实践

成本节约
- 人工成本节约 = 咨询人员平均工资 × 节省人力数量 × 12个月
- 系统投资回报周期 = 系统总投资 ÷ 年度成本节约
效率提升
- 响应时间提升 = (人工响应平均时间 - 系统响应时间) ÷ 人工响应平均时间 × 100%
- 咨询量提升 = (系统日均处理量 - 人工日均处理量) ÷ 人工日均处理量 × 100%

1.2.3.2 间接价值

知识资产沉淀
经验数字化
持续积累
可量化评估
服务质量提升
标准化响应
全时段服务
多语言支持

1.3 应用场景

企业级知识库在多个场景中得到了应用，主要包括：

客服自动化：为客户提供24/7的自动化问答服务。
员工培训：帮助新员工快速了解公司流程、制度和业务。
技术支持：快速响应技术问题和帮助请求。
文档管理：通过智能检索管理大量企业文档，提高效率。

1.3.1 应用场景分析

1. 技术支持

产品文档查询
故障诊断指导
API 使用说明
员工服务
新员工入职指引
规章制度咨询
业务流程指导
客户服务
产品咨询
售后支持
投诉处理

二、大模型与RAG技术介绍

2.1 大模型的概念

大模型指的是训练参数量极其庞大的深度学习模型，如GPT-3、GPT-4等。这些模型能够通过海量的数据学习，具备强大的语言理解和生成能力。在问答系统中，大模型能够理解用户提出的问题，并生成相关的回答。

2.1.1 大模型技术现状

1. 主流大模型对比

GPT系列
Claude
通义千问
文心一言
局限性分析
知识时效性受限
专业领域深度不足
幻觉问题
计算成本高

2.2 RAG技术

RAG（Retrieval Augmented Generation）是结合信息检索与生成技术的一种方法。传统的生成模型虽然能够生成流畅的回答，但在特定领域的问题上往往缺乏精准的知识。RAG技术通过在生成之前，首先检索相关的知识内容，将这些检索到的信息作为上下文提供给生成模型，从而提高生成结果的准确性和相关性。

RAG模型的基本流程是：

信息检索：从知识库中检索与用户问题相关的信息。
生成回答：基于检索到的信息生成回答。

RAG技术能够显著提高问答系统的性能，特别是在处理复杂的企业级问题时，效果尤为明显。

2.2.1 RAG 技术原理

1. 核心架构

文档处理 -> 向量化 -> 知识库构建 -> 相似度检索 -> 上下文融合 -> 答案生成

关键技术点
文本分块策略
向量表示方法
检索算法优化
提示词工程

2.3 系统架构设计

从代码可以看出系统采用模块化设计:

class QAAssistant:
    def __init__(self, api_key: str = None):
        # 核心组件初始化
        self.doc_processor = DocumentProcessor()  # 文档处理
        self.vector_store = VectorStore()        # 向量存储
        self.session_manager = SessionManager()  # 会话管理
        self.embedding_model = SentenceTransformer() # 向量化模型

三、本地知识库构建详解

RAG 技术架构

graph LR
A[文档输入] --> B[文档处理]
B --> C[文本分块]
C --> D[向量化]
D --> E[向量存储]
F[用户问题] --> G[问题向量化]
G --> H[相似度检索]
E --> H
H --> I[上下文组装]
I --> J[提示词构建]
J --> K[LLM生成]
K --> L[答案输出]

3.1 文本如何预处理，支持哪些格式？

在构建企业级知识库时，首先需要对文档进行预处理。常见的文档格式包括PDF、Word、Excel、Markdown、HTML等。不同格式的处理方式有所不同：

PDF：通常需要解析其中的文本内容，并去除格式信息。
Word/Excel：需要读取文档中的表格、段落等结构化数据。
Markdown/HTML：需要处理其中的标记语言，提取纯文本。

预处理的目标是将文档内容转化为机器易于处理的格式，通常为纯文本格式。

3.1.1 文本预处理

1. 文档格式支持

# 文档处理器配置
supported_formats = {
    'pdf': process_pdf,
    'txt': process_txt,
    'docx': process_docx,
    'md': process_markdown
}

处理流程
文件类型识别
文本提取
格式标准化
清洗过滤

3. 特殊处理

表格结构保持
图片说明提取
页眉页脚过滤
特殊字符处理

3.2 文档切片，切片方式有哪些？

文档切片是将长文档拆分成小块，以便于后续的向量化处理。常见的切片方式有：

按段落切割：适合结构化文本。
按句子切割：适合较短文本，如FAQ类问题。
按固定字数切割：适合长度不规则的文档。

选择切片方式时，需要根据文档的内容结构以及问答场景来确定。通常情况下，按句子或段落切割效果较好，因为能够保留上下文信息。

3.2.1 文档切片策略

1. 切片算法实现:

def _get_extended_context(self, similar_docs: List[Dict]) -> str:
    # 按文档和页码分组
    docs_by_source = {}
    for doc in similar_docs:
        key = (doc['metadata']['source'], doc['metadata']['page'])
        if key not in docs_by_source:
            docs_by_source[key] = []
            
    # 扩展上下文窗口
    extended_indices = set()
    for idx in relevant_indices:
        start = max(0, idx - RAG_CONFIG['context_window'])
        end = min(len(page_segments), idx + RAG_CONFIG['context_window'] + 1)
        extended_indices.update(range(start, end))

2. 切片参数优化

RAG_CONFIG = {
    'max_docs_per_query': 5,    # 每次查询返回文档数
    'min_similarity_score': 0.7, # 最小相似度阈值
    'context_window': 2,        # 上下文窗口大小
    'max_context_length': 2000  # 最大上下文长度
}

3. 切片质量保证

语义完整性
上下文关联
重复内容去除
长度均衡

3.3 文本向量化

文本向量化是将文本转换为数值向量的过程。常用的文本嵌入模型包括：

Word2Vec：将词语嵌入到向量空间，适用于较简单的任务。
BERT：基于Transformer的预训练模型，能捕捉上下文信息。
Sentence-BERT：对BERT进行优化，专注于句子的向量化，适用于相似度计算。

对于企业级知识库构建，推荐使用Sentence-BERT，因为它能生成高质量的句子级别向量。

3.3.1 文本向量化

1. 模型选择

self.embedding_model = SentenceTransformer(MODEL_CONFIG['embedding_model'])

2. 向量化过程

def process_documents(self, dir_path: str = "docs"):
    # 文档处理
    documents = self.doc_processor.process_directory(dir_path)
    
    # 生成向量
    texts = [doc['text'] for doc in documents]
    embeddings = self.embedding_model.encode(texts, show_progress_bar=True)
    
    # 存储向量
    self.vector_store.add_documents(documents, embeddings.tolist())

3. 性能优化

批量处理
缓存机制
并行计算

RAG_CONFIG = {
    'max_docs_per_query': 5,    # 每次查询返回文档数
    'min_similarity_score': 0.7, # 最小相似度阈值
    'context_window': 2,        # 上下文窗口大小
    'max_context_length': 2000  # 最大上下文长度
}

3.4 向量数据库选择

常见的向量数据库有：

Milvus：开源的高效向量数据库，适用于大规模数据存储与检索。
FAISS：由Facebook开发的向量数据库，适合小到中规模的任务。
Pinecone：云服务型的向量数据库，易于扩展。

选择向量数据库时，可以根据数据规模、查询速度和易用性来做决定。

3.4.1 向量存储设计

1. 存储接口定义

class VectorStore:
    def add_documents(self, documents, embeddings):
        """添加文档向量"""
        pass
        
    def search_similar(self, query_vector, top_k, min_score):
        """相似度检索"""
        pass
        
    def get_page_segments(self, source, page):
        """获取页面分段"""
        pass

2. 索引优化

HNSW索引
IVF索引
混合索引策略

3.5 Milvus介绍

Milvus是一个开源的向量数据库，专为高效的向量存储和检索设计。Milvus支持多种索引方式（如IVF、HNSW等），并提供高效的查询和检索功能。

索引构建：Milvus通过创建索引加速查询速度。常用的索引包括IVF（倒排索引）和HNSW（图结构索引）。
查询说明：Milvus支持通过相似度查询、范围查询等方式高效检索向量数据。

3.6 大模型选择

选择大模型时，可以根据需求选择合适的预训练模型。例如：

GPT系列：适用于生成和理解自然语言。
T5/PaLM：更适合处理生成性任务和文本理解。

结合RAG技术，选择适合的生成模型能够提升企业问答系统的精度和响应速度。

四、Python企业知识库实践

4.1 Sentence-BERT模型实现向量化

利用Sentence-BERT对文本进行高效向量化处理。
编写Python脚本，加载预训练模型，进行文本向量化。

from sentence_transformers import SentenceTransformer

# 加载Sentence-BERT模型
model = SentenceTransformer('paraphrase-MiniLM-L6-v2')

# 文本示例
texts = ["企业如何实现数字化转型？", "如何提高团队的工作效率？"]
# 向量化
embeddings = model.encode(texts)

4.2 Milvus Lite存储向量化数据

安装并配置Milvus Lite。
将向量化后的数据存入Milvus Lite中，构建向量索引。

from pymilvus import connections, Collection

# 连接Milvus数据库
connections.connect("default", host="localhost", port="19530")

# 创建Collection
collection = Collection("faq_knowledge_base")
# 将向量数据插入Milvus
collection.insert([embeddings])

4.3 读取本地PDF文件，检索向量知识库答案

使用Python库（如PyMuPDF）读取PDF文件，提取文本内容。
对提取的文本进行预处理和向量化。
利用Milvus Lite进行向量检索，找到与查询问题最相似的文本片段作为答案。

from PyPDF2 import PdfReader

# 读取PDF文件
reader = PdfReader('example.pdf')
text = ""
for page in reader.pages:
    text += page.extract_text()

# 进行文本切片、向量化并存入Milvus

4.4 企业级知识库问答系统实践demo

整合上述步骤，构建企业级知识库问答系统demo。
提供用户查询接口，展示问答结果。
进行系统测试和性能评估，确保系统稳定性和准确性。

# 用户输入
user_query = "如何提升客户满意度？"

# 检索相关向量
query_embedding = model.encode([user_query])
results = collection.search(query_embedding, "embedding_field")

五、后续优化点

5.1 PDF导入的智能切分

研究PDF文档结构，实现智能切分算法。
通过实验验证切分效果，优化算法参数。

5.2 知识库检索内容完整性

引入多模态检索技术，结合文本、图像等信息。
优化索引构建算法，提高检索效率和准确性。

5.3 提示词编写

分析用户查询习惯，编写有效的提示词。
通过用户反馈不断优化提示词库。

5.4 TEXT TO SQL实践难点

研究自然语言与SQL之间的映射关系。
解决自然语言歧义性和SQL语法复杂性。

5.5 用户多轮对话实现

利用对话管理系统（如Rasa、Dialogflow）实现多轮对话。
优化对话流程，提高用户体验。

5.6 智能报表展示

结合数据可视化技术（如Echarts、Tableau）实现智能报表展示。
提供丰富的图表和报表类型，满足用户多样化需求。

5.7 多智能体交互

研究多智能体协作机制，实现知识库问答系统与其他智能系统的交互。
优化交互流程，提高系统整体性能。

后续优化方向

知识库增强
多模态内容支持
知识图谱集成
实时更新机制
多源数据融合
交互体验
多轮对话优化
意图理解增强
答案解释能力
个性化定制
系统扩展
分布式部署支持
多语言能力增强
业务流程集成
安全性强化
监控运维
性能指标面板
异常预警机制
用户反馈分析
持续优化流程

最佳实践建议

文档管理
建立文档更新机制
规范文档格式标准
实施版本控制
定期清理无效内容
系统配置
根据实际需求调整参数
建立配置变更流程
保持配置文件简洁
做好配置备份
性能优化
定期进行性能评估
识别性能瓶颈
优化检索策略
合理使用缓存
安全防护
实施访问控制
数据加密存储
审计日志记录
定期安全评估

通过以上的实现和优化建议，可以构建一个高性能、可靠的企业级知识库问答系统。根据实际需求，可以进一步调整和优化相关参数和功能。

六、总结

构建企业级RAG问答知识库是一项复杂而具有挑战性的任务。通过本文的介绍和实践，我们了解了知识库构建的基本步骤和关键技术，并实现了一个初步的Python问答机器人demo。然而，这只是一个起点，后续还需要在智能切分、检索完整性、对话管理等方面进行深入研究和优化。相信随着人工智能技术的不断发展和完善，企业级RAG问答知识库将为企业带来更多的价值和机遇。

附录

1. 文档处理模块

class DocumentProcessor:
    def __init__(self):
        self.processors = {
            'pdf': self._process_pdf,
            'docx': self._process_docx,
            'txt': self._process_txt,
            'md': self._process_markdown
        }
        
    def process_directory(self, dir_path: str) -> List[Dict]:
        """处理目录下的所有文档"""
        documents = []
        for root, _, files in os.walk(dir_path):
            for file in files:
                file_path = os.path.join(root, file)
                ext = file_path.split('.')[-1].lower()
                if ext in self.processors:
                    try:
                        docs = self.processors[ext](file_path)
                        documents.extend(docs)
                    except Exception as e:
                        logger.error(f"处理文件 {file_path} 失败: {str(e)}")
        return documents

    def _process_pdf(self, file_path: str) -> List[Dict]:
        """PDF文档处理"""
        documents = []
        try:
            with pdfplumber.open(file_path) as pdf:
                for page_num, page in enumerate(pdf.pages, 1):
                    # 提取文本
                    text = page.extract_text()
                    
                    # 提取表格
                    tables = page.extract_tables()
                    if tables:
                        table_text = self._format_tables(tables)
                        text = f"{text}\n\n表格内容:\n{table_text}"
                    
                    # 处理图片说明
                    images = page.images
                    if images:
                        image_text = self._extract_image_captions(images)
                        text = f"{text}\n\n图片说明:\n{image_text}"
                    
                    documents.append({
                        'text': text,
                        'metadata': {
                            'source': file_path,
                            'page': page_num,
                            'type': 'pdf'
                        }
                    })
        except Exception as e:
            logger.error(f"PDF处理错误 {file_path}: {str(e)}")
            raise
            
        return documents

2. 文本分块模块

class TextSplitter:
    def __init__(self, 
                 chunk_size: int = 1000,
                 chunk_overlap: int = 200,
                 separator: str = "\n"):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.separator = separator
        
    def split_text(self, text: str) -> List[str]:
        """智能文本分块"""
        chunks = []
        
        # 首先按分隔符切分
        segments = text.split(self.separator)
        
        current_chunk = []
        current_length = 0
        
        for segment in segments:
            segment_length = len(segment)
            
            # 如果单个段落超过chunk_size，需要进一步分割
            if segment_length > self.chunk_size:
                if current_chunk:
                    chunks.append(self.separator.join(current_chunk))
                    current_chunk = []
                    current_length = 0
                
                # 对长段落进行分割
                sub_chunks = self._split_long_segment(segment)
                chunks.extend(sub_chunks)
                continue
            
            # 检查是否需要启动新的chunk
            if current_length + segment_length > self.chunk_size:
                chunks.append(self.separator.join(current_chunk))
                
                # 保留重叠部分
                overlap_start = max(0, len(current_chunk) - self.chunk_overlap)
                current_chunk = current_chunk[overlap_start:]
                current_length = sum(len(s) for s in current_chunk)
            
            current_chunk.append(segment)
            current_length += segment_length
        
        # 处理最后一个chunk
        if current_chunk:
            chunks.append(self.separator.join(current_chunk))
            
        return chunks
        
    def _split_long_segment(self, segment: str) -> List[str]:
        """处理超长段落"""
        words = segment.split()
        chunks = []
        current_chunk = []
        current_length = 0
        
        for word in words:
            word_length = len(word)
            if current_length + word_length > self.chunk_size:
                chunks.append(" ".join(current_chunk))
                current_chunk = []
                current_length = 0
            
            current_chunk.append(word)
            current_length += word_length
            
        if current_chunk:
            chunks.append(" ".join(current_chunk))
            
        return chunks

3. 向量存储模块

class VectorStore:
    def __init__(self, 
                 dimension: int = 768,
                 index_type: str = 'HNSW',
                 metric_type: str = 'L2'):
        """初始化向量存储"""
        self.dimension = dimension
        self.index_type = index_type
        self.metric_type = metric_type
        self.collection = None
        self._init_collection()
        
    def _init_collection(self):
        """初始化集合"""
        try:
            # 连接Milvus
            connections.connect(
                alias="default", 
                host='localhost', 
                port='19530'
            )
            
            # 创建集合
            fields = [
                FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
                FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=self.dimension),
                FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
                FieldSchema(name="metadata", dtype=DataType.JSON)
            ]
            
            schema = CollectionSchema(
                fields=fields,
                description="Document embeddings"
            )
            
            self.collection = Collection(
                name="document_store",
                schema=schema,
                using='default'
            )
            
            # 创建索引
            index_params = {
                "metric_type": self.metric_type,
                "index_type": self.index_type,
                "params": {"M": 8, "efConstruction": 64}
            }
            
            self.collection.create_index(
                field_name="embedding",
                index_params=index_params
            )
            
        except Exception as e:
            logger.error(f"初始化向量存储失败: {str(e)}")
            raise
            
    def add_documents(self, 
                     documents: List[Dict],
                     embeddings: List[List[float]]):
        """添加文档到向量存储"""
        try:
            # 准备数据
            ids = [i for i in range(len(documents))]
            texts = [doc['text'] for doc in documents]
            metadata = [doc['metadata'] for doc in documents]
            
            # 插入数据
            entities = [
                ids,
                embeddings,
                texts,
                metadata
            ]
            
            self.collection.insert(entities)
            
            # 强制刷新以确保数据可见性
            self.collection.flush()
            
        except Exception as e:
            logger.error(f"添加文档失败: {str(e)}")
            raise
            
    def search_similar(self,
                      query_vector: List[float],
                      top_k: int = 5,
                      min_score: float = 0.7) -> List[Dict]:
        """搜索相似文档"""
        try:
            self.collection.load()
            
            # 执行搜索
            search_param = {
                "metric_type": self.metric_type,
                "params": {"ef": 64}
            }
            
            results = self.collection.search(
                data=[query_vector],
                anns_field="embedding",
                param=search_param,
                limit=top_k,
                expr=None,
                output_fields=["text", "metadata"]
            )
            
            # 处理结果
            similar_docs = []
            for hits in results:
                for hit in hits:
                    if hit.score >= min_score:
                        similar_docs.append({
                            'text': hit.entity.get('text'),
                            'metadata': hit.entity.get('metadata'),
                            'score': hit.score
                        })
                        
            return similar_docs
            
        except Exception as e:
            logger.error(f"搜索相似文档失败: {str(e)}")
            raise
        finally:
            self.collection.release()

4. 问答核心模块

class QAAssistant:
    def __init__(self, api_key: str = None):
        """初始化问答助手"""
        self._init_api_key(api_key)
        self._init_components()
        self._init_prompt_template()
        
    def _init_api_key(self, api_key: str):
        """初始化API密钥"""
        if api_key:
            dashscope.api_key = api_key
        else:
            dashscope.api_key = os.getenv('DASHSCOPE_API_KEY')
            
        if not dashscope.api_key:
            raise ValueError("请设置通义千问API密钥")
            
    def _init_components(self):
        """初始化组件"""
        try:
            self.doc_processor = DocumentProcessor()
            self.text_splitter = TextSplitter()
            self.vector_store = VectorStore()
            self.session_manager = SessionManager()
            self.embedding_model = SentenceTransformer(
                MODEL_CONFIG['embedding_model']
            )
        except Exception as e:
            logger.error(f"初始化组件失败: {str(e)}")
            raise
            
    def _init_prompt_template(self):
        """初始化提示词模板"""
        self.prompt_template = """
        你是一个专业的企业知识库问答助手。我会给你以下信息：

        1. 相关文档片段：
        {context}

        2. 最近的对话历史：
        {history}

        3. 当前问题：
        {question}

        请你：
        1. 仔细阅读上述信息
        2. 基于文档内容提供准确答案
        3. 如果文档信息不足，请明确指出
        4. 回答要专业、准确、简洁
        5. 适当引用原文支持你的回答

        你的回答：
        """
        
    def get_answer(self, 
                   question: str,
                   session_id: str = None,
                   temperature: float = 0.7) -> str:
        """获取问题答案"""
        try:
            # 会话管理
            session_id = session_id or str(uuid.uuid4())
            session = self.session_manager.get_session(session_id)
            
            # 问题向量化
            query_embedding = self.embedding_model.encode(question)
            
            # 相似文档检索
            similar_docs = self.vector_store.search_similar(
                query_embedding.tolist(),
                top_k=RAG_CONFIG['max_docs_per_query'],
                min_score=RAG_CONFIG['min_similarity_score']
            )
            
            # 获取扩展上下文
            if similar_docs:
                context = self._get_extended_context(similar_docs)
            else:
                context = "未找到相关文档。"
            
            # 获取历史对话
            history = session.get_recent_context()
            
            # 构建提示词
            prompt = self.prompt_template.format(
                context=context,
                history=history,
                question=question
            )
            
            # 生成答案
            answer = self._get_answer_with_retry(
                prompt=prompt,
                temperature=temperature
            )
            
            # 记录交互
            session.add_interaction(
                question=question,
                answer=answer,
                context_docs=similar_docs
            )
            
            return answer
            
        except Exception as e:
            logger.error(f"获取答案失败: {str(e)}")
            return f"抱歉，处理您的问题时出现错误: {str(e)}"

5. 会话管理模块

class Session:
    def __init__(self, session_id: str, max_history: int = 5):
        self.session_id = session_id
        self.max_history = max_history
        self.interactions = []
        self.created_at = time.time()
        self.last_active = time.time()
        
    def add_interaction(self, 
                       question: str, 
                       answer: str, 
                       context_docs: List[Dict]):
        """添加对话交互记录"""
        self.interactions.append({
            'timestamp': time.time(),
            'question': question,
            'answer': answer,
            'context_docs': context_docs
        })
        
        # 保持历史记录在限定范围内
        if len(self.interactions) > self.max_history:
            self.interactions = self.interactions[-self.max_history:]
            
        self.last_active = time.time()
        
    def get_recent_context(self, max_tokens: int = 2000) -> str:
        """获取最近的对话历史"""
        history_texts = []
        total_tokens = 0
        
        for interaction in reversed(self.interactions):
            qa_pair = (
                f"问：{interaction['question']}\n"
                f"答：{interaction['answer']}\n"
            )
            
            # 估算token数量
            tokens = len(qa_pair) // 4  # 粗略估算
            if total_tokens + tokens > max_tokens:
                break
                
            history_texts.append(qa_pair)
            total_tokens += tokens
            
        return "\n".join(reversed(history_texts))

class SessionManager:
    def __init__(self, 
                 session_timeout: int = 3600,  # 1小时超时
                 cleanup_interval: int = 300):  # 5分钟清理一次
        self.sessions = {}
        self.session_timeout = session_timeout
        self.cleanup_interval = cleanup_interval
        self.last_cleanup = time.time()
        
    def get_session(self, session_id: str) -> Session:
        """获取或创建会话"""
        self._cleanup_expired_sessions()
        
        if session_id not in self.sessions:
            self.sessions[session_id] = Session(session_id)
        return self.sessions[session_id]
        
    def _cleanup_expired_sessions(self):
        """清理过期会话"""
        current_time = time.time()
        
        # 检查是否需要清理
        if current_time - self.last_cleanup < self.cleanup_interval:
            return
            
        expired_sessions = []
        for session_id, session in self.sessions.items():
            if current_time - session.last_active > self.session_timeout:
                expired_sessions.append(session_id)
                
        for session_id in expired_sessions:
            del self.sessions[session_id]
            
        self.last_cleanup = current_time

6. 错误处理与重试机制

class RetryHandler:
    def __init__(self, 
                 max_retries: int = 3,
                 base_delay: float = 1.0,
                 max_delay: float = 10.0,
                 exponential_base: float = 2.0):
        self.max_retries = max_retries
        self.base_delay = base_delay
        self.max_delay = max_delay
        self.exponential_base = exponential_base
        
    def execute_with_retry(self, 
                          func: Callable,
                          *args,
                          **kwargs) -> Any:
        """执行带重试的操作"""
        last_exception = None
        
        for attempt in range(self.max_retries):
            try:
                return func(*args, **kwargs)
                
            except Exception as e:
                last_exception = e
                
                # 计算延迟时间
                delay = min(
                    self.base_delay * (self.exponential_base ** attempt),
                    self.max_delay
                )
                
                # 添加随机抖动
                delay *= (0.5 + random.random())
                
                logger.warning(
                    f"第{attempt + 1}次尝试失败: {str(e)}, "
                    f"{delay:.2f}秒后重试"
                )
                
                time.sleep(delay)
                
        raise last_exception

class APIError(Exception):
    """API调用错误"""
    def __init__(self, 
                 message: str,
                 status_code: Optional[int] = None,
                 response: Optional[Any] = None):
        super().__init__(message)
        self.status_code = status_code
        self.response = response

7. 向量检索优化

class OptimizedVectorStore(VectorStore):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.cache = LRUCache(maxsize=1000)
        
    def search_similar(self,
                      query_vector: List[float],
                      top_k: int = 5,
                      min_score: float = 0.7,
                      use_cache: bool = True) -> List[Dict]:
        """优化的相似度搜索"""
        # 生成查询的缓存键
        if use_cache:
            cache_key = self._generate_cache_key(query_vector, top_k, min_score)
            cached_result = self.cache.get(cache_key)
            if cached_result is not None:
                return cached_result
        
        # 实现多级检索策略
        results = self._multi_stage_search(
            query_vector=query_vector,
            top_k=top_k,
            min_score=min_score
        )
        
        # 缓存结果
        if use_cache:
            self.cache.set(cache_key, results)
            
        return results
        
    def _multi_stage_search(self,
                           query_vector: List[float],
                           top_k: int,
                           min_score: float) -> List[Dict]:
        """多级检索策略"""
        # 第一阶段：粗粒度检索
        coarse_results = self._coarse_search(
            query_vector=query_vector,
            top_k=top_k * 2  # 扩大初筛范围
        )
        
        # 第二阶段：精确重排
        refined_results = self._fine_grained_rerank(
            candidates=coarse_results,
            query_vector=query_vector,
            top_k=top_k,
            min_score=min_score
        )
        
        return refined_results
        
    def _coarse_search(self,
                       query_vector: List[float],
                       top_k: int) -> List[Dict]:
        """粗粒度检索"""
        search_param = {
            "metric_type": self.metric_type,
            "params": {"ef": 64}  # 降低精度换取速度
        }
        
        results = self.collection.search(
            data=[query_vector],
            anns_field="embedding",
            param=search_param,
            limit=top_k,
            expr=None,
            output_fields=["text", "metadata"]
        )
        
        return self._process_search_results(results)
        
    def _fine_grained_rerank(self,
                            candidates: List[Dict],
                            query_vector: List[float],
                            top_k: int,
                            min_score: float) -> List[Dict]:
        """精确重排序"""
        # 使用更精确的相似度计算
        reranked = []
        for doc in candidates:
            score = self._calculate_similarity(
                query_vector,
                doc['embedding']
            )
            if score >= min_score:
                doc['score'] = score
                reranked.append(doc)
                
        # 按相似度排序
        reranked.sort(key=lambda x: x['score'], reverse=True)
        return reranked[:top_k]

8. 监控与日志

class MetricsCollector:
    def __init__(self):
        self.metrics = {
            'requests': 0,
            'successful_responses': 0,
            'failed_responses': 0,
            'average_response_time': 0,
            'cache_hits': 0,
            'cache_misses': 0
        }
        self.response_times = []
        
    def record_request(self):
        """记录请求"""
        self.metrics['requests'] += 1
        
    def record_response(self, 
                       success: bool,
                       response_time: float):
        """记录响应"""
        if success:
            self.metrics['successful_responses'] += 1
        else:
            self.metrics['failed_responses'] += 1
            
        self.response_times.append(response_time)
        self._update_average_response_time()
        
    def record_cache_access(self, hit: bool):
        """记录缓存访问"""
        if hit:
            self.metrics['cache_hits'] += 1
        else:
            self.metrics['cache_misses'] += 1
            
    def _update_average_response_time(self):
        """更新平均响应时间"""
        if self.response_times:
            self.metrics['average_response_time'] = (
                sum(self.response_times) / len(self.response_times)
            )
            
    def get_metrics(self) -> Dict:
        """获取指标统计"""
        return {
            **self.metrics,
            'cache_hit_rate': self._calculate_cache_hit_rate(),
            'success_rate': self._calculate_success_rate()
        }
        
    def _calculate_cache_hit_rate(self) -> float:
        """计算缓存命中率"""
        total = self.metrics['cache_hits'] + self.metrics['cache_misses']
        if total == 0:
            return 0.0
        return self.metrics['cache_hits'] / total
        
    def _calculate_success_rate(self) -> float:
        """计算成功率"""
        total = (self.metrics['successful_responses'] + 
                self.metrics['failed_responses'])
        if total == 0:
            return 0.0
        return self.metrics['successful_responses'] / total

9. 配置管理

class ConfigManager:
    def __init__(self, config_path: str = "config.yaml"):
        self.config_path = config_path
        self.config = self._load_config()
        self._validate_config()
        
    def _load_config(self) -> Dict:
        """加载配置文件"""
        try:
            with open(self.config_path, 'r', encoding='utf-8') as f:
                config = yaml.safe_load(f)
            return config
        except Exception as e:
            logger.error(f"加载配置文件失败: {str(e)}")
            return self._get_default_config()
            
    def _validate_config(self):
        """验证配置有效性"""
        required_fields = [
            'api_key',
            'model_config',
            'vector_store_config',
            'system_config'
        ]
        
        for field in required_fields:
            if field not in self.config:
                raise ValueError(f"配置文件缺少必要字段: {field}")
                
    def _get_default_config(self) -> Dict:
        """获取默认配置"""
        return {
            'model_config': {
                'embedding_model': 'paraphrase-multilingual-mpnet-base-v2',
                'llm_model': 'qwen-turbo',
                'temperature': 0.7,
                'top_p': 0.9,
                'max_tokens': 2000
            },
            'vector_store_config': {
                'dimension': 768,
                'index_type': 'HNSW',
                'metric_type': 'L2'
            },
            'system_config': {
                'max_retries': 3,
                'retry_delay': 1.0,
                'session_timeout': 3600,
                'cleanup_interval': 300
            }
        }
        
    def get_config(self, key: str) -> Any:
        """获取配置项"""
        return self.config.get(key)
        
    def update_config(self, key: str, value: Any):
        """更新配置项"""
        self.config[key] = value
        self._save_config()
        
    def _save_config(self):
        """保存配置到文件"""
        try:
            with open(self.config_path, 'w', encoding='utf-8') as f:
                yaml.safe_dump(self.config, f)
        except Exception as e:
            logger.error(f"保存配置文件失败: {str(e)}")

让我总结一下这个企业级 RAG 知识库问答系统的关键点：

使用建议

1. 部署前准备

# 1. 安装依赖
pip install -r requirements.txt

# 2. 配置环境变量
export DASHSCOPE_API_KEY='your_api_key'

# 3. 准备配置文件
cp config.example.yaml config.yaml

2. 文档处理优化

# 推荐的文档切片参数
CHUNK_CONFIG = {
    'chunk_size': 1000,    # 文本块大小
    'chunk_overlap': 200,  # 重叠长度
    'min_chunk_size': 100  # 最小块大小
}

3. 向量检索调优

# 推荐的检索参数
SEARCH_CONFIG = {
    'top_k': 5,              # 返回文档数
    'min_score': 0.7,        # 最小相似度
    'context_window': 2      # 上下文窗口
}

4. 提示词模板优化

# 建议的提示词结构
PROMPT_TEMPLATE = """
背景信息：
{context}

历史对话：
{history}

当前问题：
{question}

请基于以上信息回答问题，要求：
1. 准确性：必须基于提供的背景信息
2. 完整性：覆盖问题的各个方面
3. 简洁性：回答清晰简洁
4. 可靠性：如信息不足，请明确指出
"""