Gemini API × Cloudflare Vectorize で完全エッジ RAG を構築する — 低レイテンシ・低コスト・グローバル配信の本番設計

# wrangler.toml と同じディレクトリで実行
npx wrangler vectorize create gemini-rag-index \
  --dimensions=768 \
  --metric=cosine
 
# メタデータインデックスも作っておくとフィルタ検索に便利
npx wrangler vectorize create-metadata-index gemini-rag-index \
  --property-name=tenant_id \
  --type=string

# wrangler.toml
name = "gemini-edge-rag"
main = "src/index.ts"
compatibility_date = "2026-04-01"
 
[[vectorize]]
binding = "VECTORIZE"
index_name = "gemini-rag-index"
 
[vars]
GEMINI_MODEL = "gemini-2.5-flash"
EMBEDDING_MODEL = "text-embedding-004"

// scripts/ingest.ts — Workers から呼び出す投入用エンドポイント
import { Hono } from "hono";
 
type Env = {
  VECTORIZE: VectorizeIndex;
  GEMINI_API_KEY: string;
  EMBEDDING_MODEL: string;
};
 
const app = new Hono<{ Bindings: Env }>();
 
app.post("/ingest", async (c) => {
  // 認証は別途実装（管理者トークン推奨）
  const docs = await c.req.json<Array<{ id: string; text: string; tenant_id: string }>>();
 
  // Gemini Embedding API は 1 リクエストあたり最大 100 件のバッチ投入が可能
  // ただし Workers のレスポンスボディは最大 100MB なので、慎重にチャンク分割する
  const CHUNK = 100;
  for (let i = 0; i < docs.length; i += CHUNK) {
    const slice = docs.slice(i, i + CHUNK);
 
    const embedRes = await fetch(
      `https://generativelanguage.googleapis.com/v1beta/models/${c.env.EMBEDDING_MODEL}:batchEmbedContents`,
      {
        method: "POST",
        headers: {
          "x-goog-api-key": c.env.GEMINI_API_KEY,
          "content-type": "application/json",
        },
        body: JSON.stringify({
          requests: slice.map((d) => ({
            model: `models/${c.env.EMBEDDING_MODEL}`,
            content: { parts: [{ text: d.text }] },
            taskType: "RETRIEVAL_DOCUMENT",
          })),
        }),
      },
    );
 
    if (!embedRes.ok) {
      // 429（レート制限）と 5xx は呼び出し側で必ずリトライさせる
      const detail = await embedRes.text();
      throw new Error(`embedding_failed: ${embedRes.status} ${detail.slice(0, 200)}`);
    }
 
    const embedData = await embedRes.json<{
      embeddings: Array<{ values: number[] }>;
    }>();
 
    // Vectorize に投入。values の次元数は 768 で固定
    await c.env.VECTORIZE.upsert(
      slice.map((d, idx) => ({
        id: d.id,
        values: embedData.embeddings[idx].values,
        metadata: {
          tenant_id: d.tenant_id,
          // 本文は Vectorize のメタデータに最大 10KB まで格納できる
          // 長文の場合は KV や R2 に保存してキーだけメタデータに入れる方が安全
          text: d.text.slice(0, 9500),
        },
      })),
    );
  }
 
  return c.json({ ok: true, count: docs.length });
});
 
export default app;

// src/index.ts — 検索 + 生成エンドポイント
import { Hono } from "hono";
import { cors } from "hono/cors";
 
type Env = {
  VECTORIZE: VectorizeIndex;
  GEMINI_API_KEY: string;
  EMBEDDING_MODEL: string;
  GEMINI_MODEL: string;
};
 
const app = new Hono<{ Bindings: Env }>();
app.use("/api/*", cors({ origin: ["https://your-frontend.example"] }));
 
async function embed(text: string, env: Env, taskType = "RETRIEVAL_QUERY") {
  const res = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/${env.EMBEDDING_MODEL}:embedContent`,
    {
      method: "POST",
      headers: {
        "x-goog-api-key": env.GEMINI_API_KEY,
        "content-type": "application/json",
      },
      body: JSON.stringify({
        content: { parts: [{ text }] },
        taskType,
      }),
    },
  );
  if (!res.ok) throw new Error(`embed_failed:${res.status}`);
  const data = await res.json<{ embedding: { values: number[] } }>();
  return data.embedding.values;
}
 
async function generateAnswer(
  query: string,
  contexts: string[],
  env: Env,
): Promise<string> {
  const prompt = `あなたは正確で誠実なアシスタントです。
以下の参考情報のみに基づいて日本語で回答してください。
参考情報に答えがない場合は「資料からは判断できません」と答えてください。
出典番号は [#1] [#2] のように本文中に付与してください。
 
# 参考情報
${contexts.map((c, i) => `[#${i + 1}] ${c}`).join("\n\n")}
 
# 質問
${query}`;
 
  const res = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/${env.GEMINI_MODEL}:generateContent`,
    {
      method: "POST",
      headers: {
        "x-goog-api-key": env.GEMINI_API_KEY,
        "content-type": "application/json",
      },
      body: JSON.stringify({
        contents: [{ role: "user", parts: [{ text: prompt }] }],
        generationConfig: {
          temperature: 0.2,
          maxOutputTokens: 1024,
          // Workers の CPU 制限を超えないよう Flash + 控えめなトークン上限に
        },
      }),
    },
  );
  if (!res.ok) throw new Error(`generate_failed:${res.status}`);
  const data = await res.json<{
    candidates: Array<{ content: { parts: Array<{ text: string }> } }>;
  }>();
  return data.candidates[0]?.content.parts[0]?.text ?? "";
}
 
app.post("/api/ask", async (c) => {
  const { query, tenant_id } = await c.req.json<{
    query: string;
    tenant_id?: string;
  }>();
 
  // 1) クエリを埋め込む
  const queryVector = await embed(query, c.env, "RETRIEVAL_QUERY");
 
  // 2) Vectorize で類似検索（テナント絞り込み付き）
  const filter = tenant_id ? { tenant_id: { $eq: tenant_id } } : undefined;
  const result = await c.env.VECTORIZE.query(queryVector, {
    topK: 5,
    returnMetadata: "all",
    filter,
  });
 
  const contexts = result.matches
    .filter((m) => m.score >= 0.65) // 類似度の足切り。0.6 以下はノイズが増える
    .map((m) => String(m.metadata?.text ?? ""))
    .filter((t) => t.length > 0);
 
  if (contexts.length === 0) {
    return c.json({
      answer: "関連する資料が見つかりませんでした。質問を別の言い回しで試してください。",
      sources: [],
    });
  }
 
  // 3) Gemini で回答生成
  const answer = await generateAnswer(query, contexts, c.env);
 
  return c.json({
    answer,
    sources: result.matches.map((m) => ({ id: m.id, score: m.score })),
  });
});
 
export default app;

async function fetchWithRetry(
  url: string,
  init: RequestInit,
  opts: { timeoutMs: number; maxRetries: number },
): Promise<Response> {
  let lastErr: unknown;
  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
    const ctrl = new AbortController();
    const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs);
    try {
      const res = await fetch(url, { ...init, signal: ctrl.signal });
      clearTimeout(timer);
      // 429 / 5xx のみリトライ。4xx の他のエラーは即座に上に投げる
      if (res.status === 429 || (res.status >= 500 && res.status < 600)) {
        if (attempt < opts.maxRetries - 1) {
          // 200ms, 400ms, 800ms の指数バックオフ
          await new Promise((r) => setTimeout(r, 200 * Math.pow(2, attempt)));
          continue;
        }
      }
      return res;
    } catch (err) {
      clearTimeout(timer);
      lastErr = err;
      if (attempt === opts.maxRetries - 1) throw err;
      await new Promise((r) => setTimeout(r, 200 * Math.pow(2, attempt)));
    }
  }
  throw lastErr;
}

const MAX_QUERY_CHARS = 1000;
if (query.length > MAX_QUERY_CHARS) {
  return c.json(
    { error: "query_too_long", limit: MAX_QUERY_CHARS },
    400,
  );
}