【個人開発】GeminiにRSSをパトロールさせてSlackに通知させてみた

┌─────────────────────────────────────────────────────────────┐
│                    Cloud Scheduler                          │
│              (毎日 8:00 / 12:00 / 17:00)                     │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Cloud Run (Go)                           │
│                    process_rss_go                           │
│                                                             │
│  1. RSSフィードを取得                                         │
│  2. Firestoreで既読チェック                                   │
│  3. Gemini APIで重要度を10段階で判定                           │
│  4. しきい値以上の記事をSlackに通知                             │
│  5. Firestoreに保存（既読管理）                                │
└─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┴───────────────┐
              ▼                               ▼
┌─────────────────────────┐     ┌─────────────────────────┐
│        Slack            │     │       Firestore         │
│  「📰 重要なニュース」      │     │   既読記事を保存         │
└─────────────────────────┘     └─────────────────────────┘

func ProcessRSS(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    projectID := os.Getenv("GCP_PROJECT")
    if projectID == "" {
        projectID = "yuyayoshiok"
    }

    // RSS URLs（環境変数 or デフォルト）
    rssUrlsEnv := os.Getenv("RSS_URLS")
    var rssUrls []string
    if rssUrlsEnv != "" {
        for _, u := range strings.Split(rssUrlsEnv, ",") {
            if strings.TrimSpace(u) != "" {
                rssUrls = append(rssUrls, strings.TrimSpace(u))
            }
        }
    } else {
        rssUrls = []string{
            "https://zenn.dev/feed",
            "https://qiita.com/popular-items/feed.atom",
            "https://www.lifehacker.jp/feed/index.xml",
            "https://yamadashy.github.io/tech-blog-rss-feed/feeds/rss.xml",
        }
    }

    // シークレットを取得
    slackToken, _ := accessSecret(ctx, projectID, "slack-bot-token")
    apiKey, _ := accessSecret(ctx, projectID, "gemini-api-key")

    // チャンネルIDを環境変数から取得
    channelID := os.Getenv("CHANNEL_3_FEED_NOTIFICATIONS_ID")
    if channelID == "" {
        channelID = "C09R3DHMSFL"
    }

    // フィードを処理
    count, err := processFeeds(ctx, projectID, apiKey, slackToken, channelID, rssUrls)
    if err != nil {
        log.Printf("フィード処理エラー: %v", err)
        http.Error(w, "Failed to process feeds", http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]interface{}{
        "status": "ok",
        "count":  count,
    })
}

type ImportanceResult struct {
    Score  int    `json:"score"`
    Reason string `json:"reason"`
}

func evaluateImportance(ctx context.Context, apiKey, title, summary, url string) (ImportanceResult, error) {
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
        APIKey: apiKey,
    })
    if err != nil {
        return ImportanceResult{}, fmt.Errorf("failed to create Gemini client: %w", err)
    }

    prompt := fmt.Sprintf(`以下の技術記事のタイトルと要約から、
ゆうやさんにとっての重要度を10段階で評価してください。

記事タイトル: %s
記事要約: %s
記事URL: %s

## ゆうやさんのプロフィール
- 30代エンジニア
- 興味分野: Python, Go言語, GCP, 生成AI (Gemini, ChatGPT), Automation, Obsidian, Apple製品
- 役割: 個人開発者、フリーランス、エンジニア
- 直近の関心: RSSリーダーの開発、AIエージェントの構築、Cloud Run、Go言語

## 評価基準
- 10-9: 非常に重要。即座に読むべき。技術的なブレイクスルーや、開発中のプロジェクトに直結する内容。
- 8-7: 重要。後で読むべき。興味分野の新しいツールやベストプラクティス。
- 6-5: 普通。興味があれば読む。一般的な技術ニュース。
- 4以下: 重要ではない。

## 出力フォーマット
JSON形式で出力してください。Markdownのコードブロックは含めないでください。
{
  "score": (数値),
  "reason": "(30文字以内の簡潔な理由)"
}
`, title, summary, url)

    modelName := "gemini-2.5-flash-lite"
    resp, err := client.Models.GenerateContent(ctx, modelName, genai.Text(prompt), nil)

    if err != nil {
        // フォールバック: 別のモデルを試す
        modelName = "gemini-2.5-flash"
        resp, err = client.Models.GenerateContent(ctx, modelName, genai.Text(prompt), nil)
        if err != nil {
            return ImportanceResult{}, fmt.Errorf("Gemini APIエラー: %w", err)
        }
    }

    // レスポンスをパース
    // ...
}

func processFeeds(ctx context.Context, projectID, apiKey, slackToken, channelID string, rssUrls []string) (int, error) {
    parser := gofeed.NewParser()

    now := time.Now()
    
    // 時間帯によってしきい値を変える
    baseThreshold := 6
    if now.Hour() >= 7 && now.Hour() < 11 {
        baseThreshold = 6  // 朝は緩め（情報を多く知りたい）
    } else if now.Hour() >= 11 && now.Hour() < 15 {
        baseThreshold = 7  // 昼は普通
    } else {
        baseThreshold = 8  // 夜は厳しく（本当に重要なものだけ）
    }

    var (
        importantArticles []map[string]interface{}
        currentAPIKey     = apiKey
        usingPaidKey      = false
        mu                sync.Mutex
        wg                sync.WaitGroup
    )

    // 並列処理でフィードを取得・評価
    for _, feedURL := range rssUrls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            // タイムアウト付きでフィードを取得
            fetchCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
            feed, err := parser.ParseURLWithContext(url, fetchCtx)
            cancel()
            if err != nil {
                log.Printf("フィードのパースに失敗しました %s: %v", url, err)
                return
            }

            // ランダムにシャッフル（偏りを防ぐ）
            rand.Shuffle(len(feed.Items), func(i, j int) {
                feed.Items[i], feed.Items[j] = feed.Items[j], feed.Items[i]
            })

            // 各記事を評価
            maxItems := 20
            if strings.Contains(url, "yamadashy") {
                maxItems = 5  // 集約フィードは少なめに
            }

            for i := 0; i < maxItems && i < len(feed.Items); i++ {
                item := feed.Items[i]

                // Firestoreで既読チェック
                exists := checkArticleInFirestore(ctx, projectID, item.Link)
                if exists {
                    continue
                }

                // レート制限対策
                time.Sleep(100 * time.Millisecond)

                // 重要度を評価
                importance, err := evaluateImportance(ctx, currentAPIKey, item.Title, summary, item.Link)
                if err != nil {
                    // ...
                }

                // しきい値を超えたら重要記事として保存
                if importance.Score >= currentThreshold {
                    // ...
                }
            }
        }(feedURL)
    }

    wg.Wait()

    // 上位1件だけ通知（スパム防止）
    if len(importantArticles) > 1 {
        sort.Slice(importantArticles, func(i, j int) bool {
            return importantArticles[i]["importance"].(int) > importantArticles[j]["importance"].(int)
        })
        importantArticles = importantArticles[:1]
    }

    // Slackに通知
    for _, article := range importantArticles {
        msg := fmt.Sprintf("📰 重要な技術ニュース\n\n%s\n\n重要度（AI判定）: %d/10\n理由（AI考察）: %s\n\n🔗 %s",
            article["title"], article["importance"], article["reason"], article["url"])
        postMessage(ctx, slackToken, channelID, msg)
    }

    return len(importantArticles), nil
}

if err != nil && (strings.Contains(err.Error(), "429") || 
                  strings.Contains(err.Error(), "RESOURCE_EXHAUSTED")) {
    mu.Lock()
    if !usingPaidKey {
        log.Printf("⚠️ Gemini無料枠の上限に達しました。以降は有料キーを使用します...")
        paidKey, secretErr := accessSecret(ctx, projectID, "gemini-api-key-paid")
        if secretErr == nil && paidKey != "" {
            currentAPIKey = paidKey
            usingPaidKey = true
        } else {
            log.Printf("⚠️ 有料APIキーの取得に失敗しました: %v", secretErr)
        }
    }
    mu.Unlock()

    // 有料キーでリトライ
    if usingPaidKey {
        importance, err = evaluateImportance(ctx, currentAPIKey, item.Title, summary, item.Link)
    }
}

for _, url := range urls {
    wg.Add(1)
    go func(u string) {
        defer wg.Done()
        // 処理
    }(url)
}
wg.Wait()

📰 重要な技術ニュース

Gemini 2.5の新機能が発表されました

重要度（AI判定）: 9/10
理由（AI考察）: 開発中のAIエージェントに直結

🔗 https://example.com/...