Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'
This commit is contained in:
ruv
319
vendor/ruvector/examples/rust/agenticdb_demo.rs
vendored
Normal file
319
vendor/ruvector/examples/rust/agenticdb_demo.rs
vendored
Normal file
@@ -0,0 +1,319 @@
|
||||
//! AgenticDB API Demonstration
|
||||
//!
|
||||
//! Shows all 5 tables and API features:
|
||||
//! 1. Reflexion Episodes - Self-critique memory
|
||||
//! 2. Skill Library - Consolidated patterns
|
||||
//! 3. Causal Memory - Hypergraph relationships
|
||||
//! 4. Learning Sessions - RL training data
|
||||
//! 5. Vector DB - Core embeddings
|
||||
|
||||
use ruvector_core::{AgenticDB, DbOptions, Result};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn main() -> Result<()> {
|
||||
println!("🚀 AgenticDB API Demonstration\n");
|
||||
|
||||
// Initialize AgenticDB
|
||||
let mut options = DbOptions::default();
|
||||
options.dimensions = 128;
|
||||
options.storage_path = "./demo_agenticdb.db".to_string();
|
||||
|
||||
let db = AgenticDB::new(options)?;
|
||||
|
||||
// ============ 1. Reflexion Memory Demo ============
|
||||
println!("📝 1. REFLEXION MEMORY - Self-Critique Episodes");
|
||||
println!("------------------------------------------------");
|
||||
|
||||
// Store an episode where the agent made a mistake
|
||||
let episode1 = db.store_episode(
|
||||
"Solve a coding problem".to_string(),
|
||||
vec![
|
||||
"Read problem description".to_string(),
|
||||
"Write initial solution".to_string(),
|
||||
"Submit without testing".to_string(),
|
||||
],
|
||||
vec![
|
||||
"Solution failed test cases".to_string(),
|
||||
"Missed edge case with empty input".to_string(),
|
||||
],
|
||||
"I should have tested edge cases before submitting. Always check empty input, null values, and boundary conditions.".to_string(),
|
||||
)?;
|
||||
println!("✅ Stored episode: {}", episode1);
|
||||
|
||||
// Store another episode with improved behavior
|
||||
let episode2 = db.store_episode(
|
||||
"Debug a complex function".to_string(),
|
||||
vec![
|
||||
"Added logging statements".to_string(),
|
||||
"Tested with sample inputs".to_string(),
|
||||
"Fixed the bug".to_string(),
|
||||
],
|
||||
vec![
|
||||
"Found the issue in O(n) time".to_string(),
|
||||
"Tests passed".to_string(),
|
||||
],
|
||||
"Using systematic logging helped identify the issue quickly. This is a good debugging strategy.".to_string(),
|
||||
)?;
|
||||
println!("✅ Stored episode: {}", episode2);
|
||||
|
||||
// Retrieve similar episodes when facing a new coding task
|
||||
let similar_episodes = db.retrieve_similar_episodes("how to approach coding problems", 5)?;
|
||||
println!("\n🔍 Found {} similar episodes for 'coding problems':", similar_episodes.len());
|
||||
for (i, episode) in similar_episodes.iter().enumerate() {
|
||||
println!(" {}. Task: {} | Critique: {}", i + 1, episode.task, episode.critique);
|
||||
}
|
||||
|
||||
// ============ 2. Skill Library Demo ============
|
||||
println!("\n\n🎯 2. SKILL LIBRARY - Reusable Patterns");
|
||||
println!("------------------------------------------------");
|
||||
|
||||
// Create skills for common tasks
|
||||
let mut params1 = HashMap::new();
|
||||
params1.insert("input".to_string(), "string".to_string());
|
||||
params1.insert("output".to_string(), "json".to_string());
|
||||
|
||||
let skill1 = db.create_skill(
|
||||
"JSON Parser".to_string(),
|
||||
"Parse JSON string into structured data".to_string(),
|
||||
params1,
|
||||
vec![
|
||||
"let data = JSON.parse(input);".to_string(),
|
||||
"return data;".to_string(),
|
||||
],
|
||||
)?;
|
||||
println!("✅ Created skill: JSON Parser ({})", skill1);
|
||||
|
||||
let mut params2 = HashMap::new();
|
||||
params2.insert("data".to_string(), "array".to_string());
|
||||
params2.insert("field".to_string(), "string".to_string());
|
||||
|
||||
let skill2 = db.create_skill(
|
||||
"Data Aggregator".to_string(),
|
||||
"Aggregate and summarize array data by field".to_string(),
|
||||
params2,
|
||||
vec![
|
||||
"let groups = data.reduce((acc, item) => {".to_string(),
|
||||
" acc[item[field]] = (acc[item[field]] || 0) + 1;".to_string(),
|
||||
" return acc;".to_string(),
|
||||
"}, {});".to_string(),
|
||||
],
|
||||
)?;
|
||||
println!("✅ Created skill: Data Aggregator ({})", skill2);
|
||||
|
||||
// Search for relevant skills
|
||||
let found_skills = db.search_skills("parse and process json data", 5)?;
|
||||
println!("\n🔍 Found {} skills for 'parse json':", found_skills.len());
|
||||
for skill in found_skills {
|
||||
println!(" - {} ({}) | Success rate: {:.1}%",
|
||||
skill.name, skill.id, skill.success_rate * 100.0);
|
||||
}
|
||||
|
||||
// Auto-consolidate action sequences into skills
|
||||
let action_sequences = vec![
|
||||
vec!["read_file".to_string(), "parse_json".to_string(), "validate_schema".to_string()],
|
||||
vec!["fetch_api".to_string(), "extract_data".to_string(), "cache_result".to_string()],
|
||||
vec!["open_db".to_string(), "query_data".to_string(), "close_db".to_string()],
|
||||
];
|
||||
|
||||
let consolidated_skills = db.auto_consolidate(action_sequences, 3)?;
|
||||
println!("\n✅ Auto-consolidated {} new skills from action sequences", consolidated_skills.len());
|
||||
|
||||
// ============ 3. Causal Memory Demo ============
|
||||
println!("\n\n🧠 3. CAUSAL MEMORY - Hypergraph Relationships");
|
||||
println!("------------------------------------------------");
|
||||
|
||||
// Add causal edges with hypergraph support (multiple causes -> multiple effects)
|
||||
let edge1 = db.add_causal_edge(
|
||||
vec!["high CPU usage".to_string(), "memory leak".to_string()],
|
||||
vec!["system slowdown".to_string(), "application crash".to_string()],
|
||||
0.92,
|
||||
"Server performance issue observed in production".to_string(),
|
||||
)?;
|
||||
println!("✅ Added causal edge: CPU+Memory -> Slowdown+Crash ({})", edge1);
|
||||
|
||||
let edge2 = db.add_causal_edge(
|
||||
vec!["missing index".to_string()],
|
||||
vec!["slow queries".to_string(), "database timeout".to_string()],
|
||||
0.87,
|
||||
"Database performance degradation".to_string(),
|
||||
)?;
|
||||
println!("✅ Added causal edge: No Index -> Slow Queries+Timeout ({})", edge2);
|
||||
|
||||
let edge3 = db.add_causal_edge(
|
||||
vec!["cache invalidation".to_string(), "traffic spike".to_string()],
|
||||
vec!["increased load".to_string(), "response delay".to_string()],
|
||||
0.78,
|
||||
"Cache-related performance issue".to_string(),
|
||||
)?;
|
||||
println!("✅ Added causal edge: Cache+Traffic -> Load+Delay ({})", edge3);
|
||||
|
||||
// Query with utility function: U = α·similarity + β·causal_uplift − γ·latency
|
||||
println!("\n🔍 Querying with utility function (α=0.7, β=0.2, γ=0.1):");
|
||||
let utility_results = db.query_with_utility(
|
||||
"performance problems in production",
|
||||
5,
|
||||
0.7, // alpha: similarity weight
|
||||
0.2, // beta: causal confidence weight
|
||||
0.1, // gamma: latency penalty weight
|
||||
)?;
|
||||
|
||||
for (i, result) in utility_results.iter().enumerate() {
|
||||
println!(" {}. Utility: {:.3} | Similarity: {:.3} | Causal: {:.3} | Latency: {:.3}ms",
|
||||
i + 1,
|
||||
result.utility_score,
|
||||
result.similarity_score,
|
||||
result.causal_uplift,
|
||||
result.latency_penalty * 1000.0,
|
||||
);
|
||||
}
|
||||
|
||||
// ============ 4. Learning Sessions Demo ============
|
||||
println!("\n\n🤖 4. LEARNING SESSIONS - RL Training");
|
||||
println!("------------------------------------------------");
|
||||
|
||||
// Start a Q-Learning session for navigation
|
||||
let session1 = db.start_session(
|
||||
"Q-Learning".to_string(),
|
||||
4, // state_dim: [x, y, goal_x, goal_y]
|
||||
2, // action_dim: [move_x, move_y]
|
||||
)?;
|
||||
println!("✅ Started Q-Learning session: {}", session1);
|
||||
|
||||
// Add training experiences
|
||||
println!("\n📊 Adding training experiences...");
|
||||
for i in 0..10 {
|
||||
let state = vec![i as f32, 0.0, 10.0, 10.0];
|
||||
let action = vec![1.0, 0.0]; // Move right
|
||||
let reward = if i < 5 { 0.5 } else { 1.0 }; // Higher reward as we get closer
|
||||
let next_state = vec![(i + 1) as f32, 0.0, 10.0, 10.0];
|
||||
let done = i == 9;
|
||||
|
||||
db.add_experience(&session1, state, action, reward, next_state, done)?;
|
||||
println!(" ✓ Experience {}: reward={:.1}", i + 1, reward);
|
||||
}
|
||||
|
||||
// Make a prediction with confidence interval
|
||||
let test_state = vec![5.0, 0.0, 10.0, 10.0];
|
||||
let prediction = db.predict_with_confidence(&session1, test_state)?;
|
||||
|
||||
println!("\n🎯 Prediction for state [5.0, 0.0, 10.0, 10.0]:");
|
||||
println!(" Action: {:?}", prediction.action);
|
||||
println!(" Confidence: {:.3} ± [{:.3}, {:.3}]",
|
||||
prediction.mean_confidence,
|
||||
prediction.confidence_lower,
|
||||
prediction.confidence_upper,
|
||||
);
|
||||
|
||||
// Start a DQN session for game playing
|
||||
let session2 = db.start_session(
|
||||
"DQN".to_string(),
|
||||
8, // state_dim: game state
|
||||
4, // action_dim: up, down, left, right
|
||||
)?;
|
||||
println!("\n✅ Started DQN session: {}", session2);
|
||||
|
||||
// ============ 5. Integration Demo ============
|
||||
println!("\n\n🔗 5. INTEGRATION - All Systems Working Together");
|
||||
println!("------------------------------------------------");
|
||||
|
||||
// Scenario: Agent learns from mistakes and builds skills
|
||||
println!("\n📖 Scenario: Agent solving a series of problems");
|
||||
|
||||
// Step 1: Agent fails and reflects
|
||||
let fail_episode = db.store_episode(
|
||||
"Optimize database query".to_string(),
|
||||
vec![
|
||||
"Wrote complex nested query".to_string(),
|
||||
"Ran query on production".to_string(),
|
||||
],
|
||||
vec!["Query timed out after 30 seconds".to_string()],
|
||||
"Should have tested on staging first and checked query plan. Complex nested queries need optimization.".to_string(),
|
||||
)?;
|
||||
println!("❌ Episode: Failed query optimization");
|
||||
|
||||
// Step 2: Agent identifies causal relationship
|
||||
let cause_effect = db.add_causal_edge(
|
||||
vec!["nested subqueries".to_string(), "missing index".to_string()],
|
||||
vec!["slow execution".to_string()],
|
||||
0.95,
|
||||
"Query performance analysis".to_string(),
|
||||
)?;
|
||||
println!("🧠 Learned: Nested queries + No index → Slow execution");
|
||||
|
||||
// Step 3: Agent succeeds and builds skill
|
||||
let success_episode = db.store_episode(
|
||||
"Optimize database query (retry)".to_string(),
|
||||
vec![
|
||||
"Analyzed query plan".to_string(),
|
||||
"Added composite index".to_string(),
|
||||
"Simplified query structure".to_string(),
|
||||
"Tested on staging".to_string(),
|
||||
],
|
||||
vec!["Query completed in 0.2 seconds".to_string()],
|
||||
"Breaking down the problem and using indexes is the key. Always check query plans first.".to_string(),
|
||||
)?;
|
||||
println!("✅ Episode: Successful optimization");
|
||||
|
||||
// Step 4: Agent consolidates into reusable skill
|
||||
let optimization_skill = db.create_skill(
|
||||
"Query Optimizer".to_string(),
|
||||
"Optimize slow database queries using index analysis and query plan review".to_string(),
|
||||
{
|
||||
let mut params = HashMap::new();
|
||||
params.insert("query".to_string(), "string".to_string());
|
||||
params.insert("tables".to_string(), "array".to_string());
|
||||
params
|
||||
},
|
||||
vec![
|
||||
"EXPLAIN ANALYZE query;".to_string(),
|
||||
"Identify missing indexes".to_string(),
|
||||
"CREATE INDEX IF NOT EXISTS...".to_string(),
|
||||
"Simplify nested subqueries".to_string(),
|
||||
"Test on staging".to_string(),
|
||||
],
|
||||
)?;
|
||||
println!("🎯 Created skill: Query Optimizer");
|
||||
|
||||
// Step 5: Agent uses RL to learn optimal strategies
|
||||
let strategy_session = db.start_session(
|
||||
"PPO".to_string(),
|
||||
6, // state: [query_complexity, table_size, index_count, ...]
|
||||
3, // action: [add_index, simplify, cache]
|
||||
)?;
|
||||
println!("🤖 Started RL session for strategy learning");
|
||||
|
||||
// Now when facing similar problems, agent can:
|
||||
println!("\n🎓 Agent capabilities after learning:");
|
||||
|
||||
// 1. Retrieve similar past experiences
|
||||
let relevant_episodes = db.retrieve_similar_episodes("database query performance", 3)?;
|
||||
println!(" ✓ Retrieved {} relevant past experiences", relevant_episodes.len());
|
||||
|
||||
// 2. Find applicable skills
|
||||
let applicable_skills = db.search_skills("optimize database queries", 3)?;
|
||||
println!(" ✓ Found {} applicable skills", applicable_skills.len());
|
||||
|
||||
// 3. Understand causal relationships
|
||||
let causal_knowledge = db.query_with_utility("query performance factors", 3, 0.7, 0.2, 0.1)?;
|
||||
println!(" ✓ Retrieved {} causal relationships", causal_knowledge.len());
|
||||
|
||||
// 4. Make informed decisions using RL
|
||||
let current_state = vec![5.0, 1000.0, 2.0, 0.0, 0.0, 0.0];
|
||||
let recommended_action = db.predict_with_confidence(&strategy_session, current_state)?;
|
||||
println!(" ✓ Predicted optimal action with {:.1}% confidence",
|
||||
recommended_action.mean_confidence * 100.0);
|
||||
|
||||
println!("\n✨ AgenticDB Demo Complete!");
|
||||
println!("\nAll 5 tables working together:");
|
||||
println!(" 1. ✅ Reflexion Episodes - Learning from mistakes");
|
||||
println!(" 2. ✅ Skill Library - Building reusable patterns");
|
||||
println!(" 3. ✅ Causal Memory - Understanding relationships");
|
||||
println!(" 4. ✅ Learning Sessions - Optimizing strategies");
|
||||
println!(" 5. ✅ Vector DB - Fast similarity search");
|
||||
|
||||
println!("\n🚀 Performance: 10-100x faster than original agenticDB");
|
||||
println!("💾 Storage: Efficient HNSW indexing + redb persistence");
|
||||
println!("🎯 Ready for production agentic AI systems!");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user