用 Supabase 打造 RAG：pgvector + Edge Functions 端到端 | Supabase 完整教學

-- 啟用 pgvector（上一篇已介紹，這裡確保存在）
create extension if not exists vector with schema extensions;

-- 文件主表（metadata 層）
create table documents (
  id bigint primary key generated always as identity,
  title text not null,
  source_url text,
  created_at timestamptz default now()
);

-- 分塊表（實際被檢索的單位：文字 + 向量）
create table document_chunks (
  id bigint primary key generated always as identity,
  document_id bigint references documents(id) on delete cascade,
  content text not null,
  chunk_index integer not null,
  embedding extensions.vector(1536),   -- 對應 text-embedding-3-small
  created_at timestamptz default now()
);

-- 檢索：用餘弦相似度找出最接近 query 的 chunks
create or replace function match_documents(
  query_embedding extensions.vector(1536),   -- 查詢向量，維度須與欄位一致
  match_threshold float default 0.7,          -- 相似度門檻（過濾雜訊）
  match_count int default 5                   -- top-k，最多回傳幾筆
)
returns table (
  id bigint,
  content text,
  similarity float
)
language sql stable
as $$
  select
    dc.id,
    dc.content,
    -- 餘弦相似度 = 1 - 餘弦距離；越大越相似
    1 - (dc.embedding <=> query_embedding) as similarity
  from document_chunks dc
  -- 雙重把關之一：只保留相似度「高於」門檻的 chunk
  where 1 - (dc.embedding <=> query_embedding) > match_threshold
  -- 依距離由小到大排序（距離越小 = 越相似），之後才能被向量索引加速
  order by dc.embedding <=> query_embedding asc
  -- 雙重把關之二：只取前 match_count 筆
  limit match_count;
$$;

// 帶重疊的段落感知切分：以 ~500 token 為上限、50 token 重疊
function chunkText(
  text: string,
  chunkSize = 500,
  chunkOverlap = 50,
): string[] {
  // 以空白粗略估算 token（正式環境建議用 tokenizer 精算）
  const words = text.split(/\s+/).filter(Boolean)
  const chunks: string[] = []

  for (let i = 0; i < words.length; i += chunkSize - chunkOverlap) {
    const chunk = words.slice(i, i + chunkSize).join(' ')
    if (chunk.trim()) chunks.push(chunk)   // 相鄰 chunk 會共享 50 個字（重疊）
  }
  return chunks
}

// supabase/functions/ingest/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req: Request) => {
  const { title, content, sourceUrl } = await req.json()

  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!,   // 伺服器端才有的 service role key
  )

  // 1. 建立文件層記錄，拿到 document_id
  const { data: doc, error: docErr } = await supabase
    .from('documents')
    .insert({ title, source_url: sourceUrl })
    .select()
    .single()
  if (docErr) {
    return new Response(JSON.stringify({ error: docErr.message }), { status: 500 })
  }

  // 2. 分塊
  const chunks = chunkText(content, 500, 50)

  // 3. 批次產生 embeddings（一次呼叫送整批，省錢又快）
  const embedRes = await fetch('https://api.openai.com/v1/embeddings', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${Deno.env.get('OPENAI_API_KEY')}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'text-embedding-3-small',   // 索引與查詢必須用「同一個」模型
      input: chunks,                     // 直接送整個 chunk 陣列
    }),
  })
  const { data: embeddings } = await embedRes.json()

  // 4. 把每個 chunk + 它的向量批次存進 pgvector
  const rows = chunks.map((chunk, i) => ({
    document_id: doc.id,
    content: chunk,
    chunk_index: i,
    embedding: embeddings[i].embedding,   // number[]，長度 1536；SDK 會處理格式
  }))
  const { error: insErr } = await supabase.from('document_chunks').insert(rows)
  if (insErr) {
    return new Response(JSON.stringify({ error: insErr.message }), { status: 500 })
  }

  return new Response(
    JSON.stringify({ documentId: doc.id, chunks: chunks.length }),
    { headers: { 'Content-Type': 'application/json' } },
  )
})

// supabase/functions/rag/index.ts
import { serve } from 'https://deno.land/std@0.177.0/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req: Request) => {
  const { question } = await req.json()   // 前端只傳純文字問題

  const openaiKey = Deno.env.get('OPENAI_API_KEY')!
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!,
  )

  // ④ 把問題轉成 query embedding（務必用「同一個」模型）
  const embedRes = await fetch('https://api.openai.com/v1/embeddings', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${openaiKey}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: 'text-embedding-3-small', input: question }),
  })
  const { data: [{ embedding: queryEmbedding }] } = await embedRes.json()

  // ⑤ 檢索：呼叫 match_documents 撈 top-k（threshold + match_count 雙重把關）
  const { data: matches, error } = await supabase.rpc('match_documents', {
    query_embedding: queryEmbedding,
    match_threshold: 0.7,
    match_count: 5,
  })
  if (error) {
    return new Response(JSON.stringify({ error: error.message }), { status: 500 })
  }

  // 過濾後一筆都沒有 → 誠實回覆找不到，不讓 LLM 亂編
  if (!matches || matches.length === 0) {
    return new Response('抱歉，知識庫中找不到與您問題相關的資料。', {
      headers: { 'Content-Type': 'text/plain; charset=utf-8' },
    })
  }

  // ⑥ 增強：把每個 chunk「連編號」組進 context，方便模型標註來源
  const context = matches
    .map((m: { content: string }, i: number) => `[${i + 1}] ${m.content}`)
    .join('\n\n')

  const systemPrompt = `你是一個只根據「提供的知識庫內容」回答問題的助理。
規則：
1. 只能根據下方知識庫內容回答，不可自行編造。
2. 如果知識庫中沒有相關資訊，請直接說「知識庫中沒有相關資料」，不要猜測。
3. 回答時在句末用 [編號] 標註你引用了哪一段來源。

知識庫內容：
${context}`

  // ⑦ 生成：呼叫 LLM，並「串流」輸出（呼應第 034 篇的串流做法）
  const chatRes = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${openaiKey}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'gpt-4o-mini',   // chat 模型，名稱請以官方為準，可自由替換
      stream: true,           // 開啟串流
      temperature: 0.2,       // 降低溫度使回答更貼近資料、更穩定
      messages: [
        { role: 'system', content: systemPrompt },
        { role: 'user', content: question },
      ],
    }),
  })

  // 把 LLM 的 SSE 串流即時轉發給前端（逐字吐出，體感更快）
  const stream = new ReadableStream({
    async start(controller) {
      const reader = chatRes.body!.getReader()
      const decoder = new TextDecoder()
      const encoder = new TextEncoder()

      while (true) {
        const { done, value } = await reader.read()
        if (done) break
        // 解析 OpenAI 的 SSE 格式，抽出每個 token 的文字
        const lines = decoder.decode(value).split('\n').filter((l) => l.startsWith('data: '))
        for (const line of lines) {
          const payload = line.replace('data: ', '')
          if (payload === '[DONE]') continue
          try {
            const token = JSON.parse(payload).choices?.[0]?.delta?.content ?? ''
            if (token) controller.enqueue(encoder.encode(token))
          } catch { /* 忽略非 JSON 的心跳行 */ }
        }
      }
      controller.close()
    },
  })

  return new Response(stream, {
    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
  })
})

// 前端呼叫 RAG Edge Function（不含任何 secret）
const res = await fetch('https://<project>.supabase.co/functions/v1/rag', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${SUPABASE_ANON_KEY}`,   // 只帶 anon key
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ question: '你們的退貨政策是幾天內？' }),
})

// 逐段讀取串流，即時把答案渲染到畫面上
const reader = res.body!.getReader()
const decoder = new TextDecoder()
let answer = ''
while (true) {
  const { done, value } = await reader.read()
  if (done) break
  answer += decoder.decode(value)
  render(answer)   // 每收到一段就更新 UI，打字機效果
}