Skip to main content Inicio Creadores ruvnet ruflo reasoningbank-with-agentdb
reasoningbank-with-agentdb Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems.
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/ruvnet/ruflo --skill reasoningbank-with-agentdbEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
name ReasoningBank with AgentDB description Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems.
ReasoningBank with AgentDB
What This Skill Does
Provides ReasoningBank adaptive learning patterns using AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time with 100% backward compatibility.
Performance : 150x faster pattern retrieval, 500x faster batch operations, <1ms memory access.
Prerequisites
Node.js 18+
AgentDB v1.0.7+ (via agentic-flow)
Understanding of reinforcement learning concepts (optional)
Quick Start with CLI
Initialize ReasoningBank Database
npx agentdb@latest init ./.agentdb$reasoningbank .db --dimension 1536
npx agentdb@latest mcp
claude mcp add agentdb npx agentdb@latest mcp
Migrate from Legacy ReasoningBank
npx agentdb@latest migrate --source .swarm$memory .db
npx agentdb@latest stats ./.agentdb$reasoningbank .db
Quick Start with API
import { createAgentDBAdapter, computeEmbedding } from
'agentic-flow$reasoningbank'
const
await
createAgentDBAdapter
dbPath
'.agentdb$reasoningbank.db'
enableLearning
true
enableReasoning
true
cacheSize
1000
const
"How to optimize database queries?"
const
await
computeEmbedding
await
insertPattern
id
''
type
'experience'
domain
'database-optimization'
pattern_data
JSON
stringify
pattern
approach
'indexing + query optimization'
outcome
'success'
metrics
latency_reduction
0.85
confidence
0.95
usage_count
1
success_count
1
created_at
Date
now
last_used
Date
now
const
await
retrieveWithReasoning
domain
'database-optimization'
k
5
useMMR
true
synthesizeContext
true
console
log
'Memories:'
memories
console
log
'Context:'
context
console
log
'Patterns:'
patterns
Core ReasoningBank Concepts
1. Trajectory Tracking Track agent execution paths and outcomes:
const trajectory = {
task : 'optimize-api-endpoint' ,
steps : [
{ action : 'analyze-bottleneck' , result : 'found N+1 query' },
{ action : 'add-eager-loading' , result : 'reduced queries' },
{ action : 'add-caching' , result : 'improved latency' }
],
outcome : 'success' ,
metrics : { latency_before : 2500 , latency_after : 150 }
};
const embedding = await computeEmbedding (JSON .stringify (trajectory));
await rb.insertPattern ({
id : '' ,
type : 'trajectory' ,
domain : 'api-optimization' ,
pattern_data : JSON .stringify ({ embedding, pattern : trajectory }),
confidence : 0.9 ,
usage_count : 1 ,
success_count : 1 ,
created_at : Date .now (),
last_used : Date .now (),
});
2. Verdict Judgment Judge whether a trajectory was successful:
const similar = await rb.retrieveWithReasoning (queryEmbedding, {
domain : 'api-optimization' ,
k : 10 ,
});
const verdict = similar.memories .filter (m =>pattern .outcome === 'success' &&
m.similarity > 0.8
).length > 5 ? 'likely_success' : 'needs_review' ;
console .log ('Verdict:' , verdict);
console .log ('Confidence:' , similar.memories [0 ]?.similarity || 0 );
3. Memory Distillation Consolidate similar experiences into patterns:
const experiences = await rb.retrieveWithReasoning (embedding, {
domain : 'api-optimization' ,
k : 100 ,
optimizeMemory : true ,
});
const distilledPattern = {
domain : 'api-optimization' ,
pattern : 'For N+1 queries: add eager loading, then cache' ,
success_rate : 0.92 ,
sample_size : experiences.memories .length ,
confidence : 0.95
};
await rb.insertPattern ({
id : '' ,
type : 'distilled-pattern' ,
domain : 'api-optimization' ,
pattern_data : JSON .stringify ({
embedding : await computeEmbedding (JSON .stringify (distilledPattern)),
pattern : distilledPattern
}),
confidence : 0.95 ,
usage_count : 0 ,
success_count : 0 ,
created_at : Date .now (),
last_used : Date .now (),
});
Integration with Reasoning Agents AgentDB provides 4 reasoning modules that enhance ReasoningBank:
1. PatternMatcher Find similar successful patterns:
const result = await rb.retrieveWithReasoning (queryEmbedding, {
domain : 'problem-solving' ,
k : 10 ,
useMMR : true ,
});
result.memories .forEach (mem =>console .log (`Pattern: ${mem.pattern.approach} ` );
console .log (`Similarity: ${mem.similarity} ` );
console .log (`Success Rate: ${mem.success_count / mem.usage_count} ` );
});
2. ContextSynthesizer Generate rich context from multiple memories:
const result = await rb.retrieveWithReasoning (queryEmbedding, {
domain : 'code-optimization' ,
synthesizeContext : true ,
k : 5 ,
});
console .log ('Synthesized Context:' , result.context );
3. MemoryOptimizer Automatically consolidate and prune:
const result = await rb.retrieveWithReasoning (queryEmbedding, {
domain : 'testing' ,
optimizeMemory : true ,
});
console .log ('Optimizations:' , result.optimizations );
4. ExperienceCurator Filter by quality and relevance:
const result = await rb.retrieveWithReasoning (queryEmbedding, {
domain : 'debugging' ,
k : 20 ,
minConfidence : 0.8 ,
});
result.memories .forEach (mem =>console .log (`Confidence: ${mem.confidence} ` );
console .log (`Success Rate: ${mem.success_count / mem.usage_count} ` );
});
Legacy API Compatibility AgentDB maintains 100% backward compatibility with legacy ReasoningBank:
import {
retrieveMemories,
judgeTrajectory,
distillMemories
} from 'agentic-flow$reasoningbank' ;
const memories = await retrieveMemories (query, {
domain : 'code-generation' ,
agent : 'coder'
});
const verdict = await judgeTrajectory (trajectory, query);
const newMemories = await distillMemories (
trajectory,
verdict,
query,
{ domain : 'code-generation' }
);
Performance Characteristics
Pattern Search : 150x faster (100µs vs 15ms)Memory Retrieval : <1ms (with cache)Batch Insert : 500x faster (2ms vs 1s for 100 patterns)Trajectory Judgment : <5ms (including retrieval + analysis)Memory Distillation : <50ms (consolidate 100 patterns)
Advanced Patterns
Hierarchical Memory Organize memories by abstraction level:
await rb.insertPattern ({
type : 'concrete' ,
domain : 'debugging$null-pointer' ,
pattern_data : JSON .stringify ({
embedding,
pattern : { bug : 'NPE in UserService.getUser()' , fix : 'Add null check' }
}),
confidence : 0.9 ,
});
await rb.insertPattern ({
type : 'pattern' ,
domain : 'debugging' ,
pattern_data : JSON .stringify ({
embedding,
pattern : { category : 'null-pointer' , approach : 'defensive-checks' }
}),
confidence : 0.85 ,
});
await rb.insertPattern ({
type : 'principle' ,
domain : 'software-engineering' ,
pattern_data : JSON .stringify ({
embedding,
pattern : { principle : 'fail-fast with clear errors' }
}),
confidence : 0.95 ,
});
Multi-Domain Learning Transfer learning across domains:
const backendExperience = await rb.retrieveWithReasoning (embedding, {
domain : 'backend-optimization' ,
k : 10 ,
});
const transferredKnowledge = backendExperience.memories .map (mem =>domain : 'frontend-optimization' ,
adapted : true ,
}));
CLI Operations
Database Management
npx agentdb@latest export ./.agentdb$reasoningbank .db .$backup .json
npx agentdb@latest import .$experiences .json
npx agentdb@latest stats ./.agentdb$reasoningbank .db
Migration
npx agentdb@latest migrate --source .swarm$memory .db --target .agentdb$reasoningbank .db
npx agentdb@latest stats .agentdb$reasoningbank .db
Troubleshooting
Issue: Migration fails
ls -la .swarm$memory .db
DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm$memory .db
Issue: Low confidence scores
const result = await rb.retrieveWithReasoning (embedding, {
synthesizeContext : true ,
useMMR : true ,
k : 10 ,
});
Issue: Memory growing too large
const result = await rb.retrieveWithReasoning (embedding, {
optimizeMemory : true ,
});
await rb.optimize ();
Learn More
AgentDB Integration : node_modules$agentic-flow/docs/AGENTDB_INTEGRATION.mdGitHub : https:/$github.com$ruvnet$agentic-flow$tree$main$packages$agentdbMCP Integration : npx agentdb@latest mcpWebsite : https:/$agentdb.ruv.io
Category : Machine Learning / Reinforcement Learning
Difficulty : Intermediate
Estimated Time : 20-30 minutes
