LangChain.js+RAG企业级知识库实战：从原理到完整项目部署

RAG技术LangChain.js企业级知识库

于 2026-07-31 04:08:35 修改

·本内容遵循CC 4.0 BY-SA版权协议

这次我们来看一个基于 LangChain.js 和 RAG 技术构建企业级知识库的完整项目实战。这个项目不仅提供了完整的源码解析，更重要的是展示了如何将前沿的 AI 技术落地到实际业务场景中，打造类似字节跳动火山 AI 的知识库系统。

对于 AI 全栈开发者来说，掌握 RAG（检索增强生成）技术已经成为必备技能。这个项目最大的价值在于它提供了从零到一的完整实现方案，包括前端界面、后端服务、向量数据库集成和大模型调用等核心模块。无论是想要学习 RAG 技术原理，还是需要快速搭建企业知识库系统，这个项目都值得深入研究和实践。

1. 核心能力速览

能力项	说明
技术栈	LangChain.js + Node.js + 向量数据库 + 大模型 API
主要功能	文档上传、智能检索、问答生成、知识管理
部署方式	本地开发环境、Docker 容器化部署
硬件要求	普通开发机即可运行，无需高端 GPU
扩展性	支持多数据源接入、可定制检索策略
适用场景	企业文档管理、智能客服、内部知识库

2. RAG 技术原理与项目价值

RAG（Retrieval-Augmented Generation）技术通过结合检索和生成两个阶段，有效解决了大模型在处理专业知识时的局限性。传统的纯生成式模型容易产生"幻觉"问题，即在缺乏相关知识的情况下编造答案。RAG 技术首先从知识库中检索相关文档片段，然后基于检索结果生成回答，显著提升了回答的准确性和可靠性。

这个项目的核心价值在于它提供了一个完整的 RAG 系统实现方案。与单纯的理论讲解不同，项目包含了实际可运行的代码，涵盖了文档处理、向量化、检索、生成等完整流程。开发者可以通过这个项目快速理解 RAG 技术的实现细节，并基于此进行二次开发。

从技术架构角度看，项目采用了模块化设计，各个组件之间耦合度低，便于扩展和维护。前端负责用户交互和结果展示，后端处理业务逻辑和 AI 能力调用，向量数据库负责高效检索，大模型提供生成能力。这种分层架构确保了系统的可扩展性和稳定性。

3. 环境准备与依赖安装

在开始项目部署之前，需要确保开发环境满足基本要求。推荐使用 Node.js 16 或以上版本，同时需要准备 Python 环境用于部分数据处理任务。

首先检查 Node.js 版本：

BASH

node --version

npm --version

如果版本过低，建议使用 nvm（Node Version Manager）进行版本管理：

BASH

# 安装 nvm

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# 安装最新 LTS 版本

nvm install --lts

nvm use --lts

项目依赖的主要包包括：

JSON

{

"dependencies": {

"langchain": "^0.0.xx",

"express": "^4.18.0",

"cors": "^2.8.5",

"dotenv": "^16.0.0",

"multer": "^1.4.5"

}

安装项目依赖：

BASH

# 克隆项目代码

git clone <项目仓库地址>

cd rag-knowledge-base

# 安装依赖

npm install

# 或者使用 yarn

yarn install

环境变量配置是项目运行的关键，需要创建 .env 文件并配置相关参数：

BASH

# 大模型 API 配置

OPENAI_API_KEY=your_openai_api_key

OPENAI_BASE_URL=your_api_base_url

# 向量数据库配置

VECTOR_DB_TYPE=pinecone # 或 chroma、weaviate

VECTOR_DB_URL=your_vector_db_url

VECTOR_DB_API_KEY=your_vector_db_api_key

# 服务器配置

PORT=3000

NODE_ENV=development

4. 项目架构与核心模块解析

项目的整体架构采用典型的分层设计，主要包括表示层、业务逻辑层和数据访问层。表示层负责用户界面和 API 接口，业务逻辑层处理核心的 RAG 流程，数据访问层负责与向量数据库和大模型的交互。

核心模块包括文档处理模块、向量化模块、检索模块和生成模块。文档处理模块支持多种格式的文件上传和解析，包括 PDF、Word、Excel、TXT 等格式。向量化模块将文本内容转换为向量表示，便于后续的相似度检索。检索模块基于向量相似度从知识库中查找相关文档片段。生成模块将检索结果与大模型结合，生成准确可靠的回答。

文档处理模块的实现细节：

JAVASCRIPT

class DocumentProcessor {

constructor() {

this.supportedFormats = ['.pdf', '.docx', '.txt', '.md'];

}

async processFile(filePath) {

const extension = path.extname(filePath).toLowerCase();

let content = '';

switch(extension) {

case '.pdf':

content = await this.extractFromPDF(filePath);

break;

case '.docx':

content = await this.extractFromDocx(filePath);

break;

case '.txt':

case '.md':

content = await this.extractFromText(filePath);

break;

default:

throw new Error(`Unsupported file format: ${extension}`);

}

return this.splitIntoSegments(content);

}

splitIntoSegments(content, segmentSize = 1000) {

// 实现文本分块逻辑

const segments = [];

for (let i = 0; i < content.length; i += segmentSize) {

segments.push(content.slice(i, i + segmentSize));

}

return segments;

}

向量化模块使用 LangChain.js 提供的嵌入模型：

JAVASCRIPT

const { OpenAIEmbeddings } = require('langchain/embeddings/openai');

class VectorizationService {

constructor() {

this.embeddings = new OpenAIEmbeddings({

openAIApiKey: process.env.OPENAI_API_KEY

});

}

async generateEmbeddings(texts) {

try {

const embeddings = await this.embeddings.embedDocuments(texts);

return embeddings;

} catch (error) {

console.error('Embedding generation failed:', error);

throw error;

}

5. 数据库设计与向量存储方案

向量数据库的选择对 RAG 系统性能有重要影响。项目支持多种向量数据库，包括 Pinecone、Chroma 和 Weaviate。每种数据库都有其特点，开发者可以根据具体需求选择合适的方案。

Pinecone 作为云原生的向量数据库，提供了出色的性能和可扩展性，适合生产环境使用。Chroma 是一个轻量级的开源向量数据库，部署简单，适合开发和测试环境。Weaviate 则提供了更丰富的元数据管理能力。

数据库表结构设计需要考虑文档存储、向量索引和检索记录等需求：

JAVASCRIPT

// 文档表结构

const documentSchema = {

id: 'string',

filename: 'string',

content: 'text',

segments: 'array',

embeddings: 'vector',

metadata: 'object',

createdAt: 'timestamp',

updatedAt: 'timestamp'

};

// 检索记录表结构

const searchHistorySchema = {

id: 'string',

query: 'string',

results: 'array',

timestamp: 'timestamp',

userId: 'string'

};

向量索引的创建和优化是性能关键：

JAVASCRIPT

class VectorIndexManager {

constructor(vectorDB) {

this.vectorDB = vectorDB;

}

async createIndex(indexName, dimension = 1536) {

const indexConfig = {

name: indexName,

dimension: dimension,

metric: 'cosine', // 余弦相似度

pods: 1,

replicas: 1,

podType: 'p1.x1'

};

await this.vectorDB.createIndex(indexConfig);

}

async optimizeIndex(indexName) {

// 索引优化逻辑

await this.vectorDB.optimizeIndex(indexName);

}

6. 前端界面开发与用户体验优化

前端界面采用现代化的 Web 技术栈，确保良好的用户体验和响应式设计。界面主要包括文档上传区、问答交互区和知识库管理区。

文档上传区支持拖拽上传和批量上传，实时显示上传进度和状态。问答交互区提供清晰的对话界面，支持历史记录查看和答案溯源。知识库管理区允许用户查看、搜索和管理已上传的文档。

关键的前端组件实现：

JAVASCRIPT

// 文档上传组件

class DocumentUploader extends React.Component {

state = {

uploading: false,

progress: 0,

uploadedFiles: []

};

handleFileUpload = async (files) => {

this.setState({ uploading: true, progress: 0 });

const formData = new FormData();

files.forEach(file => {

formData.append('documents', file);

});

try {

const response = await axios.post('/api/documents/upload', formData, {

onUploadProgress: (progressEvent) => {

const progress = Math.round(

(progressEvent.loaded * 100) / progressEvent.total

);

this.setState({ progress });

}

});

this.setState({

uploading: false,

uploadedFiles: [...this.state.uploadedFiles, ...response.data.files]

});

} catch (error) {

console.error('Upload failed:', error);

this.setState({ uploading: false });

}

};

render() {

return (

{({getRootProps, getInputProps}) => (

<p>拖拽文件到这里或点击选择</p>

</div>

)}

</Dropzone>

{this.state.uploading && (

)}

</div>

);

}

问答界面的实时交互实现：

JAVASCRIPT

class ChatInterface extends React.Component {

state = {

messages: [],

inputText: '',

loading: false

};

handleSendMessage = async () => {

const { inputText, messages } = this.state;

if (!inputText.trim()) return;

const newMessages = [...messages, { role: 'user', content: inputText }];

this.setState({ messages: newMessages, inputText: '', loading: true });

try {

const response = await axios.post('/api/chat', {

message: inputText,

history: messages

});

this.setState({

messages: [...newMessages, { role: 'assistant', content: response.data.answer }],

loading: false

});

} catch (error) {

console.error('Chat error:', error);

this.setState({

messages: [...newMessages, { role: 'assistant', content: '抱歉，出现了一些问题。' }],

loading: false

});

}

};

render() {

return (

<InputArea

value={this.state.inputText}

onChange={(text) => this.setState({ inputText: text })}

onSend={this.handleSendMessage}

loading={this.state.loading}

</div>

);

}

7. 后端 API 设计与业务逻辑实现

后端采用 Express.js 框架，提供完整的 RESTful API 接口。API 设计遵循 REST 规范，确保接口的清晰性和易用性。主要接口包括文档管理接口、问答接口和系统管理接口。

文档管理接口支持文件上传、文档列表获取、文档删除等操作。问答接口处理用户提问，执行 RAG 流程并返回答案。系统管理接口提供系统状态监控、知识库统计等功能。

核心的 RAG 业务流程实现：

JAVASCRIPT

class RAGService {

constructor(vectorDB, llmService) {

this.vectorDB = vectorDB;

this.llmService = llmService;

}

async processQuery(query, options = {}) {

// 1. 查询预处理

const processedQuery = this.preprocessQuery(query);

// 2. 向量化查询

const queryEmbedding = await this.generateQueryEmbedding(processedQuery);

// 3. 向量检索

const searchResults = await this.vectorDB.search({

vector: queryEmbedding,

topK: options.topK || 5,

filter: options.filter

});

// 4. 结果重排序

const rerankedResults = this.rerankResults(searchResults, query);

// 5. 生成回答

const context = this.buildContext(rerankedResults);

const answer = await this.generateAnswer(query, context, options);

return {

answer,

sources: rerankedResults,

context

};

}

async generateAnswer(query, context, options) {

const prompt = this.buildPrompt(query, context, options);

const response = await this.llmService.generate({

prompt,

maxTokens: options.maxTokens || 1000,

temperature: options.temperature || 0.7

});

return response.text;

}

buildPrompt(query, context, options) {

return `基于以下上下文信息，请回答问题。如果上下文不足以回答问题，请如实告知。

上下文：

${context}

问题：${query}

要求：

1. 基于上下文信息回答

2. 如果上下文信息不足，请说明

3. 回答要简洁明了

4. 不要编造不存在的信息

回答：`;

}

API 路由配置和中间件处理：

JAVASCRIPT

const express = require('express');

const router = express.Router();

const documentController = require('../controllers/documentController');

const chatController = require('../controllers/chatController');

// 文档相关路由

router.post('/documents/upload',

uploadMiddleware,

documentController.uploadDocuments

);

router.get('/documents',

authMiddleware,

documentController.getDocuments

);

router.delete('/documents/:id',

authMiddleware,

documentController.deleteDocument

);

// 问答相关路由

router.post('/chat',

rateLimitMiddleware,

chatController.processMessage

);

router.get('/chat/history',

authMiddleware,

chatController.getChatHistory

);

// 健康检查路由

router.get('/health', (req, res) => {

res.json({

status: 'ok',

timestamp: new Date().toISOString(),

version: process.env.npm_package_version

});

module.exports = router;

8. 检索策略优化与性能调优

检索效果直接影响 RAG 系统的整体性能。项目实现了多种检索策略，包括基于关键词的检索、向量检索以及混合检索。每种策略都有其适用场景，可以根据具体需求进行选择和配置。

向量检索基于语义相似度，能够理解查询的深层含义，但在处理特定术语时可能不够精确。关键词检索基于字面匹配，对于专业术语和特定名称的检索效果更好。混合检索结合两者的优势，先进行向量检索获取语义相关的结果，再用关键词检索进行精炼。

检索性能优化策略：

JAVASCRIPT

class RetrievalOptimizer {

constructor() {

this.cache = new Map();

this.metrics = {

responseTime: 0,

cacheHitRate: 0,

accuracy: 0

};

}

async optimizedSearch(query, options = {}) {

const cacheKey = this.generateCacheKey(query, options);

// 缓存检查

if (this.cache.has(cacheKey) && !options.forceRefresh) {

this.metrics.cacheHitRate++;

return this.cache.get(cacheKey);

}

const startTime = Date.now();

// 并行执行多种检索策略

const [vectorResults, keywordResults] = await Promise.all([

this.vectorSearch(query, options),

this.keywordSearch(query, options)

]);

// 结果融合和重排序

const mergedResults = this.mergeResults(vectorResults, keywordResults);

const finalResults = this.rerankResults(mergedResults, query);

const endTime = Date.now();

this.metrics.responseTime = (endTime - startTime) / 1000;

// 缓存结果

this.cache.set(cacheKey, finalResults);

return finalResults;

}

mergeResults(vectorResults, keywordResults) {

// 基于得分和相似度进行结果融合

const resultsMap = new Map();

[...vectorResults, ...keywordResults].forEach(result => {

const existing = resultsMap.get(result.id);

if (!existing || result.score > existing.score) {

resultsMap.set(result.id, result);

}

});

return Array.from(resultsMap.values())

.sort((a, b) => b.score - a.score);

}

generateCacheKey(query, options) {

return `${query}-${JSON.stringify(options)}`;

}

索引优化和查询性能监控：

JAVASCRIPT

class PerformanceMonitor {

constructor() {

this.performanceData = [];

this.thresholds = {

responseTime: 2.0, // 秒

accuracy: 0.8,

availability: 0.99

};

}

recordMetric(metricName, value, timestamp = Date.now()) {

this.performanceData.push({

metric: metricName,

value: value,

timestamp: timestamp

});

// 保持数据量在合理范围内

if (this.performanceData.length > 1000) {

this.performanceData = this.performanceData.slice(-1000);

}

this.checkThresholds(metricName, value);

}

checkThresholds(metricName, value) {

const threshold = this.thresholds[metricName];

if (threshold && value > threshold) {

this.alert(metricName, value, threshold);

}

getPerformanceReport() {

const recentData = this.performanceData.slice(-100);

const report = {

averageResponseTime: this.calculateAverage('responseTime'),

accuracy: this.calculateAverage('accuracy'),

availability: this.calculateAvailability(),

trends: this.analyzeTrends()

};

return report;

}

calculateAverage(metricName) {

const values = this.performanceData

.filter(item => item.metric === metricName)

.map(item => item.value);

return values.length > 0 ?

values.reduce((a, b) => a + b) / values.length : 0;

}

9. 系统部署与运维管理

项目支持多种部署方式，包括本地开发环境部署、Docker 容器化部署和云平台部署。每种部署方式都有其特点和适用场景，开发者可以根据实际需求选择合适的方案。

本地部署适合开发和测试环境，部署简单，调试方便。Docker 部署提供了环境一致性，适合团队协作和持续集成。云平台部署适合生产环境，提供了更好的可扩展性和可靠性。

Docker 部署配置文件：

DOCKERFILE

FROM node:16-alpine

WORKDIR /app

# 复制 package.json 和安装依赖

COPY package*.json ./

RUN npm ci --only=production

# 复制源代码

COPY . .

# 创建非root用户

RUN addgroup -g 1001 -S nodejs

RUN adduser -S nextjs -u 1001

# 更改文件所有权

RUN chown -R nextjs:nodejs /app

USER nextjs

# 暴露端口

EXPOSE 3000

# 启动命令

CMD ["npm", "start"]

Docker Compose 配置用于多服务部署：

YAML

version: '3.8'

services:

app:

build: .

ports:

- "3000:3000"

environment:

- NODE_ENV=production

- OPENAI_API_KEY=${OPENAI_API_KEY}

- VECTOR_DB_URL=${VECTOR_DB_URL}

depends_on:

- redis

volumes:

- ./logs:/app/logs

redis:

image: redis:alpine

ports:

- "6379:6379"

volumes:

- redis_data:/data

nginx:

image: nginx:alpine

ports:

- "80:80"

volumes:

- ./nginx.conf:/etc/nginx/nginx.conf

depends_on:

- app

volumes:

redis_data:

系统监控和日志管理配置：

JAVASCRIPT

const winston = require('winston');

const logger = winston.createLogger({

level: 'info',

format: winston.format.combine(

winston.format.timestamp(),

winston.format.errors({ stack: true }),

winston.format.json()

transports: [

new winston.transports.File({ filename: 'error.log', level: 'error' }),

new winston.transports.File({ filename: 'combined.log' }),

new winston.transports.Console({

format: winston.format.simple()

})

]

});

// 性能监控中间件

const performanceMiddleware = (req, res, next) => {

const start = Date.now();

res.on('finish', () => {

const duration = Date.now() - start;

logger.info('API Performance', {

method: req.method,

url: req.url,

statusCode: res.statusCode,

duration: `${duration}ms`,

timestamp: new Date().toISOString()

});

next();

};

10. 安全性与权限管理

企业级知识库系统必须重视安全性，包括数据安全、访问控制和隐私保护。项目实现了完整的权限管理体系，支持基于角色的访问控制（RBAC），确保不同用户只能访问其权限范围内的数据和功能。

数据加密是保护敏感信息的重要手段。项目对存储的文档内容和用户数据进行加密处理，传输过程中使用 HTTPS 协议确保通信安全。访问日志记录所有操作行为，便于安全审计和问题追踪。

用户认证和授权实现：

JAVASCRIPT

const jwt = require('jsonwebtoken');

const bcrypt = require('bcryptjs');

class AuthService {

constructor() {

this.secretKey = process.env.JWT_SECRET;

this.tokenExpiry = '7d';

}

async authenticateUser(username, password) {

const user = await UserModel.findOne({ username });

if (!user) {

throw new Error('用户不存在');

}

const isValid = await bcrypt.compare(password, user.password);

if (!isValid) {

throw new Error('密码错误');

}

const token = this.generateToken(user);

return { token, user: this.sanitizeUser(user) };

}

generateToken(user) {

const payload = {

userId: user.id,

username: user.username,

role: user.role

};

return jwt.sign(payload, this.secretKey, {

expiresIn: this.tokenExpiry

});

}

verifyToken(token) {

try {

return jwt.verify(token, this.secretKey);

} catch (error) {

throw new Error('令牌无效');

}

sanitizeUser(user) {

const { password, ...sanitized } = user.toObject();

return sanitized;

}

基于角色的权限控制：

JAVASCRIPT

class PermissionManager {

constructor() {

this.roles = {

admin: ['read', 'write', 'delete', 'manage_users'],

editor: ['read', 'write'],

viewer: ['read']

};

}

hasPermission(userRole, action, resource) {

const rolePermissions = this.roles[userRole];

if (!rolePermissions) return false;

// 检查具体权限

const requiredPermission = `${action}_${resource}`;

return rolePermissions.includes(requiredPermission) ||

rolePermissions.includes(action);

}

canAccessDocument(user, document) {

// 文档级权限检查

if (user.role === 'admin') return true;

if (document.visibility === 'public') return true;

if (document.visibility === 'private' &&

document.ownerId === user.id) return true;

if (document.sharedWith &&

document.sharedWith.includes(user.id)) return true;

return false;

}

// 权限检查中间件

const requirePermission = (action, resource) => {

return (req, res, next) => {

const user = req.user;

const permissionManager = new PermissionManager();

if (!permissionManager.hasPermission(user.role, action, resource)) {

return res.status(403).json({

error: '权限不足'

});

}

next();

};

11. 测试策略与质量保证

完整的测试体系是项目质量的保证。项目实现了多层次的测试策略，包括单元测试、集成测试和端到端测试。单元测试验证单个模块的功能正确性，集成测试检查模块之间的协作，端到端测试模拟真实用户操作流程。

测试覆盖率是衡量测试完整性的重要指标。项目设定了最低测试覆盖率要求，确保关键业务逻辑得到充分测试。持续集成流程自动运行测试套件，在代码合并前发现问题。

单元测试示例：

JAVASCRIPT

const { describe, it, expect } = require('@jest/globals');

const { DocumentProcessor } = require('../src/services/documentProcessor');

describe('DocumentProcessor', () => {

let processor;

beforeEach(() => {

processor = new DocumentProcessor();

});

describe('splitIntoSegments', () => {

it('应该正确分割文本', () => {

const text = '这是一段测试文本。需要被分割成多个段落。';

const segments = processor.splitIntoSegments(text, 10);

expect(segments).toHaveLength(5);

expect(segments[0]).toBe('这是一段测试文');

});

it('应该处理空文本', () => {

const segments = processor.splitIntoSegments('', 100);

expect(segments).toEqual([]);

});

describe('processFile', () => {

it('应该支持 PDF 文件', async () => {

const segments = await processor.processFile('test.pdf');

expect(segments).toBeInstanceOf(Array);

expect(segments.length).toBeGreaterThan(0);

});

it('应该拒绝不支持的文件格式', async () => {

await expect(processor.processFile('test.xyz'))

.rejects

.toThrow('Unsupported file format');

});

集成测试配置：

JAVASCRIPT

const request = require('supertest');

const app = require('../src/app');

const { connectDB, disconnectDB } = require('../src/config/database');

describe('API Integration Tests', () => {

beforeAll(async () => {

await connectDB();

});

afterAll(async () => {

await disconnectDB();

});

describe('POST /api/chat', () => {

it('应该返回有效的回答', async () => {

const response = await request(app)

.post('/api/chat')

.send({ message: '什么是 RAG 技术？' })

.expect(200);

expect(response.body).toHaveProperty('answer');

expect(response.body.answer).toBeTruthy();

expect(response.body).toHaveProperty('sources');

});

it('应该处理空消息', async () => {

const response = await request(app)

.post('/api/chat')

.send({ message: '' })

.expect(400);

expect(response.body).toHaveProperty('error');

});

性能测试脚本：

JAVASCRIPT

const autocannon = require('autocannon');

class PerformanceTest {

constructor() {

this.config = {

url: 'http://localhost:3000',

connections: 10,

duration: 30,

requests: [

{

method: 'POST',

path: '/api/chat',

body: JSON.stringify({ message: '测试消息' }),

headers: {

'Content-Type': 'application/json'

}

]

};

}

async run() {

const result = await autocannon(this.config);

this.generateReport(result);

}

generateReport(result) {

console.log('性能测试结果:');

console.log(`请求总数: ${result.requests.total}`);

console.log(`错误数: ${result.errors}`);

console.log(`吞吐量: ${result.throughput.total} 请求/秒`);

console.log(`平均延迟: ${result.latency.average}ms`);

console.log(`P99 延迟: ${result.latency.p99}ms`);

}

12. 项目扩展与二次开发

项目的模块化设计为扩展和二次开发提供了良好的基础。开发者可以根据具体需求添加新的数据源支持、实现自定义的检索策略、集成不同的大模型服务，或者开发新的前端功能。

数据源扩展示例：

JAVASCRIPT

class DataSourceAdapter {

constructor() {

this.adapters = new Map();

}

registerAdapter(type, adapter) {

this.adapters.set(type, adapter);

}

async loadData(sourceConfig) {

const adapter = this.adapters.get(sourceConfig.type);

if (!adapter) {

throw new Error(`不支持的数据源类型: ${sourceConfig.type}`);

}

return await adapter.load(sourceConfig);

}

// 自定义数据源适配器

class NotionAdapter {

async load(config) {

const { apiKey, databaseId } = config;

// 实现 Notion API 集成

const response = await fetch(`https://api.notion.com/v1/databases/${databaseId}/query`, {

method: 'POST',

headers: {

'Authorization': `Bearer ${apiKey}`,

'Content-Type': 'application/json',

'Notion-Version': '2022-06-28'

}

});

const data = await response.json();

return this.transformData(data);

}

transformData(notionData) {

// 转换 Notion 数据为统一格式

return notionData.results.map(page => ({

id: page.id,

title: page.properties.Title?.title[0]?.text?.content || '无标题',

content: this.extractContent(page),

metadata: {

createdTime: page.created_time,

lastEditedTime: page.last_edited_time

}

}));

}

插件系统设计：

JAVASCRIPT

class PluginSystem {

constructor() {

this.plugins = new Map();

this.hooks = new Map();

}

registerPlugin(name, plugin) {

this.plugins.set(name, plugin);

// 注册插件钩子

if (plugin.hooks) {

Object.keys(plugin.hooks).forEach(hookName => {

if (!this.hooks.has(hookName)) {

this.hooks.set(hookName, []);

}

this.hooks.get(hookName).push(plugin.hooks[hookName]);

});

}

async executeHook(hookName, ...args) {

const hooks = this.hooks.get(hookName) || [];

for (const hook of hooks) {

await hook(...args);

}

getPlugin(name) {

return this.plugins.get(name);

}

// 示例插件：搜索结果高亮

class HighlightPlugin {

constructor() {

this.hooks = {

'post-search': this.highlightResults.bind(this)

};

}

highlightResults(results, query) {

return results.map(result => {

const highlighted = this.highlightText(result.content, query);

return { ...result, highlightedContent: highlighted };

});

}

highlightText(text, query) {

const regex = new RegExp(`(${query})`, 'gi');

return text.replace(regex, '<mark>$1</mark>');

}

这个 LangChain.js + RAG 企业级知识库项目为开发者提供了一个完整的技术解决方案。通过深入理解项目架构和实现细节，开发者可以快速掌握 RAG 技术的核心要点，并基于此构建符合自身需求的智能知识库系统。项目的模块化设计和扩展性保证了其长期的技术价值，无论是学习研究还是商业应用都具有重要意义。