AnythingLLM源码深度剖析（二）：文档解析与向量化存储原理

CarlowZJ

于 2025-07-09 00:02:17 发布

阅读量798

点赞数 16

CC 4.0 BY-SA版权

文章标签： AnythingLLM

本文链接：https://blog.youkuaiyun.com/csdn122345/article/details/149156268

摘要

本文聚焦于AnythingLLM的文档采集、解析、分块与向量化存储机制，详细剖析其多格式文档处理流程、向量数据库集成原理，并结合Python代码、Mermaid流程图、实践案例，助力中国AI开发者掌握AI知识库底层实现与优化方法。

文档采集与解析流程
多格式文档处理详解
文本分块策略与算法
向量化嵌入模型与算法
向量数据库选型与集成
Python代码实践：文档分块与向量化
实战案例与性能优化
流程图与思维导图
实施计划甘特图
常见问题、反例与最佳实践
未来展望与趋势
扩展阅读与参考资料
总结

文档采集与解析流程

AnythingLLM支持多种文档格式（PDF、Word、TXT、网页、音视频等），通过Collector模块实现文档采集、解析、分块、向量化等一系列处理。

详细架构图

流程说明：

Collector独立进程负责文档采集与解析，支持多种格式自动识别。
文本分块策略可自定义，提升大文档检索效率。
分块后通过嵌入模型转为向量，存入向量数据库。

Collector架构设计

独立进程：与主服务解耦，避免文档处理影响API响应。
插件化解析器：支持自定义格式解析器扩展。
异步处理：大文档分块、向量化异步执行，支持进度回调。
错误恢复：解析失败自动重试，支持断点续传。

部署架构图

高可用设计

多实例部署：API服务器和Collector进程多实例部署
数据库集群：向量数据库和关系数据库集群化部署
缓存策略：Redis集群提供高可用缓存
监控告警：Prometheus + Grafana监控，ELK日志分析
自动扩缩容：根据负载自动调整实例数量

多格式文档处理详解

1. PDF文档处理

技术栈：pdf-parse、pdf2pic等库。
处理流程：PDF → 文本提取 → OCR（图片页） → 分块。
挑战：表格、图片、复杂布局识别。
代码示例：

import pdfplumber
def extract_pdf_text(pdf_path):
    text = ""
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            text += page.extract_text() + "\n"
    return text

2. Word文档处理

技术栈：python-docx、mammoth等。
处理流程：DOCX → 文本提取 → 格式保留 → 分块。
特性：支持表格、图片、超链接提取。

3. 网页内容处理

技术栈：BeautifulSoup、requests等。
处理流程：URL → 网页抓取 → 内容清洗 → 分块。
挑战：反爬虫、动态内容、广告过滤。

4. 音视频转写

技术栈：Whisper、FFmpeg等。
处理流程：音视频 → 音频提取 → 语音识别 → 分块。
支持格式：MP3、MP4、WAV、M4A等。

5. 图片OCR处理

技术栈：Tesseract、PaddleOCR等。
处理流程：图片 → OCR识别 → 文本提取 → 分块。
优化：图片预处理、多语言支持。

文本分块策略与算法

1. 固定长度分块

原理：按字符数/词数固定长度切分。
适用场景：结构化文档、代码文件。
代码示例：

def fixed_length_chunk(text, chunk_size=1000, overlap=100):
    """固定长度分块，支持重叠"""
    chunks = []
    for i in range(0, len(text), chunk_size - overlap):
        chunk = text[i:i + chunk_size]
        if chunk.strip():
            chunks.append(chunk)
    return chunks

2. 语义分块

原理：基于句子边界、段落边界分块。
适用场景：自然语言文档、文章。
算法：NLTK、spaCy等NLP库。

3. 递归分块

原理：先按大粒度分块，再递归细分。
适用场景：层次化文档、长文本。

4. 滑动窗口分块

原理：固定窗口大小，滑动生成重叠块。
优势：保持上下文连续性。
代码示例：

def sliding_window_chunk(text, window_size=1000, step_size=500):
    """滑动窗口分块"""
    chunks = []
    for i in range(0, len(text), step_size):
        chunk = text[i:i + window_size]
        if chunk.strip():
            chunks.append(chunk)
    return chunks

5. 智能分块策略

原理：结合文档结构、语义边界、长度限制。
优化目标：检索精度、响应速度、存储效率。

6. 分块质量评估

def evaluate_chunk_quality(chunks):
    """评估分块质量"""
    metrics = {
        'avg_length': np.mean([len(chunk) for chunk in chunks]),
        'length_variance': np.var([len(chunk) for chunk in chunks]),
        'semantic_coherence': calculate_semantic_coherence(chunks),
        'overlap_ratio': calculate_overlap_ratio(chunks)
    }
    return metrics

def calculate_semantic_coherence(chunks):
    """计算语义连贯性"""
    # 使用嵌入模型计算相邻块的语义相似度
    embeddings = model.encode(chunks)
    similarities = []
    for i in range(len(embeddings) - 1):
        sim = cosine_similarity(embeddings[i], embeddings[i+1])
        similarities.append(sim)
    return np.mean(similarities)

7. 分块策略选择指南

技术文档：按章节、段落分块，保留层次结构
新闻文章：按段落分块，保持语义完整性
代码文件：按函数、类分块，保留代码逻辑
表格数据：按行或列分块，保持数据关联性
长篇小说：按章节分块，保持情节连贯性

向量化嵌入模型与算法

1. 主流嵌入模型对比

OpenAI Embeddings：通用性强，支持多语言。
BGE（BAAI）：中文优化，开源免费。
SentenceTransformer：轻量级，本地部署。
MiniLM：快速推理，适合实时应用。

2. 嵌入算法原理

Word2Vec：词向量，CBOW/Skip-gram。
BERT：双向Transformer，上下文感知。
Sentence-BERT：句子级嵌入，语义相似度。
对比学习：正负样本对比，提升语义理解。

3. 向量化代码实践

from sentence_transformers import SentenceTransformer
import numpy as np

# 加载模型
model = SentenceTransformer('all-MiniLM-L6-v2')

# 文本向量化
texts = ["人工智能正在改变世界", "AI is transforming the world"]
embeddings = model.encode(texts)

# 计算相似度
similarity = np.dot(embeddings[0], embeddings[1]) / (
    np.linalg.norm(embeddings[0]) * np.linalg.norm(embeddings[1])
)
print(f"相似度: {similarity:.4f}")

4. 向量优化策略

维度压缩：PCA、t-SNE降维。
量化：INT8/FP16量化，减少存储。
索引优化：HNSW、IVF等索引算法。

5. 向量质量评估

def evaluate_embedding_quality(embeddings, labels):
    """评估嵌入质量"""
    from sklearn.manifold import TSNE
    from sklearn.cluster import KMeans
    
    # 降维可视化
    tsne = TSNE(n_components=2, random_state=42)
    embeddings_2d = tsne.fit_transform(embeddings)
    
    # 聚类评估
    kmeans = KMeans(n_clusters=len(set(labels)), random_state=42)
    cluster_labels = kmeans.fit_predict(embeddings)
    
    # 计算聚类纯度
    purity = calculate_cluster_purity(cluster_labels, labels)
    
    return {
        'embeddings_2d': embeddings_2d,
        'cluster_purity': purity,
        'avg_similarity': np.mean(embeddings)
    }

6. 嵌入模型微调

def fine_tune_embedding_model(model, train_data, val_data):
    """微调嵌入模型"""
    from sentence_transformers import SentenceTransformer, InputExample
    from torch.utils.data import DataLoader
    
    # 准备训练数据
    train_examples = []
    for text1, text2, label in train_data:
        train_examples.append(InputExample(texts=[text1, text2], label=label))
    
    train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
    
    # 训练模型
    model.fit(train_objectives=[(train_dataloader, train_loss)],
              epochs=3,
              warmup_steps=100,
              show_progress_bar=True)
    
    return model

7. 多语言嵌入处理

def multilingual_embedding(texts, languages):
    """多语言嵌入处理"""
    # 语言检测
    detected_langs = detect_languages(texts)
    
    # 选择对应模型
    embeddings = []
    for text, lang in zip(texts, detected_langs):
        if lang == 'zh':
            model = SentenceTransformer('BAAI/bge-large-zh')
        elif lang == 'en':
            model = SentenceTransformer('all-MiniLM-L6-v2')
        else:
            model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        
        embedding = model.encode([text])[0]
        embeddings.append(embedding)
    
    return np.array(embeddings)

向量数据库选型与集成

AnythingLLM支持多种主流向量数据库，便于不同场景灵活选型：

1. 数据库对比分析

数据库	部署方式	性能	扩展性	成本	适用场景
LanceDB	本地	中等	中等	低	开发测试
PGVector	本地/云	中等	高	中等	企业应用
Pinecone	云原生	高	极高	高	大规模生产
Chroma	本地	中等	中等	低	原型开发
Weaviate	本地/云	高	高	中等	复杂查询
Qdrant	本地/云	高	高	中等	实时检索
Milvus	分布式	极高	极高	高	超大规模

2. 集成架构设计

适配层：统一接口，支持多数据库切换。
连接池：管理数据库连接，提升性能。
事务支持：保证数据一致性。
监控告警：性能监控、异常检测。

3. 代码示例：数据库适配

class VectorDBAdapter:
    def __init__(self, db_type, config):
        self.db_type = db_type
        self.config = config
        self.client = self._init_client()
    
    def _init_client(self):
        if self.db_type == 'chroma':
            import chromadb
            return chromadb.Client()
        elif self.db_type == 'pinecone':
            import pinecone
            pinecone.init(api_key=self.config['api_key'])
            return pinecone.Index(self.config['index_name'])
        elif self.db_type == 'milvus':
            from pymilvus import connections, Collection
            connections.connect(host=self.config['host'], port=self.config['port'])
            return Collection(self.config['collection_name'])
        elif self.db_type == 'weaviate':
            import weaviate
            return weaviate.Client(self.config['url'])
    
    def insert(self, vectors, metadata):
        if self.db_type == 'chroma':
            self.client.add(embeddings=vectors, metadatas=metadata)
        elif self.db_type == 'pinecone':
            self.client.upsert(vectors=vectors, metadata=metadata)
        elif self.db_type == 'milvus':
            self.client.insert([vectors, metadata])
        elif self.db_type == 'weaviate':
            self.client.data_object.create(vectors, metadata)
    
    def search(self, query_vector, top_k=10):
        if self.db_type == 'chroma':
            return self.client.query(query_embeddings=[query_vector], n_results=top_k)
        elif self.db_type == 'pinecone':
            return self.client.query(vector=query_vector, top_k=top_k)
        elif self.db_type == 'milvus':
            return self.client.search(query_vector, top_k)
        elif self.db_type == 'weaviate':
            return self.client.query.get("Document", ["content"]).with_near_vector({
                "vector": query_vector
            }).with_limit(top_k).do()

4. 数据库性能对比测试

import time
import numpy as np

def benchmark_vector_db(db_type, vectors, queries):
    """向量数据库性能基准测试"""
    adapter = VectorDBAdapter(db_type, config)
    
    # 插入性能测试
    start_time = time.time()
    adapter.insert(vectors, metadata)
    insert_time = time.time() - start_time
    
    # 查询性能测试
    query_times = []
    for query in queries:
        start_time = time.time()
        results = adapter.search(query, top_k=10)
        query_times.append(time.time() - start_time)
    
    return {
        'insert_time': insert_time,
        'avg_query_time': np.mean(query_times),
        'max_query_time': np.max(query_times)
    }

5. 数据库选型决策树

数据规模 < 1M向量：Chroma、LanceDB
数据规模 1M-10M向量：PGVector、Weaviate
数据规模 > 10M向量：Pinecone、Milvus
实时性要求高：Qdrant、Pinecone
成本敏感：Chroma、LanceDB
企业级需求：PGVector、Weaviate

Python代码实践：文档分块与向量化

以下为简化版文档分块与向量化存储示例，便于理解底层原理：

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sentence_transformers import SentenceTransformer
import chromadb

class DocumentProcessor:
    def __init__(self, chunk_size=1000, overlap=200):
        self.chunk_size = chunk_size
        self.overlap = overlap
        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
        self.vector_db = chromadb.Client()
    
    def split_document(self, text):
        """智能分块策略"""
        # 按句子分割
        sentences = text.split('。')
        chunks = []
        current_chunk = ""
        
        for sentence in sentences:
            if len(current_chunk) + len(sentence) > self.chunk_size:
                if current_chunk:
                    chunks.append(current_chunk.strip())
                current_chunk = sentence
            else:
                current_chunk += sentence + "。"
        
        if current_chunk:
            chunks.append(current_chunk.strip())
        
        return chunks
    
    def vectorize_chunks(self, chunks):
        """向量化文本块"""
        embeddings = self.embedding_model.encode(chunks)
        return embeddings
    
    def store_vectors(self, embeddings, metadata):
        """存储到向量数据库"""
        collection = self.vector_db.create_collection("documents")
        collection.add(
            embeddings=embeddings.tolist(),
            metadatas=metadata,
            ids=[f"doc_{i}" for i in range(len(embeddings))]
        )
    
    def search_similar(self, query, top_k=5):
        """语义搜索"""
        query_embedding = self.embedding_model.encode([query])
        collection = self.vector_db.get_collection("documents")
        results = collection.query(
            query_embeddings=query_embedding.tolist(),
            n_results=top_k
        )
        return results

# 使用示例
processor = DocumentProcessor()
text = "人工智能正在改变世界。" * 100
chunks = processor.split_document(text)
embeddings = processor.vectorize_chunks(chunks)
processor.store_vectors(embeddings, [{"source": "test"} for _ in chunks])
results = processor.search_similar("AI技术")

说明： 实际项目中建议用OpenAI、BGE、SentenceTransformer等嵌入模型，向量数据库用官方SDK对接。

实战案例与性能优化

案例1：大规模文档处理优化

背景：企业知识库包含10万+文档，处理耗时过长。
优化策略：
- 并行处理：多进程/多线程并发解析。
- 增量更新：只处理新增/修改文档。
- 缓存机制：复用已解析的文档块。
代码示例：

from concurrent.futures import ProcessPoolExecutor
import multiprocessing

def process_document_batch(docs):
    with ProcessPoolExecutor(max_workers=multiprocessing.cpu_count()) as executor:
        results = list(executor.map(process_single_doc, docs))
    return results

案例2：多语言文档处理

背景：国际化企业，文档包含中英日韩等多语言。
解决方案：
- 语言检测：自动识别文档语言。
- 多模型支持：不同语言使用对应嵌入模型。
- 混合检索：支持跨语言语义搜索。

案例3：实时文档更新

背景：文档频繁更新，需要实时同步到知识库。
实现方案：
- 文件监控：监控文档变化事件。
- 增量处理：只处理变化部分。
- 版本控制：维护文档版本历史。

性能优化技巧

批量处理：批量向量化，减少API调用。
索引优化：合理设置向量索引参数。
内存管理：大文档分片处理，避免内存溢出。
缓存策略：热点查询结果缓存。

性能基准测试

import time
import psutil
import threading
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

class PerformanceBenchmark:
    def __init__(self):
        self.results = {}
    
    def benchmark_document_processing(self, documents, chunk_sizes=[500, 1000, 2000]):
        """文档处理性能基准测试"""
        for chunk_size in chunk_sizes:
            start_time = time.time()
            start_memory = psutil.Process().memory_info().rss / 1024 / 1024  # MB
            
            # 处理文档
            processor = DocumentProcessor(chunk_size=chunk_size)
            chunks = []
            for doc in documents:
                doc_chunks = processor.split_document(doc.text)
                chunks.extend(doc_chunks)
            
            end_time = time.time()
            end_memory = psutil.Process().memory_info().rss / 1024 / 1024  # MB
            
            self.results[f'chunk_size_{chunk_size}'] = {
                'processing_time': end_time - start_time,
                'memory_usage': end_memory - start_memory,
                'total_chunks': len(chunks),
                'avg_chunk_length': sum(len(chunk) for chunk in chunks) / len(chunks)
            }
        
        return self.results
    
    def benchmark_vector_search(self, vector_db, queries, top_k_values=[5, 10, 20]):
        """向量搜索性能基准测试"""
        search_results = {}
        
        for top_k in top_k_values:
            query_times = []
            for query in queries:
                start_time = time.time()
                results = vector_db.search(query, top_k=top_k)
                query_times.append(time.time() - start_time)
            
            search_results[f'top_k_{top_k}'] = {
                'avg_query_time': sum(query_times) / len(query_times),
                'max_query_time': max(query_times),
                'min_query_time': min(query_times),
                'total_queries': len(queries)
            }
        
        return search_results
    
    def benchmark_concurrent_processing(self, documents, max_workers=[1, 2, 4, 8]):
        """并发处理性能基准测试"""
        concurrent_results = {}
        
        for workers in max_workers:
            start_time = time.time()
            
            with ThreadPoolExecutor(max_workers=workers) as executor:
                futures = [executor.submit(self.process_single_document, doc) for doc in documents]
                results = [future.result() for future in futures]
            
            end_time = time.time()
            
            concurrent_results[f'workers_{workers}'] = {
                'total_time': end_time - start_time,
                'throughput': len(documents) / (end_time - start_time),
                'avg_time_per_doc': (end_time - start_time) / len(documents)
            }
        
        return concurrent_results
    
    def generate_performance_report(self):
        """生成性能报告"""
        report = {
            'document_processing': self.results,
            'summary': {
                'best_chunk_size': min(self.results.items(), key=lambda x: x[1]['processing_time'])[0],
                'memory_efficiency': min(self.results.items(), key=lambda x: x[1]['memory_usage'])[0],
                'recommendations': self.generate_recommendations()
            }
        }
        return report
    
    def generate_recommendations(self):
        """生成优化建议"""
        recommendations = []
        
        # 基于处理时间的建议
        fastest = min(self.results.items(), key=lambda x: x[1]['processing_time'])
        recommendations.append(f"最快处理速度: {fastest[0]} (耗时: {fastest[1]['processing_time']:.2f}s)")
        
        # 基于内存使用的建议
        most_efficient = min(self.results.items(), key=lambda x: x[1]['memory_usage'])
        recommendations.append(f"最省内存: {most_efficient[0]} (内存: {most_efficient[1]['memory_usage']:.2f}MB)")
        
        # 基于分块质量的建议
        best_quality = max(self.results.items(), key=lambda x: x[1]['avg_chunk_length'])
        recommendations.append(f"最佳分块质量: {best_quality[0]} (平均长度: {best_quality[1]['avg_chunk_length']:.0f}字符)")
        
        return recommendations

性能监控仪表板

import dash
from dash import dcc, html
import plotly.graph_objs as go
import pandas as pd

def create_performance_dashboard(benchmark_results):
    """创建性能监控仪表板"""
    app = dash.Dash(__name__)
    
    # 处理时间对比图
    processing_times = [result['processing_time'] for result in benchmark_results.values()]
    chunk_sizes = [key.replace('chunk_size_', '') for key in benchmark_results.keys()]
    
    app.layout = html.Div([
        html.H1('文档处理性能监控'),
        
        dcc.Graph(
            id='processing-time-chart',
            figure=go.Figure(
                data=[go.Bar(x=chunk_sizes, y=processing_times)],
                layout=go.Layout(
                    title='不同分块大小的处理时间对比',
                    xaxis={'title': '分块大小'},
                    yaxis={'title': '处理时间(秒)'}
                )
            )
        ),
        
        dcc.Graph(
            id='memory-usage-chart',
            figure=go.Figure(
                data=[go.Scatter(x=chunk_sizes, y=[result['memory_usage'] for result in benchmark_results.values()])],
                layout=go.Layout(
                    title='内存使用情况',
                    xaxis={'title': '分块大小'},
                    yaxis={'title': '内存使用(MB)'}
                )
            )
        )
    ])
    
    return app

案例4：高并发检索优化

背景：在线客服系统，需要支持1000+并发查询。
优化方案：
- 查询缓存：Redis缓存热点查询结果。
- 连接池：数据库连接池管理。
- 异步处理：非阻塞查询处理。
代码示例：

import redis
import asyncio
from functools import lru_cache

class OptimizedSearchEngine:
    def __init__(self):
        self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
        self.cache_ttl = 3600  # 1小时缓存
    
    @lru_cache(maxsize=1000)
    def cached_search(self, query_hash):
        """缓存查询结果"""
        return self.vector_search(query_hash)
    
    async def async_search(self, query, top_k=10):
        """异步搜索"""
        query_hash = hash(query)
        cache_key = f"search:{query_hash}"
        
        # 检查缓存
        cached_result = self.redis_client.get(cache_key)
        if cached_result:
            return cached_result
        
        # 执行搜索
        result = await self.vector_search_async(query, top_k)
        
        # 缓存结果
        self.redis_client.setex(cache_key, self.cache_ttl, result)
        return result

案例5：多模态文档处理

背景：企业知识库包含PDF、图片、视频等多种格式。
解决方案：
- 统一处理流程：所有格式转换为文本。
- OCR增强：图片文字识别。
- 视频转写：语音转文字。
- 元数据提取：保留格式信息。

案例6：知识图谱集成

背景：需要构建实体关系图谱，提升检索精度。
实现方案：
- 实体识别：NER提取关键实体。
- 关系抽取：构建实体关系。
- 图谱存储：Neo4j存储图谱数据。
- 混合检索：向量+图谱联合检索。

流程图与思维导图

在这里插入图片描述

mindmap
  root((文档解析与向量化知识体系))
    采集
      Collector
      多格式支持
      异步处理
    解析
      格式识别
      文本提取
      分块策略
      智能分块
    嵌入
      OpenAI
      BGE
      SentenceTransformer
      对比学习
    存储
      LanceDB
      Pinecone
      Milvus
      适配层
    检索
      语义搜索
      相关性排序
      混合检索
    实践
      自定义解析器
      大文档优化
      多语言支持
      实时更新

实施计划甘特图

常见问题、反例与最佳实践

常见问题

Q1：大文档如何高效分块？

建议采用滑动窗口、重叠分块等策略，提升上下文连续性。

Q2：如何选择嵌入模型？

英文推荐OpenAI/BGE，中文推荐BGE/SentenceTransformer。

Q3：向量数据库如何扩展？

选用支持分布式和云原生的数据库（如Pinecone、Milvus），并结合分片与副本机制。

Q4：如何处理多语言文档？

使用多语言嵌入模型，或分别处理不同语言文档。

Q5：如何优化检索性能？

合理设置索引参数，使用混合检索策略，缓存热点查询。

反例与教训

反例1： 固定长度分块导致语义断裂，检索效果差。
反例2： 未考虑文档结构，表格、图片信息丢失。
反例3： 向量数据库选型不当，性能瓶颈明显。
反例4： 未做数据预处理，噪声数据影响检索质量。
反例5： 嵌入模型选择不当，语义理解不准确。
反例6： 缺乏监控告警，系统故障无法及时发现。

详细问题解答

Q6：如何处理文档中的表格数据？

使用专门的表格解析库（如tabula-py），将表格转换为结构化文本，保留行列关系。

Q7：向量数据库如何备份和恢复？

定期导出向量数据和元数据，支持增量备份和全量恢复。

Q8：如何评估检索效果？

使用准确率、召回率、F1分数等指标，结合人工评估。

Q9：如何处理文档更新？

实现增量更新机制，只重新处理变化的部分。

Q10：如何优化嵌入模型？

使用领域数据微调，提升特定场景的语义理解能力。

最佳实践

分块粒度与检索需求匹配，避免过大或过小。
嵌入模型与业务场景适配，定期评估效果。
数据库定期备份，保障数据安全。
监控处理性能，及时优化瓶颈。
支持增量更新，避免全量重建。

性能监控与告警

import logging
import time
from prometheus_client import Counter, Histogram, Gauge

class PerformanceMonitor:
    def __init__(self):
        self.processing_time = Histogram('document_processing_seconds', 'Document processing time')
        self.chunk_count = Counter('chunks_processed_total', 'Total chunks processed')
        self.embedding_quality = Gauge('embedding_quality_score', 'Embedding quality score')
        self.error_count = Counter('processing_errors_total', 'Total processing errors')
    
    def monitor_processing(self, func):
        """监控处理性能的装饰器"""
        def wrapper(*args, **kwargs):
            start_time = time.time()
            try:
                result = func(*args, **kwargs)
                self.processing_time.observe(time.time() - start_time)
                return result
            except Exception as e:
                self.error_count.inc()
                logging.error(f"Processing error: {e}")
                raise
        return wrapper

数据质量保障

def validate_document_quality(document):
    """验证文档质量"""
    issues = []
    
    # 检查文档长度
    if len(document.text) < 100:
        issues.append("文档过短，可能信息不足")
    
    # 检查编码问题
    if '?' in document.text or '' in document.text:
        issues.append("文档存在编码问题")
    
    # 检查重复内容
    if has_duplicate_content(document.text):
        issues.append("文档存在重复内容")
    
    # 检查格式问题
    if not has_proper_structure(document.text):
        issues.append("文档结构不规范")
    
    return issues

def has_duplicate_content(text, threshold=0.8):
    """检测重复内容"""
    sentences = text.split('。')
    for i, sent1 in enumerate(sentences):
        for j, sent2 in enumerate(sentences[i+1:], i+1):
            similarity = calculate_similarity(sent1, sent2)
            if similarity > threshold:
                return True
    return False

错误处理与恢复

class DocumentProcessor:
    def __init__(self):
        self.retry_count = 3
        self.backup_strategy = 'incremental'
    
    def process_with_retry(self, document):
        """带重试的文档处理"""
        for attempt in range(self.retry_count):
            try:
                return self.process_document(document)
            except Exception as e:
                if attempt == self.retry_count - 1:
                    self.handle_final_failure(document, e)
                    raise
                else:
                    self.handle_retry(document, e, attempt)
                    time.sleep(2 ** attempt)  # 指数退避
    
    def handle_final_failure(self, document, error):
        """处理最终失败"""
        logging.error(f"Document processing failed: {document.id}, error: {error}")
        self.mark_as_failed(document)
        self.notify_admin(document, error)
    
    def handle_retry(self, document, error, attempt):
        """处理重试"""
        logging.warning(f"Retry {attempt + 1} for document {document.id}: {error}")
        self.save_progress(document, attempt)