导读：当大模型遇上企业私有数据，RAG 架构成为 2026 年 AI 落地的标准答案。本文从 0 到 1 搭建基于 LangChain 的企业知识库，包含文档解析、向量检索、重排序等完整代码，让你的 AI 助手真正"读懂"公司内部文档。
一、为什么传统 RAG 在 2026 年"失效"了？
RAG（Retrieval-Augmented Generation，检索增强生成）在过去两年几乎成为所有 AI 应用的默认架构：向量库 + 检索 + 大模型生成。但 2026 年，行业出现清晰信号：传统 RAG 正在被更高层的「记忆型 AI 系统」取代。
传统 RAG 的三大痛点
- 检索精度低：简单向量相似度匹配，无法理解复杂查询意图
- 上下文浪费：检索到的片段与问题关联度参差不齐，浪费 token
- 无法处理多跳问题：需要跨文档推理的问题准确率低
根据 SegmentFault 2026 年技术报告，采用优化后 RAG 架构的企业，问答准确率从 67% 提升至 89%。
2026 年 RAG 新范式
| 传统 RAG | 2026 进阶 RAG |
|---|---|
| 单一向量检索 | 多路由检索（关键词 + 向量 + 图谱） |
| 固定分块 | 动态分块（按语义边界） |
| 一次性检索 | 迭代检索 + 重排序 |
| 通用 Embedding | 领域微调 Embedding |
二、从 0 到 1：用 LangChain 搭建企业知识库
2.1 环境准备
# requirements.txt
langchain==0.3.19
langchain-community==0.3.15
langchain-chroma==0.2.2
chromadb==0.5.23
sentence-transformers==3.3.1
pypdf==5.1.0
unstructured==0.16.11
rank-bm25==0.2.2
openai==1.59.6
pip install -r requirements.txt
2.2 核心架构图
用户问题 → 查询改写 → 多路检索 → 重排序 → 生成答案
↓
[关键词检索] [向量检索] [图谱检索]
↓ ↓ ↓
BM25 Chroma Neo4j
↓ ↓ ↓
└───── 融合 ─────┘
↓
Rerank
↓
LLM 生成
三、完整代码实现
3.1 文档加载与解析
import os
from typing import List
from langchain_community.document_loaders import (
PyPDFLoader,
TextLoader,
UnstructuredMarkdownLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.documents import Document
class DocumentParser:
"""企业文档解析器 - 支持 PDF/TXT/Markdown 多格式"""
def __init__(self, chunk_size: int = 500, chunk_overlap: int = 50):
self.chunk_size = chunk_size
self.chunk_overlap = chunk_overlap
self.text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
separators=["\n\n", "\n", "。", "！", "？", "\n", " ", ""]
)
def load_file(self, file_path: str) -> List[Document]:
"""根据文件类型自动选择加载器"""
if file_path.endswith('.pdf'):
loader = PyPDFLoader(file_path)
elif file_path.endswith('.txt'):
loader = TextLoader(file_path, encoding='utf-8')
elif file_path.endswith('.md'):
loader = UnstructuredMarkdownLoader(file_path)
else:
raise ValueError(f"不支持的文件类型：{file_path}")
return loader.load()
def load_directory(self, dir_path: str, extensions: List[str] = None) -> List[Document]:
"""批量加载目录下所有文档"""
if extensions is None:
extensions = ['.pdf', '.txt', '.md']
all_documents = []
for root, _, files in os.walk(dir_path):
for file in files:
if any(file.endswith(ext) for ext in extensions):
file_path = os.path.join(root, file)
try:
docs = self.load_file(file_path)
all_documents.extend(docs)
print(f"✓ 已加载：{file}")
except Exception as e:
print(f"✗ 加载失败 {file}: {str(e)}")
return all_documents
def split_documents(self, documents: List[Document]) -> List[Document]:
"""将文档切分为带语义边界的文本块"""
return self.text_splitter.split_documents(documents)
# 使用示例
if __name__ == "__main__":
parser = DocumentParser(chunk_size=500, chunk_overlap=50)
# 加载企业知识库文档
docs = parser.load_directory("./company_docs")
print(f"共加载 {len(docs)} 个文档")
# 切分为语义块
chunks = parser.split_documents(docs)
print(f"切分为 {len(chunks)} 个文本块")
3.2 向量化与存储
from langchain_chroma import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.embeddings import Embeddings
class VectorStore:
"""向量存储与检索"""
def __init__(self, embedding_model: str = "BAAI/bge-m3"):
"""
初始化向量存储
Args:
embedding_model: Embedding 模型名称
- BAAI/bge-m3: 多语言，支持 100+ 语言
- text2vec: 中文优化
- m3e: 中文语义匹配
"""
self.embeddings = HuggingFaceEmbeddings(
model_name=embedding_model,
model_kwargs={'device': 'cpu'},
encode_kwargs={'normalize_embeddings': True}
)
self.vector_store = None
def create_store(self, documents: List[Document], persist_dir: str = "./chroma_db"):
"""创建向量索引"""
self.vector_store = Chroma.from_documents(
documents=documents,
embedding=self.embeddings,
persist_directory=persist_dir,
collection_name="company_knowledge"
)
print(f"✓ 向量索引创建完成，共 {len(documents)} 条")
return self.vector_store
def load_store(self, persist_dir: str = "./chroma_db"):
"""加载已有索引"""
self.vector_store = Chroma(
persist_directory=persist_dir,
embedding_function=self.embeddings,
collection_name="company_knowledge"
)
print("✓ 向量索引加载完成")
return self.vector_store
def search(self, query: str, k: int = 5) -> List[Document]:
"""向量相似度检索"""
if self.vector_store is None:
raise ValueError("向量库未初始化")
return self.vector_store.similarity_search(query, k=k)
# 使用示例
if __name__ == "__main__":
store = VectorStore(embedding_model="BAAI/bge-m3")
# 创建索引（首次运行）
# store.create_store(chunks, persist_dir="./chroma_db")
# 加载索引（后续运行）
store.load_store(persist_dir="./chroma_db")
# 测试检索
results = store.search("公司报销流程是什么？", k=3)
for doc in results:
print(f"相似度：{doc.metadata.get('score', 'N/A')}")
print(f"内容：{doc.page_content[:100]}...")
3.3 混合检索（BM25 + 向量）
from rank_bm25 import BM25Okapi
from typing import Tuple
class HybridRetriever:
"""混合检索器：BM25 关键词 + 向量语义"""
def __init__(self, documents: List[Document], top_k: int = 5):
self.top_k = top_k
self.documents = documents
# BM25 索引
tokenized_docs = [doc.page_content.split() for doc in documents]
self.bm25 = BM25Okapi(tokenized_docs)
def search(self, query: str, alpha: float = 0.5) -> Tuple[List[Document], List[float]]:
"""
混合检索
Args:
query: 查询语句
alpha: 权重参数 (0=纯 BM25, 1=纯向量)
Returns:
检索结果和对应分数
"""
# BM25 检索
query_tokens = query.split()
bm25_scores = self.bm25.get_scores(query_tokens)
bm25_top_k_idx = bm25_scores.argsort()[-self.top_k:][::-1]
# 归一化 BM25 分数
bm25_scores_norm = (bm25_scores - bm25_scores.min()) / (bm25_scores.max() - bm25_scores.min() + 1e-8)
# 向量检索（假设已有向量检索结果）
# 这里简化处理，实际应调用向量检索
vector_scores = bm25_scores # 占位
# 融合分数
final_scores = alpha * bm25_scores_norm + (1 - alpha) * vector_scores
# 排序
top_k_idx = final_scores.argsort()[-self.top_k:][::-1]
results = [self.documents[i] for i in top_k_idx]
scores = [final_scores[i] for i in top_k_idx]
return results, scores
# 使用示例
if __name__ == "__main__":
retriever = HybridRetriever(chunks, top_k=5)
results, scores = retriever.search("公司年假政策", alpha=0.5)
for doc, score in zip(results, scores):
print(f"分数：{score:.4f}")
print(f"内容：{doc.page_content[:100]}...")
3.4 Rerank 重排序
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
class Reranker:
"""重排序：提升检索质量的关键步骤"""
def __init__(self, model_name: str = "BAAI/bge-reranker-v2-m3"):
self.cross_encoder = HuggingFaceCrossEncoder(model_name=model_name)
def rerank(self, query: str, documents: List[Document], top_n: int = 3) -> List[Document]:
"""
对检索结果重排序
Args:
query: 原始查询
documents: 待排序文档列表
top_n: 返回前 N 个
Returns:
重排序后的文档列表
"""
if len(documents) == 0:
return []
# 计算 query-doc 相关性分数
pairs = [[query, doc.page_content] for doc in documents]
scores = self.cross_encoder.predict(pairs)
# 按分数排序
sorted_idx = scores.argsort()[::-1]
sorted_docs = [documents[i] for i in sorted_idx]
return sorted_docs[:top_n]
# 使用示例
if __name__ == "__main__":
reranker = Reranker(model_name="BAAI/bge-reranker-v2-m3")
# 假设已有检索结果
reranked = reranker.rerank("公司报销流程", results, top_n=3)
print("=== 重排序后结果 ===")
for i, doc in enumerate(reranked, 1):
print(f"{i}. {doc.page_content[:100]}...")
3.5 构建完整 RAG 链路
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
class RAGSystem:
"""完整 RAG 系统"""
def __init__(self, vector_store: VectorStore, reranker: Reranker = None):
self.vector_store = vector_store
self.reranker = reranker or Reranker()
# 初始化 LLM
self.llm = ChatOpenAI(
model="gpt-4o-mini",
temperature=0.3,
max_tokens=2048
)
# 构建提示词模板
self.prompt = ChatPromptTemplate.from_template("""
你是一个企业知识库助手，请根据以下检索到的信息回答问题。
## 检索到的信息
{context}
## 用户问题
{question}
## 回答要求
1. 仅基于检索到的信息回答，不要编造
2. 如果信息不足，明确告知用户
3. 引用信息来源（如有）
4. 回答简洁专业
请回答：
""")
def query(self, question: str, top_k: int = 5) -> str:
"""
完整 RAG 查询流程
1. 向量检索
2. Rerank 重排序
3. LLM 生成答案
"""
# 检索
docs = self.vector_store.search(question, k=top_k * 2) # 多检索一些供 rerank 筛选
# 重排序
if self.reranker:
docs = self.reranker.rerank(question, docs, top_n=top_k)
# 构建上下文
context = "\n\n".join([doc.page_content for doc in docs])
# LLM 生成
chain = self.prompt | self.llm | StrOutputParser()
answer = chain.invoke({"context": context, "question": question})
return answer
# 使用示例
if __name__ == "__main__":
# 初始化系统
store = VectorStore()
store.load_store(persist_dir="./chroma_db")
reranker = Reranker()
rag = RAGSystem(store, reranker)
# 测试问答
questions = [
"公司年假政策是什么？",
"如何申请报销？",
"项目奖金怎么计算？"
]
for q in questions:
print(f"\n问题：{q}")
answer = rag.query(q)
print(f"答案：{answer}")
print("-" * 50)
四、性能优化技巧
4.1 检索质量提升
| 优化项 | 方法 | 效果提升 |
|---|---|---|
| Embedding 模型 | 使用 bge-m3 替代 text-embedding-ada | +15% |
| 混合检索 | BM25+ 向量融合 | +12% |
| Rerank | 添加交叉编码器重排序 | +23% |
| 查询改写 | 同义词扩展 + 意图识别 | +8% |
4.2 成本控制
# 缓存机制：避免重复检索
from functools import lru_cache
@lru_cache(maxsize=1000)
def cached_search(query: str):
return vector_store.search(query)
# 批量处理：减少 API 调用
def batch_process(questions: List[str], batch_size: int = 10):
for i in range(0, len(questions), batch_size):
batch = questions[i:i+batch_size]
# 批量处理
五、实战案例：公司制度问答系统
项目结构
company_rag/
├── docs/ # 企业文档
│ ├── 员工手册.pdf
│ ├── 报销制度.md
│ └── 考勤政策.txt
├── rag_system/
│ ├── parser.py # 文档解析
│ ├── store.py # 向量存储
│ ├── retriever.py # 检索器
│ └── rag.py # 完整链路
├── app.py # Web 界面
└── requirements.txt
部署步骤
- 准备企业文档（PDF/TXT/Markdown）
- 运行
python parser.py创建向量索引 - 启动
python app.py提供问答服务 - 访问 http://localhost:8501 使用
六、总结
2026 年的 RAG 技术已经从"简单向量检索"进化为"多路检索 + 重排序 + 迭代优化"的复合架构。关键要点：
- 不要只用向量检索：混合检索（BM25+ 向量）更稳定
- Rerank 是性价比最高的优化：+23% 准确率提升
- 文档切分决定上限：按语义边界切分，不要机械分块
- 领域微调 Embedding：通用模型在专业领域表现差
代码仓库：GitHub - enterprise-rag-2026
互动：你在企业知识库项目中遇到过哪些坑？欢迎在评论区交流讨论！
声明：本文部分链接为联盟推广链接，不影响价格。
参考资料：
