壁紙・ヒーリングアプリに Claude API を実装した全記録 — コンテンツキュレーションから多言語説明文生成まで

import anthropic
import time
 
client = anthropic.Anthropic()
 
TARGET_LANGUAGES = {
    "en": "English (US)",
    "ja": "日本語",
    "fr": "Français",
    "de": "Deutsch",
    "es": "Español",
    "pt": "Português (BR)",
    "ko": "한국어",
    "zh-Hans": "简体中文"
}
 
def generate_localized_description(
    app_name: str,
    base_description_ja: str,
    target_lang: str,
    lang_name: str,
    max_chars: int = 4000
) -> str:
    """
    アプリの説明文を特定言語向けにローカライズして生成する
    
    Args:
        app_name: アプリ名
        base_description_ja: 日本語の基本説明文
        target_lang: 言語コード (例: "en", "fr")
        lang_name: 言語の表示名
        max_chars: App Store の文字数上限
    
    Returns:
        ローカライズされた説明文テキスト
    """
    
    if target_lang == "ja":
        # 日本語はそのまま返す
        return base_description_ja
    
    system_prompt = f"""
あなたはヒーリング・ウェルネス系モバイルアプリのコピーライターです。
App Store / Google Play の説明文を{lang_name}で作成します。
 
重要な指針:
- トーンは穏やか、温かく、押しつけがましくない
- ユーザーの「疲れ」「休息」「日常の美しさ」への共感を示す
- 機能の羅列ではなく、体験を伝える
- 最大{max_chars}文字（{lang_name}）に収める
- {lang_name}のApp Storeユーザーが自然に読める表現を使う
- 翻訳ではなく、{lang_name}のネイティブが書いたようなテキストにする
"""
    
    user_prompt = f"""
アプリ名: {app_name}
 
日本語の説明文（参考）:
{base_description_ja}
 
この説明文を参考に、{lang_name}のApp Storeユーザーに向けた説明文を作成してください。
直訳せず、{lang_name}圏のユーザーに自然に響く表現で書いてください。
"""
    
    try:
        message = client.messages.create(
            model="claude-sonnet-4-6",  # 品質重視のためSonnetを使用
            max_tokens=1500,
            system=system_prompt,
            messages=[{"role": "user", "content": user_prompt}]
        )
        return message.content[0].text.strip()
        
    except anthropic.RateLimitError:
        # レート制限に当たった場合は30秒待ってリトライ
        time.sleep(30)
        return generate_localized_description(
            app_name, base_description_ja, target_lang, lang_name, max_chars
        )
    except anthropic.APIError as e:
        raise RuntimeError(f"{lang_name}の生成に失敗: {str(e)}")
 
def generate_all_localizations(
    app_name: str, 
    base_description_ja: str
) -> dict:
    """全対応言語の説明文を生成する"""
    results = {}
    
    for lang_code, lang_name in TARGET_LANGUAGES.items():
        print(f"  生成中: {lang_name}...")
        
        try:
            text = generate_localized_description(
                app_name=app_name,
                base_description_ja=base_description_ja,
                target_lang=lang_code,
                lang_name=lang_name
            )
            results[lang_code] = {
                "status": "success",
                "text": text,
                "char_count": len(text)
            }
        except RuntimeError as e:
            results[lang_code] = {
                "status": "error",
                "error": str(e),
                "text": ""
            }
        
        # APIレート制限への配慮（言語間で2秒待機）
        if lang_code \!= list(TARGET_LANGUAGES.keys())[-1]:
            time.sleep(2)
    
    return results
 
# 使用例
if __name__ == "__main__":
    app_name = "Healing Wallpapers — Calm Screens"
    
    base_ja = """
毎日の疲れを、壁紙で少しだけ和らげませんか。
 
「Healing Wallpapers」は、自然の静けさと現代的なミニマリズムが交わる壁紙を集めたコレクションアプリです。湖面に映る朝霧、秋の光が差し込む森、モノクロームの波紋——どれも、眺めるだけで少し呼吸が楽になるような画を選んでいます。
 
毎週新しい壁紙を追加。季節に合わせた特集も定期的にお届けします。
    """.strip()
    
    print(f"説明文を{len(TARGET_LANGUAGES)}言語で生成中...\n")
    results = generate_all_localizations(app_name, base_ja)
    
    for lang_code, result in results.items():
        print(f"\n[{lang_code}] {TARGET_LANGUAGES[lang_code]}")
        if result["status"] == "success":
            print(f"文字数: {result['char_count']}")
            print(result["text"][:200] + "..." if len(result["text"]) > 200 else result["text"])
        else:
            print(f"エラー: {result['error']}")

import anthropic
import json
 
client = anthropic.Anthropic()
 
# アプリで使用するタグセット（変更は少ない）
ALLOWED_TAGS = {
    "color": ["monochrome", "pastel", "earth-tones", "cool", "warm"],
    "motif": ["nature", "water", "forest", "sky", "architecture", "abstract"],
    "mood": ["calm", "nostalgic", "minimal", "meditative", "joyful"],
    "time": ["morning", "evening", "night", "golden-hour"],
    "season": ["spring", "summer", "autumn", "winter", "timeless"]
}
 
ALLOWED_CATEGORIES = [
    "nature-calm",
    "urban-minimal", 
    "abstract-art",
    "seasonal-special",
    "monochrome"
]
 
def tag_and_categorize(content_description: str) -> dict:
    """
    コンテンツの説明文からタグとカテゴリを自動生成する
    
    Args:
        content_description: コンテンツの自然言語による説明
    
    Returns:
        タグとカテゴリを含む辞書
    """
    
    system_prompt = """
壁紙アプリのコンテンツタグ付けを行います。
指定されたタグと カテゴリのみを使用してください。
必ずJSON形式で返してください。
"""
    
    user_prompt = f"""
以下のコンテンツにタグとカテゴリを付けてください。
 
コンテンツ説明:
{content_description}
 
使用可能なタグ（各グループから0〜2個選択）:
{json.dumps(ALLOWED_TAGS, ensure_ascii=False)}
 
使用可能なカテゴリ（1つだけ選択）:
{ALLOWED_CATEGORIES}
 
JSON形式で返してください:
{{
  "tags": {{
    "color": [...],
    "motif": [...],
    "mood": [...],
    "time": [...],
    "season": [...]
  }},
  "primary_category": "...",
  "confidence": <0.0-1.0の数値>
}}
"""
    
    try:
        message = client.messages.create(
            model="claude-haiku-4-5-20251001",
            max_tokens=400,
            system=system_prompt,
            messages=[{"role": "user", "content": user_prompt}]
        )
        
        response_text = message.content[0].text.strip()
        start = response_text.find('{')
        end = response_text.rfind('}') + 1
        
        if start >= 0 and end > start:
            result = json.loads(response_text[start:end])
            
            # バリデーション: 許可されていないタグを除去
            validated_tags = {}
            for group, tags in result.get("tags", {}).items():
                if group in ALLOWED_TAGS:
                    validated_tags[group] = [
                        t for t in tags if t in ALLOWED_TAGS[group]
                    ]
            result["tags"] = validated_tags
            
            # バリデーション: 許可されていないカテゴリはデフォルトに
            if result.get("primary_category") not in ALLOWED_CATEGORIES:
                result["primary_category"] = "nature-calm"
                result["confidence"] = 0.5
            
            return result
        else:
            raise ValueError(f"JSONが見つかりません")
            
    except (json.JSONDecodeError, ValueError) as e:
        # エラー時はデフォルト値を返す（処理は止めない）
        return {
            "tags": {k: [] for k in ALLOWED_TAGS.keys()},
            "primary_category": "nature-calm",
            "confidence": 0.0,
            "error": str(e)
        }
 
# 使用例
if __name__ == "__main__":
    desc = "霧の中、湖面に映る一本の裸木。早朝の青みがかった光。音が消えたような静けさ。"
    result = tag_and_categorize(desc)
    print(json.dumps(result, ensure_ascii=False, indent=2))
    
    # 期待する出力例:
    # {
    #   "tags": {
    #     "color": ["cool", "monochrome"],
    #     "motif": ["nature", "water"],
    #     "mood": ["calm", "minimal"],
    #     "time": ["morning"],
    #     "season": ["timeless"]
    #   },
    #   "primary_category": "nature-calm",
    #   "confidence": 0.91
    # }

import json
import os
import time
import random
import anthropic
 
client = anthropic.Anthropic()
STATE_PATH = "curation_state.json"
 
def load_state() -> dict:
    if os.path.exists(STATE_PATH):
        with open(STATE_PATH, encoding="utf-8") as f:
            return json.load(f)
    return {}
 
def save_state(state: dict) -> None:
    # 一時ファイルに書いてから置き換える（処理中のクラッシュで壊さない）
    tmp = STATE_PATH + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(state, f, ensure_ascii=False)
    os.replace(tmp, STATE_PATH)
 
def call_with_backoff(score_fn, item, max_retries: int = 6):
    """指数バックオフ付きで1件処理する。429/5xx のみリトライする"""
    for attempt in range(max_retries):
        try:
            return score_fn(item)
        except anthropic.RateLimitError:
            wait = min(2 ** attempt + random.uniform(0, 1), 60)
            print(f"  rate limited, retry in {wait:.1f}s ({attempt + 1}/{max_retries})")
            time.sleep(wait)
        except anthropic.APIStatusError as e:
            if e.status_code and e.status_code >= 500:
                wait = min(2 ** attempt, 30)
                time.sleep(wait)
            else:
                raise  # 4xx は設定ミスなので即座に表面化させる
    raise RuntimeError(f"max retries exceeded for {item['id']}")
 
def process_library(items, score_fn):
    """再開可能なバッチ処理。落ちても処理済みはスキップする"""
    state = load_state()
    done = 0
    for item in items:
        if item["id"] in state:
            continue  # すでに処理済み
        result = call_with_backoff(score_fn, item)
        state[item["id"]] = result
        save_state(state)  # 1件ごとに永続化
        done += 1
    print(f"完了: 新規 {done} 件 / 累計 {len(state)} 件")
    return state