附录 I：向量数据库 — Agent 的记忆引擎

// → 使用 OpenAI 嵌入 API
async function embed(text: string): Promise<number[]> {
  const response = await fetch("https://api.openai.com/v1/embeddings", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "text-embedding-3-small",
      input: text,
    }),
  })
  const data = await response.json()
  return data.data[0].embedding  // number[1536]
}

// → 使用 Ollama 本地嵌入（免费，无需 API key）
async function embedLocal(text: string): Promise<number[]> {
  const response = await fetch("http://localhost:11434/api/embeddings", {
    method: "POST",
    body: JSON.stringify({ model: "nomic-embed-text", prompt: text }),
  })
  const data = await response.json()
  return data.embedding  // number[768]
}

// → 余弦相似度：最常用的向量相似度度量
function cosineSimilarity(a: number[], b: number[]): number {
  let dot = 0, normA = 0, normB = 0
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i]
    normA += a[i] * a[i]
    normB += b[i] * b[i]
  }
  return dot / (Math.sqrt(normA) * Math.sqrt(normB))
}

// 典型阈值：
// > 0.85 — 高度相关（基本同一个话题）
// 0.70-0.85 — 相关（值得检索）
// < 0.70 — 不相关

// → minimal-rag.ts — 从零到可用的 RAG 系统
import { LanceDB } from "@lancedb/lancedb"  // 嵌入式向量数据库
import { embedLocal } from "./embedding"     // 嵌入函数

interface Memory {
  id: string
  content: string
  metadata: { timestamp: string; source?: string }
}

class MemoryStore {
  private db: any
  private table: any

  async init(path: string): Promise<void> {
    this.db = await LanceDB.connect(path)
    // 如果表不存在则创建
    const tables = await this.db.tableNames()
    if (!tables.includes("memories")) {
      this.table = await this.db.createTable("memories", [
        { id: "seed", vector: new Array(768).fill(0), content: "", metadata: "{}" }
      ])
    } else {
      this.table = await this.db.openTable("memories")
    }
  }

  // 存：文字 → 向量 → 数据库
  async add(memory: Memory): Promise<void> {
    const vector = await embedLocal(memory.content)
    await this.table.add([{
      id: memory.id,
      vector,
      content: memory.content,
      metadata: JSON.stringify(memory.metadata),
    }])
  }

  // 查：query → 向量 → 最相似的 K 个
  async search(query: string, k = 5): Promise<Memory[]> {
    const queryVector = await embedLocal(query)
    const results = await this.table
      .search(queryVector)
      .limit(k)
      .toArray()

    return results.map((r: any) => ({
      id: r.id,
      content: r.content,
      metadata: JSON.parse(r.metadata),
    }))
  }
}

// 使用
const store = new MemoryStore()
await store.init("./agent-memories")

await store.add({
  id: "mem-1",
  content: "用户偏好 React 18 的 useId hook 来生成唯一 ID",
  metadata: { timestamp: new Date().toISOString(), source: "conversation" },
})

await store.add({
  id: "mem-2",
  content: "项目使用 Zustand 做状态管理，不要引入 Redux",
  metadata: { timestamp: new Date().toISOString(), source: "conversation" },
})

// 语义搜索："ID 生成" 能命中 "useId hook"
const results = await store.search("React 中如何生成唯一 ID", 3)
console.log(results.map(r => r.content))

// → 固定大小 + 重叠的 Chunk 策略
function chunkText(text: string, chunkSize = 500, overlap = 50): string[] {
  const chunks: string[] = []
  let i = 0
  while (i < text.length) {
    chunks.push(text.substring(i, i + chunkSize))
    i += chunkSize - overlap  // 重叠 50 字符，避免语义断裂
  }
  return chunks
}

// → 两阶段检索
async function searchWithRerank(query: string, k = 5): Promise<Memory[]> {
  // 第一阶段：向量检索（快，500ms）
  const candidates = await store.search(query, 50)

  // 第二阶段：Cross-encoder 重排（慢但准，200ms）
  // Cross-encoder 同时看 query 和 document，判断相关性
  const reranked = await rerankWithCrossEncoder(query, candidates)

  return reranked.slice(0, k)
}

// LanceDB 的追加写入
await table.add([{ id, vector, content, metadata }])  // 增量，不重建