14.01-RAG基本概念

// ❌ 把所有文档塞进 Prompt
const allDocs = await loadAllCompanyDocuments()  // 可能几百万字
const prompt = `
根据以下文档回答用户的问题。
 
${allDocs}
 
用户问题：${userQuestion}
`

// 这一步的输入输出
type ParsedDocument = {
  id: string
  title: string
  content: string       // 纯文本内容
  metadata: {
    source: string      // 来源：文件路径、URL
    format: 'pdf' | 'docx' | 'html' | 'markdown'
    createdAt: string
    author?: string
  }
}

// 切分策略示意
const chunks = chunkText(document.content, {
  chunkSize: 1000,    // 每段 1000 字符
  overlap: 200,       // 段与段之间重叠 200 字符
})
 
// 一篇 5000 字的文档可能切成 6-8 段
// 每段独立成为一个检索单元

// 调用 embedding 模型
const embedding = await callEmbeddingAPI(chunk.text)
// 返回类似 [0.12, -0.34, 0.88, ..., 0.05] 的浮点数数组
// 维度通常是 768、1024 或 1536

// 写入向量数据库
await vectorDB.upsert({
  id: `${document.id}-chunk-${index}`,
  vector: embedding,
  metadata: {
    text: chunk.text,
    documentId: document.id,
    documentTitle: document.title,
    chunkIndex: index,
    source: document.metadata.source,
  },
})

const queryVector = await callEmbeddingAPI(userQuestion)

const results = await vectorDB.query(queryVector, {
  topK: 5,
  returnMetadata: 'all',
})
 
// results.matches 是 5 个最相似的 chunk
// 每个 match 包含 id、score（相似度分数）、metadata（原文、来源等）

const context = results.matches
  .map((m, i) => `[${i + 1}] ${m.metadata.text}`)
  .join('\n\n')
 
const systemPrompt = `你是一个根据提供的上下文回答问题的助手。
 
只使用下面的上下文回答。如果上下文里没有答案，明确告知用户。
 
上下文：
${context}`
 
const messages = [
  { role: 'system', content: systemPrompt },
  { role: 'user', content: userQuestion },
]

const response = await callModelAPI({
  model: 'gpt-4o',
  messages,
  temperature: 0,  // 基于事实的回答，降低随机性
})
 
const answer = response.choices[0].message.content

return c.json({
  answer,
  sources: results.matches.map((m) => ({
    documentId: m.metadata.documentId,
    documentTitle: m.metadata.documentTitle,
    chunkIndex: m.metadata.chunkIndex,
    score: m.score,
  })),
})

// 同时使用 RAG 和微调
const messages = [
  { role: 'system', content: ragContext },          // RAG：提供事实
  // 模型本身经过微调，知道怎么组织回答          // 微调：提供风格
  { role: 'user', content: userQuestion },
]
 
const response = await callModelAPI({
  model: 'my-fine-tuned-model',  // 微调过的模型
  messages,
})

// src/services/rag/index.ts
import { Hono } from 'hono'
import { callEmbeddingAPI } from '@/services/embedding'
import { callModelAPI } from '@/services/llm'
import { vectorDB } from '@/services/vector-db'
 
const ragApp = new Hono()
 
// 索引接口：上传文档并建立索引
ragApp.post('/index', async (c) => {
  const { documents } = await c.req.json<{
    documents: Array<{ id: string; title: string; content: string; source: string }>
  }>()
 
  const indexed = []
 
  for (const doc of documents) {
    // 1. 切分
    const chunks = chunkText(doc.content, { chunkSize: 1000, overlap: 200 })
 
    // 2. 向量化（批量）
    const embeddings = await callEmbeddingAPI(chunks.map((c) => c.text))
 
    // 3. 写入向量数据库
    const vectors = chunks.map((chunk, i) => ({
      id: `${doc.id}-chunk-${i}`,
      vector: embeddings[i],
      metadata: {
        text: chunk.text,
        documentId: doc.id,
        documentTitle: doc.title,
        chunkIndex: i,
        source: doc.source,
      },
    }))
 
    await vectorDB.upsert(vectors)
    indexed.push({ documentId: doc.id, chunks: chunks.length })
  }
 
  return c.json({ indexed })
})
 
// 查询接口：检索 + 生成
ragApp.post('/query', async (c) => {
  const { question, topK = 5 } = await c.req.json<{
    question: string
    topK?: number
  }>()
 
  // 1. 问题向量化
  const [queryVector] = await callEmbeddingAPI([question])
 
  // 2. 检索
  const results = await vectorDB.query(queryVector, {
    topK,
    returnMetadata: 'all',
  })
 
  // 3. 拼接上下文
  const context = results.matches
    .map((m, i) => `[${i + 1}] ${m.metadata.text}`)
    .join('\n\n')
 
  const systemPrompt = `你是一个根据提供的上下文回答问题的助手。
 
## 规则
- 只使用下面的上下文回答
- 如果上下文里没有答案，回答「根据现有资料无法回答」
- 回答时引用来源编号，如「根据文档 [1]」
 
## 上下文
${context}`
 
  // 4. 生成回答
  const response = await callModelAPI({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: question },
    ],
    temperature: 0,
  })
 
  return c.json({
    answer: response.choices[0].message.content,
    sources: results.matches.map((m) => ({
      documentId: m.metadata.documentId,
      documentTitle: m.metadata.documentTitle,
      chunkIndex: m.metadata.chunkIndex,
      score: m.score,
    })),
  })
})
 
// 切分函数（简化版，第 14.05 节会展开）
function chunkText(text: string, options: { chunkSize: number; overlap: number }) {
  const chunks: Array<{ text: string; start: number }> = []
  let start = 0
  while (start < text.length) {
    const end = Math.min(start + options.chunkSize, text.length)
    chunks.push({ text: text.slice(start, end), start })
    start += options.chunkSize - options.overlap
  }
  return chunks
}
 
export default ragApp