do-memory-mcp 0.1.31

Model Context Protocol (MCP) server for AI agents
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

//! Audit logging operations - Query and batch operations
//!
//! This module provides logging methods for query and batch operations.

use super::core::AuditLogger;
use super::types::AuditLogLevel;
use serde_json::json;

impl AuditLogger {
    // === Batch Operations ===

    /// Log batch execution
    pub async fn log_batch_execution(
        &self,
        client_id: &str,
        operation_count: usize,
        success_count: usize,
        failure_count: usize,
        success: bool,
    ) {
        let metadata = json!({
            "operation_count": operation_count,
            "success_count": success_count,
            "failure_count": failure_count
        });

        self.log_event(
            AuditLogLevel::Info,
            client_id,
            "batch_execute",
            if success { "success" } else { "failure" },
            metadata,
        )
        .await;
    }

    /// Log bulk episode retrieval
    pub async fn log_bulk_episodes(&self, client_id: &str, episode_count: usize, success: bool) {
        let metadata = json!({
            "episode_count": episode_count
        });

        self.log_event(
            AuditLogLevel::Debug,
            client_id,
            "bulk_episodes",
            if success { "success" } else { "failure" },
            metadata,
        )
        .await;
    }

    // === Memory Query Operations ===

    /// Log memory query
    pub async fn log_memory_query(
        &self,
        client_id: &str,
        query: &str,
        result_count: usize,
        success: bool,
    ) {
        let metadata = json!({
            "query": query,
            "result_count": result_count
        });

        self.log_event(
            AuditLogLevel::Debug,
            client_id,
            "query_memory",
            if success { "success" } else { "failure" },
            metadata,
        )
        .await;
    }

    /// Log semantic memory query
    pub async fn log_semantic_query(
        &self,
        client_id: &str,
        query: &str,
        result_count: usize,
        success: bool,
    ) {
        let metadata = json!({
            "query": query,
            "result_count": result_count
        });

        self.log_event(
            AuditLogLevel::Debug,
            client_id,
            "query_semantic_memory",
            if success { "success" } else { "failure" },
            metadata,
        )
        .await;
    }
}