---

name: context-window-management description: LLM 上下文窗口管理策略，包括摘要、裁剪、路由和避免上下文腐化 risk: unknown source: vibeship-spawner-skills (Apache 2.0) date_added: 2026-02-27

上下文窗口管理

LLM 上下文窗口管理策略，包括摘要、裁剪、路由和避免上下文腐化

能力

• 上下文工程
• 上下文摘要
• 上下文裁剪
• 上下文路由
• Token 计数
• 上下文优先级排序

前置条件

• 知识：LLM 基础、分词基础、提示工程
• 推荐技能：prompt-engineering

范围

• 不涵盖：RAG 实现细节、模型微调、嵌入模型
• 边界：聚焦上下文优化，涵盖策略而非具体实现

生态系统

主要工具

• tiktoken - OpenAI 的分词器，用于计算 token 数量
• LangChain - 包含上下文管理工具的框架
• Claude API - 支持 200K+ 上下文及缓存

模式

分层上下文策略

根据上下文大小采用不同策略

适用场景：构建任何多轮对话系统

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 };
    }
}

序列位置优化

将重要内容放在开头和结尾

适用场景：构建包含大量上下文的提示词

// LLM 对开头和结尾的内容赋予更高权重
// 利用这一特性来组织提示词结构

function buildOptimalPrompt(components: {
    systemPrompt: string;
    criticalContext: string;
    conversationHistory: Message[];
    currentQuery: string;
}): string {
    // 开头：系统指令（始终放在最前面）
    const parts = [components.systemPrompt];

    // 关键上下文：紧跟系统指令（高首因效应）
    if (components.criticalContext) {
        parts.push(`## Key Context\
${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)\
${oldSummary}`);
        parts.push(`## Recent Messages\
${formatMessages(recent)}`);
    } else {
        parts.push(`## Conversation\
${formatMessages(history)}`);
    }

    // 结尾：当前查询（高近因效应）
    parts.push(`## Current Request\
${components.currentQuery}`);

    // 最后：关键约束提醒
    parts.push(`Remember: ${extractKeyConstraints(components.systemPrompt)}`);

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

智能摘要

按重要性而非仅按时间顺序进行摘要

适用场景：上下文超出最优大小时

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);
        }
    }

    const summary = await generateSummary(summarizePool);
    return [summary, ...keep.sort((a, b) => a.timestamp - b.timestamp)];
}