对知识库内容进行分片与预处理，表面上看似常规的技术步骤，但深入探究后会发现，这背后蕴藏着 RAG（检索增强生成）系统设计的一套精妙逻辑。先从最根本的挑战说起：大语言模型天然存在输入长度限制，无论模型多么先进，token 数量始终是硬性约束。通过合理分片，我们可以优雅地处理任意长度的文档——就像把一本厚重的书拆解成易于理解的章节。然而，仅靠分片远远不够：想象一下，你翻开一本书的某一页，却完全不知道前后文，能真正理解这一页的内容吗？这正是预处理的核心价值所在。

目录

• 01 上下文检索预处理流程
• 02 与传统检索方式对比
• 03 上下文预处理的核心优势
• 04 关键代码实现与解析

01 上下文检索预处理流程

（Contextual Retrieval Preprocessing）流程

1. 开始阶段 — 知识库处理
   从知识库 (Corpus) 中获取文档，并将文档切分成多个文本块（Chunk 1, Chunk 2, … Chunk X）。
2. 上下文处理阶段
   对每个分片使用特定的 prompt 进行处理——该 prompt 的目标是确定该文本块在整个文档结构中的位置或语义关系。Claude 会为每个 prompt 生成 50–100 tokens 的相关背景信息，然后将这些背景信息插入到对应文本段的开头。
3. 向量化阶段
   Embedding 模型生成向量嵌入，TF-IDF 处理生成 TF-IDF 向量。将上下文与分片组合（Context 1 + Chunk 1, Context 2 + Chunk 2, etc.），并采用两种方式处理组合后的内容。
4. 检索准备阶段
   向量嵌入存入向量数据库用于语义相似性搜索，TF-IDF 向量存入 TF-IDF 索引，最终实现类似 Elasticsearch 关键词检索的全文搜索功能（由 BM25 提供）。

02 与传统检索方式对比

该流程最大的特点在于：它将语义理解（通过 Claude 生成上下文）与传统检索方法（TF-IDF）有机结合，提供了更全面的检索能力。用户查询时，可以通过向量相似性搜索找到语义相关的内容，同时也能通过关键词匹配精准定位。这种预处理方式显著提升了检索的准确性与相关性。

举个形象的例子：为每个分片生成 50–100 tokens 的上下文描述，相当于给每一张“书页”都贴上了导航标签，帮助系统理解该段内容在整体文档中的定位和意义。

更巧妙的是，这种设计采用了“双引擎”驱动：

• 向量数据库负责理解语义相似性，就像理解“苹果”和“水果”之间的关联；
• TF-IDF 处理则精确捕捉关键词，就像在书中精确定位一个专有名词。

这种预处理不仅提升了检索的准确性，还大幅优化了系统响应速度。毕竟，提前做好功课总比临时抱佛脚高效得多。

03 上下文预处理的核心优势

1. 解决长文本处理的限制
   绝大多数模型都有输入长度限制（token 限制），通过分片可以处理任意长度的文档，每个分片大小控制在模型能够高效处理的范围内。
2. 提升检索准确性
   单纯的文本分片可能会丢失上下文信息。通过给每个分片添加上下文描述（Context），保留了文档的结构和语义连贯性。预处理生成的上下文有助于理解该分片在整个文档中的位置与作用。
3. 优化检索效率
   预计算的向量和 TF-IDF 能够显著提升检索速度，避免了实时处理带来的计算开销。双重索引（向量数据库 + TF-IDF）提供了多种检索路径，满足不同场景需求。
4. 平衡语义理解与关键词匹配
   向量检索擅长捕捉语义相似性，TF-IDF 擅长精确的关键词匹配，两种方法互补，有效提升检索的综合表现。
5. 提升检索质量
   携带上下文的分片比孤立的文本片段能更好地回答用户问题，减少因分片导致的信息碎片化，更容易定位到真正相关的内容。
6. 灵活性与可扩展性
   分片大小可根据实际需求调整，预处理步骤可以根据应用场景灵活增减，索引方式也可以根据业务需求选择。

04 关键代码实现与解析

import numpy as np
from typing import List, Dict, Tuple
from dataclasses import dataclass
from transformers import AutoTokenizer, AutoModel
from sklearn.feature_extraction.text import TfidfVectorizer
import torch
import nltk
from nltk.tokenize import sent_tokenize
nltk.download('punkt')

@dataclass
class Document:
    content: str
    metadata: Dict = None

@dataclass
class Chunk:
    content: str
    context: str = ""
    metadata: Dict = None

class DocumentPreprocessor:
    def __init__(self, 
                 embedding_model_name: str = "sentence-transformers/all-MiniLM-L6-v2",
                 max_chunk_size: int = 512,
                 overlap_size: int = 50):
        self.tokenizer = AutoTokenizer.from_pretrained(embedding_model_name)
        self.model = AutoModel.from_pretrained(embedding_model_name)
        self.max_chunk_size = max_chunk_size
        self.overlap_size = overlap_size
        self.tfidf_vectorizer = TfidfVectorizer()

    def chunk_document(self, document: Document) -> List[Chunk]:
        """Split document into overlapping chunks based on sentence boundaries"""
        sentences = sent_tokenize(document.content)
        chunks = []
        current_chunk = []
        current_length = 0

        for sentence in sentences:
            sentence_tokens = self.tokenizer.tokenize(sentence)
            sentence_length = len(sentence_tokens)

            if current_length + sentence_length > self.max_chunk_size and current_chunk:
                chunk_text = " ".join(current_chunk)
                chunks.append(Chunk(content=chunk_text, metadata=document.metadata))

                overlap_sentences = current_chunk[-2:] if len(current_chunk) > 2 else current_chunk
                current_chunk = overlap_sentences + [sentence]
                current_length = sum(len(self.tokenizer.tokenize(s)) for s in current_chunk)
            else:
                current_chunk.append(sentence)
                current_length += sentence_length

        if current_chunk:
            chunks.append(Chunk(content=" ".join(current_chunk), metadata=document.metadata))
        return chunks

    def generate_context(self, chunk: Chunk, document: Document) -> str:
        """Generate context description for a chunk using a template prompt"""
        prompt_template = """

{{WHOLE_DOCUMENT}}

Here is the chunk we want to situate within the whole document

{{CHUNK_CONTENT}}

Please give a short succinct context to situate this chunk within the overall document for 
the purposes of improving search retrieval of the chunk. Answer only with the succinct context 
and nothing else.
"""
        chunk_position = document.content.find(chunk.content)
        total_length = len(document.content)
        position_description = "beginning" if chunk_position < total_length/3 else \
                               "middle" if chunk_position < 2*total_length/3 else "end"
        return f"This section appears in the {position_description} of the document and discusses {chunk.content[:50]}..."

    def compute_embeddings(self, chunks: List[Chunk]) -> np.ndarray:
        """Generate embeddings for chunks using the embedding model"""
        embeddings = []
        for chunk in chunks:
            full_text = f"{chunk.context} {chunk.content}"
            inputs = self.tokenizer(full_text, return_tensors="pt", 
                                    truncation=True, max_length=self.max_chunk_size)
            with torch.no_grad():
                outputs = self.model(**inputs)
                embedding = outputs.last_hidden_state[0][0].numpy()
            embeddings.append(embedding)
        return np.array(embeddings)

    def compute_tfidf(self, chunks: List[Chunk]) -> Tuple[np.ndarray, TfidfVectorizer]:
        """Compute TF-IDF vectors for chunks"""
        texts = [f"{chunk.context} {chunk.content}" for chunk in chunks]
        tfidf_matrix = self.tfidf_vectorizer.fit_transform(texts)
        return tfidf_matrix, self.tfidf_vectorizer

    def process_document(self, document: Document) -> Tuple[List[Chunk], np.ndarray, np.ndarray]:
        """Complete preprocessing pipeline for a document"""
        chunks = self.chunk_document(document)
        for chunk in chunks:
            chunk.context = self.generate_context(chunk, document)
        embeddings = self.compute_embeddings(chunks)
        tfidf_matrix, _ = self.compute_tfidf(chunks)
        return chunks, embeddings, tfidf_matrix

if __name__ == "__main__":
    doc = Document(
        content="""
Machine learning is a subset of artificial intelligence that focuses on developing systems 
that can learn from data. Deep learning is a subset of machine learning that uses neural 
networks with multiple layers. These neural networks are designed to automatically learn 
representations of data with multiple levels of abstraction.

Modern deep learning has achieved remarkable success in many fields, including computer vision,
natural language processing, and robotics. The key to this success has been the a vailability 
of large datasets and powerful computing resources.
""",
        metadata={"title": "Introduction to Deep Learning", "author": "AI Researcher"}
    )
    preprocessor = DocumentPreprocessor()
    chunks, embeddings, tfidf_matrix = preprocessor.process_document(doc)
    print(f"Number of chunks: {len(chunks)}")
    print(f"Embedding shape: {embeddings.shape}")
    print(f"TF-IDF matrix shape: {tfidf_matrix.shape}")
    print("nFirst chunk:")
    print(f"Context: {chunks[0].context}")
    print(f"Content: {chunks[0].content}")