プロンプトキャッシング

LLM プロンプトのキャッシング戦略。Anthropic プロンプトキャッシング、レスポンスキャッシング、CAG (Cache Augmented Generation) を含む

機能

• prompt-cache
• response-cache
• kv-cache
• cag-patterns
• cache-invalidation

前提条件

• 知識: キャッシング基礎、LLM API 使用法、ハッシュ関数
• 推奨スキル: context-window-management

スコープ

• 対象外: CDN キャッシング、データベースクエリキャッシング、静的アセットキャッシング
• 境界: LLM 固有のキャッシングに焦点、プロンプトとレスポンスキャッシングをカバー

エコシステム

Primary_tools

• Anthropic Prompt Caching - Claude API のネイティブプロンプトキャッシング
• Redis - レスポンスのインメモリキャッシュ
• OpenAI Caching - OpenAI API の自動キャッシング

パターン

Anthropic プロンプトキャッシング

Claude のネイティブプロンプトキャッシングを使用して繰り返されるプレフィックスをキャッシング

使用すべき場合: Claude API を使用して安定したシステムプロンプトまたはコンテキストがある場合

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

// プロンプトの安定した部分をキャッシング
async function queryWithCaching(userQuery: string) {
    const response = await client.messages.create({
        model: "claude-sonnet-4-20250514",
        max_tokens: 1024,
        system: [
            {
                type: "text",
                text: LONG_SYSTEM_PROMPT,  // Your detailed instructions
                cache_control: { type: "ephemeral" }  // Cache this!
            },
            {
                type: "text",
                text: KNOWLEDGE_BASE,  // Large static context
                cache_control: { type: "ephemeral" }
            }
        ],
        messages: [
            { role: "user", content: userQuery }  // Dynamic part
        ]
    });

    // キャッシュ使用状況をチェック
    console.log(`Cache read: ${response.usage.cache_read_input_tokens}`);
    console.log(`Cache write: ${response.usage.cache_creation_input_tokens}`);

    return response;
}

// コスト削減: キャッシュされたトークンで 90% 削減
// レイテンシ削減: 最大 2 倍高速

レスポンスキャッシング

同一または類似したクエリの完全な LLM レスポンスをキャッシング

使用すべき場合: 同じクエリが繰り返し聞かれる場合

import { createHash } from 'crypto';
import Redis from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);

class ResponseCache {
    private ttl = 3600;  // デフォルト 1 時間

    // 完全一致キャッシング
    async getCached(prompt: string): Promise<string | null> {
        const key = this.hashPrompt(prompt);
        return await redis.get(`response:${key}`);
    }

    async setCached(prompt: string, response: string): Promise<void> {
        const key = this.hashPrompt(prompt);
        await redis.set(`response:${key}`, response, 'EX', this.ttl);
    }

    private hashPrompt(prompt: string): string {
        return createHash('sha256').update(prompt).digest('hex');
    }

    // セマンティック類似性キャッシング
    async getSemanticallySimilar(
        prompt: string,
        threshold: number = 0.95
    ): Promise<string | null> {
        const embedding = await embed(prompt);
        const similar = await this.vectorCache.search(embedding, 1);

        if (similar.length && similar[0].similarity > threshold) {
            return await redis.get(`response:${similar[0].id}`);
        }
        return null;
    }

    // 温度対応キャッシング
    async getCachedWithParams(
        prompt: string,
        params: { temperature: number; model: string }
    ): Promise<string | null> {
        // 低温レスポンスのみをキャッシング
        if (params.temperature > 0.5) return null;

        const key = this.hashPrompt(
            `${prompt}|${params.model}|${params.temperature}`
        );
        return await redis.get(`response:${key}`);
    }
}

キャッシュ拡張生成 (CAG)

RAG 検索の代わりにドキュメントをプロンプトに事前キャッシング

使用すべき場合: ドキュメントコーパスが安定してコンテキストに収まる場合

// CAG: ドキュメントコンテキストを事前計算し、プロンプトにキャッシング
// 以下の場合、RAG より優れている:
// - ドキュメントが安定している
// - 合計がコンテキストウィンドウに収まる
// - レイテンシが重要

class CAGSystem {
    private cachedContext: string | null = null;
    private lastUpdate: number = 0;

    async buildCachedContext(documents: Document[]): Promise<void> {
        // ドキュメントを事前処理して形式化
        const formatted = documents.map(d =>
            `## ${d.title}\n${d.content}`
        ).join('\n\n');

        // タイムスタンプと共に保存
        this.cachedContext = formatted;
        this.lastUpdate = Date.now();
    }

    async query(userQuery: string): Promise<string> {
        // キャッシュされたコンテキストをプロンプトで直接使用
        const response = await client.messages.create({
            model: "claude-sonnet-4-20250514",
            max_tokens: 1024,
            system: [
                {
                    type: "text",
                    text: "You are a helpful assistant with access to the following documentation.",
                    cache_control: { type: "ephemeral" }
                },
                {
                    type: "text",
                    text: this.cachedContext!,  // 事前キャッシュされたドキュメント
                    cache_control: { type: "ephemeral" }
                }
            ],
            messages: [{ role: "user", content: userQuery }]
        });

        return response.content[0].text;
    }

    // 定期的なリフレッシュ
    async refreshIfNeeded(documents: Document[]): Promise<void> {
        const stale = Date.now() - this.lastUpdate > 3600000;  // 1 時間
        if (stale) {
            await this.buildCachedContext(documents);
        }
    }
}

// CAG vs RAG 決定マトリックス:
// | 要因             | CAG が優良 | RAG が優良 |
// |------------------|-----------|-----------|
// | コーパスサイズ   | < 100K tokens | > 100K tokens |
// | 更新頻度         | 低         | 高         |
// | レイテンシニーズ | 重要       | 柔軟       |
// | クエリ特異性     | 一般的     | 具体的     |

鋭いエッジケース

キャッシュミスが追加オーバーヘッドでレイテンシスパイクを引き起こす

重大度: 高

状況: キャッシュミス時の低速レスポンス。キャッシングなしより遅い

症状:

• キャッシュミス時の低速レスポンス
• キャッシュヒット率が 50% 未満
• キャッシュなしより高いレイテンシ

これが壊れる理由: キャッシュチェックはレイテンシを追加します。 キャッシュ書き込みはさらにレイテンシを追加します。 ミス + オーバーヘッド > キャッシングなし。

推奨される修正:

// キャッシュヒットだけでなくミスも最適化

class OptimizedCache {
    async queryWithCache(prompt: string): Promise<string> {
        const cacheKey = this.hash(prompt);

        // ノンブロッキングキャッシュチェック
        const cachedPromise = this.cache.get(cacheKey);
        const llmPromise = this.queryLLM(prompt);

        // レース: LLM が戻る前にキャッシュが利用可能なら使用
        const cached = await Promise.race([
            cachedPromise,
            sleep(50).then(() => null)  // 50ms キャッシュタイムアウト
        ]);

        if (cached) {
            // 可能ならば LLM リクエストをキャンセル
            return cached;
        }

        // キャッシュミス: LLM で続行
        const response = await llmPromise;

        // 非同期キャッシュ書き込み (レスポンスをブロックしない)
        this.cache.set(cacheKey, response).catch(console.error);

        return response;
    }
}

// 代替案: 確率的キャッシング
// 既知の高頻度パターンに一致するクエリのみをキャッシング
class SelectiveCache {
    private patterns: Map<string, number> = new Map();

    shouldCache(prompt: string): boolean {
        const pattern = this.extractPattern(prompt);
        const frequency = this.patterns.get(pattern) || 0;

        // 高頻度パターンのみをキャッシング
        return frequency > 10;
    }

    recordQuery(prompt: string): void {
        const pattern = this.extractPattern(prompt);
        this.patterns.set(pattern, (this.patterns.get(pattern) || 0) + 1);
    }
}

キャッシュされたレスポンスが時間経過で正確ではなくなる

重大度: 高

状況: ユーザーがキャッシュから古い情報または誤った情報を取得

症状:

• ユーザーが誤った情報を報告
• 回答が現在のデータと一致しない
• 古いレスポンスについてのクレーム

これが壊れる理由: ソースデータが変更されました。 キャッシュ無効化がありません。 動的データの長い TTL。

推奨される修正:

// 適切なキャッシュ無効化を実装

class InvalidatingCache {
    // バージョンベースの無効化
    private cacheVersion = 1;

    getCacheKey(prompt: string): string {
        return `v${this.cacheVersion}:${this.hash(prompt)}`;
    }

    invalidateAll(): void {
        this.cacheVersion++;
        // 古いキーは自動的に孤立する
    }

    // コンテンツハッシュ無効化
    async setWithContentHash(
        key: string,
        response: string,
        sourceContent: string
    ): Promise<void> {
        const contentHash = this.hash(sourceContent);
        await this.cache.set(key, {
            response,
            contentHash,
            timestamp: Date.now()
        });
    }

    async getIfValid(
        key: string,
        currentSourceContent: string
    ): Promise<string | null> {
        const cached = await this.cache.get(key);
        if (!cached) return null;

        // ソースコンテンツが変更されたかをチェック
        const currentHash = this.hash(currentSourceContent);
        if (cached.contentHash !== currentHash) {
            await this.cache.delete(key);
            return null;
        }

        return cached.response;
    }

    // イベントベースの無効化
    onSourceUpdate(sourceId: string): void {
        // このソースを使用したすべてのキャッシュを無効化
        this.invalidateByTag(`source:${sourceId}`);
    }
}

プロンプトキャッシングがプレフィックス変更のため機能しない

重大度: 中

状況: 類似したプロンプトにもかかわらずキャッシュミス

症状:

• 期待より低いキャッシュヒット率
• キャッシュ作成トークンは高いが読み取りは低い
• 類似したプロンプトがキャッシュにヒットしない

これが壊れる理由: Anthropic キャッシングは正確なプレフィックス一致が必要。 プレフィックス内のタイムスタンプまたは動的コンテンツ。 異なるメッセージ順序。

推奨される修正:

// 最適なキャッシング用にプロンプトを構造化

class CacheOptimizedPrompts {
    // 誤り: キャッシュされたプレフィックス内の動的コンテンツ
    buildPromptBad(query: string): SystemMessage[] {
        return [
            {
                type: "text",
                text: `You are helpful. Current time: ${new Date()}`,  // キャッシュを破壊!
                cache_control: { type: "ephemeral" }
            }
        ];
    }

    // 正し: 静的プレフィックス、最後に動的
    buildPromptGood(query: string): SystemMessage[] {
        return [
            {
                type: "text",
                text: STATIC_SYSTEM_PROMPT,  // 変わらない
                cache_control: { type: "ephemeral" }
            },
            {
                type: "text",
                text: STATIC_KNOWLEDGE_BASE,  // めったに変わらない
                cache_control: { type: "ephemeral" }
            }
            // 動的コンテンツは messages に入る。system ではない
        ];
    }

    // プレフィックス順序が重要
    buildWithConsistentOrder(components: string[]): SystemMessage[] {
        // 一貫した順序付けのためにコンポーネントをソート
        const sorted = [...components].sort();
        return sorted.map((c, i) => ({
            type: "text",
            text: c,
            cache_control: i === sorted.length - 1
                ? { type: "ephemeral" }
                : undefined  // 完全なプレフィックスのみをキャッシング
        }));
    }
}

検証チェック

高い温度のレスポンスをキャッシング

重大度: 警告

メッセージ: 高い温度でキャッシング。レスポンスは非確定的です。

修正アクション: 温度 <= 0.5 のレスポンスのみをキャッシング

TTL なしのキャッシュ

重大度: 警告

メッセージ: TTL なしのキャッシュ。 無期限に古いデータを提供する可能性があります。

修正アクション: データの鮮度要件に基づいて適切な TTL を設定

キャッシュされたプレフィックス内の動的コンテンツ

重大度: 警告

メッセージ: キャッシュされたプレフィックス内の動的コンテンツ。キャッシュミスを引き起こします。

修正アクション: 動的コンテンツを cache_control ブロック外に移動

キャッシュメトリックなし

重大度: 情報

メッセージ: ヒット/ミス追跡なしのキャッシュ。 効果を測定できません。

修正アクション: キャッシュヒット/ミスメトリックスとログを追加

協力

委任トリガー

• context window|token -> context-window-management (コンテキスト最適化が必要)
• rag|retrieval -> rag-implementation (検索システムが必要)
• memory -> conversation-memory (メモリ永続化が必要)

高性能 LLM システム

スキル: prompt-caching, context-window-management, rag-implementation

ワークフロー:

1. クエリパターンを分析
2. 安定したプレフィックス用にプロンプトキャッシングを実装
3. 頻繁なクエリ用にレスポンスキャッシングを追加
4. 安定したドキュメントセット用に CAG を検討
5. ヒット率をモニタリングして最適化

関連スキル

以下と相性が良い: context-window-management, rag-implementation, conversation-memory

使用する場合

• ユーザーが言及するか暗に示す: prompt caching
• ユーザーが言及するか暗に示す: cache prompt
• ユーザーが言及するか暗に示す: response cache
• ユーザーが言及するか暗に示す: cag
• ユーザーが言及するか暗に示す: cache augmented

制限事項

• このスキルは、上記で説明されているスコープに明確に一致するタスクの場合のみ使用してください。
• 出力を環境固有の検証、テスト、または専門家によるレビューの代替として扱わないでください。
• 必要な入力、権限、安全性の境界、または成功基準が不足している場合は、停止して明確化を求めてください。