rucora 0.4.0

High-performance, type-safe LLM agent framework with built-in tools and multi-provider support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! 默认研究引擎实现

use async_trait::async_trait;
use rucora_core::provider::LlmProvider;
use rucora_core::research::{
    ResearchConfig, ResearchContext, ResearchPhase, ResearchProgress, ResearchReport,
    ResearchStrategy, StrategyTrait,
};
use std::sync::{Arc, RwLock};

/// 默认深度研究引擎
pub struct DefaultResearchEngine {
    config: ResearchConfig,
    strategy: Box<dyn StrategyTrait>,
    progress: Arc<RwLock<ResearchProgress>>,
}

impl DefaultResearchEngine {
    pub fn new(strategy: Box<dyn StrategyTrait>) -> Self {
        let config = strategy.config().clone();
        Self {
            config,
            strategy,
            progress: Arc::new(RwLock::new(ResearchProgress::new(ResearchPhase::Init, 10))),
        }
    }

    pub fn with_config(config: ResearchConfig) -> Self {
        let max_iter = config.max_iterations;
        let strategy: Box<dyn StrategyTrait> = match config.strategy {
            ResearchStrategy::Fast => Box::new(super::strategies::FastStrategy::new()),
            _ => Box::new(super::strategies::StandardStrategy::with_config(
                config.clone(),
            )),
        };
        Self {
            config,
            strategy,
            progress: Arc::new(RwLock::new(ResearchProgress::new(
                ResearchPhase::Init,
                max_iter,
            ))),
        }
    }

    /// 使用指定的研究策略创建引擎
    pub fn with_strategy(config: ResearchConfig, strategy: Box<dyn StrategyTrait>) -> Self {
        let max_iter = config.max_iterations;
        Self {
            config,
            strategy,
            progress: Arc::new(RwLock::new(ResearchProgress::new(
                ResearchPhase::Init,
                max_iter,
            ))),
        }
    }
}

#[async_trait]
impl rucora_core::research::DeepResearchEngine for DefaultResearchEngine {
    async fn research(
        &self,
        provider: &Arc<dyn LlmProvider>,
        topic: &str,
    ) -> Result<ResearchReport, rucora_core::research::ResearchError> {
        // 更新进度
        {
            let mut p = self.progress.write().unwrap();
            p.phase = ResearchPhase::Search;
            p.description = format!("开始研究: {topic}");
        }

        let mut context = ResearchContext::new(topic);
        context.set_phase(ResearchPhase::Search);

        // 使用策略执行搜索
        let result = self.strategy.search(provider, topic, &mut context).await;

        // 创建报告
        let mut report = ResearchReport::new(topic.to_string(), self.config.strategy);

        match result {
            Ok(strategy_result) => {
                report.set_tokens(strategy_result.tokens_used);
                report.summary =
                    format!("研究完成，收集到 {} 条信息", strategy_result.new_info.len());
            }
            Err(e) => {
                report.summary = format!("研究失败: {e}");
            }
        }

        // 更新进度为完成
        {
            let mut p = self.progress.write().unwrap();
            p.phase = ResearchPhase::Complete;
            p.description = "研究完成".to_string();
        }

        Ok(report)
    }

    fn progress(&self) -> ResearchProgress {
        self.progress.read().unwrap().clone()
    }
}