aidaemon 0.11.13

A personal AI agent that runs as a background daemon, accessible via Telegram, Slack, or Discord, with tool use, MCP integration, and persistent memory
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

use super::*;

#[async_trait]
impl crate::traits::LearningStore for SqliteStateStore {
    async fn get_behavior_patterns(
        &self,
        min_confidence: f32,
    ) -> anyhow::Result<Vec<BehaviorPattern>> {
        SqliteStateStore::get_behavior_patterns(self, min_confidence).await
    }

    async fn record_behavior_pattern(
        &self,
        pattern_type: &str,
        description: &str,
        trigger_context: Option<&str>,
        action: Option<&str>,
        confidence_hint: f32,
        occurrence_delta: i32,
    ) -> anyhow::Result<()> {
        SqliteStateStore::record_behavior_pattern(
            self,
            pattern_type,
            description,
            trigger_context,
            action,
            confidence_hint,
            occurrence_delta,
        )
        .await
    }

    async fn get_relevant_procedures(
        &self,
        query: &str,
        limit: usize,
    ) -> anyhow::Result<Vec<Procedure>> {
        SqliteStateStore::get_relevant_procedures(self, query, limit).await
    }

    async fn get_relevant_error_solutions(
        &self,
        error: &str,
        limit: usize,
    ) -> anyhow::Result<Vec<ErrorSolution>> {
        SqliteStateStore::get_relevant_error_solutions(self, error, limit).await
    }

    async fn get_all_expertise(&self) -> anyhow::Result<Vec<Expertise>> {
        SqliteStateStore::get_all_expertise(self).await
    }

    async fn get_user_profile(&self) -> anyhow::Result<Option<UserProfile>> {
        Ok(Some(SqliteStateStore::get_user_profile(self).await?))
    }

    async fn get_trusted_command_patterns(&self) -> anyhow::Result<Vec<(String, i32)>> {
        SqliteStateStore::get_trusted_command_patterns(self).await
    }

    async fn increment_expertise(
        &self,
        domain: &str,
        success: bool,
        error: Option<&str>,
    ) -> anyhow::Result<()> {
        SqliteStateStore::increment_expertise(self, domain, success, error).await
    }

    async fn upsert_procedure(&self, procedure: &Procedure) -> anyhow::Result<i64> {
        SqliteStateStore::insert_procedure(self, procedure).await
    }

    async fn update_procedure_outcome(
        &self,
        procedure_id: i64,
        success: bool,
        duration: Option<f32>,
    ) -> anyhow::Result<()> {
        SqliteStateStore::update_procedure(self, procedure_id, success, None, duration).await
    }

    async fn insert_error_solution(&self, solution: &ErrorSolution) -> anyhow::Result<i64> {
        SqliteStateStore::insert_error_solution(self, solution).await
    }

    async fn update_error_solution_outcome(
        &self,
        solution_id: i64,
        success: bool,
    ) -> anyhow::Result<()> {
        SqliteStateStore::update_error_solution(self, solution_id, success).await
    }
}