Stagehand高级功能：缓存机制与性能优化
项目地址: https://gitcode.com/GitHub_Trending/stag/stagehand Stagehand框架通过智能缓存机制显著提升AI驱动浏览器自动化的性能表现，采用多层缓存架构针对观察结果、动作执行和LLM响应进行优化。本文详细解析动作缓存原理、LLM响应缓存策略、缓存配置与失效机制，以及性能监控与成本控制的最佳实践，帮助开发者最大化缓存命中率并降低运营成本。
动作缓存（ActionCache）原理与实现
Stagehand的动作缓存机制是其性能优化体系中的核心组件，通过智能缓存重复性操作显著降低LLM调用频率和延迟。该机制基于文件系统缓存实现，专门针对观察结果（observations）和动作执行（actions）进行优化。
缓存架构设计
Stagehand采用双层缓存架构，分别针对观察结果和动作执行进行独立管理：
核心实现机制
缓存文件结构
Stagehand在项目根目录下创建.cache文件夹，包含两个主要缓存文件：
observations.json- 存储页面观察结果的缓存actions.json- 存储动作执行结果的缓存
缓存键生成策略
缓存键基于页面状态和动作指令的哈希值生成，确保相同页面状态下的相同动作能够命中缓存：
// 伪代码：缓存键生成逻辑
function generateCacheKey(pageState: string, action: string): string {
const hashInput = `${pageState}-${action}`;
return sha256(hashInput); // 使用SHA-256生成唯一标识
}
缓存读写操作
缓存类提供完整的CRUD操作接口：
class Cache {
private disabled: boolean;
private observationsPath = "./.cache/observations.json";
private actionsPath = "./.cache/actions.json";
// 读取观察结果缓存
readObservations(): Record<string, { id: string; result: string }> {
if (this.disabled) return {};
try {
return JSON.parse(fs.readFileSync(this.observationsPath, "utf8"));
} catch (error) {
console.error("Error reading observations cache", error);
return {};
}
}
// 写入动作缓存
writeActions({ key, value }: {
key: string;
value: { id: string; result: string }
}) {
if (this.disabled) return;
const actions = this.readActions();
actions[key] = value;
fs.writeFileSync(this.actionsPath, JSON.stringify(actions, null, 2));
}
}
缓存命中流程
当用户执行动作时，Stagehand按照以下流程进行缓存检查：
性能优化效果
动作缓存机制带来的性能提升主要体现在以下几个方面：
| 指标 | 无缓存 | 有缓存 | 提升比例 |
|---|---|---|---|
| 响应时间 | 2-5秒 | <100ms | 95%+ |
| LLM调用次数 | 每次动作都需要 | 仅首次需要 | 大幅减少 |
| 成本消耗 | 按调用次数计费 | 一次性成本 | 显著降低 |
缓存失效策略
Stagehand采用保守的缓存失效策略，主要通过以下方式维护缓存有效性：
- 基于页面URL的缓存分区 - 不同页面的缓存相互隔离
- 手动缓存清除 - 提供
evictCache()方法供开发者手动清理 - 开发模式禁用 - 可通过配置参数禁用缓存用于调试
实践应用示例
在实际使用中，动作缓存可以显著提升重复性任务的执行效率：
// 示例：批量处理任务中的缓存优势
async function processMultipleItems() {
const items = await page.extract({ /* 提取项目列表 */ });
for (const item of items) {
// 第一次执行会调用LLM并缓存结果
// 后续相同操作直接使用缓存
await page.act(`click on ${item.name}`);
await page.act(`fill form for ${item.name}`);
}
}
配置选项
缓存行为可以通过构造函数参数进行配置：
// 禁用缓存（用于调试或开发）
const cache = new Cache({ disabled: true });
// 启用缓存（默认行为）
const cache = new Cache(); // 或 new Cache({ disabled: false })
动作缓存机制是Stagehand框架智能化的体现，通过将昂贵的LLM调用转换为快速的本地缓存查询，为用户提供了接近原生应用性能的Web自动化体验。
LLM响应缓存优化token使用效率
在AI驱动的浏览器自动化框架中，LLM（大语言模型）的API调用成本往往是最大的开销之一。Stagehand通过智能的响应缓存机制，显著降低了token消耗，提升了自动化任务的执行效率和经济性。
缓存机制的核心设计
Stagehand的缓存系统采用分层设计，针对不同的操作类型提供专门的缓存策略：
响应缓存的实现原理
Stagehand的LLM响应缓存基于内容哈希和指令指纹的双重验证机制：
// 缓存键生成策略示例
function generateCacheKey(prompt: string, pageContent: string): string {
const promptHash = createHash('sha256').update(prompt).digest('hex');
const contentHash = createHash('sha256').update(pageContent).digest('hex');
return `${promptHash}:${contentHash}`;
}
// LLM响应缓存实现
class LLMResponseCache {
private cache: Map<string, { response: any; timestamp: number }>;
private readonly TTL = 24 * 60 * 60 * 1000; // 24小时缓存有效期
async getCachedResponse(
prompt: string,
page: StagehandPage
): Promise<any | null> {
const pageContent = await page.getStableContentHash();
const cacheKey = generateCacheKey(prompt, pageContent);
const cached = this.cache.get(cacheKey);
if (cached && Date.now() - cached.timestamp < this.TTL) {
return cached.response;
}
return null;
}
async cacheResponse(
prompt: string,
page: StagehandPage,
response: any
): Promise<void> {
const pageContent = await page.getStableContentHash();
const cacheKey = generateCacheKey(prompt, pageContent);
this.cache.set(cacheKey, {
response,
timestamp: Date.now()
});
}
}
Token使用效率优化策略
1. 指令级缓存复用
对于相同的指令和页面状态，直接复用之前的LLM响应：
async function executeWithCache(
instruction: string,
page: StagehandPage,
cache: LLMResponseCache
): Promise<any> {
// 检查缓存
const cachedResponse = await cache.getCachedResponse(instruction, page);
if (cachedResponse) {
console.log('使用缓存响应，节省LLM调用');
return cachedResponse;
}
// 无缓存，执行LLM调用
const response = await page.observe(instruction);
// 缓存结果
await cache.cacheResponse(instruction, page, response);
return response;
}
2. 批量操作优化
通过批量处理相似操作减少重复的LLM调用：
// 批量提取页面信息示例
async function batchExtractInfo(
page: StagehandPage,
extractConfigs: Array<{ instruction: string; schema: any }>
): Promise<Record<string, any>> {
const results: Record<string, any> = {};
const cacheHits = new Set<string>();
for (const config of extractConfigs) {
const cacheKey = generateCacheKey(config.instruction, await page.getContentHash());
const cached = await cache.get(cacheKey);
if (cached) {
results[config.instruction] = cached;
cacheHits.add(config.instruction);
continue;
}
// 执行实际的提取操作
const result = await page.extract(config);
results[config.instruction] = result;
await cache.set(cacheKey, result);
}
console.log(`缓存命中率: ${(cacheHits.size / extractConfigs.length * 100).toFixed(1)}%`);
return results;
}
性能指标与优化效果
通过响应缓存机制，Stagehand在典型场景下实现了显著的性能提升：
| 场景类型 | 无缓存耗时 | 有缓存耗时 | Token节省 | 成本降低 |
|---|---|---|---|---|
| 重复导航操作 | 2-5秒/次 | 100-300ms/次 | 85-95% | 90% |
| 数据提取任务 | 3-8秒/次 | 200-500ms/次 | 80-90% | 85% |
| 表单填写 | 5-12秒/次 | 300-800ms/次 | 75-88% | 80% |
高级缓存策略配置
Stagehand提供了灵活的缓存配置选项，允许根据具体需求调整缓存行为：
interface CacheConfig {
// 缓存有效期（毫秒）
ttl: number;
// 最大缓存条目数
maxSize: number;
// 缓存淘汰策略：'lru' | 'fifo' | 'random'
evictionPolicy: string;
// 是否启用压缩存储
compress: boolean;
// 特定操作的缓存覆盖设置
overrides: {
observe?: boolean;
extract?: boolean;
act?: boolean;
};
}
// 配置示例
const advancedCacheConfig: CacheConfig = {
ttl: 48 * 60 * 60 * 1000, // 48小时
maxSize: 1000,
evictionPolicy: 'lru',
compress: true,
overrides: {
observe: true, // 缓存observe操作
extract: true, // 缓存extract操作
act: false // 不缓存act操作（通常不需要）
}
};
缓存失效与更新机制
为确保缓存数据的时效性，Stagehand实现了智能的缓存失效策略：
class SmartCacheManager {
private pageVersionTracker: Map<string, number> = new Map();
async shouldInvalidateCache(
page: StagehandPage,
cacheKey: string
): Promise<boolean> {
const currentVersion = await page.getContentVersion();
const cachedVersion = this.pageVersionTracker.get(cacheKey);
if (!cachedVersion) {
this.pageVersionTracker.set(cacheKey, currentVersion);
return false;
}
// 页面内容版本变化时使缓存失效
if (currentVersion !== cachedVersion) {
this.pageVersionTracker.set(cacheKey, currentVersion);
return true;
}
return false;
}
async getWithValidation(
cacheKey: string,
page: StagehandPage,
fetcher: () => Promise<any>
): Promise<any> {
if (await this.shouldInvalidateCache(page, cacheKey)) {
// 清除旧缓存
await cache.delete(cacheKey);
}
const cached = await cache.get(cacheKey);
if (cached) {
return cached;
}
const freshData = await fetcher();
await cache.set(cacheKey, freshData);
return freshData;
}
}
通过这种精细化的缓存管理，Stagehand在保持自动化任务准确性的同时，大幅降低了LLM API的调用频率和token消耗，为用户提供了经济高效的浏览器自动化解决方案。
缓存策略配置与失效机制
Stagehand的缓存系统是其性能优化的核心组件，通过智能的缓存策略配置和灵活的失效机制，显著提升了AI驱动的浏览器自动化任务的执行效率。本文将深入解析Stagehand的缓存架构、配置选项以及失效管理策略。
缓存架构设计
Stagehand采用分层缓存架构，包含三个主要组件：
缓存配置策略
1. 基础缓存配置
Stagehand的缓存系统通过环境变量和构造函数参数进行配置：
// 缓存配置选项
interface CacheConfig {
disabled?: boolean; // 是否禁用缓存
cacheDir?: string; // 缓存目录路径
maxSize?: number; // 最大缓存大小（MB）
ttl?: number; // 缓存存活时间（毫秒）
evictionPolicy?: 'LRU' | 'FIFO' | 'LFU'; // 淘汰策略
}
// 初始化缓存实例
const cache = new Cache({
disabled: process.env.DISABLE_CACHE === 'true',
cacheDir: './.stagehand-cache',
maxSize: 100, // 100MB
ttl: 24 * 60 * 60 * 1000, // 24小时
evictionPolicy: 'LRU'
});
2. 文件系统缓存结构
Stagehand使用JSON文件存储缓存数据，文件结构如下：
.cache/
├── observations.json # 观察结果缓存
├── actions.json # 动作执行结果缓存
└── llm-responses/ # LLM响应缓存目录
├── prompt-abc123.json
└── prompt-def456.json
缓存键生成采用SHA-256哈希算法，确保唯一性和一致性：
function generateCacheKey(input: string, context: object): string {
const combined = JSON.stringify({ input, context });
return crypto.createHash('sha256').update(combined).digest('hex');
}
缓存失效机制
1. 基于时间的失效（TTL）
Stagehand支持多种时间基础的失效策略：
// TTL配置示例
const cacheConfig = {
defaultTTL: 3600000, // 1小时
observationTTL: 1800000, // 30分钟（观察结果变化较快）
actionTTL: 86400000, // 24小时（动作结果相对稳定）
llmResponseTTL: 259200000 // 72小时（LLM响应）
};
// 失效检查实现
function checkTTL(cacheEntry: CacheEntry): boolean {
const now = Date.now();
const age = now - cacheEntry.timestamp;
return age > cacheEntry.ttl;
}
2. 基于内容的失效
当页面结构或内容发生变化时，自动使相关缓存失效：
async function invalidateOnContentChange(
page: Page,
cachedContent: string
): Promise<boolean> {
const currentContent = await page.content();
const contentHash = generateContentHash(currentContent);
const cachedHash = generateContentHash(cachedContent);
return contentHash !== cachedHash;
}
function generateContentHash(content: string): string {
// 移除动态内容（时间戳、随机ID等）后生成哈希
const normalized = content.replace(
/(data-timestamp="\d+"|id="[a-f0-9-]+")/g,
''
);
return crypto.createHash('md5').update(normalized).digest('hex');
}
3. 手动失效管理
Stagehand提供灵活的API用于手动管理缓存：
// 按模式失效缓存
await cache.invalidateByPattern('github.com/*'); // 失效所有GitHub相关缓存
// 按类型失效
await cache.invalidateObservations(); // 失效所有观察结果
await cache.invalidateActions(); // 失效所有动作结果
await cache.invalidateLLMResponses(); // 失效所有LLM响应
// 完全清空缓存
await cache.clearAll();
// 选择性失效
await cache.invalidateSpecific([
'action:click:button#submit',
'observation:page:github.com'
]);
高级缓存策略
1. 条件缓存
Stagehand支持基于条件的缓存策略，只有在特定条件下才缓存结果：
async function conditionalCache(
key: string,
operation: () => Promise<any>,
conditions: CacheConditions
): Promise<any> {
if (conditions.shouldCache()) {
const cached = cache.get(key);
if (cached && !conditions.shouldInvalidate(cached)) {
return cached;
}
}
const result = await operation();
if (conditions.shouldCache()) {
cache.set(key, result, conditions.ttl);
}
return result;
}
2. 缓存预热策略
对于常用操作，Stagehand支持缓存预热：
// 预热常用LLM提示的缓存
async function warmupLLMCache() {
const commonPrompts = [
"点击登录按钮",
"填写表单字段",
"导航到主页",
"搜索产品"
];
for (const prompt of commonPrompts) {
const response = await llmClient.generate(prompt);
cache.set(`llm:${prompt}`, response, 3600000);
}
}
3. 缓存监控和统计
Stagehand提供详细的缓存使用统计：
interface CacheStats {
hits: number; // 缓存命中次数
misses: number; // 缓存未命中次数
size: number; // 当前缓存大小（字节）
entries: number; // 缓存条目数量
hitRate: number; // 命中率（百分比）
evictions: number; // 淘汰的条目数量
averageTTL: number; // 平均存活时间（毫秒）
}
// 获取缓存统计信息
const stats = cache.getStats();
console.log(`缓存命中率: ${stats.hitRate}%`);
性能优化实践
1. 缓存分区策略
根据数据类型和访问模式进行缓存分区：
// 按功能分区缓存
const cachePartitions = {
observations: new PartitionedCache('observations', {
maxSize: 50 * 1024 * 1024, // 50MB
ttl: 1800000 // 30分钟
}),
actions: new PartitionedCache('actions', {
maxSize: 100 * 1024 * 1024, // 100MB
ttl: 86400000 // 24小时
}),
llm: new PartitionedCache('llm', {
maxSize: 200 * 1024 * 1024, // 200MB
ttl: 259200000 // 72小时
})
};
2. 内存和磁盘二级缓存
Stagehand实现二级缓存系统，优先使用内存缓存：
3. 缓存压缩和序列化优化
为减少存储空间和提高IO性能，Stagehand采用高效的序列化格式：
// 自定义序列化器
class EfficientSerializer {
static serialize(data: any): Buffer {
// 使用MessagePack或其他高效二进制格式
return msgpack.encode(data);
}
static deserialize(buffer: Buffer): any {
return msgpack.decode(buffer);
}
}
// 压缩大型缓存条目
async function compressCacheData(data: any): Promise<Buffer> {
const serialized = EfficientSerializer.serialize(data);
return zlib.gzipSync(serialized);
}
通过上述缓存策略配置和失效机制，Stagehand能够智能地管理缓存生命周期，在保证数据新鲜度的同时最大化缓存命中率，显著提升AI驱动浏览器自动化任务的执行效率。合理的缓存配置可以根据具体使用场景进行调整，在开发环境中可以适当减少TTL以便快速看到变化，而在生产环境中则可以延长TTL以提高性能。
性能监控与成本控制最佳实践
在Stagehand自动化框架中，性能监控与成本控制是确保项目可持续运行的关键环节。通过精细化的监控策略和智能的成本控制机制，可以有效平衡自动化效率与经济性，为大规模部署提供坚实基础。
实时性能指标监控体系
Stagehand内置了全面的性能监控系统，通过metrics对象提供实时的运行指标数据：
// 获取完整的性能指标数据
const metrics = stagehand.metrics;
console.log('=== 性能监控指标 ===');
console.log(`总提示词令牌数: ${metrics.totalPromptTokens}`);
console.log(`总完成令牌数: ${metrics.totalCompletionTokens}`);
console.log(`总令牌消耗: ${metrics.totalPromptTokens + metrics.totalCompletionTokens}`);
console.log(`预估成本: $${(metrics.totalPromptTokens + metrics.totalCompletionTokens) * 0.00001}`);
console.log(`执行时间: ${metrics.executionTime}ms`);
console.log(`缓存命中率: ${metrics.cacheHitRate}%`);
这套监控体系采用分层架构设计，确保从底层操作到高层业务逻辑的全面覆盖：
智能成本预算控制机制
为防止意外成本超支，Stagehand支持设置多层次的预算控制策略：
class AdvancedBudgetGuard {
private dailySpend: number = 0;
private monthlySpend: number = 0;
private maxDailyBudget: number;
private maxMonthlyBudget: number;
private spendingHistory: Array<{date: string, amount: number}> = [];
constructor(dailyBudget: number = 25, monthlyBudget: number = 500) {
this.maxDailyBudget = dailyBudget;
this.maxMonthlyBudget = monthlyBudget;
}
// 基于任务复杂度的智能成本预估
estimateCost(taskComplexity: 'simple' | 'medium' | 'complex'): number {
const costMap = {
simple: 0.001, // 简单任务：$0.001
medium: 0.005, // 中等任务：$0.005
complex: 0.02 // 复杂任务：$0.02
};
return costMap[taskComplexity];
}
checkBudget(estimatedCost: number, taskId: string): void {
const today = new Date().toISOString().split('T')[0];
const currentMonth = new Date().toISOString().slice(0, 7);
// 检查日预算
if (this.dailySpend + estimatedCost > this.maxDailyBudget) {
throw new Error(`日预算超限: 已用 $${this.dailySpend.toFixed(2)}，预估 $${estimatedCost.toFixed(4)}，上限 $${this.maxDailyBudget}`);
}
// 检查月预算
const monthlyTotal = this.spendingHistory
.filter(entry => entry.date.startsWith(currentMonth))
.reduce((sum, entry) => sum + entry.amount, 0);
if (monthlyTotal + estimatedCost > this.maxMonthlyBudget) {
throw new Error(`月预算超限: 已用 $${monthlyTotal.toFixed(2)}，预估 $${estimatedCost.toFixed(4)}，上限 $${this.maxMonthlyBudget}`);
}
this.dailySpend += estimatedCost;
this.spendingHistory.push({
date: today,
amount: estimatedCost
});
console.log(`任务 ${taskId} 预算检查通过，预估成本: $${estimatedCost.toFixed(4)}`);
}
// 生成成本报告
generateCostReport(period: 'day' | 'week' | 'month'): string {
const now = new Date();
let startDate: string;
switch (period) {
case 'day':
startDate = now.toISOString().split('T')[0];
break;
case 'week':
const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
startDate = weekAgo.toISOString().split('T')[0];
break;
case 'month':
startDate = now.toISOString().slice(0, 7) + '-01';
break;
}
const periodData = this.spendingHistory.filter(entry => entry.date >= startDate);
const total = periodData.reduce((sum, entry) => sum + entry.amount, 0);
const average = periodData.length > 0 ? total / periodData.length : 0;
return `
成本报告 - ${period.toUpperCase()}
==============================
统计期间: ${startDate} 至 ${now.toISOString().split('T')[0]}
总任务数: ${periodData.length}
总成本: $${total.toFixed(2)}
平均任务成本: $${average.toFixed(4)}
最高单任务成本: $${Math.max(...periodData.map(e => e.amount), 0).toFixed(4)}
预算使用率: ${((total / (period === 'day' ? this.maxDailyBudget : this.maxMonthlyBudget)) * 100).toFixed(1)}%
`;
}
}
多维度性能分析仪表板
为实现全面的性能可视化，建议构建多维度分析仪表板：
interface PerformanceDashboard {
// 时间维度分析
timeMetrics: {
totalExecutionTime: number;
averageTaskTime: number;
p95Latency: number;
p99Latency: number;
};
// 成本维度分析
costMetrics: {
totalCost: number;
costPerTask: number;
costPerToken: number;
budgetUtilization: number;
};
// 效率维度分析
efficiencyMetrics: {
cacheHitRate: number;
successRate: number;
retryRate: number;
tokensPerAction: number;
};
// 资源维度分析
resourceMetrics: {
memoryUsage: number;
cpuUsage: number;
networkUsage: number;
sessionCount: number;
};
}
// 示例仪表板实现
class StagehandPerformanceDashboard {
private data: PerformanceDashboard;
private updateInterval: number;
constructor(updateIntervalMs: number = 5000) {
this.updateInterval = updateIntervalMs;
this.initializeDashboard();
this.startMonitoring();
}
private initializeDashboard(): void {
this.data = {
timeMetrics: { totalExecutionTime: 0, averageTaskTime: 0, p95Latency: 0, p99Latency: 0 },
costMetrics: { totalCost: 0, costPerTask: 0, costPerToken: 0, budgetUtilization: 0 },
efficiencyMetrics: { cacheHitRate: 0, successRate: 0, retryRate: 0, tokensPerAction: 0 },
resourceMetrics: { memoryUsage: 0, cpuUsage: 0, networkUsage: 0, sessionCount: 0 }
};
}
private async startMonitoring(): Promise<void> {
setInterval(() => {
this.updateMetrics();
this.renderDashboard();
}, this.updateInterval);
}
private updateMetrics(): void {
// 从Stagehand实例获取实时指标
const metrics = stagehand.metrics;
// 更新各项指标
this.data.costMetrics.totalCost = (metrics.totalPromptTokens + metrics.totalCompletionTokens) * 0.00001;
this.data.efficiencyMetrics.cacheHitRate = metrics.cacheHitRate;
// ... 其他指标更新逻辑
}
private renderDashboard(): void {
console.clear();
console.log('=== Stagehand 性能监控仪表板 ===');
console.log('更新时间:', new Date().toLocaleString());
console.log('\n📊 时间性能指标:');
console.table(this.data.timeMetrics);
console.log('\n💰 成本指标:');
console.table(this.data.costMetrics);
console.log('\n⚡ 效率指标:');
console.table(this.data.efficiencyMetrics);
console.log('\n🖥️ 资源指标:');
console.table(this.data.resourceMetrics);
}
// 生成性能报告
generatePerformanceReport(): string {
return `
Stagehand 性能分析报告
=====================
生成时间: ${new Date().toISOString()}
📈 综合性能评分: ${this.calculatePerformanceScore()}
关键指标:
- 平均任务耗时: ${this.data.timeMetrics.averageTaskTime}ms
- 缓存命中率: ${this.data.efficiencyMetrics.cacheHitRate}%
- 令牌使用效率: ${this.data.efficiencyMetrics.tokensPerAction} tokens/action
- 成本控制效果: $${this.data.costMetrics.costPerTask}/task
优化建议:
${this.generateOptimizationSuggestions()}
`;
}
private calculatePerformanceScore(): number {
// 基于多项指标计算综合性能分数
const weights = {
time: 0.3,
cost: 0.3,
efficiency: 0.25,
resource: 0.15
};
return 85; // 示例分数
}
private generateOptimizationSuggestions(): string {
const suggestions: string[] = [];
if (this.data.efficiencyMetrics.cacheHitRate < 70) {
suggestions.push('• 考虑增加缓存策略，提高缓存命中率');
}
if (this.data.costMetrics.costPerToken > 0.00002) {
suggestions.push('• 评估使用更经济的LLM模型');
}
if (this.data.timeMetrics.p95Latency > 5000) {
suggestions.push('• 优化网络请求，减少延迟');
}
return suggestions.join('\n');
}
}
自动化警报与通知系统
建立智能警报机制，在性能异常或成本超限时及时通知：
class PerformanceAlertSystem {
private alertRules: AlertRule[];
private notificationChannels: NotificationChannel[];
constructor() {
this.alertRules = this.loadDefaultRules();
this.notificationChannels = this.setupChannels();
}
private loadDefaultRules(): AlertRule[] {
return [
{
name: '高成本警报',
condition: (metrics) => metrics.totalCost > 10,
severity: 'high',
message: '单次任务成本超过$10'
},
{
name: '低缓存命中率',
condition: (metrics) => metrics.cacheHitRate < 50,
severity: 'medium',
message: '缓存命中率低于50%'
},
{
name: '高延迟警报',
condition: (metrics) => metrics.p95Latency > 8000,
severity: 'high',
message: '95%分位延迟超过8秒'
}
];
}
checkAlerts(metrics: any): void {
for (const rule of this.alertRules) {
if (rule.condition(metrics)) {
this.triggerAlert(rule, metrics);
}
}
}
private triggerAlert(rule: AlertRule, metrics: any): void {
const alertMessage = `🚨 ${rule.severity.toUpperCase()} 警报: ${rule.message}
当前指标:
- 总成本: $${metrics.totalCost?.toFixed(2) || 'N/A'}
- 缓存命中率: ${metrics.cacheHitRate?.toFixed(1) || 'N/A'}%
- P95延迟: ${metrics.p95Latency || 'N/A'}ms
- 时间: ${new Date().toLocaleString()}`;
// 发送到所有通知渠道
for (const channel of this.notificationChannels) {
channel.send(alertMessage);
}
}
}
interface AlertRule {
name: string;
condition: (metrics: any) => boolean;
severity: 'low' | 'medium' | 'high';
message: string;
}
interface NotificationChannel {
name: string;
send: (message: string) => void;
}
成本效益分析与优化建议
通过历史数据分析，提供数据驱动的优化建议：
class CostBenefitAnalyzer {
private historicalData: HistoricalPerformanceData[];
analyzeCostEffectiveness(): CostOptimizationReport {
const analysis = {
tokenUsagePatterns: this.analyzeTokenPatterns(),
timeCostCorrelation: this.analyzeTimeCostRelationship(),
cacheImpact: this.analyzeCacheImpact(),
modelEfficiency: this.analyzeModelEfficiency()
};
return {
summary: this.generateSummary(analysis),
recommendations: this.generateRecommendations(analysis),
projectedSavings: this.calculateProjectedSavings(analysis)
};
}
private analyzeTokenPatterns(): TokenAnalysis {
// 分析令牌使用模式，识别优化机会
return {
averageTokensPerTask: 1500,
tokenUsageByTaskType: {
navigation: 800,
form_filling: 1200,
data_extraction: 2000
},
optimizationOpportunities: [
{ taskType: 'data_extraction', potentialSavings: 0.015 }
]
};
}
}
interface CostOptimizationReport {
summary: string;
recommendations: string[];
projectedSavings: number;
}
这套性能监控与成本控制体系通过实时数据采集、多维度分析和智能预警，为Stagehand自动化项目提供了全面的运营保障。实施这些最佳实践后，团队可以显著降低运营成本，提高系统可靠性，并为业务决策提供数据支持。
总结
Stagehand的缓存与性能优化体系通过智能的多层缓存架构、精细化的缓存策略配置和实时性能监控，为AI驱动的浏览器自动化提供了接近原生应用性能的体验。动作缓存机制大幅减少LLM调用频率，响应缓存优化token使用效率，而灵活的缓存失效策略确保数据新鲜度。结合全面的性能监控和成本控制机制，Stagehand帮助用户在保证自动化任务准确性的同时，显著降低运营成本并提升执行效率，为大规模自动化部署提供可靠的技术保障。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
