d14150da75
Implement intelligent agent learning from Knowledge Graph execution history with per-task-type expertise tracking, recency bias, and learning curves. ## Phase 5.3 Implementation ### Learning Infrastructure (✅ Complete) - LearningProfileService with per-task-type expertise metrics - TaskTypeExpertise model tracking success_rate, confidence, learning curves - Recency bias weighting: recent 7 days weighted 3x higher (exponential decay) - Confidence scoring prevents overfitting: min(1.0, executions / 20) - Learning curves computed from daily execution windows ### Agent Scoring Service (✅ Complete) - Unified AgentScore combining SwarmCoordinator + learning profiles - Scoring formula: 0.3*base + 0.5*expertise + 0.2*confidence - Rank agents by combined score for intelligent assignment - Support for recency-biased scoring (recent_success_rate) - Methods: rank_agents, select_best, rank_agents_with_recency ### KG Integration (✅ Complete) - KGPersistence::get_executions_for_task_type() - query by agent + task type - KGPersistence::get_agent_executions() - all executions for agent - Coordinator::load_learning_profile_from_kg() - core KG→Learning integration - Coordinator::load_all_learning_profiles() - batch load for multiple agents - Convert PersistedExecution → ExecutionData for learning calculations ### Agent Assignment Integration (✅ Complete) - AgentCoordinator uses learning profiles for task assignment - extract_task_type() infers task type from title/description - assign_task() scores candidates using AgentScoringService - Fallback to load-based selection if no learning data available - Learning profiles stored in coordinator.learning_profiles RwLock ### Profile Adapter Enhancements (✅ Complete) - create_learning_profile() - initialize empty profiles - add_task_type_expertise() - set task-type expertise - update_profile_with_learning() - update swarm profiles from learning ## Files Modified ### vapora-knowledge-graph/src/persistence.rs (+30 lines) - get_executions_for_task_type(agent_id, task_type, limit) - get_agent_executions(agent_id, limit) ### vapora-agents/src/coordinator.rs (+100 lines) - load_learning_profile_from_kg() - core KG integration method - load_all_learning_profiles() - batch loading for agents - assign_task() already uses learning-based scoring via AgentScoringService ### Existing Complete Implementation - vapora-knowledge-graph/src/learning.rs - calculation functions - vapora-agents/src/learning_profile.rs - data structures and expertise - vapora-agents/src/scoring.rs - unified scoring service - vapora-agents/src/profile_adapter.rs - adapter methods ## Tests Passing - learning_profile: 7 tests ✅ - scoring: 5 tests ✅ - profile_adapter: 6 tests ✅ - coordinator: learning-specific tests ✅ ## Data Flow 1. Task arrives → AgentCoordinator::assign_task() 2. Extract task_type from description 3. Query KG for task-type executions (load_learning_profile_from_kg) 4. Calculate expertise with recency bias 5. Score candidates (SwarmCoordinator + learning) 6. Assign to top-scored agent 7. Execution result → KG → Update learning profiles ## Key Design Decisions ✅ Recency bias: 7-day half-life with 3x weight for recent performance ✅ Confidence scoring: min(1.0, total_executions / 20) prevents overfitting ✅ Hierarchical scoring: 30% base load, 50% expertise, 20% confidence ✅ KG query limit: 100 recent executions per task-type for performance ✅ Async loading: load_learning_profile_from_kg supports concurrent loads ## Next: Phase 5.4 - Cost Optimization Ready to implement budget enforcement and cost-aware provider selection.
89 lines
2.4 KiB
Rust
Executable File
89 lines
2.4 KiB
Rust
Executable File
//! Doc-lifecycle plugin for VAPORA
|
|
|
|
use crate::config::PluginConfig;
|
|
use crate::Result;
|
|
use doc_lifecycle_core::prelude::*;
|
|
use std::path::PathBuf;
|
|
|
|
/// Main plugin interface for doc-lifecycle integration
|
|
#[derive(Debug)]
|
|
pub struct DocLifecyclePlugin {
|
|
config: PluginConfig,
|
|
classifier: Classifier,
|
|
consolidator: Consolidator,
|
|
rag_indexer: RagIndexer,
|
|
mdbook_generator: Option<MdBookGenerator>,
|
|
}
|
|
|
|
impl DocLifecyclePlugin {
|
|
/// Create a new doc-lifecycle plugin
|
|
pub fn new(config: PluginConfig) -> Result<Self> {
|
|
let mdbook_generator = if config.generate_mdbook {
|
|
let mdbook_config = doc_lifecycle_core::mdbook_generator::MdBookConfig::new(
|
|
PathBuf::from("book"),
|
|
"VAPORA Project".to_string(),
|
|
);
|
|
Some(MdBookGenerator::new(mdbook_config))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
Ok(Self {
|
|
config,
|
|
classifier: Classifier::new(),
|
|
consolidator: Consolidator::new(),
|
|
rag_indexer: RagIndexer::new(),
|
|
mdbook_generator,
|
|
})
|
|
}
|
|
|
|
/// Process documentation for a completed task
|
|
pub async fn process_task_docs(&mut self, task_id: &str) -> Result<()> {
|
|
tracing::info!("Processing task docs for task {}", task_id);
|
|
|
|
// 1. Classify documents
|
|
if self.config.auto_classify {
|
|
self.classify_session_docs(task_id).await?;
|
|
}
|
|
|
|
// 2. Consolidate duplicates
|
|
if self.config.auto_consolidate {
|
|
self.consolidate_docs().await?;
|
|
}
|
|
|
|
// 3. Generate RAG index
|
|
if self.config.generate_rag_index {
|
|
self.update_rag_index().await?;
|
|
}
|
|
|
|
// 4. Generate mdBook
|
|
if self.config.generate_mdbook {
|
|
self.generate_mdbook().await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn classify_session_docs(&self, _task_id: &str) -> Result<()> {
|
|
// TODO: Implement session doc classification
|
|
Ok(())
|
|
}
|
|
|
|
async fn consolidate_docs(&self) -> Result<()> {
|
|
// TODO: Implement consolidation
|
|
Ok(())
|
|
}
|
|
|
|
async fn update_rag_index(&self) -> Result<()> {
|
|
// TODO: Implement RAG index update
|
|
Ok(())
|
|
}
|
|
|
|
async fn generate_mdbook(&self) -> Result<()> {
|
|
if let Some(generator) = &self.mdbook_generator {
|
|
generator.generate()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|