Atopos

1
┌─────────────────────────────────────────────────────────────────┐
2
│                        RAG 端到端流程                           │
3
├─────────────────────────────────────────────────────────────────┤
4
│                                                                 │
5
│  【离线阶段】文档 → 切分 → 向量化 → 存入向量库                   │
6
│                                                                 │
7
│  【在线阶段】用户提问 → 向量化 → 检索相似片段 → 构建 Prompt      │
8
│                        → LLM 生成答案 + 引用来源                │
9
│                                                                 │
10
└─────────────────────────────────────────────────────────────────┘

1
┌─────────────────────────────────────────────────────────────────┐
2
│                      索引阶段（Indexing）                        │
3
├─────────────────────────────────────────────────────────────────┤
4
│                                                                 │
5
│  原始文档：PDF、Word、Markdown、数据库、网页...                   │
6
│       │                                                         │
7
│       ▼                                                         │
8
│  ① 文档加载与解析（Loading & Parsing）                           │
9
│     把各种格式的文档统一提取为纯文本                               │
10
│       │                                                         │
11
│       ▼                                                         │
12
│  ② 文本切分（Chunking）                                         │
13
│     按语义边界切分成 200-500 字的小片段                            │
14
│       │                                                         │
15
│       ▼                                                         │
16
│  ③ 向量化（Embedding）                                          │
17
│     用 Embedding 模型把文本转成高维向量                            │
18
│       │                                                         │
19
│       ▼                                                         │
20
│  ④ 存入向量数据库                                                │
21
│     MemoryVectorStore / Chroma / Milvus / pgvector              │
22
│                                                                 │
23
└─────────────────────────────────────────────────────────────────┘

1
┌─────────────────────────────────────────────────────────────────┐
2
│                  检索 + 生成阶段（Retrieval & Generation）       │
3
├─────────────────────────────────────────────────────────────────┤
4
│                                                                 │
5
│  用户提问：「转账 5 万需要审批吗？」                               │
6
│       │                                                         │
7
│       ▼                                                         │
8
│  ① 把用户问题向量化                                             │
9
│       │                                                         │
10
│       ▼                                                         │
11
│  ② 在向量数据库中检索最相似的 3-5 个片段                          │
12
│       │                                                         │
13
│       ▼                                                         │
14
│  ③ 构建 Prompt：System + 检索结果 + 用户问题                     │
15
│       │                                                         │
16
│       ▼                                                         │
17
│  ④ LLM 生成答案 + 引用来源                                       │
18
│                                                                 │
19
│  输出示例：                                                     │
20
│  「是的，转账 5 万元需要审批。                                   │
21
│   根据【转账规则】，单笔转账超过 5 万元需经过审批流程。」          │
22
│                                                                 │
23
└─────────────────────────────────────────────────────────────────┘

1
import { Embeddings } from "@langchain/core/embeddings";
2

3
class TfIdfEmbeddings extends Embeddings {
4
  private vocab = new Map<string, number>();  // 词汇表
5
  private docCount = 0;                       // 文档计数
6
  private df = new Map<number, number>();     // 文档频率
7

8
  constructor() { super({}); }
9

10
  // 中文分词：汉字 + 英文/数字
11
  private tokenize(text: string): string[] {
12
    const tokens: string[] = [];
13
    const re = /[一-鿿]|[a-zA-Z0-9]+/g;
14
    for (const match of text.toLowerCase().matchAll(re)) {
15
      tokens.push(match[0]);
16
    }
17
    return tokens;
18
  }
19

20
  // 文本 → TF-IDF 向量
21
  private textToVec(text: string): number[] {
22
    const tokens = this.tokenize(text);
23

24
    // 1. 构建词汇表
25
    for (const t of tokens) {
26
      if (!this.vocab.has(t)) {
27
        this.vocab.set(t, this.vocab.size);
28
        this.df.set(this.vocab.size - 1, 0);
29
      }
30
    }
31

32
    // 2. 计算 TF（词频）
33
    const tf = new Array(this.vocab.size).fill(0);
34
    for (const t of tokens) tf[this.vocab.get(t)!]++;
35

36
    // 3. 计算 TF-IDF + L2 归一化
37
    const n = this.docCount || 1;
38
    for (let i = 0; i < tf.length; i++) {
39
      if (tf[i] > 0) {
40
        tf[i] = (1 + Math.log(tf[i])) * (Math.log(n / (this.df.get(i) || 1)) + 1);
41
      }
42
    }
43
    const norm = Math.sqrt(tf.reduce((s, v) => s + v * v, 0)) || 1;
44
    return tf.map(v => v / norm);
45
  }
46

47
  async embedQuery(text: string): Promise<number[]> {
48
    return this.textToVec(text);
49
  }
50

51
  async embedDocuments(documents: string[]): Promise<number[][]> {
52
    this.docCount += documents.length;
53
    // 更新文档频率
54
    for (const doc of documents) {
55
      const seen = new Set<number>();
56
      const tokens = this.tokenize(doc);
57
      for (const t of tokens) {
58
        const idx = this.vocab.get(t);
59
        if (idx !== undefined && !seen.has(idx)) {
60
          seen.add(idx);
61
          this.df.set(idx, (this.df.get(idx) || 0) + 1);
62
        }
63
      }
64
    }
65
    return documents.map(doc => this.textToVec(doc));
66
  }
67
}

1
import { MemoryVectorStore } from "@langchain/classic/vectorstores/memory";
2

3
// 从文档创建向量存储
4
const vectorStore = await MemoryVectorStore.fromDocuments(splitDocs, embeddings);
5

6
// 创建检索器：返回最相似的 3 个片段
7
const retriever = vectorStore.asRetriever({ k: 3 });
8

9
// 检索相关文档
10
const relevantDocs = await retriever.invoke("用户的问题");

1
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
2

3
const textSplitter = new RecursiveCharacterTextSplitter({
4
  chunkSize: 300,        // 每个片段约 300 字
5
  chunkOverlap: 150,     // 重叠 50%！（防止语义断裂）
6
  separators: [
7
    "\n\n", "\n",        // 优先按段落、换行切
8
    "。", "！", "？",   // 中文句号、感叹号、问号
9
    "，", "、", "；",   // 中文逗号、顿号、分号
10
    " "                  // 最后按空格
11
  ],
12
});
13

14
const splitDocs = await textSplitter.splitDocuments(docs);

1
import { PromptTemplate } from "@langchain/core/prompts";
2
import { StringOutputParser } from "@langchain/core/output_parsers";
3
import { RunnablePassthrough } from "@langchain/core/runnables";
4

5
// 1. Prompt 模板（防幻觉是关键！）
6
const ragPrompt = PromptTemplate.fromTemplate(
7
`你是一个知识库问答助手。请根据提供的上下文回答用户问题。
8

9
上下文：
10
{context}
11

12
用户问题：{question}
13

14
要求：
15
- 仅根据上述上下文回答，不要编造信息
16
- 如果上下文中没有相关信息，请回答"抱歉，知识库中没有相关内容"
17
- 回答要简洁、准确、有条理`
18
);
19

20
// 2. 构建 RAG 链
21
const ragChain = RunnablePassthrough.assign({
22
  context: (input: { question: string }) =>
23
    retriever.invoke(input.question).then(docs =>
24
      docs.map(d => d.pageContent).join("\n---\n")
25
    ),
26
}).pipe(ragPrompt).pipe(llm).pipe(parser);
27

28
// 3. 调用
29
const answer = await ragChain.invoke({ question: "李元静的专业是什么？" });

1
用户问题
2
    │
3
    ▼
4
RunnablePassthrough.assign
5
    ├─ 保持 question 不变
6
    └─ 调用 retriever → 生成 context
7
    │
8
    ▼
9
ragPrompt 模板 → 拼装完整 Prompt
10
    │
11
    ▼
12
LLM 生成回答
13
    │
14
    ▼
15
StringOutputParser → 纯文本输出

1
const TEXT_EXTENSIONS = new Set([
2
  ".md", ".markdown", ".txt", ".csv", ".json",
3
  ".xml", ".html", ".log", ".yaml", ".yml",
4
  ".py", ".js", ".ts", ".java", ".c", ".cpp", ".h",
5
]);
6

7
async function loadDocuments(docsDir: string): Promise<Document[]> {
8
  const allDocs: Document[] = [];
9
  const files = collectFiles(docsDir);
10

11
  for (const filePath of files) {
12
    const ext = path.extname(file).toLowerCase();
13
    if (ext === ".pdf") {
14
      allDocs.push(...await new PDFLoader(filePath).load());
15
    } else if (TEXT_EXTENSIONS.has(ext)) {
16
      allDocs.push(...await new TextLoader(filePath).load());
17
    }
18
  }
19
  return allDocs;
20
}

1
import express from "express";
2

3
const app = express();
4
app.use(express.json());
5

6
// 1. 单轮 RAG 问答
7
app.post("/api/chat", async (req, res) => {
8
  const { question } = req.body;
9
  const answer = await ragChain.invoke({ question });
10
  res.json({ answer });
11
});
12

13
// 2. 流式 RAG（SSE）
14
app.post("/api/chat/stream", async (req, res) => {
15
  res.setHeader("Content-Type", "text/event-stream");
16
  res.setHeader("Cache-Control", "no-cache");
17
  res.setHeader("Connection", "keep-alive");
18

19
  const stream = await ragChain.stream({ question });
20
  for await (const chunk of stream) {
21
    res.write(`data: ${JSON.stringify({ chunk })}\n\n`);
22
  }
23
  res.write(`data: ${JSON.stringify({ done: true })}\n\n`);
24
  res.end();
25
});
26

27
// 3. 检索调试接口（看检索到了什么片段）
28
app.post("/api/retrieve", async (req, res) => {
29
  const docs = await retriever.invoke(question);
30
  res.json({ question, results: docs.map((d, i) => ({
31
    index: i + 1, content: d.pageContent, metadata: d.metadata,
32
  })) });
33
});

1
🚀 RAG 服务已启动: http://localhost:3000
2
   📌 POST /api/chat           — 单轮 RAG 问答
3
   📌 POST /api/chat/stream    — 流式 RAG
4
   📌 POST /api/retrieve       — 检索调试

1
📄 从 library/ 加载文档...
2
  📃 加载文本: business.md
3
  📄 加载 PDF: reference.pdf
4
  ✓ 共加载 7 个文档
5
  ✓ 分割完成: 36 个文本块
6
  🔍 正在构建向量索引...
7
  ✓ 向量索引创建成功！
8

9
────────────────────────────────────────────────────
10
❓ 用户: 李元静的专业是什么？
11
🔎 正在检索相关文档...
12
📚 检索到 3 段相关文本
13
💬 LLM 正在生成回答...
14

15
🤖 回答: 李元静的专业是软件工程。
16

17
────────────────────────────────────────────────────
18
❓ 用户: 李元静会哪些前端技术？
19
🔎 正在检索相关文档...
20
📚 检索到 3 段相关文本
21
💬 LLM 正在生成回答...
22

23
🤖 回答: 李元静掌握的前端技术包括：Vue.js、TypeScript、Vite、
24
Tailwind CSS，并且有企业级管理系统开发经验。
25

26
────────────────────────────────────────────────────
27
🎉 RAG 完整链路演示完成！

1
// ❌ 按固定 200 字切，重叠太小
2
chunkSize: 200, chunkOverlap: 20

1
// ✅ 重叠 50%，按中文语义边界切
2
chunkSize: 300, chunkOverlap: 150,
3
separators: ["\n\n", "\n", "。", "！", "？", "，", "、", "；", " "]

1
请回答用户的问题。

1
你是一个知识库问答助手。请严格遵循以下规则：
2

3
1. 仅根据「上下文」回答用户的问题
4
2. 如果上下文中没有明确的答案，请回答：「抱歉，知识库中没有相关内容」
5
3. 不要在答案中编造任何上下文中没有的内容
6
4. 回答要简洁、准确
7

8
上下文：
9
{context}
10

11
用户问题：{question}

1
TF-IDF（原型） → BGE-small-zh（本地部署） → text-embedding-3（生产）