语义搜索工具

pnpm add @xenova/transformers

<!-- 直接在 HTML 中引入 CDN -->
<script type="module">
  import { pipeline } from "https://cdn.jsdelivr.net/npm/@xenova/transformers";
</script>

# 在 semantic-search 目录下
pnpm install

# 方法1: 使用 pnpm 脚本
pnpm run demo

# 方法2: 使用 Windows 批处理脚本
双击 scripts/start-node-demo.bat

# 方法3: 直接运行
node nodes/semantic-search-demo.js

import { ContentIndexer } from "./nodes/content-indexer.js";

// 创建索引器
const indexer = new ContentIndexer({
  modelName: "Xenova/multilingual-e5-small", // 小模型（384维）
  dimension: 384,
  cacheDir: "./.cache/transformers", // 模型缓存目录
});

// 初始化（首次运行会下载模型，约 116MB）
await indexer.initialize();

// 索引内容
await indexer.indexContent(
  1, // pageId
  "https://example.com", // url
  "机器学习入门", // title
  "机器学习是人工智能的..." // content
);

// 搜索
const results = await indexer.searchContent("机器学习算法", 10);
console.log(results);

# 方法1: 使用 pnpm 脚本（自动打开浏览器）
pnpm run browser

# 方法2: 使用 Windows 批处理脚本
双击 scripts/start-browser.bat

# 方法3: 直接打开 HTML 文件
双击 semantic-search-browser.html

用户查询
   ↓
ContentIndexer (索引管理层)
   ↓
┌──────────────────┬─────────────────────┬──────────────────┐
↓                  ↓                     ↓
TextChunker    SemanticEngine      VectorDatabase
(文本分块)      (生成向量)           (存储&搜索)

{
  maxWordsPerChunk: 80,      // 每块最大词数
  overlapSentences: 1,        // 重叠句子数（避免语义断裂）
  minChunkLength: 20          // 最小块长度
}

import { TextChunker } from "./nodes/text-chunker.js";

const chunker = new TextChunker({
  maxWordsPerChunk: 80,
  overlapSentences: 1,
  minChunkLength: 20,
});

const chunks = chunker.chunkText(longText, "Title");
// 返回: [{ text, source }, { text, source }, ...]

{
  modelName: 'Xenova/multilingual-e5-small',  // 模型名称
  dimension: 384,                              // 向量维度（small: 384, base: 768）
  cacheDir: './.cache/transformers',          // 模型缓存目录
  useQuantized: true                           // 是否使用量化模型（更小更快）
}

import { SemanticEngine } from "./nodes/semantic-engine.js";

const engine = new SemanticEngine({
  modelName: "Xenova/multilingual-e5-small",
  dimension: 384,
  cacheDir: "./.cache/transformers",
});

await engine.initialize();

// 单个文本
const embedding = await engine.getEmbedding("查询文本");
// 返回: Float32Array(384)

// 批量生成
const embeddings = await engine.getEmbeddingsBatch(["文本1", "文本2"]);
// 返回: [Float32Array(384), Float32Array(384)]

{
  dimension: 384,           // 向量维度（必须与模型一致）
  maxElements: 10000        // 最大存储数量
}

import { VectorDatabase } from "./nodes/vector-database.js";

const db = new VectorDatabase({
  dimension: 384,
  maxElements: 10000,
});

await db.initialize();

// 添加文档
await db.addDocument(
  1, // pageId
  "url", // url
  "title", // title
  { text: "...", source: "body" }, // chunk
  embedding // Float32Array(384)
);

// 搜索
const results = await db.search(queryEmbedding, 10);
// 返回: [{ pageId, url, title, similarity, ... }, ...]

import { ContentIndexer } from "./nodes/content-indexer.js";

const indexer = new ContentIndexer({
  // TextChunker 配置
  maxWordsPerChunk: 80,
  overlapSentences: 1,
  minChunkLength: 20,

  // SemanticEngine 配置
  modelName: "Xenova/multilingual-e5-small",
  dimension: 384,
  cacheDir: "./.cache/transformers",

  // VectorDatabase 配置
  maxElements: 10000,
});

await indexer.initialize();

// 索引单个页面
const result = await indexer.indexContent(pageId, url, title, content);

// 批量索引
const results = await indexer.indexContentBatch([
  { pageId: 1, url: "...", title: "...", content: "..." },
  { pageId: 2, url: "...", title: "...", content: "..." },
]);

// 搜索
const searchResults = await indexer.searchContent("查询", 10);

// 删除页面索引
await indexer.removePageIndex(pageId);

// 清空所有索引
indexer.clearAll();

// 获取统计信息
const stats = indexer.getStats();
console.log(stats);
// {
//   isInitialized: true,
//   indexedPagesCount: 5,
//   totalDocuments: 15,
//   totalVectors: 15,
//   capacityUsage: '1.50%',
//   modelName: 'Xenova/multilingual-e5-small',
//   dimension: 384,
//   cacheSize: 15
// }

import { ContentIndexer } from "./nodes/content-indexer.js";

const indexer = new ContentIndexer({
  modelName: "Xenova/multilingual-e5-small",
  dimension: 384,
});

await indexer.initialize();
// 首次运行会下载模型（约 116MB）
// 后续运行会使用缓存，快速启动

// 索引网页内容
await indexer.indexContent(
  1, // 唯一的页面ID
  "https://example.com/article", // 页面URL
  "机器学习基础教程", // 页面标题
  `
    机器学习是人工智能的一个重要分支。
    它让计算机能够从数据中学习规律。
    常见的机器学习算法包括决策树、随机森林等。
  ` // 页面内容
);

// 索引更多页面...
await indexer.indexContent(2, "url2", "title2", "content2");
await indexer.indexContent(3, "url3", "title3", "content3");

const results = await indexer.searchContent("机器学习算法", 10);

results.forEach((result, index) => {
  console.log(`${index + 1}. ${result.title}`);
  console.log(`   URL: ${result.url}`);
  console.log(`   相似度: ${(result.similarity * 100).toFixed(2)}%`);
  console.log(`   片段: ${result.snippet}`);
  console.log();
});

// 获取统计信息
const stats = indexer.getStats();
console.log(`已索引页面: ${stats.indexedPagesCount}`);
console.log(`总文档数: ${stats.totalDocuments}`);
console.log(`容量使用: ${stats.capacityUsage}`);

// 删除指定页面
await indexer.removePageIndex(1);

// 清空所有
indexer.clearAll();

const indexer = new ContentIndexer();
await indexer.initialize();

// 模拟爬取多个网页并索引
const pages = [
  { id: 1, url: "page1.html", title: "Title1", content: "..." },
  { id: 2, url: "page2.html", title: "Title2", content: "..." },
  { id: 3, url: "page3.html", title: "Title3", content: "..." },
];

for (const page of pages) {
  await indexer.indexContent(page.id, page.url, page.title, page.content);
}

// 搜索
const results = await indexer.searchContent("关键词", 5);

const indexer = new ContentIndexer({
  maxElements: 50000, // 支持更多文档
});

await indexer.initialize();

// 批量索引文档
const documents = loadDocuments(); // 从数据库或文件加载
await indexer.indexContentBatch(documents);

// 智能搜索
const answer = await searchKnowledge("如何使用机器学习？");

import { ContentIndexer } from "./semantic-search/nodes/content-indexer.js";
import { ipcMain } from "electron";

let indexer;

ipcMain.handle("search:initialize", async () => {
  indexer = new ContentIndexer({
    modelName: "Xenova/multilingual-e5-small",
    dimension: 384,
  });
  await indexer.initialize();
  return { success: true };
});

ipcMain.handle("search:index", async (event, pageData) => {
  return await indexer.indexContent(
    pageData.id,
    pageData.url,
    pageData.title,
    pageData.content
  );
});

ipcMain.handle("search:query", async (event, query, topK) => {
  return await indexer.searchContent(query, topK);
});

ipcMain.handle("search:stats", async () => {
  return indexer.getStats();
});

// 初始化
await ipcRenderer.invoke("search:initialize");

// 索引当前页面
await ipcRenderer.invoke("search:index", {
  id: pageId,
  url: window.location.href,
  title: document.title,
  content: document.body.innerText,
});

// 搜索
const results = await ipcRenderer.invoke("search:query", "查询", 10);
displayResults(results);

// 速度优先（推荐）
const indexer = new ContentIndexer({
  modelName: "Xenova/multilingual-e5-small",
  dimension: 384,
});

// 精度优先
const indexer = new ContentIndexer({
  modelName: "Xenova/multilingual-e5-base",
  dimension: 768,
});

// ❌ 不推荐：逐个索引
for (const page of pages) {
  await indexer.indexContent(...);
}

// ✅ 推荐：批量索引
await indexer.indexContentBatch(pages);

// SemanticEngine 内置了 LRU 缓存
const indexer = new ContentIndexer({
  maxCacheSize: 1000, // 缓存 1000 个 embedding
});

正在加载模型: Xenova/multilingual-e5-small...
提示: 首次运行会下载模型 (约 116MB)，请稍候。后续运行会使用缓存。

semantic-search/
├── nodes/                              # Node.js 版本核心代码
│   ├── content-indexer.js             # 内容索引器（协调器）
│   ├── semantic-engine.js             # 语义引擎（AI 模型加载）
│   ├── text-chunker.js                # 文本分块器
│   ├── vector-database.js             # 向量数据库（纯 JS 实现）
│   └── semantic-search-demo.js        # 完整演示脚本
│
├── scripts/                            # 启动脚本
│   ├── start-node-demo.bat            # Windows: 启动 Node.js 演示
│   ├── start-browser.bat              # Windows: 启动浏览器演示
│   └── start-browser.js               # 跨平台: 启动浏览器脚本
│
├── semantic-search-browser.html        # 浏览器版本（独立 HTML）
├── 快速启动-Node版本.bat               # 快速启动 Node.js 版本（自动安装依赖）
├── 快速启动-浏览器版本.bat             # 快速启动浏览器版本
├── 示例代码.js                          # 使用示例代码
├── package.json                        # 依赖管理
├── .gitignore                          # Git 忽略文件
└── README.md                           # 本文档

原始文本 → 分词 → Transformer → Pooling → 归一化 → 向量 (Float32Array)

similarity = (A · B) / (||A|| × ||B||)

查询文本 → 生成向量 → 计算相似度 → 排序 → 去重 → 返回前 K 个

需要演示或快速测试？
  ↓
  使用浏览器版本（semantic-search-browser.html）

生产环境或 Electron 应用？
  ↓
  使用 Node.js 版本（nodes/）

需要处理大规模数据？
  ↓
  使用 Node.js 版本 + 增大 maxElements