Firebase Genkit × Gemini でサーバーレスAIアプリを組む実装ノート

// src/flows/greeting.ts
import { z } from "genkit";
import { ai } from "../genkit";
 
export const greetingFlow = ai.defineFlow(
  {
    name: "greeting",
    inputSchema: z.object({
      name: z.string(),
      language: z.enum(["ja", "en"]),
    }),
    outputSchema: z.string(),
  },
  async ({ name, language }) => {
    const prompt =
      language === "ja"
        ? `${name}さんへの、短くて親切な挨拶を日本語で書いてください。`
        : `Write a short, friendly greeting for ${name}.`;
 
    const { text } = await ai.generate({ prompt });
    return text;
  },
);

# Dev UI を起動（http://localhost:4000 でフローを試せます）
npx genkit start -- npx tsx --watch src/index.ts

// src/flows/documentAnalysis.ts
import { z } from "genkit";
import { ai } from "../genkit";
 
export const documentAnalysisFlow = ai.defineFlow(
  {
    name: "documentAnalysis",
    inputSchema: z.object({
      documentText: z.string(),
      analysisType: z.enum(["summary", "sentiment", "keywords"]),
    }),
    outputSchema: z.object({
      analysisType: z.string(),
      result: z.string(),
    }),
  },
  async ({ documentText, analysisType }) => {
    // ステップ1: 入力を安全な長さに切り詰める
    const cleaned = documentText.trim().slice(0, 5000);
 
    // ステップ2: 分析種別ごとにプロンプトを用意
    const prompts: Record<string, string> = {
      summary: `次の文書を3文で要約してください:\n${cleaned}`,
      sentiment: `次の文書の感情を ネガティブ / ニュートラル / ポジティブ で判定してください:\n${cleaned}`,
      keywords: `次の文書から主要キーワードを5つ挙げてください:\n${cleaned}`,
    };
 
    // ステップ3: Gemini で生成し、構造化して返す
    const { text } = await ai.generate({ prompt: prompts[analysisType] });
    return { analysisType, result: text };
  },
);

// src/tools/weather.ts
import { z } from "genkit";
import { ai } from "../genkit";
 
export const getWeather = ai.defineTool(
  {
    name: "getWeather",
    description: "指定した都市の現在の天気を返します",
    inputSchema: z.object({ city: z.string() }),
    outputSchema: z.object({
      city: z.string(),
      temperature: z.number(),
      condition: z.string(),
    }),
  },
  async ({ city }) => {
    // 実運用では外部の天気APIを呼び出します
    return { city, temperature: 25, condition: "晴れ" };
  },
);

// src/flows/assistant.ts
import { z } from "genkit";
import { ai } from "../genkit";
import { getWeather } from "../tools/weather";
 
export const assistantFlow = ai.defineFlow(
  {
    name: "assistant",
    inputSchema: z.object({ question: z.string() }),
    outputSchema: z.string(),
  },
  async ({ question }) => {
    const { text } = await ai.generate({
      prompt: question,
      tools: [getWeather],
      system: "あなたは有能なアシスタントです。必要な場合のみツールを使い、簡潔に答えてください。",
    });
    return text;
  },
);

// src/flows/rag.ts
import { z } from "genkit";
import { ai } from "../genkit";
import { googleAI } from "@genkit-ai/googleai";
 
export const ragFlow = ai.defineFlow(
  {
    name: "documentRAG",
    inputSchema: z.object({ query: z.string(), topK: z.number().default(3) }),
    outputSchema: z.string(),
  },
  async ({ query, topK }) => {
    // 1. クエリを埋め込みベクトルに変換
    const [embedding] = await ai.embed({
      embedder: googleAI.embedder("text-embedding-004"),
      content: query,
    });
 
    // 2. Firestore Vector Search で近傍文書を取得
    const docs = await searchSimilar(embedding.embedding, topK);
 
    // 3. 取得した文脈だけを根拠にプロンプトを組む
    const context = docs.map((d) => `- ${d.content}`).join("\n");
    const { text } = await ai.generate({
      prompt: `次の参考資料だけを根拠に、日本語で簡潔に答えてください。根拠がなければ その旨を述べてください。\n\n参考資料:\n${context}\n\n質問: ${query}`,
    });
    return text;
  },
);
 
// Firestore の近傍検索は別記事に実装を分けています
async function searchSimilar(
  _embedding: number[],
  _topK: number,
): Promise<Array<{ content: string }>> {
  return [];
}

// functions/src/index.ts
import { onCallGenkit } from "firebase-functions/https";
import { defineSecret } from "firebase-functions/params";
import { greetingFlow } from "./flows/greeting";
import { assistantFlow } from "./flows/assistant";
 
// APIキーは Secret Manager から注入する
const apiKey = defineSecret("GOOGLE_API_KEY");
 
export const greeting = onCallGenkit({ secrets: [apiKey] }, greetingFlow);
export const assistant = onCallGenkit({ secrets: [apiKey] }, assistantFlow);

# 1. Firebase CLI を用意
npm install -g firebase-tools
 
# 2. APIキーを Secret Manager に登録（コードには残さない）
firebase functions:secrets:set GOOGLE_API_KEY
 
# 3. Functions のみをデプロイ
firebase deploy --only functions
 
# 4. 一覧で確認
firebase functions:list

// src/flows/routed.ts
import { z } from "genkit";
import { ai } from "../genkit";
import { googleAI } from "@genkit-ai/googleai";
 
const FLASH = googleAI.model("gemini-2.5-flash");
const PRO = googleAI.model("gemini-2.5-pro");
 
export const routedFlow = ai.defineFlow(
  {
    name: "routed",
    inputSchema: z.object({ prompt: z.string(), hard: z.boolean() }),
    outputSchema: z.string(),
  },
  async ({ prompt, hard }) => {
    // 難しいタスクだけ Pro に回し、それ以外は Flash で捌く
    const { text } = await ai.generate({ model: hard ? PRO : FLASH, prompt });
    return text;
  },
);

// src/usage.ts
import { appendFileSync } from "node:fs";
import { ai } from "./genkit";
 
type GenArgs = Parameters<typeof ai.generate>[0];
 
// フロー名を添えて generate を包み、usage を1行 JSON で残す
export async function generateWithUsage(flow: string, args: GenArgs) {
  const startedAt = Date.now();
  const res = await ai.generate(args);
  const u = res.usage ?? {};
  const record = {
    ts: new Date().toISOString(),
    flow,
    model:
      typeof args.model === "string" ? args.model : args.model?.name ?? "default",
    inputTokens: u.inputTokens ?? 0,
    outputTokens: u.outputTokens ?? 0,
    ms: Date.now() - startedAt,
  };
 
  if (process.env.USAGE_LOG) {
    appendFileSync(process.env.USAGE_LOG, JSON.stringify(record) + "\n");
  } else {
    // Cloud Functions ではファイルは残らないので構造化ログに落とす
    console.log(JSON.stringify({ severity: "INFO", genkitUsage: record }));
  }
  return res;
}

// scripts/usage-report.mjs
import { readFileSync } from "node:fs";
 
// 単価は改定されるので、自分の請求画面の値に置き換えてください（1Mトークンあたり USD）
const PRICE = {
  "gemini-2.5-flash": { in: 0.3, out: 2.5 },
  "gemini-2.5-pro": { in: 1.25, out: 10.0 },
};
const JPY = 150;
 
const rows = readFileSync(process.argv[2], "utf8")
  .trim()
  .split("\n")
  .map((line) => JSON.parse(line));
 
const agg = new Map();
for (const r of rows) {
  const key = `${r.flow}\t${r.model}`;
  const a = agg.get(key) ?? { calls: 0, in: 0, out: 0, ms: [] };
  a.calls += 1;
  a.in += r.inputTokens;
  a.out += r.outputTokens;
  a.ms.push(r.ms);
  agg.set(key, a);
}
 
const pct = (xs, p) => [...xs].sort((x, y) => x - y)[Math.floor(xs.length * p)] ?? 0;
 
for (const [key, a] of agg) {
  const [flow, model] = key.split("\t");
  const price = PRICE[model] ?? PRICE["gemini-2.5-flash"];
  const usd = (a.in / 1e6) * price.in + (a.out / 1e6) * price.out;
  const per1k = (usd / a.calls) * 1000 * JPY;
  console.log(
    [
      flow.padEnd(18),
      `calls=${a.calls}`,
      `in/回=${Math.round(a.in / a.calls)}`,
      `out/回=${Math.round(a.out / a.calls)}`,
      `${per1k.toFixed(0)}円 / 1,000呼び出し`,
      `p90 ${pct(a.ms, 0.9)}ms`,
      `p90入力 ${pct(rows.filter((r) => r.flow === flow).map((r) => r.inputTokens), 0.9)}tok`,
    ].join("  "),
  );
}