Context Window Management

LLM コンテキストウィンドウを管理するための戦略。要約、トリミング、ルーティング、コンテキスト腐敗の防止を含みます。

Capabilities

• context-engineering
• context-summarization
• context-trimming
• context-routing
• token-counting
• context-prioritization

Prerequisites

• Knowledge: LLM の基礎、トークン化の基礎、プロンプトエンジニアリング
• Skills_recommended: prompt-engineering

Scope

• Does_not_cover: RAG 実装の詳細、モデルのファインチューニング、埋め込みモデル
• Boundaries: コンテキスト最適化に焦点を当てます。特定の実装ではなく戦略をカバーします。

Ecosystem

Primary_tools

• tiktoken - OpenAI のトークンカウント用トークナイザー
• LangChain - コンテキスト管理ユーティリティを備えたフレームワーク
• Claude API - 200K+ のコンテキストとキャッシング対応

Patterns

Tiered Context Strategy

コンテキストサイズに基づく異なる戦略

使用時機: マルチターン会話システムを構築するときのあらゆる場面

interface ContextTier {
    maxTokens: number;
    strategy: 'full' | 'summarize' | 'rag';
    model: string;
}

const TIERS: ContextTier[] = [
    { maxTokens: 8000, strategy: 'full', model: 'claude-3-haiku' },
    { maxTokens: 32000, strategy: 'full', model: 'claude-3-5-sonnet' },
    { maxTokens: 100000, strategy: 'summarize', model: 'claude-3-5-sonnet' },
    { maxTokens: Infinity, strategy: 'rag', model: 'claude-3-5-sonnet' }
];

async function selectStrategy(messages: Message[]): ContextTier {
    const tokens = await countTokens(messages);

    for (const tier of TIERS) {
        if (tokens <= tier.maxTokens) {
            return tier;
        }
    }
    return TIERS[TIERS.length - 1];
}

async function prepareContext(messages: Message[]): PreparedContext {
    const tier = await selectStrategy(messages);

    switch (tier.strategy) {
        case 'full':
            return { messages, model: tier.model };

        case 'summarize':
            const summary = await summarizeOldMessages(messages);
            return { messages: [summary, ...recentMessages(messages)], model: tier.model };

        case 'rag':
            const relevant = await retrieveRelevant(messages);
            return { messages: [...relevant, ...recentMessages(messages)], model: tier.model };
    }
}

Serial Position Optimization

重要なコンテンツを開始と終了に配置する

使用時機: 大量のコンテキストを含むプロンプトを構築するとき

// LLM は開始と終了をより重くウェイト付けします
// この特性を活用するようにプロンプトを構造化します

function buildOptimalPrompt(components: {
    systemPrompt: string;
    criticalContext: string;
    conversationHistory: Message[];
    currentQuery: string;
}): string {
    // 開始: システム指示（常に最初）
    const parts = [components.systemPrompt];

    // 重要なコンテキスト: システムの直後（高い初頭効果）
    if (components.criticalContext) {
        parts.push(`## Key Context\n${components.criticalContext}`);
    }

    // 中間: 会話履歴（低いウェイト）
    // 長い場合は要約、最近のメッセージは完全に保持
    const history = components.conversationHistory;
    if (history.length > 10) {
        const oldSummary = summarize(history.slice(0, -5));
        const recent = history.slice(-5);
        parts.push(`## Earlier Conversation (Summary)\n${oldSummary}`);
        parts.push(`## Recent Messages\n${formatMessages(recent)}`);
    } else {
        parts.push(`## Conversation\n${formatMessages(history)}`);
    }

    // 終了: 現在のクエリ（高い最新性効果）
    // 重要な要件をここで再確認
    parts.push(`## Current Request\n${components.currentQuery}`);

    // 最後: 主要な制約の再度確認
    parts.push(`Remember: ${extractKeyConstraints(components.systemPrompt)}`);

    return parts.join('\n\n');
}

Intelligent Summarization

最近性ではなく重要性で要約する

使用時機: コンテキストが最適なサイズを超えるとき

interface MessageWithMetadata extends Message {
    importance: number;  // 0-1 のスコア
    hasCriticalInfo: boolean;  // ユーザーの好みや決定
    referenced: boolean;  // 後で参照されたか？
}

async function smartSummarize(
    messages: MessageWithMetadata[],
    targetTokens: number
): Message[] {
    // 重要性でソート、同点の場合は順序を保持
    const sorted = [...messages].sort((a, b) =>
        (b.importance + (b.hasCriticalInfo ? 0.5 : 0) + (b.referenced ? 0.3 : 0)) -
        (a.importance + (a.hasCriticalInfo ? 0.5 : 0) + (a.referenced ? 0.3 : 0))
    );

    const keep: Message[] = [];
    const summarizePool: Message[] = [];
    let currentTokens = 0;

    for (const msg of sorted) {
        const msgTokens = await countTokens([msg]);
        if (currentTokens + msgTokens < targetTokens * 0.7) {
            keep.push(msg);
            currentTokens += msgTokens;
        } else {
            summarizePool.push(msg);
        }
    }

    // 低優先度のメッセージを要約
    if (summarizePool.length > 0) {
        const summary = await llm.complete(`
            Summarize these messages, preserving:
            - Any user preferences or decisions
            - Key facts that might be referenced later
            - The overall flow of conversation

            Messages:
            ${formatMessages(summarizePool)}
        `);

        keep.unshift({ role: 'system', content: `[Earlier context: ${summary}]` });
    }

    // 元の順序に戻す
    return keep.sort((a, b) => a.timestamp - b.timestamp);
}

Token Budget Allocation

コンテキストコンポーネント全体にトークン予算を配分する

使用時機: 予測可能なコンテキスト管理が必要なとき

interface TokenBudget {
    system: number;      // システムプロンプト
    criticalContext: number;  // ユーザー設定、重要情報
    history: number;     // 会話履歴
    query: number;       // 現在のクエリ
    response: number;    // レスポンス用に予約
}

function allocateBudget(totalTokens: number): TokenBudget {
    return {
        system: Math.floor(totalTokens * 0.10),      // 10%
        criticalContext: Math.floor(totalTokens * 0.15),  // 15%
        history: Math.floor(totalTokens * 0.40),     // 40%
        query: Math.floor(totalTokens * 0.10),       // 10%
        response: Math.floor(totalTokens * 0.25),    // 25%
    };
}

async function buildWithBudget(
    components: ContextComponents,
    modelMaxTokens: number
): PreparedContext {
    const budget = allocateBudget(modelMaxTokens);

    // 予算に合わせて各コンポーネントを切り詰めたり要約したりする
    const prepared = {
        system: truncateToTokens(components.system, budget.system),
        criticalContext: truncateToTokens(
            components.criticalContext, budget.criticalContext
        ),
        history: await summarizeToTokens(components.history, budget.history),
        query: truncateToTokens(components.query, budget.query),
    };

    // 未使用予算を再配分
    const used = await countTokens(Object.values(prepared).join('\n'));
    const remaining = modelMaxTokens - used - budget.response;

    if (remaining > 0) {
        // 余分を履歴に割り当てる（会話に最も価値がある）
        prepared.history = await summarizeToTokens(
            components.history,
            budget.history + remaining
        );
    }

    return prepared;
}

Validation Checks

No Token Counting

Severity: WARNING

Message: トークンカウントなしでコンテキストを構築しています。モデルの制限を超える可能性があります。

Fix action: 送信前にトークンをカウントし、予算配分を実装する

Naive Message Truncation

Severity: WARNING

Message: 要約なしでメッセージを切り詰めています。重要なコンテキストが失われる可能性があります。

Fix action: メッセージを単に削除するのではなく、古いメッセージを要約する

Hardcoded Token Limit

Severity: INFO

Message: ハードコードされたトークン制限があります。モデルごとに設定可能にすることを検討してください。

Fix action: 設定からモデル固有の制限を使用する

No Context Management Strategy

Severity: WARNING

Message: コンテキスト管理戦略なしで LLM を呼び出しています。

Fix action: コンテキスト管理を実装します: 予算、要約、または RAG

Collaboration

Delegation Triggers

• retrieval|rag|search -> rag-implementation (検索システムが必要)
• memory|persistence|remember -> conversation-memory (メモリストレージが必要)
• cache|caching -> prompt-caching (キャッシング最適化が必要)

Complete Context System

Skills: context-window-management, rag-implementation, conversation-memory, prompt-caching

Workflow:

1. コンテキスト戦略を設計する
2. 大規模なコーパスのために RAG を実装する
3. メモリ永続性を設定する
4. パフォーマンスのためのキャッシングを追加する

Related Skills

Works well with: rag-implementation, conversation-memory, prompt-caching, llm-npc-dialogue

When to Use

• ユーザーが言及または暗に示唆: コンテキストウィンドウ
• ユーザーが言及または暗に示唆: トークン制限
• ユーザーが言及または暗に示唆: コンテキスト管理
• ユーザーが言及または暗に示唆: コンテキストエンジニアリング
• ユーザーが言及または暗に示唆: 長いコンテキスト
• ユーザーが言及または暗に示唆: コンテキストオーバーフロー

Limitations

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