Rork で作る AI 読書アシスタントアプリ実装 — 本棚スキャン、進捗管理、章別要約の設計と運用

// app/(tabs)/scan.tsx
import { useState } from 'react';
import { View, Text, Pressable, Image, ActivityIndicator } from 'react-native';
import * as ImagePicker from 'expo-image-picker';
import * as ImageManipulator from 'expo-image-manipulator';
import { scanBookshelfApi } from '@/lib/api/bookshelf';
 
type DetectedBook = {
  title: string;
  author?: string;
  confidence: number;
};
 
export default function BookshelfScanScreen() {
  const [image, setImage] = useState<string | null>(null);
  const [books, setBooks] = useState<DetectedBook[] | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
 
  const pickAndScan = async () => {
    try {
      setError(null);
 
      const result = await ImagePicker.launchCameraAsync({
        mediaTypes: ImagePicker.MediaTypeOptions.Images,
        quality: 0.9,
        allowsEditing: false,
      });
 
      if (result.canceled) return;
 
      // 2048px を上限にリサイズ（転送コストと OCR 精度のバランス）
      const manipulated = await ImageManipulator.manipulateAsync(
        result.assets[0].uri,
        [{ resize: { width: 2048 } }],
        { compress: 0.85, format: ImageManipulator.SaveFormat.JPEG, base64: true },
      );
 
      setImage(manipulated.uri);
      setLoading(true);
 
      const detected = await scanBookshelfApi(manipulated.base64!);
      setBooks(detected);
    } catch (e: any) {
      // ユーザーに見せるのは短いメッセージ。詳細は Sentry に送る
      setError('本棚の認識に失敗しました。光が反射していない角度で撮り直してみてください。');
      console.error('[BookshelfScan]', e);
    } finally {
      setLoading(false);
    }
  };
 
  return (
    <View className="flex-1 items-center justify-center p-4">
      <Pressable
        onPress={pickAndScan}
        className="bg-indigo-600 px-6 py-4 rounded-full"
        accessibilityLabel="本棚を撮影して蔵書を登録"
      >
        <Text className="text-white font-semibold">本棚を撮影する</Text>
      </Pressable>
 
      {image && <Image source={{ uri: image }} className="w-full h-64 mt-4 rounded-lg" />}
      {loading && <ActivityIndicator className="mt-4" />}
      {error && <Text className="text-red-500 mt-4">{error}</Text>}
      {books && (
        <View className="w-full mt-4">
          <Text className="font-semibold mb-2">{books.length} 冊認識しました</Text>
          {books.map((b, i) => (
            <Text key={i} className="text-sm text-gray-700">
              {b.title}
              {b.author ? ` / ${b.author}` : ''}（信頼度 {Math.round(b.confidence * 100)}%）
            </Text>
          ))}
        </View>
      )}
    </View>
  );
}

// workers/src/routes/bookshelf.ts
import { Hono } from 'hono';
import Anthropic from '@anthropic-ai/sdk';
import { GoogleGenerativeAI } from '@google/generative-ai';
 
type Env = {
  ANTHROPIC_API_KEY: string;
  GEMINI_API_KEY: string;
};
 
type DetectedBook = { title: string; author?: string; confidence: number };
 
const app = new Hono<{ Bindings: Env }>();
 
app.post('/api/bookshelf/scan', async (c) => {
  const { imageBase64 } = await c.req.json<{ imageBase64: string }>();
 
  if (!imageBase64 || imageBase64.length < 1000) {
    return c.json({ error: 'Invalid image data' }, 400);
  }
 
  try {
    // Claude と Gemini に並列で問い合わせる
    const [claudeResult, geminiResult] = await Promise.allSettled([
      detectBooksWithClaude(imageBase64, c.env.ANTHROPIC_API_KEY),
      detectBooksWithGemini(imageBase64, c.env.GEMINI_API_KEY),
    ]);
 
    // 両者の結果をマージ（タイトルの Jaro 距離でデデュープ）
    const merged = mergeDetections(
      claudeResult.status === 'fulfilled' ? claudeResult.value : [],
      geminiResult.status === 'fulfilled' ? geminiResult.value : [],
    );
 
    return c.json({ books: merged });
  } catch (e) {
    console.error('[BookshelfScan] unexpected error', e);
    return c.json({ error: 'Scan failed' }, 500);
  }
});
 
async function detectBooksWithClaude(base64: string, apiKey: string): Promise<DetectedBook[]> {
  const client = new Anthropic({ apiKey });
 
  const response = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 2000,
    messages: [
      {
        role: 'user',
        content: [
          {
            type: 'image',
            source: { type: 'base64', media_type: 'image/jpeg', data: base64 },
          },
          {
            type: 'text',
            text: `この本棚の画像から、背表紙に見える本のタイトルと著者を読み取ってください。
JSON 配列だけを返してください。以下の形式です:
[{"title": "タイトル", "author": "著者名 or null", "confidence": 0.0-1.0}]
 
不鮮明で読めない本は出力しないでください。推測でタイトルを作り出すのは禁止です。`,
          },
        ],
      },
    ],
  });
 
  const text = response.content[0].type === 'text' ? response.content[0].text : '';
  return parseJsonArray<DetectedBook>(text);
}
 
async function detectBooksWithGemini(base64: string, apiKey: string): Promise<DetectedBook[]> {
  const genAI = new GoogleGenerativeAI(apiKey);
  const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' });
 
  const result = await model.generateContent([
    { inlineData: { data: base64, mimeType: 'image/jpeg' } },
    `本棚画像から背表紙のタイトルと著者を JSON で返してください。形式: [{"title": "...", "author": "...", "confidence": 0.0-1.0}]`,
  ]);
 
  return parseJsonArray<DetectedBook>(result.response.text());
}
 
function parseJsonArray<T>(raw: string): T[] {
  // モデルが ```json ... ``` や前置きを付けてくることがあるので、最初の [ から最後の ] までを抜き出す
  const match = raw.match(/\[[\s\S]*\]/);
  if (!match) return [];
  try {
    return JSON.parse(match[0]);
  } catch {
    return [];
  }
}
 
function mergeDetections(a: DetectedBook[], b: DetectedBook[]): DetectedBook[] {
  const merged = [...a];
  for (const book of b) {
    const similar = merged.find(
      (m) => normalizeTitle(m.title) === normalizeTitle(book.title),
    );
    if (!similar) {
      merged.push(book);
    } else if (book.confidence > similar.confidence) {
      similar.confidence = Math.min(1, (similar.confidence + book.confidence) / 2 + 0.1);
      similar.author = similar.author ?? book.author;
    }
  }
  return merged
    .filter((b) => b.confidence >= 0.5)
    .sort((x, y) => y.confidence - x.confidence);
}
 
function normalizeTitle(t: string): string {
  return t.toLowerCase().replace(/[\s　・：:｜|\-—–]/g, '');
}
 
export default app;

// workers/src/routes/chapters.ts
import { Hono } from 'hono';
import Anthropic from '@anthropic-ai/sdk';
 
type Chapter = { index: number; title: string; estimatedPages?: [number, number] };
 
const app = new Hono<{ Bindings: { ANTHROPIC_API_KEY: string } }>();
 
app.post('/api/books/:bookId/chapters', async (c) => {
  const bookId = c.req.param('bookId');
  const { title, author, totalPages } = await c.req.json<{
    title: string;
    author?: string;
    totalPages?: number;
  }>();
 
  if (!title || title.length > 200) {
    return c.json({ error: 'Invalid title' }, 400);
  }
 
  const client = new Anthropic({ apiKey: c.env.ANTHROPIC_API_KEY });
 
  const response = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1500,
    messages: [
      {
        role: 'user',
        content: `書籍「${title}」${author ? `（${author} 著）` : ''}の章構成を推定してください。
${totalPages ? `総ページ数は約 ${totalPages} ページです。各章の推定ページ範囲も含めてください。` : ''}
JSON 配列のみを返してください。形式:
[{"index": 1, "title": "章タイトル", "estimatedPages": [1, 30]}]
 
章構成が不明な場合は空配列 [] を返してください。推測で作り出さないでください。`,
      },
    ],
  });
 
  const text = response.content[0].type === 'text' ? response.content[0].text : '[]';
  const match = text.match(/\[[\s\S]*\]/);
  let chapters: Chapter[] = [];
  try {
    chapters = match ? JSON.parse(match[0]) : [];
  } catch {
    chapters = [];
  }
 
  // Supabase に保存（省略）
  return c.json({ chapters, source: chapters.length > 0 ? 'ai-estimated' : 'unknown' });
});
 
export default app;

// workers/src/lib/summarize.ts
import Anthropic from '@anthropic-ai/sdk';
 
type SummaryRequest = {
  bookTitle: string;
  chapterTitle: string;
  userNote?: string; // ユーザーが読みながら取ったメモ
  apiKey: string;
};
 
type SummaryResult = {
  keyPoints: string[];
  openQuestions: string[];
  encouragement: string;
};
 
export async function generateChapterSummary(req: SummaryRequest): Promise<SummaryResult> {
  const client = new Anthropic({ apiKey: req.apiKey });
 
  const response = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1200,
    system: `あなたは読者一人ひとりに寄り添う、温かく知的な読書パートナーです。
章の要約は読者の理解を助けるためのもので、ネタバレ全開の要約にはしません。
「考える余地を残す」「読者の問いを広げる」ことを優先してください。`,
    messages: [
      {
        role: 'user',
        content: `書籍「${req.bookTitle}」の「${req.chapterTitle}」章を読み終えた読者向けに、以下の JSON を返してください。
 
${req.userNote ? `読者のメモ: 「${req.userNote}」\n\nこのメモを踏まえて要約してください。\n` : ''}
 
{
  "keyPoints": ["要点を 3 つ、各 60 文字以内"],
  "openQuestions": ["この章を踏まえて、読者が次の章に進む前に考えておくと面白い問いを 3 つ"],
  "encouragement": "読者に向けた一言（80 文字以内、押し付けがましくならないように）"
}
 
JSON のみを返し、前置きや後置きは不要です。`,
      },
    ],
  });
 
  const text = response.content[0].type === 'text' ? response.content[0].text : '{}';
  const match = text.match(/\{[\s\S]*\}/);
  if (!match) {
    throw new Error('Summary generation returned no JSON');
  }
 
  try {
    return JSON.parse(match[0]) as SummaryResult;
  } catch (e) {
    throw new Error('Summary JSON parse failed');
  }
}

{
  "keyPoints": [
    "グライダー型とエンジン型の違いは『与えられた情報を超えて考えられるか』である",
    "学校教育は受動的な理解力を鍛えるが、創造的思考は別の訓練が必要になる",
    "頭を『寝かせる』ことで、ばらばらの情報が結びつき新しい洞察が生まれる"
  ],
  "openQuestions": [
    "自分の仕事や学びの中で、グライダー型に偏っている場面はどこだろうか",
    "今抱えている課題を一度『寝かせて』みたら、どんな変化があるだろうか",
    "アイデアを生み出すための自分なりの『寝かせ方』はどう設計できるか"
  ],
  "encouragement": "読み終えたあと、今日は一度この章の問いを忘れて、明日もう一度戻ってみてください。"
}

// lib/storage/bookStorage.ts
import { MMKV } from 'react-native-mmkv';
 
const storage = new MMKV({ id: 'reading-assistant' });
 
type BookState = {
  id: string;
  title: string;
  author?: string;
  currentPage: number;
  totalPages?: number;
  lastReadAt: number;
  pendingSync: boolean;
};
 
export const bookStorage = {
  upsert(book: BookState): void {
    storage.set(`book:${book.id}`, JSON.stringify({ ...book, pendingSync: true }));
  },
 
  get(id: string): BookState | null {
    const raw = storage.getString(`book:${id}`);
    if (!raw) return null;
    try {
      return JSON.parse(raw);
    } catch {
      return null;
    }
  },
 
  getPendingSync(): BookState[] {
    const keys = storage.getAllKeys().filter((k) => k.startsWith('book:'));
    const books: BookState[] = [];
    for (const key of keys) {
      const raw = storage.getString(key);
      if (!raw) continue;
      try {
        const book = JSON.parse(raw) as BookState;
        if (book.pendingSync) books.push(book);
      } catch {
        // 破損したエントリは無視してそのまま次へ
        continue;
      }
    }
    return books;
  },
 
  markSynced(id: string): void {
    const book = this.get(id);
    if (book) {
      storage.set(`book:${id}`, JSON.stringify({ ...book, pendingSync: false }));
    }
  },
};