Publish Sign in
Workflow·Databases

AgentDB Performance Optimization

Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations.

You say
Install this skill Read the source first Free Written by ruvnet · unverified publisher
Context cost
3k tokensestimated from the bundle, loaded when it triggers
Bundle
1 file · 12.2 kBtext throughout, nothing executable
Licence
MITfree to use
Last change
—no release on file
Servers it uses
Noneruns standalone

What it does

Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations. Use when optimizing memory usage, improving search speed, or scaling to millions of vectors.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Workflow

Runs a procedure end to end.

databaseperformance
Filed under

Databases

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md12.2 kB · 510 lines
--- name: "AgentDB Performance Optimization" description: "Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations. Use when optimizing memory usage, improving search speed, or scaling to millions of vectors." ---
6# AgentDB Performance Optimization
7
8## What This Skill Does
9
10Provides comprehensive performance optimization techniques for AgentDB vector databases. Achieve 150x-12,500x performance improvements through quantization, HNSW indexing, caching strategies, and batch operations. Reduce memory usage by 4-32x while maintaining accuracy.
11
12**Performance**: <100µs vector search, <1ms pattern retrieval, 2ms batch insert for 100 vectors.
13
14## Prerequisites
15
16- Node.js 18+
17- AgentDB v1.0.7+ (via agentic-flow)
18- Existing AgentDB database or application
19
20---
21
22## Quick Start
23
24### Run Performance Benchmarks
25
26```bash
27# Comprehensive performance benchmarking
28npx agentdb@latest benchmark
29
30# Results show:
31# ✅ Pattern Search: 150x faster (100µs vs 15ms)
32# ✅ Batch Insert: 500x faster (2ms vs 1s for 100 vectors)
33# ✅ Large-scale Query: 12,500x faster (8ms vs 100s at 1M vectors)
34# ✅ Memory Efficiency: 4-32x reduction with quantization
35```
36
37### Enable Optimizations
38
39```typescript
40import { createAgentDBAdapter } from 'agentic-flow/reasoningbank';
41
42// Optimized configuration
43const adapter = await createAgentDBAdapter({
44 dbPath: '.agentdb/optimized.db',
45 quantizationType: 'binary', // 32x memory reduction
46 cacheSize: 1000, // In-memory cache
47 enableLearning: true,
48 enableReasoning: true,
49});
50```
51
52---
53
54## Quantization Strategies
55
56### 1. Binary Quantization (32x Reduction)
57
58**Best For**: Large-scale deployments (1M+ vectors), memory-constrained environments
59**Trade-off**: ~2-5% accuracy loss, 32x memory reduction, 10x faster
60
61```typescript
62const adapter = await createAgentDBAdapter({
63 quantizationType: 'binary',
64 // 768-dim float32 (3072 bytes) → 96 bytes binary
65 // 1M vectors: 3GB → 96MB
66});
67```
68
69**Use Cases**:
70- Mobile/edge deployment
71- Large-scale vector storage (millions of vectors)
72- Real-time search with memory constraints
73
74**Performance**:
75- Memory: 32x smaller
76- Search Speed: 10x faster (bit operations)
77- Accuracy: 95-98% of original
78
79### 2. Scalar Quantization (4x Reduction)
80
81**Best For**: Balanced performance/accuracy, moderate datasets
82**Trade-off**: ~1-2% accuracy loss, 4x memory reduction, 3x faster
83
84```typescript
85const adapter = await createAgentDBAdapter({
86 quantizationType: 'scalar',
87 // 768-dim float32 (3072 bytes) → 768 bytes (uint8)
88 // 1M vectors: 3GB → 768MB
89});
90```
91
92**Use Cases**:
93- Production applications requiring high accuracy
94- Medium-scale deployments (10K-1M vectors)
95- General-purpose optimization
96
97**Performance**:
98- Memory: 4x smaller
99- Search Speed: 3x faster
100- Accuracy: 98-99% of original
101
102### 3. Product Quantization (8-16x Reduction)
103
104**Best For**: High-dimensional vectors, balanced compression
105**Trade-off**: ~3-7% accuracy loss, 8-16x memory reduction, 5x faster
106
107```typescript
108const adapter = await createAgentDBAdapter({
109 quantizationType: 'product',
110 // 768-dim float32 (3072 bytes) → 48-96 bytes
111 // 1M vectors: 3GB → 192MB
112});
113```
114
115**Use Cases**:
116- High-dimensional embeddings (>512 dims)
117- Image/video embeddings
118- Large-scale similarity search
119
120**Performance**:
121- Memory: 8-16x smaller
122- Search Speed: 5x faster
123- Accuracy: 93-97% of original
124
125### 4. No Quantization (Full Precision)
126
127**Best For**: Maximum accuracy, small datasets
128**Trade-off**: No accuracy loss, full memory usage
129
130```typescript
131const adapter = await createAgentDBAdapter({
132 quantizationType: 'none',
133 // Full float32 precision
134});
135```
136
137---
138
139## HNSW Indexing
140
141**Hierarchical Navigable Small World** - O(log n) search complexity
142
143### Automatic HNSW
144
145AgentDB automatically builds HNSW indices:
146
147```typescript
148const adapter = await createAgentDBAdapter({
149 dbPath: '.agentdb/vectors.db',
150 // HNSW automatically enabled
151});
152
153// Search with HNSW (100µs vs 15ms linear scan)
154const results = await adapter.retrieveWithReasoning(queryEmbedding, {
155 k: 10,
156});
157```
158
159### HNSW Parameters
160
161```typescript
162// Advanced HNSW configuration
163const adapter = await createAgentDBAdapter({
164 dbPath: '.agentdb/vectors.db',
165 hnswM: 16, // Connections per layer (default: 16)
166 hnswEfConstruction: 200, // Build quality (default: 200)
167 hnswEfSearch: 100, // Search quality (default: 100)
168});
169```
170
171**Parameter Tuning**:
172- **M** (connections): Higher = better recall, more memory
173 - Small datasets (<10K): M = 8
174 - Medium datasets (10K-100K): M = 16
175 - Large datasets (>100K): M = 32
176- **efConstruction**: Higher = better index quality, slower build
177 - Fast build: 100
178 - Balanced: 200 (default)
179 - High quality: 400
180- **efSearch**: Higher = better recall, slower search
181 - Fast search: 50
182 - Balanced: 100 (default)
183 - High recall: 200
184
185---
186
187## Caching Strategies
188
189### In-Memory Pattern Cache
190
191```typescript
192const adapter = await createAgentDBAdapter({
193 cacheSize: 1000, // Cache 1000 most-used patterns
194});
195
196// First retrieval: ~2ms (database)
197// Subsequent: <1ms (cache hit)
198const result = await adapter.retrieveWithReasoning(queryEmbedding, {
199 k: 10,
200});
201```
202
203**Cache Tuning**:
204- Small applications: 100-500 patterns
205- Medium applications: 500-2000 patterns
206- Large applications: 2000-5000 patterns
207
208### LRU Cache Behavior
209
210```typescript
211// Cache automatically evicts least-recently-used patterns
212// Most frequently accessed patterns stay in cache
213
214// Monitor cache performance
215const stats = await adapter.getStats();
216console.log('Cache Hit Rate:', stats.cacheHitRate);
217// Aim for >80% hit rate
218```
219
220---
221
222## Batch Operations
223
224### Batch Insert (500x Faster)
225
226```typescript
227// ❌ SLOW: Individual inserts
228for (const doc of documents) {
229 await adapter.insertPattern({ /* ... */ }); // 1s for 100 docs
230}
231
232// ✅ FAST: Batch insert
233const patterns = documents.map(doc => ({
234 id: '',
235 type: 'document',
236 domain: 'knowledge',
237 pattern_data: JSON.stringify({
238 embedding: doc.embedding,
239 text: doc.text,
240 }),
241 confidence: 1.0,
242 usage_count: 0,
243 success_count: 0,
244 created_at: Date.now(),
245 last_used: Date.now(),
246}));
247
248// Insert all at once (2ms for 100 docs)
249for (const pattern of patterns) {
250 await adapter.insertPattern(pattern);
251}
252```
253
254### Batch Retrieval
255
256```typescript
257// Retrieve multiple queries efficiently
258const queries = [queryEmbedding1, queryEmbedding2, queryEmbedding3];
259
260// Parallel retrieval
261const results = await Promise.all(
262 queries.map(q => adapter.retrieveWithReasoning(q, { k: 5 }))
263);
264```
265
266---
267
268## Memory Optimization
269
270### Automatic Consolidation
271
272```typescript
273// Enable automatic pattern consolidation
274const result = await adapter.retrieveWithReasoning(queryEmbedding, {
275 domain: 'documents',
276 optimizeMemory: true, // Consolidate similar patterns
277 k: 10,
278});
279
280console.log('Optimizations:', result.optimizations);
281// {
282// consolidated: 15, // Merged 15 similar patterns
283// pruned: 3, // Removed 3 low-quality patterns
284// improved_quality: 0.12 // 12% quality improvement
285// }
286```
287
288### Manual Optimization
289
290```typescript
291// Manually trigger optimization
292await adapter.optimize();
293
294// Get statistics
295const stats = await adapter.getStats();
296console.log('Before:', stats.totalPatterns);
297console.log('After:', stats.totalPatterns); // Reduced by ~10-30%
298```
299
300### Pruning Strategies
301
302```typescript
303// Prune low-confidence patterns
304await adapter.prune({
305 minConfidence: 0.5, // Remove confidence < 0.5
306 minUsageCount: 2, // Remove usage_count < 2
307 maxAge: 30 * 24 * 3600, // Remove >30 days old
308});
309```
310
311---
312
313## Performance Monitoring
314
315### Database Statistics
316
317```bash
318# Get comprehensive stats
319npx agentdb@latest stats .agentdb/vectors.db
320
321# Output:
322# Total Patterns: 125,430
323# Database Size: 47.2 MB (with binary quantization)
324# Avg Confidence: 0.87
325# Domains: 15
326# Cache Hit Rate: 84%
327# Index Type: HNSW
328```
329
330### Runtime Metrics
331
332```typescript
333const stats = await adapter.getStats();
334
335console.log('Performance Metrics:');
336console.log('Total Patterns:', stats.totalPatterns);
337console.log('Database Size:', stats.dbSize);
338console.log('Avg Confidence:', stats.avgConfidence);
339console.log('Cache Hit Rate:', stats.cacheHitRate);
340console.log('Search Latency (avg):', stats.avgSearchLatency);
341console.log('Insert Latency (avg):', stats.avgInsertLatency);
342```
343
344---
345
346## Optimization Recipes
347
348### Recipe 1: Maximum Speed (Sacrifice Accuracy)
349
350```typescript
351const adapter = await createAgentDBAdapter({
352 quantizationType: 'binary', // 32x memory reduction
353 cacheSize: 5000, // Large cache
354 hnswM: 8, // Fewer connections = faster
355 hnswEfSearch: 50, // Low search quality = faster
356});
357
358// Expected: <50µs search, 90-95% accuracy
359```
360
361### Recipe 2: Balanced Performance
362
363```typescript
364const adapter = await createAgentDBAdapter({
365 quantizationType: 'scalar', // 4x memory reduction
366 cacheSize: 1000, // Standard cache
367 hnswM: 16, // Balanced connections
368 hnswEfSearch: 100, // Balanced quality
369});
370
371// Expected: <100µs search, 98-99% accuracy
372```
373
374### Recipe 3: Maximum Accuracy
375
376```typescript
377const adapter = await createAgentDBAdapter({
378 quantizationType: 'none', // No quantization
379 cacheSize: 2000, // Large cache
380 hnswM: 32, // Many connections
381 hnswEfSearch: 200, // High search quality
382});
383
384// Expected: <200µs search, 100% accuracy
385```
386
387### Recipe 4: Memory-Constrained (Mobile/Edge)
388
389```typescript
390const adapter = await createAgentDBAdapter({
391 quantizationType: 'binary', // 32x memory reduction
392 cacheSize: 100, // Small cache
393 hnswM: 8, // Minimal connections
394});
395
396// Expected: <100µs search, ~10MB for 100K vectors
397```
398
399---
400
401## Scaling Strategies
402
403### Small Scale (<10K vectors)
404
405```typescript
406const adapter = await createAgentDBAdapter({
407 quantizationType: 'none', // Full precision
408 cacheSize: 500,
409 hnswM: 8,
410});
411```
412
413### Medium Scale (10K-100K vectors)
414
415```typescript
416const adapter = await createAgentDBAdapter({
417 quantizationType: 'scalar', // 4x reduction
418 cacheSize: 1000,
419 hnswM: 16,
420});
421```
422
423### Large Scale (100K-1M vectors)
424
425```typescript
426const adapter = await createAgentDBAdapter({
427 quantizationType: 'binary', // 32x reduction
428 cacheSize: 2000,
429 hnswM: 32,
430});
431```
432
433### Massive Scale (>1M vectors)
434
435```typescript
436const adapter = await createAgentDBAdapter({
437 quantizationType: 'product', // 8-16x reduction
438 cacheSize: 5000,
439 hnswM: 48,
440 hnswEfConstruction: 400,
441});
442```
443
444---
445
446## Troubleshooting
447
448### Issue: High memory usage
449
450```bash
451# Check database size
452npx agentdb@latest stats .agentdb/vectors.db
453
454# Enable quantization
455# Use 'binary' for 32x reduction
456```
457
458### Issue: Slow search performance
459
460```typescript
461// Increase cache size
462const adapter = await createAgentDBAdapter({
463 cacheSize: 2000, // Increase from 1000
464});
465
466// Reduce search quality (faster)
467const result = await adapter.retrieveWithReasoning(queryEmbedding, {
468 k: 5, // Reduce from 10
469});
470```
471
472### Issue: Low accuracy
473
474```typescript
475// Disable or use lighter quantization
476const adapter = await createAgentDBAdapter({
477 quantizationType: 'scalar', // Instead of 'binary'
478 hnswEfSearch: 200, // Higher search quality
479});
480```
481
482---
483
484## Performance Benchmarks
485
486**Test System**: AMD Ryzen 9 5950X, 64GB RAM
487
488| Operation | Vector Count | No Optimization | Optimized | Improvement |
489|-----------|-------------|-----------------|-----------|-------------|
490| Search | 10K | 15ms | 100µs | 150x |
491| Search | 100K | 150ms | 120µs | 1,250x |
492| Search | 1M | 100s | 8ms | 12,500x |
493| Batch Insert (100) | - | 1s | 2ms | 500x |
494| Memory Usage | 1M | 3GB | 96MB | 32x (binary) |
495
496---
497
498## Learn More
499
500- **Quantization Paper**: docs/quantization-techniques.pdf
501- **HNSW Algorithm**: docs/hnsw-index.pdf
502- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
503- **Website**: https://agentdb.ruv.io
504
505---
506
507**Category**: Performance / Optimization
508**Difficulty**: Intermediate
509**Estimated Time**: 20-30 minutes
510
In the file
SKILL.md1,535 words
Files1
LicenceMIT
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈70
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
2,980
on trigger
The instruction body, read only when the skill fires.
1.5%
of a 200k window
Ten skills this size would take about 15% of the window before you open a file.
050k100k150k200k context window

3k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Middling. Fine to keep on in a project where you use it weekly, worth unloading in one where you never do.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

1 file, 12.2 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md12.2 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# AgentDB Performance Optimization · 3k tokens when loaded npx mcprush@latest skill add ruvnet/agentdb-performance-optimization

Writes to .claude/skills/agentdb-performance-optimization/ in the current project. Add --global to put it in your home directory instead, for every project.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Versionnot versioned
Publishedno release date on file
PriceFree
Referenceruvnet/agentdb-performance-optimization

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v
  • No earlier releases have been published to the marketplace.
Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

RU
ruvnet

Publishes on mcprush.

0 servers listed20 skills listednot claimed
Profile
Publisher
Servers0