【ElasticSearch 实战】建索引、CRUD、混合检索一条龙

1
GET /_cat/indices?v

1
PUT /article/_settings
2
{
3
  "index": { "number_of_replicas": 0 }
4
}

1
PUT /article
2
{
3
  "mappings": {
4
    "properties": {
5
      "title":      { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" },
6
      "content":    { "type": "text", "analyzer": "ik_max_word", "search_analyzer": "ik_smart" },
7
      "author":     { "type": "keyword" },
8
      "createTime": { "type": "date" },
9
      "viewCount":  { "type": "integer" }
10
    }
11
  }
12
}

1
"analyzer": "ik_max_word"     ← 写入时用，最细粒度分词，追求高召回
2
"search_analyzer": "ik_smart" ← 搜索时用，最粗粒度分词，追求高精确

1
# 验证写入时的分词
2
POST /_analyze
3
{
4
  "analyzer": "ik_max_word",
5
  "text": "RAG混合检索实战"
6
}
7

8
# 验证搜索时的分词
9
POST /_analyze
10
{
11
  "analyzer": "ik_smart",
12
  "text": "RAG混合检索实战"
13
}

1
POST /article/_doc
2
{
3
  "title": "RAG混合检索实战",
4
  "content": "ES负责关键词检索，Milvus负责向量语义检索，结合使用效果更佳",
5
  "author": "AI开发",
6
  "createTime": "2026-04-26",
7
  "viewCount": 256
8
}

1
PUT /article/_doc/my-doc-1
2
{
3
  "title": "RAG混合检索实战",
4
  ...
5
}

1
GET /article/_search
2
{
3
  "query": {
4
    "match": { "title": "全文检索" }
5
  },
6
  "size": 10
7
}

1
# match 查询：会分词，适合 text 字段
2
GET /article/_search
3
{
4
  "query": { "match": { "title": "全文检索" } }
5
}
6

7
# term 查询：不分词，适合 keyword 字段
8
GET /article/_search
9
{
10
  "query": { "term": { "author": "AI开发" } }
11
}

1
GET /article/_search
2
{
3
  "query": {
4
    "bool": {
5
      "must": [
6
        { "match": { "title": "检索" } }
7
      ],
8
      "filter": [
9
        { "term": { "author": "AI开发" } },
10
        { "range": { "viewCount": { "gte": 100 } } }
11
      ]
12
    }
13
  }
14
}

1
POST /article/_update/my-doc-1
2
{
3
  "doc": {
4
    "viewCount": 300
5
  }
6
}

1
DELETE /article/_doc/my-doc-1

1
POST /article/_delete_by_query
2
{
3
  "query": {
4
    "match": { "title": "RAG混合检索实战" }
5
  }
6
}

1
DELETE /article

1
GET /article/_mapping

1
import { Client } from '@elastic/elasticsearch';
2

3
const client = new Client({ node: 'http://localhost:9200' });
4

5
// 验证连接
6
const info = await client.info();
7
console.log('ES 版本:', info.version.number);

1
// 先检查索引是否存在，避免重复创建报错
2
const exists = await client.indices.exists({ index: 'travel_journal' });
3
if (exists) {
4
  console.log('索引已存在，跳过创建');
5
} else {
6
  await client.indices.create({
7
    index: 'travel_journal',
8
    mappings: {
9
      properties: {
10
        note_title: {
11
          type: 'text',
12
          analyzer: 'ik_max_word',       // 写入时：最细粒度分词
13
          search_analyzer: 'ik_smart'    // 搜索时：最粗粒度分词
14
        },
15
        note_body: {
16
          type: 'text',
17
          analyzer: 'ik_max_word',
18
          search_analyzer: 'ik_smart'
19
        },
20
        tags:       { type: 'keyword' },  // 标签：精确匹配，不分词
21
        mood:       { type: 'keyword' },  // 心情：精确匹配，不分词
22
        priority:   { type: 'integer' },
23
        created_at: { type: 'date' }
24
      }
25
    }
26
  });
27
  console.log('索引创建成功');
28
}

1
// ===== 新增（指定 ID，避免重复）=====
2
await client.index({
3
  index: 'travel_journal',
4
  id: 'note-001',           // 指定 ID，重复写入会覆盖
5
  document: {
6
    note_title: '杭州西湖半日游',
7
    note_body: '早上绕湖慢跑，中午吃片儿川，下午在断桥拍照放松。',
8
    tags: ['旅行', '周末', '杭州'],
9
    mood: 'relaxed',
10
    priority: 2,
11
    created_at: new Date().toISOString()
12
  }
13
});
14

15
// ===== 查询单条（按 ID）=====
16
const doc = await client.get({
17
  index: 'travel_journal',
18
  id: 'note-001'
19
});
20
console.log(doc._source);  // 原始文档内容在 _source 里
21

22
// ===== 全文搜索 =====
23
const results = await client.search({
24
  index: 'travel_journal',
25
  query: {
26
    match: { note_body: '西湖跑步' }  // ik_smart 分词后匹配
27
  },
28
  size: 5
29
});
30

31
// 结果在 hits.hits 里，每条有 _score（BM25 打分）
32
results.hits.hits.forEach(hit => {
33
  console.log(`分数: ${hit._score}, 标题: ${hit._source.note_title}`);
34
});
35

36
// ===== 更新（局部更新）=====
37
await client.update({
38
  index: 'travel_journal',
39
  id: 'note-001',
40
  doc: { priority: 3 }  // 只更新 priority 字段
41
});
42

43
// ===== 删除（按 ID）=====
44
await client.delete({
45
  index: 'travel_journal',
46
  id: 'note-001'
47
});

1
用户输入："推荐一些杭州周末活动"
2
         │
3
         ▼
4
┌─────────────────────────────────────────────────────┐
5
│  Step 1: Query 重写（可选，但推荐）                   │
6
│  用 LLM 把用户问题改写成多个角度的查询词               │
7
│  原始: "推荐一些杭州周末活动"                          │
8
│  重写: ["杭州周末", "杭州旅游景点", "西湖周边活动"]     │
9
└─────────────────────────────────────────────────────┘
10
         │
11
         ▼
12
┌──────────────────────┐    ┌──────────────────────────┐
13
│  Step 2a: ES 词条检索  │    │  Step 2b: Milvus 语义检索  │
14
│                       │    │                           │
15
│  ik_smart 分词查询     │    │  Embedding 模型生成向量    │
16
│  倒排索引查找           │    │  余弦相似度计算            │
17
│  BM25 打分排序         │    │  ANN 近似最近邻搜索        │
18
│  召回 Top 20           │    │  召回 Top 20              │
19
└──────────────────────┘    └──────────────────────────┘
20
         │                            │
21
         └────────────┬───────────────┘
22
                      ▼
23
         ┌─────────────────────────┐
24
         │  Step 3: 合并去重        │
25
         │  同 ID 保留更高分数       │
26
         │  合并后约 30-40 条候选    │
27
         └─────────────────────────┘
28
                      │
29
                      ▼
30
         ┌─────────────────────────┐
31
         │  Step 4: Rerank 精排    │
32
         │  Cross-Encoder 重新打分  │
33
         │  选出最相关的 Top 5      │
34
         └─────────────────────────┘
35
                      │
36
                      ▼
37
         ┌─────────────────────────┐
38
         │  Step 5: 拼 Prompt      │
39
         │  Top 5 文档 + 用户问题   │
40
         │  → LLM 生成回答          │
41
         └─────────────────────────┘

1
async function rewriteQuery(originalQuery) {
2
  const response = await openai.chat.completions.create({
3
    model: 'gpt-4o-mini',
4
    messages: [{
5
      role: 'user',
6
      content: `将以下问题改写成 3 个不同角度的搜索词，用于检索知识库。
7
只返回 JSON 数组，不要其他内容。
8
问题：${originalQuery}
9
格式：["搜索词1", "搜索词2", "搜索词3"]`
10
    }]
11
  });
12

13
  return JSON.parse(response.choices[0].message.content);
14
}

1
async function searchES(queries) {
2
  const allHits = [];
3

4
  for (const query of queries) {
5
    const result = await esClient.search({
6
      index: 'life_notes',
7
      query: {
8
        bool: {
9
          should: [
10
            { match: { note_title: { query, boost: 2 } } },  // 标题权重更高
11
            { match: { note_body: query } }
12
          ]
13
        }
14
      },
15
      size: 10
16
    });
17

18
    // 把 ES 结果格式化成统一结构
19
    result.hits.hits.forEach(hit => {
20
      allHits.push({
21
        id: hit._id,
22
        content: hit._source.note_body,
23
        title: hit._source.note_title,
24
        score: hit._score,
25
        source: 'es'
26
      });
27
    });
28
  }
29

30
  return allHits;
31
}

1
async function searchMilvus(queries) {
2
  const allHits = [];
3

4
  for (const query of queries) {
5
    // similaritySearchWithScore 返回 [Document, score] 数组
6
    const results = await vectorStore.similaritySearchWithScore(query, 10);
7

8
    results.forEach(([doc, score]) => {
9
      allHits.push({
10
        id: doc.metadata.id,
11
        content: doc.pageContent,
12
        title: doc.metadata.title,
13
        score: score,           // 余弦相似度，越高越相关
14
        source: 'milvus'
15
      });
16
    });
17
  }
18

19
  return allHits;
20
}

1
function mergeAndDeduplicate(esHits, milvusHits) {
2
  const map = new Map();
3

4
  // 先放 ES 结果
5
  for (const doc of esHits) {
6
    map.set(doc.id, doc);
7
  }
8

9
  // 再放 Milvus 结果，同 ID 保留更高分数
10
  for (const doc of milvusHits) {
11
    const existing = map.get(doc.id);
12
    if (!existing || doc.score > existing.score) {
13
      map.set(doc.id, doc);
14
    }
15
  }
16

17
  // 按分数降序排列
18
  return Array.from(map.values())
19
    .sort((a, b) => b.score - a.score);
20
}

1
async function rerank(query, candidates) {
2
  // 用 LLM 对每个候选文档打相关性分数
3
  const scored = await Promise.all(
4
    candidates.slice(0, 20).map(async (doc) => {  // 只对前 20 条精排
5
      const response = await openai.chat.completions.create({
6
        model: 'gpt-4o-mini',
7
        messages: [{
8
          role: 'user',
9
          content: `判断以下文档与问题的相关性，返回 0-10 的整数分数，只返回数字。
10
问题：${query}
11
文档：${doc.content}
12
分数：`
13
        }]
14
      });
15

16
      return {
17
        ...doc,
18
        rerankScore: parseInt(response.choices[0].message.content.trim())
19
      };
20
    })
21
  );
22

23
  // 按 Rerank 分数降序，取 Top 5
24
  return scored
25
    .sort((a, b) => b.rerankScore - a.rerankScore)
26
    .slice(0, 5);
27
}

1
async function generateAnswer(query, topDocs) {
2
  const context = topDocs
3
    .map((doc, i) => `[${i + 1}] ${doc.title}\n${doc.content}`)
4
    .join('\n\n');
5

6
  const response = await openai.chat.completions.create({
7
    model: 'gpt-4o',
8
    messages: [
9
      {
10
        role: 'system',
11
        content: `你是一个知识助手。请基于以下检索到的资料回答用户问题。
12
如果资料中没有相关信息，请直接说"我没有找到相关信息"，不要编造。
13

14
参考资料：
15
${context}`
16
      },
17
      {
18
        role: 'user',
19
        content: query
20
      }
21
    ]
22
  });
23

24
  return response.choices[0].message.content;
25
}

1
async function hybridRetrieval(userQuery) {
2
  console.log(`\n用户问题: ${userQuery}`);
3

4
  // Step 1: Query 重写
5
  const queries = await rewriteQuery(userQuery);
6
  console.log('重写后的查询词:', queries);
7

8
  // Step 2: 并行双路检索
9
  const [esHits, milvusHits] = await Promise.all([
10
    searchES(queries),
11
    searchMilvus(queries)
12
  ]);
13
  console.log(`ES 召回: ${esHits.length} 条, Milvus 召回: ${milvusHits.length} 条`);
14

15
  // Step 3: 合并去重
16
  const merged = mergeAndDeduplicate(esHits, milvusHits);
17
  console.log(`合并去重后: ${merged.length} 条`);
18

19
  // Step 4: Rerank 精排
20
  const topDocs = await rerank(userQuery, merged);
21
  console.log(`Rerank 后 Top ${topDocs.length} 条`);
22

23
  // Step 5: LLM 作答
24
  const answer = await generateAnswer(userQuery, topDocs);
25
  console.log('\n最终回答:\n', answer);
26

27
  return answer;
28
}
29

30
// 跑起来
31
await hybridRetrieval('推荐一些杭州周末活动');

1
# ❌ 错误
2
地址: localhost:19530
3

4
# ✅ 正确
5
地址: milvus-standalone:19530  ← 用 Milvus 容器的 container_name

1
POST /article/_delete_by_query
2
{
3
  "query": { "match": { "title": "RAG混合检索实战" } }
4
}

1
POST /article/_refresh

1
# ❌ 这样搜不到
2
GET /article/_search
3
{
4
  "query": { "term": { "title": "RAG混合检索" } }
5
}

1
# ✅ 正确做法：text 字段用 match 查询
2
GET /article/_search
3
{
4
  "query": { "match": { "title": "RAG混合检索" } }
5
}