Skip to main content 首页 创作者 dicklesworthstone pi_agent_rust clay-performance-tuning
clay-performance-tuning Optimize Clay API performance with caching, batching, and connection pooling.
Use when experiencing slow API responses, implementing caching strategies,
or optimizing request throughput for Clay integrations.
Trigger with phrases like "clay performance", "optimize clay",
"clay latency", "clay caching", "clay slow", "clay batch".
跳到安装 Skills Marketplace 发现并探索由社区构建的 Agent Skills
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/Dicklesworthstone/pi_agent_rust --skill clay-performance-tuning命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
下载 Zip 下载中... name clay-performance-tuning description Optimize Clay API performance with caching, batching, and connection pooling.
Use when experiencing slow API responses, implementing caching strategies,
or optimizing request throughput for Clay integrations.
Trigger with phrases like "clay performance", "optimize clay",
"clay latency", "clay caching", "clay slow", "clay batch".
allowed-tools Read, Write, Edit version 1.0.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io>
Clay Performance Tuning
Overview
Optimize Clay API performance with caching, batching, and connection pooling.
Prerequisites
Clay SDK installed
Understanding of async patterns
Redis or in-memory cache available (optional)
Performance monitoring in place
Latency Benchmarks
Read 50ms 150ms 300ms Write 100ms 250ms 500ms List 75ms 200ms 400ms
Caching Strategy
Response Caching import { LRUCache } from 'lru-cache' ;
const cache = new LRUCache <string , any >({
max : 1000 ,
ttl : 60000 ,
updateAgeOnGet : true ,
});
async function cachedClayRequest<T>(
key : string ,
fetcher : () => Promise <T>,
ttl ?: number
): Promise <T> {
const cached = cache.get (key);
if (cached) return cached as T;
const result = await fetcher ();
cache.set (key, result, { ttl });
return result;
}
Redis Caching (Distributed) import Redis from 'ioredis' ;
const redis = new Redis (process.env .REDIS_URL );
async function cachedWithRedis<T>(
key : string ,
fetcher : () => Promise <T>,
ttlSeconds = 60
): Promise <T> {
const cached = await redis.get (key);
if (cached) return JSON .parse (cached);
const result = await fetcher ();
await redis.setex (key, ttlSeconds, JSON .stringify (result));
return result;
}
Request Batching import DataLoader from 'dataloader' ;
const clayLoader = new DataLoader <string , any >(
async (ids) => {
const results = await clayClient.batchGet (ids);
return ids.map (id =>find (r =>id === id) || null );
},
{
maxBatchSize : 100 ,
batchScheduleFn : callback =>setTimeout (callback, 10 ),
}
);
const [item1, item2, item3] = await Promise .all ([
clayLoader.load ('id-1' ),
clayLoader.load ('id-2' ),
clayLoader.load ('id-3' ),
]);
Connection Optimization import { Agent } from 'https' ;
const agent = new Agent ({
keepAlive : true ,
maxSockets : 10 ,
maxFreeSockets : 5 ,
timeout : 30000 ,
});
const client = new ClayClient ({
apiKey : process.env .CLAY_API_KEY !,
httpAgent : agent,
});
Pagination Optimization async function * paginatedClayList<T>(
fetcher : (cursor ?: string Promise <{ data : T[]; nextCursor ?: string }>
): AsyncGenerator <T> {
let cursor : string | undefined ;
do {
const { data, nextCursor } = await fetcher (cursor);
for (const item of data) {
yield item;
}
cursor = nextCursor;
} while (cursor);
}
for await (const item of paginatedClayList (cursor =>list ({ cursor, limit : 100 })
)) {
await process (item);
}
Performance Monitoring async function measuredClayCall<T>(
operation : string ,
fn : () => Promise <T>
): Promise <T> {
const start = performance.now ();
try {
const result = await fn ();
const duration = performance.now () - start;
console .log ({ operation, duration, status : 'success' });
return result;
} catch (error) {
const duration = performance.now () - start;
console .error ({ operation, duration, status : 'error' , error });
throw error;
}
}
Instructions
Step 1: Establish Baseline Measure current latency for critical Clay operations.
Step 2: Implement Caching Add response caching for frequently accessed data.
Step 3: Enable Batching Use DataLoader or similar for automatic request batching.
Step 4: Optimize Connections Configure connection pooling with keep-alive.
Output
Reduced API latency
Caching layer implemented
Request batching enabled
Connection pooling configured
Error Handling Issue Cause Solution Cache miss storm TTL expired Use stale-while-revalidate Batch timeout Too many items Reduce batch size Connection exhausted No pooling Configure max sockets Memory pressure Cache too large Set max cache entries
Examples
Quick Performance Wrapper const withPerformance = <T>(name : string , fn : () => Promise <T>
measuredClayCall (name, () =>
cachedClayRequest (`cache:${name} ` , fn)
);
Resources
Next Steps For cost optimization, see clay-cost-tuning.
