Rork で作る AI 資格試験対策アプリ：苦手分野を自動分析して合格を最短で目指す仕組み

-- 問題テーブル
CREATE TABLE questions (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  category TEXT NOT NULL,           -- 例: 'ネットワーク', 'セキュリティ'
  difficulty INTEGER DEFAULT 1,     -- 1:易 2:中 3:難
  question_text TEXT NOT NULL,
  options JSONB NOT NULL,           -- ["選択肢A", "選択肢B", "選択肢C", "選択肢D"]
  correct_index INTEGER NOT NULL,   -- 0-3 の正解インデックス
  explanation TEXT,                 -- 解説文
  created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- 解答ログテーブル
CREATE TABLE answer_logs (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID NOT NULL,
  question_id UUID REFERENCES questions(id),
  selected_index INTEGER NOT NULL,
  is_correct BOOLEAN NOT NULL,
  time_spent_seconds INTEGER,       -- 解答にかかった秒数
  answered_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- 弱点分析テーブル
CREATE TABLE weak_analysis (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID NOT NULL,
  analyzed_at TIMESTAMPTZ DEFAULT NOW(),
  weak_categories JSONB,            -- [{"category": "ネットワーク", "accuracy": 0.4, ...}]
  ai_suggestion TEXT,              -- Gemini が生成したアドバイス文
  next_question_ids UUID[]          -- 優先的に出題すべき問題ID
);

ALTER TABLE answer_logs ENABLE ROW LEVEL SECURITY;
 
CREATE POLICY "Users see own logs"
  ON answer_logs FOR ALL
  USING (user_id = auth.uid());

// src/lib/questionSelector.ts
import { supabase } from './supabase';
 
export async function getNextQuestion(userId: string) {
  // まず弱点分析データを確認
  const { data: analysis } = await supabase
    .from('weak_analysis')
    .select('next_question_ids, weak_categories')
    .eq('user_id', userId)
    .order('analyzed_at', { ascending: false })
    .limit(1)
    .single();
 
  if (analysis?.next_question_ids?.length > 0) {
    // 優先問題リストから未回答のものを取得
    const { data: priorityQuestion } = await supabase
      .from('questions')
      .select('*')
      .in('id', analysis.next_question_ids)
      .not('id', 'in', await getRecentlyAnswered(userId))  // 直近回答済みを除く
      .order('difficulty', { ascending: true })            // 易しいものから
      .limit(1)
      .single();
 
    if (priorityQuestion) return priorityQuestion;
  }
 
  // 弱点データがない場合はランダム（ただし直近の問題は除く）
  const { data: randomQuestion } = await supabase
    .from('questions')
    .select('*')
    .not('id', 'in', await getRecentlyAnswered(userId))
    .order('id') // 疑似ランダム
    .limit(10)
    .then(({ data }) => ({ data: data?.[Math.floor(Math.random() * (data?.length ?? 1))] }));
 
  return randomQuestion;
}
 
async function getRecentlyAnswered(userId: string): Promise<string[]> {
  // 直近24時間に回答した問題IDを返す（同じ問題の連続出題を防ぐ）
  const { data } = await supabase
    .from('answer_logs')
    .select('question_id')
    .eq('user_id', userId)
    .gte('answered_at', new Date(Date.now() - 86400000).toISOString());
 
  return data?.map(d => d.question_id) ?? [];
}

// src/lib/weaknessAnalyzer.ts
const GEMINI_API_KEY = process.env.EXPO_PUBLIC_GEMINI_API_KEY; // YOUR_GEMINI_API_KEY
 
export async function analyzeWeakness(
  userId: string,
  answerLogs: AnswerLog[]
): Promise<void> {
  // カテゴリ別の正答率を集計
  const categoryStats = answerLogs.reduce((acc, log) => {
    const cat = log.question.category;
    if (!acc[cat]) acc[cat] = { correct: 0, total: 0, avgTime: 0 };
    acc[cat].total++;
    if (log.is_correct) acc[cat].correct++;
    acc[cat].avgTime += log.time_spent_seconds;
    return acc;
  }, {} as Record<string, { correct: number; total: number; avgTime: number }>);
 
  const statsText = Object.entries(categoryStats)
    .map(([cat, s]) => {
      const accuracy = (s.correct / s.total * 100).toFixed(0);
      const avgTime = (s.avgTime / s.total).toFixed(0);
      return `${cat}: 正答率${accuracy}%、平均${avgTime}秒`;
    })
    .join('\n');
 
  // Gemini API に分析を依頼
  const response = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=${GEMINI_API_KEY}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        contents: [{
          parts: [{
            text: `資格試験学習者の解答データを分析してください。
 
カテゴリ別成績：
${statsText}
 
以下の形式で JSON を返してください：
{
  "weakest_category": "最も苦手なカテゴリ名",
  "accuracy_map": {"カテゴリ名": 正答率(0-1)},
  "advice": "100文字以内の学習アドバイス（です・ます調で）",
  "focus_categories": ["優先的に学習すべきカテゴリ（最大3つ）"]
}`
          }]
        }],
        generationConfig: {
          responseMimeType: 'application/json',
          temperature: 0.3
        }
      })
    }
  );
 
  const result = await response.json();
  const analysisData = JSON.parse(
    result.candidates[0].content.parts[0].text
  );
 
  // 弱点分野に対応する問題を取得
  const { data: weakQuestions } = await supabase
    .from('questions')
    .select('id')
    .in('category', analysisData.focus_categories)
    .order('difficulty', { ascending: true })
    .limit(20);
 
  // 分析結果を Supabase に保存
  await supabase.from('weak_analysis').insert({
    user_id: userId,
    weak_categories: Object.entries(analysisData.accuracy_map).map(
      ([category, accuracy]) => ({ category, accuracy })
    ),
    ai_suggestion: analysisData.advice,
    next_question_ids: weakQuestions?.map(q => q.id) ?? []
  });
}

// scripts/generateQuestions.ts
// ローカルで実行して Supabase に一括インポートするスクリプト
 
const categories = ['ネットワーク', 'セキュリティ', 'データベース', 'プログラミング'];
 
for (const category of categories) {
  const response = await fetch(
    `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent?key=${GEMINI_API_KEY}`,
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        contents: [{
          parts: [{
            text: `${category}に関する情報処理試験レベルの4択問題を10問作成してください。
JSON形式で返してください：
[{
  "category": "${category}",
  "difficulty": 1-3,
  "question_text": "問題文",
  "options": ["A", "B", "C", "D"],
  "correct_index": 0-3,
  "explanation": "解説（100文字以内）"
}]`
          }]
        }],
        generationConfig: { responseMimeType: 'application/json' }
      })
    }
  );
  // ... Supabase に INSERT
}