Agent Skills
Discover and share powerful Agent Skills for AI assistants
exa-performance-tuning - Agent Skill - Agent Skills
/ Skills / exa-performance-tuning exa-performance-tuning MIT
Optimize Exa API performance with caching, batching, and connection pooling.
Use when experiencing slow API responses, implementing caching strategies,
or optimizing request throughput for Exa integrations.
Trigger with phrases like "exa performance", "optimize exa",
"exa latency", "exa caching", "exa slow", "exa batch".
Use the skills CLI to install this skill with one command. Auto-detects all installed AI assistants.
Method 1 - skills CLI
npx skills i jeremylongshore/claude-code-plugins-plus-skills/plugins/saas-packs/exa-pack/skills/exa-performance-tuningMethod 2 - openskills (supports sync & update)
npx openskills install jeremylongshore/claude-code-plugins-plus-skillsAuto-detects Claude Code, Cursor, Codex CLI, Gemini CLI, and more. One install, works everywhere.
Installation Path
Download and extract to one of the following locations:
Claude Code Cursor OpenCode Gemini CLI Codex CLI
~/.claude/skills/exa-performance-tuning/ Back No setup needed. Let our cloud agents run this skill for you.
Select Model
Claude Haiku 4.5 $0.10 Claude Sonnet 4.5 $0.20 Claude Opus 4.5 $0.50 Claude Sonnet 4.5 $0.20 /task
Best for coding tasks
No setup required
Optimize Exa API performance with caching, batching, and connection pooling.
Exa SDK installed
Understanding of async patterns
Redis or in-memory cache available (optional)
Performance monitoring in place
Operation P50 P95 P99 Read 50ms 150ms 300ms Write 100ms 250ms 500ms List 75ms 200ms 400ms
import { LRUCache } from 'lru-cache' ;
const cache = new LRUCache < string , any >({ max: 1000 , ttl: 60000 , // 1 minute updateAgeOnGet: true , });
async function cachedExaRequest < T >( import Redis from 'ioredis' ;
const redis = new Redis (process.env. REDIS_URL );
async function cachedWithRedis < T >( key : string , fetcher : () => Promise < T >, ttlSeconds = import DataLoader from 'dataloader' ;
const exaLoader = new DataLoader < string , any >( async ( ids ) => { // Batch fetch from Exa const results = await exaClient. batchGet (ids); return ids. import { Agent } from 'https' ;
// Keep-alive connection pooling const agent = new Agent ({ keepAlive: true , maxSockets: 10 , maxFreeSockets: 5 , timeout: 30000 , });
const client = new ExaClient ({ apiKey: process.env. async function* paginatedExaList < T >( fetcher : ( cursor ?: string ) => Promise <{ data : T []; nextCursor ?: string }> ) : AsyncGenerator < T > { let cursor : string async function measuredExaCall < T >( operation : string , fn : () => Promise < T > ) : Promise < T > { const start = performance. now (); try { const Measure current latency for critical Exa operations.
Add response caching for frequently accessed data.
Use DataLoader or similar for automatic request batching.
Configure connection pooling with keep-alive.
Reduced API latency
Caching layer implemented
Request batching enabled
Connection pooling configured
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
const withPerformance = < T >( name : string , fn : () => Promise < T >) => measuredExaCall (name, () => cachedExaRequest ( `cache:${ name }` , fn) ); For cost optimization, see exa-cost-tuning.
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;
}
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;
}
map
(
id
=>
results.
find
(
r
=>
r.id
===
id)
||
null
);
},
{
maxBatchSize: 100 ,
batchScheduleFn : callback => setTimeout (callback, 10 ),
}
);
// Usage - automatically batched
const [ item1 , item2 , item3 ] = await Promise . all ([
exaLoader. load ( 'id-1' ),
exaLoader. load ( 'id-2' ),
exaLoader. load ( 'id-3' ),
]);
EXA_API_KEY
!
,
httpAgent: agent,
});
|
undefined
;
do {
const { data , nextCursor } = await fetcher (cursor);
for ( const item of data) {
yield item;
}
cursor = nextCursor;
} while (cursor);
}
// Usage
for await ( const item of paginatedExaList ( cursor =>
exaClient. list ({ cursor, limit: 100 })
)) {
await process (item);
}
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;
}
}
Claude Sonnet 4.5