do-memory-mcp 0.1.29

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

//! Episode timeline tool for MCP server
//!
//! This module provides the tool for retrieving a chronological view
//! of all steps in an episode.

use crate::server::MemoryMCPServer;
use anyhow::{Result, anyhow};
use do_memory_core::{ExecutionResult, TaskOutcome};
use serde_json::{Value, json};
use tracing::debug;
use uuid::Uuid;

impl MemoryMCPServer {
    /// Get a timeline view of episode execution
    ///
    /// This tool provides a chronological view of all steps in an episode,
    /// useful for visualizing task progression.
    ///
    /// # Arguments (from JSON)
    ///
    /// * `episode_id` - UUID of the episode
    pub async fn get_episode_timeline_tool(&self, args: Value) -> Result<Value> {
        debug!("Getting episode timeline with args: {}", args);

        let episode_id_str = args
            .get("episode_id")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow!("Missing required field: episode_id"))?;

        let episode_id = Uuid::parse_str(episode_id_str)
            .map_err(|e| anyhow!("Invalid episode_id format: {}", e))?;

        let episode = self
            .memory
            .get_episode(episode_id)
            .await
            .map_err(|e| anyhow!("Failed to get episode: {}", e))?;

        // Build timeline
        let timeline: Vec<Value> = episode
            .steps
            .iter()
            .map(|step| {
                json!({
                    "step_number": step.step_number,
                    "timestamp": step.timestamp.to_rfc3339(),
                    "tool": step.tool,
                    "action": step.action,
                    "result_type": match &step.result {
                        Some(ExecutionResult::Success { .. }) => "success",
                        Some(ExecutionResult::Error { .. }) => "error",
                        Some(ExecutionResult::Timeout) => "timeout",
                        None => "pending",
                    },
                    "latency_ms": step.latency_ms,
                })
            })
            .collect();

        let duration_seconds = episode
            .end_time
            .map(|end| (end.timestamp() - episode.start_time.timestamp()) as f64);

        Ok(json!({
            "success": true,
            "episode_id": episode_id.to_string(),
            "task_description": episode.task_description,
            "start_time": episode.start_time.to_rfc3339(),
            "end_time": episode.end_time.map(|t| t.to_rfc3339()),
            "duration_seconds": duration_seconds,
            "step_count": episode.steps.len(),
            "timeline": timeline,
            "outcome": episode.outcome.as_ref().map(|o| match o {
                TaskOutcome::Success { .. } => "success",
                TaskOutcome::PartialSuccess { .. } => "partial_success",
                TaskOutcome::Failure { .. } => "failure",
            }),
        }))
    }
}